CREATE_BLOCK,
FRAGMENT,
RENDER_SLOT,
- APPLY_DIRECTIVES
+ WITH_DIRECTIVES
} from '../src/runtimeHelpers'
import { transformIf } from '../src/transforms/vIf'
import { transformFor } from '../src/transforms/vFor'
{
type: NodeTypes.JS_CALL_EXPRESSION,
// should wrap applyDirectives() around createBlock()
- callee: APPLY_DIRECTIVES,
+ callee: WITH_DIRECTIVES,
arguments: [
{ callee: CREATE_BLOCK },
{ type: NodeTypes.JS_ARRAY_EXPRESSION }
return function render() {
with (this) {
- const { createVNode: _createVNode, applyDirectives: _applyDirectives, resolveDirective: _resolveDirective, createBlock: _createBlock, openBlock: _openBlock } = _Vue
+ const { createVNode: _createVNode, withDirectives: _withDirectives, resolveDirective: _resolveDirective, createBlock: _createBlock, openBlock: _openBlock } = _Vue
const _directive_foo = _resolveDirective(\\"foo\\")
return (_openBlock(), _createBlock(\\"div\\", null, [
- _applyDirectives(_createVNode(\\"div\\", _hoisted_1, null, 32 /* NEED_PATCH */), [
+ _withDirectives(_createVNode(\\"div\\", _hoisted_1, null, 32 /* NEED_PATCH */), [
[_directive_foo]
])
]))
return function render() {
with (this) {
- const { renderList: _renderList, openBlock: _openBlock, createBlock: _createBlock, Fragment: _Fragment, createVNode: _createVNode, applyDirectives: _applyDirectives, resolveDirective: _resolveDirective } = _Vue
+ const { renderList: _renderList, openBlock: _openBlock, createBlock: _createBlock, Fragment: _Fragment, createVNode: _createVNode, withDirectives: _withDirectives, resolveDirective: _resolveDirective } = _Vue
const _directive_foo = _resolveDirective(\\"foo\\")
return (_openBlock(), _createBlock(_Fragment, null, _renderList(list, (i) => {
- return (_openBlock(), _applyDirectives(_createBlock(\\"div\\", null, null, 32 /* NEED_PATCH */), [
+ return (_openBlock(), _withDirectives(_createBlock(\\"div\\", null, null, 32 /* NEED_PATCH */), [
[_directive_foo]
]))
}), 128 /* UNKEYED_FRAGMENT */))
OPEN_BLOCK,
CREATE_BLOCK,
CREATE_VNODE,
- APPLY_DIRECTIVES,
+ WITH_DIRECTIVES,
FRAGMENT,
RENDER_LIST
} from '../../src/runtimeHelpers'
{
type: NodeTypes.ELEMENT,
codegenNode: {
- callee: APPLY_DIRECTIVES,
+ callee: WITH_DIRECTIVES,
arguments: [
{
callee: CREATE_VNODE,
CREATE_VNODE,
MERGE_PROPS,
RESOLVE_DIRECTIVE,
- APPLY_DIRECTIVES,
+ WITH_DIRECTIVES,
TO_HANDLERS,
helperNameMap,
PORTAL,
expect(root.helpers).toContain(RESOLVE_DIRECTIVE)
expect(root.directives).toContain(`foo`)
- expect(node.callee).toBe(APPLY_DIRECTIVES)
+ expect(node.callee).toBe(WITH_DIRECTIVES)
expect(node.arguments).toMatchObject([
{
type: NodeTypes.JS_CALL_EXPRESSION,
expect(root.directives).toContain(`bar`)
expect(root.directives).toContain(`baz`)
- expect(node.callee).toBe(APPLY_DIRECTIVES)
+ expect(node.callee).toBe(WITH_DIRECTIVES)
expect(node.arguments).toMatchObject([
{
type: NodeTypes.JS_CALL_EXPRESSION
FRAGMENT,
RENDER_LIST,
RENDER_SLOT,
- APPLY_DIRECTIVES
+ WITH_DIRECTIVES
} from '../../src/runtimeHelpers'
import { PatchFlags } from '@vue/runtime-dom'
import { createObjectMatcher, genFlagText } from '../testUtils'
{ callee: OPEN_BLOCK },
// should wrap applyDirectives() around createBlock()
{
- callee: APPLY_DIRECTIVES,
+ callee: WITH_DIRECTIVES,
arguments: [
{ callee: CREATE_BLOCK },
{ type: NodeTypes.JS_ARRAY_EXPRESSION }
COMMENT,
FRAGMENT,
MERGE_PROPS,
- APPLY_DIRECTIVES,
+ WITH_DIRECTIVES,
RENDER_SLOT
} from '../../src/runtimeHelpers'
import { createObjectMatcher } from '../testUtils'
} = parseWithIfTransform(`<div v-if="ok" v-foo />`)
const branch1 = (codegenNode.expressions[1] as ConditionalExpression)
.consequent as CallExpression
- expect(branch1.callee).toBe(APPLY_DIRECTIVES)
+ expect(branch1.callee).toBe(WITH_DIRECTIVES)
const realBranch = branch1.arguments[0] as CallExpression
expect(realBranch.arguments[1]).toMatchObject(
createObjectMatcher({ key: `[0]` })
import { ForParseResult } from './transforms/vFor'
import {
CREATE_VNODE,
- APPLY_DIRECTIVES,
+ WITH_DIRECTIVES,
RENDER_SLOT,
CREATE_SLOTS,
RENDER_LIST,
// ])
export interface CodegenNodeWithDirective<T extends CallExpression>
extends CallExpression {
- callee: typeof APPLY_DIRECTIVES
+ callee: typeof WITH_DIRECTIVES
arguments: [T, DirectiveArguments]
}
| typeof CREATE_VNODE
| typeof CREATE_BLOCK
? PlainElementCodegenNode | PlainComponentCodegenNode
- : T extends typeof APPLY_DIRECTIVES
+ : T extends typeof WITH_DIRECTIVES
?
| CodegenNodeWithDirective<PlainElementCodegenNode>
| CodegenNodeWithDirective<PlainComponentCodegenNode>
__DEV__ ? `resolveDynamicComponent` : ``
)
export const RESOLVE_DIRECTIVE = Symbol(__DEV__ ? `resolveDirective` : ``)
-export const APPLY_DIRECTIVES = Symbol(__DEV__ ? `applyDirectives` : ``)
+export const WITH_DIRECTIVES = Symbol(__DEV__ ? `withDirectives` : ``)
export const RENDER_LIST = Symbol(__DEV__ ? `renderList` : ``)
export const RENDER_SLOT = Symbol(__DEV__ ? `renderSlot` : ``)
export const CREATE_SLOTS = Symbol(__DEV__ ? `createSlots` : ``)
[RESOLVE_COMPONENT]: `resolveComponent`,
[RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
[RESOLVE_DIRECTIVE]: `resolveDirective`,
- [APPLY_DIRECTIVES]: `applyDirectives`,
+ [WITH_DIRECTIVES]: `withDirectives`,
[RENDER_LIST]: `renderList`,
[RENDER_SLOT]: `renderSlot`,
[CREATE_SLOTS]: `createSlots`,
CREATE_VNODE,
FRAGMENT,
helperNameMap,
- APPLY_DIRECTIVES,
+ WITH_DIRECTIVES,
CREATE_BLOCK
} from './runtimeHelpers'
import { isVSlot, createBlockExpression } from './utils'
const codegenNode = child.codegenNode as
| ElementCodegenNode
| ComponentCodegenNode
- if (codegenNode.callee === APPLY_DIRECTIVES) {
+ if (codegenNode.callee === WITH_DIRECTIVES) {
codegenNode.arguments[0].callee = helper(CREATE_BLOCK)
} else {
codegenNode.callee = helper(CREATE_BLOCK)
ElementNode
} from '../ast'
import { TransformContext } from '../transform'
-import { APPLY_DIRECTIVES } from '../runtimeHelpers'
+import { WITH_DIRECTIVES } from '../runtimeHelpers'
import { PatchFlags, isString, isSymbol } from '@vue/shared'
import { isSlotOutlet, findProp } from '../utils'
!hasDynamicKeyOrRef(child)
) {
let codegenNode = child.codegenNode as ElementCodegenNode
- if (codegenNode.callee === APPLY_DIRECTIVES) {
+ if (codegenNode.callee === WITH_DIRECTIVES) {
codegenNode = codegenNode.arguments[0]
}
const props = codegenNode.arguments[1]
function getPatchFlag(node: PlainElementNode): number | undefined {
let codegenNode = node.codegenNode as ElementCodegenNode
- if (codegenNode.callee === APPLY_DIRECTIVES) {
+ if (codegenNode.callee === WITH_DIRECTIVES) {
codegenNode = codegenNode.arguments[0]
}
const flag = codegenNode.arguments[3]
import { createCompilerError, ErrorCodes } from '../errors'
import {
CREATE_VNODE,
- APPLY_DIRECTIVES,
+ WITH_DIRECTIVES,
RESOLVE_DIRECTIVE,
RESOLVE_COMPONENT,
RESOLVE_DYNAMIC_COMPONENT,
if (runtimeDirectives && runtimeDirectives.length) {
node.codegenNode = createCallExpression(
- context.helper(APPLY_DIRECTIVES),
+ context.helper(WITH_DIRECTIVES),
[
vnode,
createArrayExpression(
OPEN_BLOCK,
CREATE_BLOCK,
FRAGMENT,
- APPLY_DIRECTIVES
+ WITH_DIRECTIVES
} from '../runtimeHelpers'
import { processExpression } from './transformExpression'
import { PatchFlags, PatchFlagNames } from '@vue/shared'
// Normal element v-for. Directly use the child's codegenNode
// arguments, but replace createVNode() with createBlock()
let codegenNode = node.codegenNode as ElementCodegenNode
- if (codegenNode.callee === APPLY_DIRECTIVES) {
+ if (codegenNode.callee === WITH_DIRECTIVES) {
codegenNode.arguments[0].callee = helper(CREATE_BLOCK)
} else {
codegenNode.callee = helper(CREATE_BLOCK)
CREATE_BLOCK,
COMMENT,
FRAGMENT,
- APPLY_DIRECTIVES,
+ WITH_DIRECTIVES,
CREATE_VNODE
} from '../runtimeHelpers'
import { injectProp } from '../utils'
| SlotOutletCodegenNode
let vnodeCall = childCodegen
// Element with custom directives. Locate the actual createVNode() call.
- if (vnodeCall.callee === APPLY_DIRECTIVES) {
+ if (vnodeCall.callee === WITH_DIRECTIVES) {
vnodeCall = vnodeCall.arguments[0]
}
// Change createVNode to createBlock.
return function render() {
with (this) {
- const { vModelText: _vModelText, createVNode: _createVNode, applyDirectives: _applyDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
+ const { vModelText: _vModelText, createVNode: _createVNode, withDirectives: _withDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
- return (_openBlock(), _applyDirectives(_createBlock(\\"input\\", {
+ return (_openBlock(), _withDirectives(_createBlock(\\"input\\", {
modelValue: model,
\\"onUpdate:modelValue\\": $event => (model = $event)
}, null, 8 /* PROPS */, [\\"modelValue\\", \\"onUpdate:modelValue\\"]), [
return function render() {
with (this) {
- const { vModelText: _vModelText, createVNode: _createVNode, applyDirectives: _applyDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
+ const { vModelText: _vModelText, createVNode: _createVNode, withDirectives: _withDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
- return (_openBlock(), _applyDirectives(_createBlock(\\"input\\", {
+ return (_openBlock(), _withDirectives(_createBlock(\\"input\\", {
modelValue: model,
\\"onUpdate:modelValue\\": $event => (model = $event)
}, null, 8 /* PROPS */, [\\"modelValue\\", \\"onUpdate:modelValue\\"]), [
return function render() {
with (this) {
- const { vModelText: _vModelText, createVNode: _createVNode, applyDirectives: _applyDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
+ const { vModelText: _vModelText, createVNode: _createVNode, withDirectives: _withDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
- return (_openBlock(), _applyDirectives(_createBlock(\\"input\\", {
+ return (_openBlock(), _withDirectives(_createBlock(\\"input\\", {
modelValue: model,
\\"onUpdate:modelValue\\": $event => (model = $event)
}, null, 8 /* PROPS */, [\\"modelValue\\", \\"onUpdate:modelValue\\"]), [
return function render() {
with (this) {
- const { vModelText: _vModelText, createVNode: _createVNode, applyDirectives: _applyDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
+ const { vModelText: _vModelText, createVNode: _createVNode, withDirectives: _withDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
- return (_openBlock(), _applyDirectives(_createBlock(\\"input\\", {
+ return (_openBlock(), _withDirectives(_createBlock(\\"input\\", {
modelValue: model,
\\"onUpdate:modelValue\\": $event => (model = $event)
}, null, 8 /* PROPS */, [\\"modelValue\\", \\"onUpdate:modelValue\\"]), [
return function render() {
with (this) {
- const { vModelCheckbox: _vModelCheckbox, createVNode: _createVNode, applyDirectives: _applyDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
+ const { vModelCheckbox: _vModelCheckbox, createVNode: _createVNode, withDirectives: _withDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
- return (_openBlock(), _applyDirectives(_createBlock(\\"input\\", {
+ return (_openBlock(), _withDirectives(_createBlock(\\"input\\", {
type: \\"checkbox\\",
modelValue: model,
\\"onUpdate:modelValue\\": $event => (model = $event)
return function render() {
with (this) {
- const { vModelDynamic: _vModelDynamic, createVNode: _createVNode, applyDirectives: _applyDirectives, resolveDirective: _resolveDirective, createBlock: _createBlock, openBlock: _openBlock } = _Vue
+ const { vModelDynamic: _vModelDynamic, createVNode: _createVNode, withDirectives: _withDirectives, resolveDirective: _resolveDirective, createBlock: _createBlock, openBlock: _openBlock } = _Vue
const _directive_bind = _resolveDirective(\\"bind\\")
- return (_openBlock(), _applyDirectives(_createBlock(\\"input\\", {
+ return (_openBlock(), _withDirectives(_createBlock(\\"input\\", {
modelValue: model,
\\"onUpdate:modelValue\\": $event => (model = $event)
}, null, 8 /* PROPS */, [\\"modelValue\\", \\"onUpdate:modelValue\\"]), [
return function render() {
with (this) {
- const { vModelRadio: _vModelRadio, createVNode: _createVNode, applyDirectives: _applyDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
+ const { vModelRadio: _vModelRadio, createVNode: _createVNode, withDirectives: _withDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
- return (_openBlock(), _applyDirectives(_createBlock(\\"input\\", {
+ return (_openBlock(), _withDirectives(_createBlock(\\"input\\", {
type: \\"radio\\",
modelValue: model,
\\"onUpdate:modelValue\\": $event => (model = $event)
return function render() {
with (this) {
- const { vModelText: _vModelText, createVNode: _createVNode, applyDirectives: _applyDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
+ const { vModelText: _vModelText, createVNode: _createVNode, withDirectives: _withDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
- return (_openBlock(), _applyDirectives(_createBlock(\\"input\\", {
+ return (_openBlock(), _withDirectives(_createBlock(\\"input\\", {
type: \\"text\\",
modelValue: model,
\\"onUpdate:modelValue\\": $event => (model = $event)
return function render() {
with (this) {
- const { vModelSelect: _vModelSelect, createVNode: _createVNode, applyDirectives: _applyDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
+ const { vModelSelect: _vModelSelect, createVNode: _createVNode, withDirectives: _withDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
- return (_openBlock(), _applyDirectives(_createBlock(\\"select\\", {
+ return (_openBlock(), _withDirectives(_createBlock(\\"select\\", {
modelValue: model,
\\"onUpdate:modelValue\\": $event => (model = $event)
}, null, 8 /* PROPS */, [\\"modelValue\\", \\"onUpdate:modelValue\\"]), [
return function render() {
with (this) {
- const { vModelText: _vModelText, createVNode: _createVNode, applyDirectives: _applyDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
+ const { vModelText: _vModelText, createVNode: _createVNode, withDirectives: _withDirectives, createBlock: _createBlock, openBlock: _openBlock } = _Vue
- return (_openBlock(), _applyDirectives(_createBlock(\\"textarea\\", {
+ return (_openBlock(), _withDirectives(_createBlock(\\"textarea\\", {
modelValue: model,
\\"onUpdate:modelValue\\": $event => (model = $event)
}, null, 8 /* PROPS */, [\\"modelValue\\", \\"onUpdate:modelValue\\"]), [
inject,
resolveComponent,
resolveDirective,
- applyDirectives,
+ withDirectives,
Plugin,
ref,
getCurrentInstance
return () => {
// resolve in render
const BarBaz = resolveDirective('bar-baz')!
- return applyDirectives(h('div'), [[FooBar], [BarBaz]])
+ return withDirectives(h('div'), [[FooBar], [BarBaz]])
}
}
}
import {
h,
- applyDirectives,
+ withDirectives,
ref,
render,
nodeOps,
},
render() {
_prevVnode = _vnode
- _vnode = applyDirectives(h('div', count.value), [
+ _vnode = withDirectives(h('div', count.value), [
[
{
beforeMount,
},
render() {
_prevVnode = _vnode
- _vnode = applyDirectives(h('div', count.value), [
+ _vnode = withDirectives(h('div', count.value), [
[
fn,
// value
])
*/
-import { VNode, cloneVNode } from './vnode'
-import { extend, isArray, isFunction, EMPTY_OBJ, makeMap } from '@vue/shared'
+import { VNode } from './vnode'
+import { isArray, isFunction, EMPTY_OBJ, makeMap } from '@vue/shared'
import { warn } from './warning'
import { ComponentInternalInstance } from './component'
import { currentRenderingInstance } from './componentRenderUtils'
| [Directive, any, string, DirectiveModifiers]
>
-export function applyDirectives(vnode: VNode, directives: DirectiveArguments) {
+export function withDirectives(vnode: VNode, directives: DirectiveArguments) {
const instance = currentRenderingInstance
if (instance !== null) {
- vnode = cloneVNode(vnode)
- vnode.props = vnode.props != null ? extend({}, vnode.props) : {}
+ vnode.props = vnode.props || {}
for (let i = 0; i < directives.length; i++) {
const [dir, value, arg, modifiers] = directives[i]
applyDirective(vnode.props, instance, dir, value, arg, modifiers)
// Internal, for compiler generated code
// should sync with '@vue/compiler-core/src/runtimeConstants.ts'
-export { applyDirectives } from './directives'
+export { withDirectives } from './directives'
export {
resolveComponent,
resolveDirective,
nextTick,
createComponent,
vModelDynamic,
- applyDirectives,
+ withDirectives,
VNode
} from '@vue/runtime-dom'
}
const withVModel = (node: VNode, arg: any, mods?: any) =>
- applyDirectives(node, [[vModelDynamic, arg, '', mods]])
+ withDirectives(node, [[vModelDynamic, arg, '', mods]])
const setValue = function(this: any, value: any) {
this.value = value