@vue/compiler-sfc 3.3.9 → 3.4.0-alpha.2

package/dist/compiler-sfc.cjs.js

@@ -2,19 +2,18 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var compilerCore = require('@vue/compiler-core');
 var CompilerDOM = require('@vue/compiler-dom');
 var sourceMapJs = require('source-map-js');
 var path$3 = require('path');
 var parser$2 = require('@babel/parser');
 var shared = require('@vue/shared');
-var compilerCore = require('@vue/compiler-core');
 var url = require('url');
 var CompilerSSR = require('@vue/compiler-ssr');
 var require$$2 = require('util');
 var require$$0 = require('fs');
 var require$$0$1 = require('postcss');
 var estreeWalker = require('estree-walker');
-var reactivityTransform = require('@vue/reactivity-transform');
 var MagicString = require('magic-string');
 var process$1 = require('process');
 
@@ -1731,44 +1730,43 @@ function resolveTemplateUsageCheckString(sfc) {
     return cached;
   }
   let code = "";
-  CompilerDOM.transform(CompilerDOM.createRoot([ast]), {
-    nodeTransforms: [
-      (node) => {
-        var _a;
-        if (node.type === 1) {
-          if (!CompilerDOM.parserOptions.isNativeTag(node.tag) && !CompilerDOM.parserOptions.isBuiltInComponent(node.tag)) {
-            code += `,${shared.camelize(node.tag)},${shared.capitalize(shared.camelize(node.tag))}`;
-          }
-          for (let i = 0; i < node.props.length; i++) {
-            const prop = node.props[i];
-            if (prop.type === 7) {
-              if (!shared.isBuiltInDirective(prop.name)) {
-                code += `,v${shared.capitalize(shared.camelize(prop.name))}`;
-              }
-              if (prop.arg && !prop.arg.isStatic) {
-                code += `,${stripStrings(
-                  prop.arg.content
-                )}`;
-              }
-              if (prop.exp) {
-                code += `,${processExp(
-                  prop.exp.content,
-                  prop.name
-                )}`;
-              }
+  ast.children.forEach(walk);
+  function walk(node) {
+    var _a;
+    switch (node.type) {
+      case 1:
+        if (!CompilerDOM.parserOptions.isNativeTag(node.tag) && !CompilerDOM.parserOptions.isBuiltInComponent(node.tag)) {
+          code += `,${shared.camelize(node.tag)},${shared.capitalize(shared.camelize(node.tag))}`;
+        }
+        for (let i = 0; i < node.props.length; i++) {
+          const prop = node.props[i];
+          if (prop.type === 7) {
+            if (!shared.isBuiltInDirective(prop.name)) {
+              code += `,v${shared.capitalize(shared.camelize(prop.name))}`;
             }
-            if (prop.type === 6 && prop.name === "ref" && ((_a = prop.value) == null ? void 0 : _a.content)) {
-              code += `,${prop.value.content}`;
+            if (prop.arg && !prop.arg.isStatic) {
+              code += `,${stripStrings(
+                prop.arg.content
+              )}`;
             }
+            if (prop.exp) {
+              code += `,${processExp(
+                prop.exp.content,
+                prop.name
+              )}`;
+            }
+          }
+          if (prop.type === 6 && prop.name === "ref" && ((_a = prop.value) == null ? void 0 : _a.content)) {
+            code += `,${prop.value.content}`;
           }
-        } else if (node.type === 5) {
-          code += `,${processExp(
-            node.content.content
-          )}`;
         }
-      }
-    ]
-  });
+        node.children.forEach(walk);
+        break;
+      case 5:
+        code += `,${processExp(node.content.content)}`;
+        break;
+    }
+  }
   code += ";";
   templateUsageCheckCache.set(content, code);
   return code;
@@ -1836,20 +1834,7 @@ function parse$2(source, {
   };
   const errors = [];
   const ast = compiler.parse(source, {
-    // there are no components at SFC parsing level
-    isNativeTag: () => true,
-    // preserve all whitespaces
-    isPreTag: () => true,
-    getTextMode: ({ tag, props }, parent) => {
-      if (!parent && tag !== "template" || // <template lang="xxx"> should also be treated as raw text
-      tag === "template" && props.some(
-        (p) => p.type === 6 && p.name === "lang" && p.value && p.value.content && p.value.content !== "html"
-      )) {
-        return 2;
-      } else {
-        return 0;
-      }
-    },
+    parseMode: "sfc",
     onError: (e) => {
       errors.push(e);
     }
@@ -1869,12 +1854,16 @@ function parse$2(source, {
             source,
             false
           );
-          templateBlock.ast = node;
+          if (!templateBlock.attrs.src) {
+            templateBlock.ast = compilerCore.createRoot(node.children, source);
+          }
           if (templateBlock.attrs.functional) {
             const err = new SyntaxError(
               `<template functional> is no longer supported in Vue 3, since functional components no longer have significant performance difference from stateful ones. Just use a normal <template> instead.`
             );
-            err.loc = node.props.find((p) => p.name === "functional").loc;
+            err.loc = node.props.find(
+              (p) => p.type === 6 && p.name === "functional"
+            ).loc;
             errors.push(err);
           }
         } else {
@@ -1973,32 +1962,11 @@ function createDuplicateBlockError(node, isScriptSetup = false) {
 }
 function createBlock(node, source, pad) {
   const type = node.tag;
-  let { start, end } = node.loc;
-  let content = "";
-  if (node.children.length) {
-    start = node.children[0].loc.start;
-    end = node.children[node.children.length - 1].loc.end;
-    content = source.slice(start.offset, end.offset);
-  } else {
-    const offset = node.loc.source.indexOf(`</`);
-    if (offset > -1) {
-      start = {
-        line: start.line,
-        column: start.column + offset,
-        offset: start.offset + offset
-      };
-    }
-    end = { ...start };
-  }
-  const loc = {
-    source: content,
-    start,
-    end
-  };
+  const loc = node.innerLoc;
   const attrs = {};
   const block = {
     type,
-    content,
+    content: source.slice(loc.start.offset, loc.end.offset),
     loc,
     attrs
   };
@@ -2007,18 +1975,19 @@ function createBlock(node, source, pad) {
   }
   node.props.forEach((p) => {
     if (p.type === 6) {
-      attrs[p.name] = p.value ? p.value.content || true : true;
-      if (p.name === "lang") {
+      const name = p.name;
+      attrs[name] = p.value ? p.value.content || true : true;
+      if (name === "lang") {
         block.lang = p.value && p.value.content;
-      } else if (p.name === "src") {
+      } else if (name === "src") {
         block.src = p.value && p.value.content;
       } else if (type === "style") {
-        if (p.name === "scoped") {
+        if (name === "scoped") {
           block.scoped = true;
-        } else if (p.name === "module") {
-          block.module = attrs[p.name];
+        } else if (name === "module") {
+          block.module = attrs[name];
         }
-      } else if (type === "script" && p.name === "setup") {
+      } else if (type === "script" && name === "setup") {
         block.setup = attrs.setup;
       }
     }
@@ -2034,28 +2003,27 @@ function generateSourceMap(filename, source, generated, sourceRoot, lineOffset)
     sourceRoot: sourceRoot.replace(/\\/g, "/")
   });
   map.setSourceContent(filename, source);
+  map._sources.add(filename);
   generated.split(splitRE).forEach((line, index) => {
     if (!emptyRE.test(line)) {
       const originalLine = index + 1 + lineOffset;
       const generatedLine = index + 1;
       for (let i = 0; i < line.length; i++) {
         if (!/\s/.test(line[i])) {
-          map.addMapping({
+          map._mappings.add({
+            originalLine,
+            originalColumn: i,
+            generatedLine,
+            generatedColumn: i,
             source: filename,
-            original: {
-              line: originalLine,
-              column: i
-            },
-            generated: {
-              line: generatedLine,
-              column: i
-            }
+            // @ts-ignore
+            name: null
           });
         }
       }
     }
   });
-  return JSON.parse(map.toString());
+  return map.toJSON();
 }
 function padContent(content, block, pad) {
   content = content.slice(0, block.loc.start.offset);
@@ -4195,7 +4163,9 @@ function compileTemplate(options) {
     try {
       return doCompileTemplate({
         ...options,
-        source: preprocess$1(options, preprocessor)
+        source: preprocess$1(options, preprocessor),
+        ast: void 0
+        // invalidate AST if template goes through preprocessor
       });
     } catch (e) {
       return {
@@ -4227,10 +4197,11 @@ function doCompileTemplate({
   slotted,
   inMap,
   source,
+  ast: inAST,
   ssr = false,
   ssrCssVars,
   isProd = false,
-  compiler = ssr ? CompilerSSR__namespace : CompilerDOM__namespace,
+  compiler,
   compilerOptions = {},
   transformAssetUrls
 }) {
@@ -4257,7 +4228,22 @@ function doCompileTemplate({
   }
   const shortId = id.replace(/^data-v-/, "");
   const longId = `data-v-${shortId}`;
-  let { code, ast, preamble, map } = compiler.compile(source, {
+  const defaultCompiler = ssr ? CompilerSSR__namespace : CompilerDOM__namespace;
+  compiler = compiler || defaultCompiler;
+  if (compiler !== defaultCompiler) {
+    inAST = void 0;
+  }
+  if (inAST == null ? void 0 : inAST.transformed) {
+    const newAST = (ssr ? CompilerDOM__namespace : compiler).parse(inAST.source, {
+      parseMode: "sfc",
+      onError: (e) => errors.push(e)
+    });
+    const template = newAST.children.find(
+      (node) => node.type === 1 && node.tag === "template"
+    );
+    inAST = compilerCore.createRoot(template.children, inAST.source);
+  }
+  let { code, ast, preamble, map } = compiler.compile(inAST || source, {
     mode: "module",
     prefixIdentifiers: true,
     hoistStatic: true,
@@ -4273,7 +4259,7 @@ function doCompileTemplate({
     onError: (e) => errors.push(e),
     onWarn: (w) => warnings.push(w)
   });
-  if (inMap) {
+  if (inMap && !inAST) {
     if (map) {
       map = mapLines(inMap, map);
     }
@@ -4286,7 +4272,7 @@ function doCompileTemplate({
     if (w.loc) {
       msg += `
 ${shared.generateCodeFrame(
-        source,
+        (inAST == null ? void 0 : inAST.source) || source,
         w.loc.start.offset,
         w.loc.end.offset
       )}`;
@@ -11185,7 +11171,10 @@ const scss = (source, map, options, load = require) => {
     if (map) {
       return {
         code: result.css.toString(),
-        map: merge$1(map, JSON.parse(result.map.toString())),
+        map: merge$1(
+          map,
+          result.map.toJSON ? result.map.toJSON() : JSON.parse(result.map.toString())
+        ),
         errors: [],
         dependencies
       };
@@ -15546,30 +15535,8 @@ function processNormalScript(ctx, scopeId) {
     let map = script.map;
     const scriptAst = ctx.scriptAst;
     const bindings = analyzeScriptBindings(scriptAst.body);
-    const { source, filename, cssVars } = ctx.descriptor;
-    const { sourceMap, genDefaultAs, isProd } = ctx.options;
-    if (ctx.options.reactivityTransform && reactivityTransform.shouldTransform(content)) {
-      const s = new MagicString(source);
-      const startOffset = script.loc.start.offset;
-      const endOffset = script.loc.end.offset;
-      const { importedHelpers } = reactivityTransform.transformAST(scriptAst, s, startOffset);
-      if (importedHelpers.length) {
-        s.prepend(
-          `import { ${importedHelpers.map((h) => `${h} as _${h}`).join(", ")} } from 'vue'
-`
-        );
-      }
-      s.remove(0, startOffset);
-      s.remove(endOffset, source.length);
-      content = s.toString();
-      if (sourceMap !== false) {
-        map = s.generateMap({
-          source: filename,
-          hires: true,
-          includeContent: true
-        });
-      }
-    }
+    const { cssVars } = ctx.descriptor;
+    const { genDefaultAs, isProd } = ctx.options;
     if (cssVars.length || genDefaultAs) {
       const defaultVar = genDefaultAs || normalScriptDefaultVar;
       const s = new MagicString(content);
@@ -19149,7 +19116,7 @@ function genRuntimeProps(ctx) {
       }
     }
   } else if (ctx.propsTypeDecl) {
-    propsDecls = genRuntimePropsFromTypes(ctx);
+    propsDecls = extractRuntimeProps(ctx);
   }
   const modelsDecls = genModelProps(ctx);
   if (propsDecls && modelsDecls) {
@@ -19158,7 +19125,7 @@ function genRuntimeProps(ctx) {
     return modelsDecls || propsDecls;
   }
 }
-function genRuntimePropsFromTypes(ctx) {
+function extractRuntimeProps(ctx) {
   const props = resolveRuntimePropsFromType(ctx, ctx.propsTypeDecl);
   if (!props.length) {
     return;
@@ -19167,7 +19134,7 @@ function genRuntimePropsFromTypes(ctx) {
   const hasStaticDefaults = hasStaticWithDefaults(ctx);
   for (const prop of props) {
     propStrings.push(genRuntimePropFromType(ctx, prop, hasStaticDefaults));
-    if (!(prop.key in ctx.bindingMetadata)) {
+    if ("bindingMetadata" in ctx && !(prop.key in ctx.bindingMetadata)) {
       ctx.bindingMetadata[prop.key] = "props";
     }
   }
@@ -19292,7 +19259,7 @@ function inferValueType(node) {
 }
 
 function processPropsDestructure(ctx, declId) {
-  if (!ctx.options.propsDestructure && !ctx.options.reactivityTransform) {
+  if (!ctx.options.propsDestructure) {
     return;
   }
   warnOnce(
@@ -19340,7 +19307,7 @@ To stay updated, follow the RFC at https://github.com/vuejs/rfcs/discussions/502
   }
 }
 function transformDestructuredProps(ctx, vueImportAliases) {
-  if (!ctx.options.propsDestructure && !ctx.options.reactivityTransform) {
+  if (!ctx.options.propsDestructure) {
     return;
   }
   const rootScope = {};
@@ -19691,8 +19658,6 @@ Upgrade your vite or vue-loader version for compatibility with the latest experi
   const scopeId = options.id ? options.id.replace(/^data-v-/, "") : "";
   const scriptLang = script && script.lang;
   const scriptSetupLang = scriptSetup && scriptSetup.lang;
-  const enableReactivityTransform = !!options.reactivityTransform;
-  let refBindings;
   if (!scriptSetup) {
     if (!script) {
       throw new Error(`[@vue/compiler-sfc] SFC contains no <script> tags.`);
@@ -19906,17 +19871,6 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
         );
       }
     }
-    if (enableReactivityTransform && reactivityTransform.shouldTransform(script.content)) {
-      const { rootRefs, importedHelpers } = reactivityTransform.transformAST(
-        scriptAst,
-        ctx.s,
-        scriptStartOffset
-      );
-      refBindings = rootRefs;
-      for (const h of importedHelpers) {
-        ctx.helperImports.add(h);
-      }
-    }
     if (scriptStartOffset > startOffset) {
       if (!/\n$/.test(script.content.trim())) {
         ctx.s.appendLeft(scriptEndOffset, `
@@ -20044,19 +19998,6 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
   if (ctx.propsDestructureDecl) {
     transformDestructuredProps(ctx, vueImportAliases);
   }
-  if (enableReactivityTransform && // normal <script> had ref bindings that maybe used in <script setup>
-  (refBindings || reactivityTransform.shouldTransform(scriptSetup.content))) {
-    const { rootRefs, importedHelpers } = reactivityTransform.transformAST(
-      scriptSetupAst,
-      ctx.s,
-      startOffset,
-      refBindings
-    );
-    refBindings = refBindings ? [...refBindings, ...rootRefs] : rootRefs;
-    for (const h of importedHelpers) {
-      ctx.helperImports.add(h);
-    }
-  }
   checkInvalidScopeReference(ctx.propsRuntimeDecl, DEFINE_PROPS);
   checkInvalidScopeReference(ctx.propsRuntimeDefaults, DEFINE_PROPS);
   checkInvalidScopeReference(ctx.propsDestructureDecl, DEFINE_PROPS);
@@ -20092,11 +20033,6 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
   for (const key in setupBindings) {
     ctx.bindingMetadata[key] = setupBindings[key];
   }
-  if (refBindings) {
-    for (const key of refBindings) {
-      ctx.bindingMetadata[key] = "setup-ref";
-    }
-  }
   if (sfc.cssVars.length && // no need to do this when targeting SSR
   !((_a = options.templateOptions) == null ? void 0 : _a.ssr)) {
     ctx.helperImports.add(CSS_VARS_HELPER);
@@ -20312,7 +20248,6 @@ ${exposeCall}`
 `
     );
   }
-  ctx.s.trim();
   return {
     ...scriptSetup,
     bindings: ctx.bindingMetadata,
@@ -20484,24 +20419,24 @@ function isStaticNode(node) {
   return false;
 }
 
-const version = "3.3.9";
+const version = "3.4.0-alpha.2";
 const parseCache = parseCache$1;
 const walk = estreeWalker.walk;
+const shouldTransformRef = () => false;
 
-exports.babelParse = parser$2.parse;
 exports.extractIdentifiers = compilerCore.extractIdentifiers;
 exports.generateCodeFrame = compilerCore.generateCodeFrame;
 exports.isInDestructureAssignment = compilerCore.isInDestructureAssignment;
 exports.isStaticProperty = compilerCore.isStaticProperty;
 exports.walkIdentifiers = compilerCore.walkIdentifiers;
-exports.shouldTransformRef = reactivityTransform.shouldTransform;
-exports.transformRef = reactivityTransform.transform;
-exports.transformRefAST = reactivityTransform.transformAST;
+exports.babelParse = parser$2.parse;
 exports.MagicString = MagicString;
 exports.compileScript = compileScript;
 exports.compileStyle = compileStyle;
 exports.compileStyleAsync = compileStyleAsync;
 exports.compileTemplate = compileTemplate;
+exports.extractRuntimeEmits = extractRuntimeEmits;
+exports.extractRuntimeProps = extractRuntimeProps;
 exports.inferRuntimeType = inferRuntimeType;
 exports.invalidateTypeCache = invalidateTypeCache;
 exports.parse = parse$2;
@@ -20510,5 +20445,6 @@ exports.registerTS = registerTS;
 exports.resolveTypeElements = resolveTypeElements;
 exports.rewriteDefault = rewriteDefault;
 exports.rewriteDefaultAST = rewriteDefaultAST;
+exports.shouldTransformRef = shouldTransformRef;
 exports.version = version;
 exports.walk = walk;

package/dist/compiler-sfc.d.ts

@@ -1,6 +1,6 @@
 import * as _babel_types from '@babel/types';
 import { Statement, Expression, TSType, Program, CallExpression, Node, ObjectPattern, TSModuleDeclaration, TSPropertySignature, TSMethodSignature, TSCallSignatureDeclaration, TSFunctionType } from '@babel/types';
-import { CompilerOptions, CodegenResult, ParserOptions, RootNode, CompilerError, SourceLocation, ElementNode, BindingMetadata as BindingMetadata$1 } from '@vue/compiler-core';
+import { RootNode, CompilerOptions, CodegenResult, ParserOptions, CompilerError, SourceLocation, BindingMetadata as BindingMetadata$1 } from '@vue/compiler-core';
 export { BindingMetadata, CompilerError, CompilerOptions, extractIdentifiers, generateCodeFrame, isInDestructureAssignment, isStaticProperty, walkIdentifiers } from '@vue/compiler-core';
 import { RawSourceMap } from 'source-map-js';
 import { ParserPlugin } from '@babel/parser';
@@ -9,7 +9,6 @@ import { Result, LazyResult } from 'postcss';
 import MagicString from 'magic-string';
 export { default as MagicString } from 'magic-string';
 import TS from 'typescript';
-export { shouldTransform as shouldTransformRef, transform as transformRef, transformAST as transformRefAST } from '@vue/reactivity-transform';
 
 export interface AssetURLTagConfig {
     [name: string]: string[];
@@ -28,7 +27,7 @@ export interface AssetURLOptions {
 }
 
 export interface TemplateCompiler {
-    compile(template: string, options: CompilerOptions): CodegenResult;
+    compile(source: string | RootNode, options: CompilerOptions): CodegenResult;
     parse(template: string, options: ParserOptions): RootNode;
 }
 export interface SFCTemplateCompileResults {
@@ -42,6 +41,7 @@ export interface SFCTemplateCompileResults {
 }
 export interface SFCTemplateCompileOptions {
     source: string;
+    ast?: RootNode;
     filename: string;
     id: string;
     scoped?: boolean;
@@ -136,14 +136,6 @@ export interface SFCScriptCompileOptions {
         fileExists(file: string): boolean;
         readFile(file: string): string | undefined;
     };
-    /**
-     * (Experimental) Enable syntax transform for using refs without `.value` and
-     * using destructured props with reactivity
-     * @deprecated the Reactivity Transform proposal has been dropped. This
-     * feature will be removed from Vue core in 3.4. If you intend to continue
-     * using it, disable this and switch to the [Vue Macros implementation](https://vue-macros.sxzz.moe/features/reactivity-transform.html).
-     */
-    reactivityTransform?: boolean;
 }
 interface ImportBinding {
     isType: boolean;
@@ -179,7 +171,7 @@ export interface SFCBlock {
 }
 export interface SFCTemplateBlock extends SFCBlock {
     type: 'template';
-    ast: ElementNode;
+    ast?: RootNode;
 }
 export interface SFCScriptBlock extends SFCBlock {
     type: 'script';
@@ -291,6 +283,7 @@ type PropsDestructureBindings = Record<string, // public prop key
     local: string;
     default?: Expression;
 }>;
+export declare function extractRuntimeProps(ctx: TypeResolveContext): string | undefined;
 
 interface ModelDecl {
     type: TSType | undefined;
@@ -402,6 +395,7 @@ export declare class ScriptCompileContext {
     error(msg: string, node: Node, scope?: TypeScope): never;
 }
 
+export type SimpleTypeResolveOptions = Partial<Pick<SFCScriptCompileOptions, 'globalTypeFiles' | 'fs' | 'babelParserPlugins' | 'isProd'>>;
 /**
  * TypeResolveContext is compatible with ScriptCompileContext
  * but also allows a simpler version of it with minimal required properties
@@ -417,8 +411,9 @@ export declare class ScriptCompileContext {
  * }
  * ```
  */
-export type SimpleTypeResolveContext = Pick<ScriptCompileContext, 'source' | 'filename' | 'error' | 'options'> & Partial<Pick<ScriptCompileContext, 'scope' | 'globalScopes' | 'deps' | 'fs'>> & {
+export type SimpleTypeResolveContext = Pick<ScriptCompileContext, 'source' | 'filename' | 'error' | 'helper' | 'getString' | 'propsTypeDecl' | 'propsRuntimeDefaults' | 'propsDestructuredBindings' | 'emitsTypeDecl'> & Partial<Pick<ScriptCompileContext, 'scope' | 'globalScopes' | 'deps' | 'fs'>> & {
     ast: Statement[];
+    options: SimpleTypeResolveOptions;
 };
 export type TypeResolveContext = ScriptCompileContext | SimpleTypeResolveContext;
 type Import = Pick<ImportBinding, 'source' | 'imported'>;
@@ -466,9 +461,18 @@ export declare function registerTS(_loadTS: () => typeof TS): void;
 export declare function invalidateTypeCache(filename: string): void;
 export declare function inferRuntimeType(ctx: TypeResolveContext, node: Node & MaybeWithScope, scope?: TypeScope): string[];
 
+export declare function extractRuntimeEmits(ctx: TypeResolveContext): Set<string>;
+
 export declare const version: string;
 
 export declare const parseCache: Map<string, SFCParseResult>;
 
 export declare const walk: any;
 
+/**
+ * @deprecated this is preserved to avoid breaking vite-plugin-vue < 5.0
+ * with reactivityTransform: true. The desired behavior should be silently
+ * ignoring the option instead of breaking.
+ */
+export declare const shouldTransformRef: () => boolean;
+