@vue/compiler-sfc 3.3.1 → 3.3.3

package/dist/compiler-sfc.cjs.js

@@ -4,9 +4,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 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 path$3 = require('path');
 var compilerCore = require('@vue/compiler-core');
 var url = require('url');
 var CompilerSSR = require('@vue/compiler-ssr');
@@ -18,19 +18,80 @@ var reactivityTransform = require('@vue/reactivity-transform');
 var MagicString = require('magic-string');
 
 function _interopNamespaceDefault(e) {
-	var n = Object.create(null);
-	if (e) {
-		for (var k in e) {
-			n[k] = e[k];
-		}
-	}
-	n.default = e;
-	return Object.freeze(n);
+  var n = Object.create(null);
+  if (e) {
+    for (var k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
 }
 
 var CompilerDOM__namespace = /*#__PURE__*/_interopNamespaceDefault(CompilerDOM);
 var CompilerSSR__namespace = /*#__PURE__*/_interopNamespaceDefault(CompilerSSR);
 
+const UNKNOWN_TYPE = "Unknown";
+function resolveObjectKey(node, computed) {
+  switch (node.type) {
+    case "StringLiteral":
+    case "NumericLiteral":
+      return String(node.value);
+    case "Identifier":
+      if (!computed)
+        return node.name;
+  }
+  return void 0;
+}
+function concatStrings(strs) {
+  return strs.filter((s) => !!s).join(", ");
+}
+function isLiteralNode(node) {
+  return node.type.endsWith("Literal");
+}
+function unwrapTSNode(node) {
+  if (CompilerDOM.TS_NODE_TYPES.includes(node.type)) {
+    return unwrapTSNode(node.expression);
+  } else {
+    return node;
+  }
+}
+function isCallOf(node, test) {
+  return !!(node && test && node.type === "CallExpression" && node.callee.type === "Identifier" && (typeof test === "string" ? node.callee.name === test : test(node.callee.name)));
+}
+function toRuntimeTypeString(types) {
+  return types.length > 1 ? `[${types.join(", ")}]` : types[0];
+}
+function getImportedName(specifier) {
+  if (specifier.type === "ImportSpecifier")
+    return specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+  else if (specifier.type === "ImportNamespaceSpecifier")
+    return "*";
+  return "default";
+}
+function getId(node) {
+  return node.type === "Identifier" ? node.name : node.type === "StringLiteral" ? node.value : null;
+}
+const identity = (str) => str;
+const fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g;
+const toLowerCase = (str) => str.toLowerCase();
+function toFileNameLowerCase(x) {
+  return fileNameLowerCaseRegExp.test(x) ? x.replace(fileNameLowerCaseRegExp, toLowerCase) : x;
+}
+function createGetCanonicalFileName(useCaseSensitiveFileNames) {
+  return useCaseSensitiveFileNames ? identity : toFileNameLowerCase;
+}
+const normalize = (path$3.posix || path$3).normalize;
+const windowsSlashRE = /\\/g;
+function normalizePath(p) {
+  return normalize(p.replace(windowsSlashRE, "/"));
+}
+const joinPaths = (path$3.posix || path$3).join;
+const escapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
+function getEscapedKey(key) {
+  return escapeSymbolsRE.test(key) ? JSON.stringify(key) : key;
+}
+
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
@@ -119,10 +180,7 @@ function genVarName(id, raw, isProd) {
   if (isProd) {
     return hash$1(id + raw);
   } else {
-    return `${id}-${raw.replace(
-      /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g,
-      (s) => `\\${s}`
-    )}`;
+    return `${id}-${raw.replace(escapeSymbolsRE, (s) => `\\${s}`)}`;
   }
 }
 function normalizeExpression(exp) {
@@ -1084,7 +1142,8 @@ function processExp(exp, dir) {
     } else if (dir === "for") {
       const inMatch = exp.match(forAliasRE);
       if (inMatch) {
-        const [, LHS, RHS] = inMatch;
+        let [, LHS, RHS] = inMatch;
+        LHS = LHS.trim().replace(/^\(|\)$/g, "");
         return processExp(`(${LHS})=>{}`) + processExp(RHS);
       }
     }
@@ -15484,63 +15543,6 @@ function preprocess(options, preprocessor) {
   );
 }
 
-const UNKNOWN_TYPE = "Unknown";
-function resolveObjectKey(node, computed) {
-  switch (node.type) {
-    case "StringLiteral":
-    case "NumericLiteral":
-      return String(node.value);
-    case "Identifier":
-      if (!computed)
-        return node.name;
-  }
-  return void 0;
-}
-function concatStrings(strs) {
-  return strs.filter((s) => !!s).join(", ");
-}
-function isLiteralNode(node) {
-  return node.type.endsWith("Literal");
-}
-function unwrapTSNode(node) {
-  if (CompilerDOM.TS_NODE_TYPES.includes(node.type)) {
-    return unwrapTSNode(node.expression);
-  } else {
-    return node;
-  }
-}
-function isCallOf(node, test) {
-  return !!(node && test && node.type === "CallExpression" && node.callee.type === "Identifier" && (typeof test === "string" ? node.callee.name === test : test(node.callee.name)));
-}
-function toRuntimeTypeString(types) {
-  return types.length > 1 ? `[${types.join(", ")}]` : types[0];
-}
-function getImportedName(specifier) {
-  if (specifier.type === "ImportSpecifier")
-    return specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
-  else if (specifier.type === "ImportNamespaceSpecifier")
-    return "*";
-  return "default";
-}
-function getId(node) {
-  return node.type === "Identifier" ? node.name : node.type === "StringLiteral" ? node.value : null;
-}
-const identity = (str) => str;
-const fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g;
-const toLowerCase = (str) => str.toLowerCase();
-function toFileNameLowerCase(x) {
-  return fileNameLowerCaseRegExp.test(x) ? x.replace(fileNameLowerCaseRegExp, toLowerCase) : x;
-}
-function createGetCanonicalFileName(useCaseSensitiveFileNames) {
-  return useCaseSensitiveFileNames ? identity : toFileNameLowerCase;
-}
-const normalize = (path$3.posix || path$3).normalize;
-const windowsSlashRE = /\\/g;
-function normalizePath(p) {
-  return normalize(p.replace(windowsSlashRE, "/"));
-}
-const joinPaths = (path$3.posix || path$3).join;
-
 function analyzeScriptBindings(ast) {
   for (const node of ast) {
     if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "ObjectExpression") {
@@ -15848,7 +15850,7 @@ ${shared.generateCodeFrame(
     );
   }
 }
-function resolveParserPlugins(lang, userPlugins) {
+function resolveParserPlugins(lang, userPlugins, dts = false) {
   const plugins = [];
   if (lang === "jsx" || lang === "tsx") {
     plugins.push("jsx");
@@ -15856,7 +15858,7 @@ function resolveParserPlugins(lang, userPlugins) {
     userPlugins = userPlugins.filter((p) => p !== "jsx");
   }
   if (lang === "ts" || lang === "tsx") {
-    plugins.push("typescript");
+    plugins.push(["typescript", { dts }]);
     if (!plugins.includes("decorators")) {
       plugins.push("decorators-legacy");
     }
@@ -18065,11 +18067,26 @@ function resolveInterfaceMembers(ctx, node, scope) {
   const base = typeElementsToMap(ctx, node.body.body, node._ownerScope);
   if (node.extends) {
     for (const ext of node.extends) {
-      const { props } = resolveTypeElements(ctx, ext, scope);
-      for (const key in props) {
-        if (!shared.hasOwn(base.props, key)) {
-          base.props[key] = props[key];
+      if (ext.leadingComments && ext.leadingComments.some((c) => c.value.includes("@vue-ignore"))) {
+        continue;
+      }
+      try {
+        const { props } = resolveTypeElements(ctx, ext, scope);
+        for (const key in props) {
+          if (!shared.hasOwn(base.props, key)) {
+            base.props[key] = props[key];
+          }
         }
+      } catch (e) {
+        ctx.error(
+          `Failed to resolve extends base type.
+If this previously worked in 3.2, you can instruct the compiler to ignore this extend by adding /* @vue-ignore */ before it, for example:
+
+interface Props extends /* @vue-ignore */ Base {}
+
+Note: both in 3.2 or with the ignore, the properties in the base type are treated as fallthrough attrs at runtime.`,
+          ext
+        );
       }
     }
   }
@@ -18335,7 +18352,7 @@ function qualifiedNameToPath(node) {
 }
 function resolveGlobalScope(ctx) {
   if (ctx.options.globalTypeFiles) {
-    const fs = ctx.options.fs || (ts == null ? void 0 : ts.sys);
+    const fs = resolveFS(ctx);
     if (!fs) {
       throw new Error("[vue/compiler-sfc] globalTypeFiles requires fs access.");
     }
@@ -18348,15 +18365,38 @@ let ts;
 function registerTS(_ts) {
   ts = _ts;
 }
+function resolveFS(ctx) {
+  if (ctx.fs) {
+    return ctx.fs;
+  }
+  const fs = ctx.options.fs || ts.sys;
+  if (!fs) {
+    return;
+  }
+  return ctx.fs = {
+    fileExists(file) {
+      if (file.endsWith(".vue.ts")) {
+        file = file.replace(/\.ts$/, "");
+      }
+      return fs.fileExists(file);
+    },
+    readFile(file) {
+      if (file.endsWith(".vue.ts")) {
+        file = file.replace(/\.ts$/, "");
+      }
+      return fs.readFile(file);
+    }
+  };
+}
 function resolveTypeFromImport(ctx, node, name, scope) {
   const { source, imported } = scope.imports[name];
   const sourceScope = importSourceToScope(ctx, node, scope, source);
   return resolveTypeReference(ctx, node, sourceScope, imported, true);
 }
 function importSourceToScope(ctx, node, scope, source) {
-  const fs = ctx.options.fs || (ts == null ? void 0 : ts.sys);
+  const fs = resolveFS(ctx);
   if (!fs) {
-    ctx.error(
+    return ctx.error(
       `No fs option provided to \`compileScript\` in non-Node environment. File system access is required for resolving imported types.`,
       node,
       scope
@@ -18393,6 +18433,7 @@ function importSourceToScope(ctx, node, scope, source) {
   }
 }
 function resolveExt(filename, fs) {
+  filename = filename.replace(/\.js$/, "");
   const tryResolve = (filename2) => {
     if (fs.fileExists(filename2))
       return filename2;
@@ -18455,7 +18496,11 @@ function resolveWithTS(containingFile, source, fs) {
     tsResolveCache
   );
   if (res.resolvedModule) {
-    return res.resolvedModule.resolvedFileName;
+    let filename = res.resolvedModule.resolvedFileName;
+    if (filename.endsWith(".vue.ts")) {
+      filename = filename.replace(/\.ts$/, "");
+    }
+    return filename;
   }
 }
 function loadTSConfig(configPath, fs) {
@@ -18490,7 +18535,7 @@ function fileToScope(ctx, filename, asGlobal = false) {
   if (cached) {
     return cached;
   }
-  const fs = ctx.options.fs || (ts == null ? void 0 : ts.sys);
+  const fs = resolveFS(ctx);
   const source = fs.readFile(filename) || "";
   const body = parseFile(filename, source, ctx.options.babelParserPlugins);
   const scope = new TypeScope(filename, source, 0, recordImports(body));
@@ -18502,7 +18547,11 @@ function parseFile(filename, content, parserPlugins) {
   const ext = path$3.extname(filename);
   if (ext === ".ts" || ext === ".tsx") {
     return parser$2.parse(content, {
-      plugins: resolveParserPlugins(ext.slice(1), parserPlugins),
+      plugins: resolveParserPlugins(
+        ext.slice(1),
+        parserPlugins,
+        filename.endsWith(".d.ts")
+      ),
       sourceType: "module"
     }).program.body;
   } else if (ext === ".vue") {
@@ -19017,6 +19066,20 @@ function resolveReturnType(ctx, arg, scope) {
     return resolved.returnType;
   }
 }
+function resolveUnionType(ctx, node, scope) {
+  if (node.type === "TSTypeReference") {
+    const resolved = resolveTypeReference(ctx, node, scope);
+    if (resolved)
+      node = resolved;
+  }
+  let types;
+  if (node.type === "TSUnionType") {
+    types = node.types.flatMap((node2) => resolveUnionType(ctx, node2, scope));
+  } else {
+    types = [node];
+  }
+  return types;
+}
 
 const DEFINE_MODEL = "defineModel";
 function processDefineModel(ctx, node, declId) {
@@ -19185,9 +19248,10 @@ function genRuntimeProps(ctx) {
       const defaults = [];
       for (const key in ctx.propsDestructuredBindings) {
         const d = genDestructuredDefaultValue(ctx, key);
+        const finalKey = getEscapedKey(key);
         if (d)
           defaults.push(
-            `${key}: ${d.valueString}${d.needSkipFactory ? `, __skip_${key}: true` : ``}`
+            `${finalKey}: ${d.valueString}${d.needSkipFactory ? `, __skip_${finalKey}: true` : ``}`
           );
       }
       if (defaults.length) {
@@ -19276,8 +19340,9 @@ function genRuntimePropFromType(ctx, { key, required, type, skipCheck }, hasStat
       }
     }
   }
+  const finalKey = getEscapedKey(key);
   if (!ctx.options.isProd) {
-    return `${key}: { ${concatStrings([
+    return `${finalKey}: { ${concatStrings([
       `type: ${toRuntimeTypeString(type)}`,
       `required: ${required}`,
       skipCheck && "skipCheck: true",
@@ -19286,12 +19351,12 @@ function genRuntimePropFromType(ctx, { key, required, type, skipCheck }, hasStat
   } else if (type.some(
     (el) => el === "Boolean" || (!hasStaticDefaults || defaultString) && el === "Function"
   )) {
-    return `${key}: { ${concatStrings([
+    return `${finalKey}: { ${concatStrings([
       `type: ${toRuntimeTypeString(type)}`,
       defaultString
     ])} }`;
   } else {
-    return `${key}: ${defaultString ? `{ ${defaultString} }` : `{}`}`;
+    return `${finalKey}: ${defaultString ? `{ ${defaultString} }` : `{}`}`;
   }
 }
 function hasStaticWithDefaults(ctx) {
@@ -19305,7 +19370,7 @@ function genDestructuredDefaultValue(ctx, key, inferredType) {
   if (defaultVal) {
     const value = ctx.getString(defaultVal);
     const unwrapped = unwrapTSNode(defaultVal);
-    if (inferredType && inferredType.length && !inferredType.includes(UNKNOWN_TYPE)) {
+    if (inferredType && inferredType.length && !inferredType.includes("null")) {
       const valueType = inferValueType(unwrapped);
       if (valueType && !inferredType.includes(valueType)) {
         ctx.error(
@@ -19342,6 +19407,7 @@ function inferValueType(node) {
 
 function processPropsDestructure(ctx, declId) {
   if (!ctx.options.propsDestructure && !ctx.options.reactivityTransform) {
+    ctx.propsIdentifier = ctx.getString(declId);
     return;
   }
   warnOnce(
@@ -19573,7 +19639,7 @@ function extractRuntimeEmits(ctx) {
   const emits = /* @__PURE__ */ new Set();
   const node = ctx.emitsTypeDecl;
   if (node.type === "TSFunctionType") {
-    extractEventNames(node.parameters[0], emits);
+    extractEventNames(ctx, node.parameters[0], emits);
     return emits;
   }
   const { props, calls } = resolveTypeElements(ctx, node);
@@ -19590,22 +19656,18 @@ function extractRuntimeEmits(ctx) {
       );
     }
     for (const call of calls) {
-      extractEventNames(call.parameters[0], emits);
+      extractEventNames(ctx, call.parameters[0], emits);
     }
   }
   return emits;
 }
-function extractEventNames(eventName, emits) {
+function extractEventNames(ctx, eventName, emits) {
   if (eventName.type === "Identifier" && eventName.typeAnnotation && eventName.typeAnnotation.type === "TSTypeAnnotation") {
-    const typeNode = eventName.typeAnnotation.typeAnnotation;
-    if (typeNode.type === "TSLiteralType") {
-      if (typeNode.literal.type !== "UnaryExpression" && typeNode.literal.type !== "TemplateLiteral") {
-        emits.add(String(typeNode.literal.value));
-      }
-    } else if (typeNode.type === "TSUnionType") {
-      for (const t of typeNode.types) {
-        if (t.type === "TSLiteralType" && t.literal.type !== "UnaryExpression" && t.literal.type !== "TemplateLiteral") {
-          emits.add(String(t.literal.value));
+    const types = resolveUnionType(ctx, eventName.typeAnnotation.typeAnnotation);
+    for (const type of types) {
+      if (type.type === "TSLiteralType") {
+        if (type.literal.type !== "UnaryExpression" && type.literal.type !== "TemplateLiteral") {
+          emits.add(String(type.literal.value));
         }
       }
     }
@@ -20508,6 +20570,7 @@ function canNeverBeRef(node, userReactiveImport) {
   }
 }
 function isStaticNode(node) {
+  node = unwrapTSNode(node);
   switch (node.type) {
     case "UnaryExpression":
       return isStaticNode(node.argument);
@@ -20521,19 +20584,18 @@ function isStaticNode(node) {
     case "TemplateLiteral":
       return node.expressions.every((expr) => isStaticNode(expr));
     case "ParenthesizedExpression":
-    case "TSNonNullExpression":
-    case "TSAsExpression":
-    case "TSTypeAssertion":
       return isStaticNode(node.expression);
-    default:
-      if (isLiteralNode(node)) {
-        return true;
-      }
-      return false;
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+    case "NullLiteral":
+    case "BigIntLiteral":
+      return true;
   }
+  return false;
 }
 
-const version = "3.3.1";
+const version = "3.3.3";
 const walk = estreeWalker.walk;
 
 exports.babelParse = parser$2.parse;

package/dist/compiler-sfc.d.ts

@@ -394,6 +394,10 @@ export declare class ScriptCompileContext {
      * to be exposed on compiled script block for HMR cache busting
      */
     deps?: Set<string>;
+    /**
+     * cache for resolved fs
+     */
+    fs?: NonNullable<SFCScriptCompileOptions['fs']>;
     constructor(descriptor: SFCDescriptor, options: Partial<SFCScriptCompileOptions>);
     getString(node: Node, scriptSetup?: boolean): string;
     error(msg: string, node: Node, scope?: TypeScope): never;
@@ -414,7 +418,7 @@ export declare class ScriptCompileContext {
  * }
  * ```
  */
-export type SimpleTypeResolveContext = Pick<ScriptCompileContext, 'source' | 'filename' | 'error' | 'options'> & Partial<Pick<ScriptCompileContext, 'scope' | 'globalScopes' | 'deps'>> & {
+export type SimpleTypeResolveContext = Pick<ScriptCompileContext, 'source' | 'filename' | 'error' | 'options'> & Partial<Pick<ScriptCompileContext, 'scope' | 'globalScopes' | 'deps' | 'fs'>> & {
     ast: Statement[];
 };
 export type TypeResolveContext = ScriptCompileContext | SimpleTypeResolveContext;