@vue/compiler-sfc 2.7.0-alpha.8 → 2.7.0-alpha.9

package/dist/compiler-sfc.d.ts

@@ -5,6 +5,144 @@ declare interface AssetURLOptions {
     [name: string]: string | string[];
 }
 
+declare type ASTAttr = {
+    name: string;
+    value: any;
+    dynamic?: boolean;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTDirective = {
+    name: string;
+    rawName: string;
+    value: string;
+    arg: string | null;
+    isDynamicArg: boolean;
+    modifiers: ASTModifiers | null;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTElement = {
+    type: 1;
+    tag: string;
+    attrsList: Array<ASTAttr>;
+    attrsMap: {
+        [key: string]: any;
+    };
+    rawAttrsMap: {
+        [key: string]: ASTAttr;
+    };
+    parent: ASTElement | void;
+    children: Array<ASTNode>;
+    start?: number;
+    end?: number;
+    processed?: true;
+    static?: boolean;
+    staticRoot?: boolean;
+    staticInFor?: boolean;
+    staticProcessed?: boolean;
+    hasBindings?: boolean;
+    text?: string;
+    attrs?: Array<ASTAttr>;
+    dynamicAttrs?: Array<ASTAttr>;
+    props?: Array<ASTAttr>;
+    plain?: boolean;
+    pre?: true;
+    ns?: string;
+    component?: string;
+    inlineTemplate?: true;
+    transitionMode?: string | null;
+    slotName?: string | null;
+    slotTarget?: string | null;
+    slotTargetDynamic?: boolean;
+    slotScope?: string | null;
+    scopedSlots?: {
+        [name: string]: ASTElement;
+    };
+    ref?: string;
+    refInFor?: boolean;
+    if?: string;
+    ifProcessed?: boolean;
+    elseif?: string;
+    else?: true;
+    ifConditions?: ASTIfConditions;
+    for?: string;
+    forProcessed?: boolean;
+    key?: string;
+    alias?: string;
+    iterator1?: string;
+    iterator2?: string;
+    staticClass?: string;
+    classBinding?: string;
+    staticStyle?: string;
+    styleBinding?: string;
+    events?: ASTElementHandlers;
+    nativeEvents?: ASTElementHandlers;
+    transition?: string | true;
+    transitionOnAppear?: boolean;
+    model?: {
+        value: string;
+        callback: string;
+        expression: string;
+    };
+    directives?: Array<ASTDirective>;
+    forbidden?: true;
+    once?: true;
+    onceProcessed?: boolean;
+    wrapData?: (code: string) => string;
+    wrapListeners?: (code: string) => string;
+    ssrOptimizability?: number;
+};
+
+declare type ASTElementHandler = {
+    value: string;
+    params?: Array<any>;
+    modifiers: ASTModifiers | null;
+    dynamic?: boolean;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTElementHandlers = {
+    [key: string]: ASTElementHandler | Array<ASTElementHandler>;
+};
+
+declare type ASTExpression = {
+    type: 2;
+    expression: string;
+    text: string;
+    tokens: Array<string | Object>;
+    static?: boolean;
+    ssrOptimizability?: number;
+    start?: number;
+    end?: number;
+};
+
+declare type ASTIfCondition = {
+    exp: string | null;
+    block: ASTElement;
+};
+
+declare type ASTIfConditions = Array<ASTIfCondition>;
+
+declare type ASTModifiers = {
+    [key: string]: boolean;
+};
+
+declare type ASTNode = ASTElement | ASTText | ASTExpression;
+
+declare type ASTText = {
+    type: 3;
+    text: string;
+    static?: boolean;
+    isComment?: boolean;
+    ssrOptimizability?: number;
+    start?: number;
+    end?: number;
+};
+
 declare type BindingMetadata = {
     [key: string]: BindingTypes | undefined;
 } & {
@@ -53,6 +191,44 @@ declare const enum BindingTypes {
     OPTIONS = "options"
 }
 
+declare type CompiledResult = {
+    ast: ASTElement | null;
+    render: string;
+    staticRenderFns: Array<string>;
+    stringRenderFns?: Array<string>;
+    errors?: Array<string | WarningMessage>;
+    tips?: Array<string | WarningMessage>;
+};
+
+declare type CompilerOptions = {
+    warn?: Function;
+    modules?: Array<ModuleOptions>;
+    directives?: {
+        [key: string]: Function;
+    };
+    staticKeys?: string;
+    isUnaryTag?: (tag: string) => boolean | undefined;
+    canBeLeftOpenTag?: (tag: string) => boolean | undefined;
+    isReservedTag?: (tag: string) => boolean | undefined;
+    preserveWhitespace?: boolean;
+    whitespace?: 'preserve' | 'condense';
+    optimize?: boolean;
+    mustUseProp?: (tag: string, type: string | null, name: string) => boolean;
+    isPreTag?: (attr: string) => boolean | null;
+    getTagNamespace?: (tag: string) => string | undefined;
+    expectHTML?: boolean;
+    isFromDOM?: boolean;
+    shouldDecodeTags?: boolean;
+    shouldDecodeNewlines?: boolean;
+    shouldDecodeNewlinesForHref?: boolean;
+    outputSourceRange?: boolean;
+    shouldKeepComment?: boolean;
+    delimiters?: [string, string];
+    comments?: boolean;
+    scopeId?: string;
+    bindings?: BindingMetadata;
+};
+
 /**
  * Compile `<script setup>`
  * It requires the whole SFC descriptor because we need to handle and merge
@@ -76,6 +252,15 @@ declare interface ImportBinding {
     isUsedInTemplate: boolean;
 }
 
+declare type ModuleOptions = {
+    preTransformNode?: (el: ASTElement) => ASTElement | null | void;
+    transformNode?: (el: ASTElement) => ASTElement | null | void;
+    postTransformNode?: (el: ASTElement) => void;
+    genData?: (el: ASTElement) => string;
+    transformCode?: (el: ASTElement, code: string) => string;
+    staticKeys?: Array<string>;
+};
+
 export declare function parse(options: ParseOptions): SFCDescriptor;
 
 declare interface ParseOptions {
@@ -203,6 +388,7 @@ export declare interface TemplateCompileOptions {
     optimizeSSR?: boolean;
     prettify?: boolean;
     isTS?: boolean;
+    bindings?: BindingMetadata;
 }
 
 export declare interface TemplateCompileResult {
@@ -227,14 +413,7 @@ declare interface VueTemplateCompiler {
     ssrCompile(template: string, options: VueTemplateCompilerOptions): VueTemplateCompilerResults;
 }
 
-declare interface VueTemplateCompilerOptions {
-    modules?: Object[];
-    outputSourceRange?: boolean;
-    whitespace?: 'preserve' | 'condense';
-    directives?: {
-        [key: string]: Function;
-    };
-}
+declare type VueTemplateCompilerOptions = CompilerOptions;
 
 declare interface VueTemplateCompilerParseOptions {
     pad?: 'line' | 'space' | boolean;
@@ -242,13 +421,7 @@ declare interface VueTemplateCompilerParseOptions {
     outputSourceRange?: boolean;
 }
 
-declare interface VueTemplateCompilerResults {
-    ast: Object | undefined;
-    render: string;
-    staticRenderFns: string[];
-    errors: (string | WarningMessage)[];
-    tips: (string | WarningMessage)[];
-}
+declare type VueTemplateCompilerResults = CompiledResult;
 
 declare type WarningMessage = {
     msg: string;

package/dist/compiler-sfc.js

@@ -5789,7 +5789,7 @@ function resolveAsset(options, type, id, warnMissing) {
     // fallback to prototype chain
     const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
     if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-        warn$3('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+        warn$3('Failed to resolve ' + type.slice(0, -1) + ': ' + id);
     }
     return res;
 }
@@ -8772,7 +8772,7 @@ function compileScript(sfc, options = {}) {
         const any = isTS ? `: any` : ``;
         s.prependLeft(startOffset, `\nlet __temp${any}, __restore${any}\n`);
     }
-    const destructureElements = [`expose`];
+    const destructureElements = hasDefineExposeCall ? [`expose`] : [];
     if (emitIdentifier) {
         destructureElements.push(emitIdentifier === `emit` ? `emit` : `emit: ${emitIdentifier}`);
     }
@@ -8789,7 +8789,9 @@ function compileScript(sfc, options = {}) {
             allBindings[key] = true;
         }
     }
-    const returned = `{ ${Object.keys(allBindings).join(', ')} }`;
+    // __sfc marker indicates these bindings are compiled from <script setup>
+    // and should not be proxied on `this`
+    const returned = `{ ${`__sfc: true,`}${Object.keys(allBindings).join(', ')} }`;
     s.appendRight(endOffset, `\nreturn ${returned}\n}\n\n`);
     // 11. finalize default export
     let runtimeOptions = ``;
@@ -8816,9 +8818,6 @@ function compileScript(sfc, options = {}) {
     else if (emitsTypeDecl) {
         runtimeOptions += genRuntimeEmits(typeDeclaredEmits);
     }
-    // <script setup> components are closed by default. If the user did not
-    // explicitly call `defineExpose`, call expose() with no args.
-    const exposeCall = hasDefineExposeCall ? `` : `  expose();\n`;
     // wrap setup code with function.
     if (isTS) {
         // for TS, make sure the exported type is still valid type with
@@ -8827,7 +8826,7 @@ function compileScript(sfc, options = {}) {
         // user's TS setting should compile it down to proper targets
         // export default defineComponent({ ...__default__, ... })
         const def = defaultExport ? `\n  ...${DEFAULT_VAR},` : ``;
-        s.prependLeft(startOffset, `\nexport default /*#__PURE__*/${helper(`defineComponent`)}({${def}${runtimeOptions}\n  ${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`);
+        s.prependLeft(startOffset, `\nexport default /*#__PURE__*/${helper(`defineComponent`)}({${def}${runtimeOptions}\n  ${hasAwait ? `async ` : ``}setup(${args}) {\n`);
         s.appendRight(endOffset, `})`);
     }
     else {
@@ -8835,12 +8834,12 @@ function compileScript(sfc, options = {}) {
             // without TS, can't rely on rest spread, so we use Object.assign
             // export default Object.assign(__default__, { ... })
             s.prependLeft(startOffset, `\nexport default /*#__PURE__*/Object.assign(${DEFAULT_VAR}, {${runtimeOptions}\n  ` +
-                `${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`);
+                `${hasAwait ? `async ` : ``}setup(${args}) {\n`);
             s.appendRight(endOffset, `})`);
         }
         else {
             s.prependLeft(startOffset, `\nexport default {${runtimeOptions}\n  ` +
-                `${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`);
+                `${hasAwait ? `async ` : ``}setup(${args}) {\n`);
             s.appendRight(endOffset, `}`);
         }
     }
@@ -11741,8 +11740,19 @@ function genElement(el, state) {
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
                 data = genData(el, state);
             }
+            let tag;
+            // check if this is a component in <script setup>
+            const bindings = state.options.bindings;
+            if (bindings && bindings.__isScriptSetup !== false) {
+                tag =
+                    checkBindingType(bindings, el.tag) ||
+                        checkBindingType(bindings, camelize(el.tag)) ||
+                        checkBindingType(bindings, capitalize(camelize(el.tag)));
+            }
+            if (!tag)
+                tag = `'${el.tag}'`;
             const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            code = `_c(${tag}${data ? `,${data}` : '' // data
             }${children ? `,${children}` : '' // children
             })`;
         }
@@ -11753,6 +11763,12 @@ function genElement(el, state) {
         return code;
     }
 }
+function checkBindingType(bindings, key) {
+    const type = bindings[key];
+    if (type && type.startsWith('setup')) {
+        return key;
+    }
+}
 // hoist static sub-trees out
 function genStatic(el, state) {
     el.staticProcessed = true;
@@ -12907,7 +12923,7 @@ const doNotPrefix = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
  * The input is expected to be the render function code directly returned from
  * `compile()` calls, e.g. `with(this){return ...}`
  */
-function stripWith(source, fnName = '', isFunctional = false, isTS = false, babelOptions = {}) {
+function prefixIdentifiers(source, fnName = '', isFunctional = false, isTS = false, babelOptions = {}, bindings) {
     source = `function ${fnName}(${isFunctional ? `_c,_vm` : ``}){${source}\n}`;
     const s = new MagicString(source);
     const plugins = [
@@ -12915,21 +12931,36 @@ function stripWith(source, fnName = '', isFunctional = false, isTS = false, babe
         ...((babelOptions === null || babelOptions === void 0 ? void 0 : babelOptions.plugins) || [])
     ];
     const ast = parser$1.parseExpression(source, Object.assign(Object.assign({}, babelOptions), { plugins }));
+    const isScriptSetup = bindings && bindings.__isScriptSetup !== false;
     walkIdentifiers(ast, ident => {
-        if (doNotPrefix(ident.name)) {
+        const { name } = ident;
+        if (doNotPrefix(name)) {
+            return;
+        }
+        if (!isScriptSetup) {
+            s.prependRight(ident.start, '_vm.');
             return;
         }
-        s.prependRight(ident.start, '_vm.');
+        s.overwrite(ident.start, ident.end, rewriteIdentifier(name, bindings));
     }, node => {
         if (node.type === 'WithStatement') {
             s.remove(node.start, node.body.start + 1);
             s.remove(node.end - 1, node.end);
             if (!isFunctional) {
-                s.prependRight(node.start, `var _vm=this;var _c=_vm._self._c;`);
+                s.prependRight(node.start, `var _vm=this,_c=_vm._self._c${isScriptSetup ? `,_setup=_vm._setupProxy;` : `;`}`);
             }
         }
     });
     return s.toString();
+}
+function rewriteIdentifier(name, bindings) {
+    const type = bindings[name];
+    if (type && type.startsWith('setup')) {
+        return `_setup.${name}`;
+    }
+    else {
+        return `_vm.${name}`;
+    }
 }
 
 function compileTemplate(options) {
@@ -12977,7 +13008,7 @@ function preprocess$1(options, preprocessor) {
     return res;
 }
 function actuallyCompile(options) {
-    const { source, compiler = _compiler, compilerOptions = {}, transpileOptions = {}, transformAssetUrls, transformAssetUrlsOptions, isProduction = process.env.NODE_ENV === 'production', isFunctional = false, optimizeSSR = false, prettify = true, isTS = false } = options;
+    const { source, compiler = _compiler, compilerOptions = {}, transpileOptions = {}, transformAssetUrls, transformAssetUrlsOptions, isProduction = process.env.NODE_ENV === 'production', isFunctional = false, optimizeSSR = false, prettify = true, isTS = false, bindings } = options;
     const compile = optimizeSSR && compiler.ssrCompile ? compiler.ssrCompile : compiler.compile;
     let finalCompilerOptions = compilerOptions;
     if (transformAssetUrls) {
@@ -12992,6 +13023,7 @@ function actuallyCompile(options) {
             filename: options.filename
         });
     }
+    finalCompilerOptions.bindings = bindings;
     const { ast, render, staticRenderFns, tips, errors } = compile(source, finalCompilerOptions);
     if (errors && errors.length) {
         return {
@@ -13005,8 +13037,8 @@ function actuallyCompile(options) {
     else {
         // transpile code with vue-template-es2015-compiler, which is a forked
         // version of Buble that applies ES2015 transforms + stripping `with` usage
-        let code = `var __render__ = ${stripWith(render, `render`, isFunctional, isTS, transpileOptions)}\n` +
-            `var __staticRenderFns__ = [${staticRenderFns.map(code => stripWith(code, ``, isFunctional, isTS, transpileOptions))}]` +
+        let code = `var __render__ = ${prefixIdentifiers(render, `render`, isFunctional, isTS, transpileOptions, bindings)}\n` +
+            `var __staticRenderFns__ = [${staticRenderFns.map(code => prefixIdentifiers(code, ``, isFunctional, isTS, transpileOptions, bindings))}]` +
             `\n`;
         // #23 we use __render__ to avoid `render` not being prefixed by the
         // transpiler when stripping with, but revert it back to `render` to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.8",
+  "version": "2.7.0-alpha.9",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",