@vue/compiler-sfc 3.5.26 → 3.5.28

package/dist/compiler-sfc.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.26
+* @vue/compiler-sfc v3.5.28
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -7158,7 +7158,7 @@ function requireParser$2 () {
 		      if (_space2.endsWith(' ') && _rawSpace2.endsWith(' ')) {
 		        spaces.before = _space2.slice(0, _space2.length - 1);
 		        raws.spaces.before = _rawSpace2.slice(0, _rawSpace2.length - 1);
-		      } else if (_space2.startsWith(' ') && _rawSpace2.startsWith(' ')) {
+		      } else if (_space2[0] === ' ' && _rawSpace2[0] === ' ') {
 		        spaces.after = _space2.slice(1);
 		        raws.spaces.after = _rawSpace2.slice(1);
 		      } else {
@@ -19810,7 +19810,7 @@ function resolveParserPlugins(lang, userPlugins, dts = false) {
   } else if (userPlugins) {
     userPlugins = userPlugins.filter((p) => p !== "jsx");
   }
-  if (lang === "ts" || lang === "mts" || lang === "tsx" || lang === "mtsx") {
+  if (lang === "ts" || lang === "mts" || lang === "tsx" || lang === "cts" || lang === "mtsx") {
     plugins.push(["typescript", { dts }], "explicitResourceManagement");
     if (!userPlugins || !userPlugins.includes("decorators")) {
       plugins.push("decorators-legacy");
@@ -20025,6 +20025,7 @@ const openPattern = /\\{/g;
 const closePattern = /\\}/g;
 const commaPattern = /\\,/g;
 const periodPattern = /\\./g;
+const EXPANSION_MAX = 100_000;
 function numeric(str) {
     return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
 }
@@ -20069,10 +20070,11 @@ function parseCommaParts(str) {
     parts.push.apply(parts, p);
     return parts;
 }
-function expand(str) {
+function expand(str, options = {}) {
     if (!str) {
         return [];
     }
+    const { max = EXPANSION_MAX } = options;
     // I don't know why Bash 4.3 does this, but it does.
     // Anything starting with {} will have the first two bytes preserved
     // but *only* at the top level, so {},a}b will not expand to anything,
@@ -20082,7 +20084,7 @@ function expand(str) {
     if (str.slice(0, 2) === '{}') {
         str = '\\{\\}' + str.slice(2);
     }
-    return expand_(escapeBraces(str), true).map(unescapeBraces);
+    return expand_(escapeBraces(str), max, true).map(unescapeBraces);
 }
 function embrace(str) {
     return '{' + str + '}';
@@ -20096,7 +20098,7 @@ function lte(i, y) {
 function gte(i, y) {
     return i >= y;
 }
-function expand_(str, isTop) {
+function expand_(str, max, isTop) {
     /** @type {string[]} */
     const expansions = [];
     const m = balanced('{', '}', str);
@@ -20104,9 +20106,9 @@ function expand_(str, isTop) {
         return [str];
     // no need to expand pre, since it is guaranteed to be free of brace-sets
     const pre = m.pre;
-    const post = m.post.length ? expand_(m.post, false) : [''];
+    const post = m.post.length ? expand_(m.post, max, false) : [''];
     if (/\$$/.test(m.pre)) {
-        for (let k = 0; k < post.length; k++) {
+        for (let k = 0; k < post.length && k < max; k++) {
             const expansion = pre + '{' + m.body + '}' + post[k];
             expansions.push(expansion);
         }
@@ -20120,7 +20122,7 @@ function expand_(str, isTop) {
             // {a},b}
             if (m.post.match(/,(?!,).*\}/)) {
                 str = m.pre + '{' + m.body + escClose + m.post;
-                return expand_(str);
+                return expand_(str, max, true);
             }
             return [str];
         }
@@ -20132,7 +20134,7 @@ function expand_(str, isTop) {
             n = parseCommaParts(m.body);
             if (n.length === 1 && n[0] !== undefined) {
                 // x{{a,b}}y ==> x{a}y x{b}y
-                n = expand_(n[0], false).map(embrace);
+                n = expand_(n[0], max, false).map(embrace);
                 //XXX is this necessary? Can't seem to hit it in tests.
                 /* c8 ignore start */
                 if (n.length === 1) {
@@ -20186,11 +20188,11 @@ function expand_(str, isTop) {
         else {
             N = [];
             for (let j = 0; j < n.length; j++) {
-                N.push.apply(N, expand_(n[j], false));
+                N.push.apply(N, expand_(n[j], max, false));
             }
         }
         for (let j = 0; j < N.length; j++) {
-            for (let k = 0; k < post.length; k++) {
+            for (let k = 0; k < post.length && expansions.length < max; k++) {
                 const expansion = pre + N[j] + post[k];
                 if (!isTop || isSequence || expansion) {
                     expansions.push(expansion);
@@ -22263,16 +22265,18 @@ function resolveInterfaceMembers(ctx, node, scope, typeParameters) {
           (base.calls || (base.calls = [])).push(...calls);
         }
       } catch (e) {
-        ctx.error(
-          `Failed to resolve extends base type.
+        if (!ctx.silentOnExtendsFailure) {
+          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,
-          scope
-        );
+            ext,
+            scope
+          );
+        }
       }
     }
   }
@@ -22681,11 +22685,21 @@ function importSourceToScope(ctx, node, scope, source) {
   }
 }
 function resolveExt(filename, fs) {
-  filename = filename.replace(/\.js$/, "");
+  let moduleType = "u";
+  if (filename.endsWith(".mjs")) {
+    moduleType = "m";
+  } else if (filename.endsWith(".cjs")) {
+    moduleType = "c";
+  }
+  filename = filename.replace(/\.[cm]?jsx?$/, "");
   const tryResolve = (filename2) => {
     if (fs.fileExists(filename2)) return filename2;
   };
-  return tryResolve(filename) || tryResolve(filename + `.ts`) || tryResolve(filename + `.tsx`) || tryResolve(filename + `.d.ts`) || tryResolve(joinPaths(filename, `index.ts`)) || tryResolve(joinPaths(filename, `index.tsx`)) || tryResolve(joinPaths(filename, `index.d.ts`));
+  const resolveTs = () => tryResolve(filename + `.ts`) || tryResolve(filename + `.tsx`) || tryResolve(filename + `.d.ts`);
+  const resolveMts = () => tryResolve(filename + `.mts`) || tryResolve(filename + `.d.mts`);
+  const resolveCts = () => tryResolve(filename + `.cts`) || tryResolve(filename + `.d.cts`);
+  return tryResolve(filename) || // For explicit .mjs/.cjs imports, prefer .mts/.cts declarations first.
+  (moduleType === "m" ? resolveMts() || resolveTs() : moduleType === "c" ? resolveCts() || resolveTs() : resolveTs() || resolveMts() || resolveCts()) || tryResolve(joinPaths(filename, `index.ts`)) || tryResolve(joinPaths(filename, `index.tsx`)) || tryResolve(joinPaths(filename, `index.d.ts`));
 }
 const tsConfigCache = createCache();
 const tsConfigRefMap = /* @__PURE__ */ new Map();
@@ -22801,12 +22815,12 @@ function fileToScope(ctx, filename, asGlobal = false) {
 }
 function parseFile(filename, content, fs, parserPlugins) {
   const ext = path$1.extname(filename);
-  if (ext === ".ts" || ext === ".mts" || ext === ".tsx" || ext === ".mtsx") {
+  if (ext === ".ts" || ext === ".mts" || ext === ".tsx" || ext === ".cts" || ext === ".mtsx") {
     return parser$2.parse(content, {
       plugins: resolveParserPlugins(
         ext.slice(1),
         parserPlugins,
-        /\.d\.m?ts$/.test(filename)
+        /\.d\.[cm]?ts$/.test(filename)
       ),
       sourceType: "module"
     }).program.body;
@@ -22972,6 +22986,17 @@ function recordType(node, types, declares, overwriteId) {
     case "TSInterfaceDeclaration":
     case "TSEnumDeclaration":
     case "TSModuleDeclaration": {
+      if (node.type === "TSModuleDeclaration" && node.global) {
+        const body = node.body;
+        for (const s of body.body) {
+          if (s.type === "ExportNamedDeclaration" && s.declaration) {
+            recordType(s.declaration, types, declares);
+          } else {
+            recordType(s, types, declares);
+          }
+        }
+        break;
+      }
       const id = overwriteId || getId(node.id);
       let existing = types[id];
       if (existing) {
@@ -23076,6 +23101,8 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
   if (node.leadingComments && node.leadingComments.some((c) => c.value.includes("@vue-ignore"))) {
     return [UNKNOWN_TYPE];
   }
+  const prevSilent = ctx.silentOnExtendsFailure;
+  ctx.silentOnExtendsFailure = true;
   try {
     switch (node.type) {
       case "TSStringKeyword":
@@ -23380,18 +23407,32 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
       }
     }
   } catch (e) {
+  } finally {
+    ctx.silentOnExtendsFailure = prevSilent;
   }
   return [UNKNOWN_TYPE];
 }
 function flattenTypes(ctx, types, scope, isKeyOf = false, typeParameters = void 0) {
   if (types.length === 1) {
-    return inferRuntimeType(ctx, types[0], scope, isKeyOf, typeParameters);
+    return inferRuntimeType(
+      ctx,
+      types[0],
+      types[0]._ownerScope || scope,
+      isKeyOf,
+      typeParameters
+    );
   }
   return [
     ...new Set(
       [].concat(
         ...types.map(
-          (t) => inferRuntimeType(ctx, t, scope, isKeyOf, typeParameters)
+          (t) => inferRuntimeType(
+            ctx,
+            t,
+            t._ownerScope || scope,
+            isKeyOf,
+            typeParameters
+          )
         )
       )
     )
@@ -23792,7 +23833,13 @@ function genRuntimePropFromType(ctx, { key, required, type, skipCheck }, hasStat
       if (prop.type === "ObjectProperty") {
         defaultString = `default: ${ctx.getString(prop.value)}`;
       } else {
-        defaultString = `${prop.async ? "async " : ""}${prop.kind !== "method" ? `${prop.kind} ` : ""}default() ${ctx.getString(prop.body)}`;
+        let paramsString = "";
+        if (prop.params.length) {
+          const start = prop.params[0].start;
+          const end = prop.params[prop.params.length - 1].end;
+          paramsString = ctx.getString({ start, end });
+        }
+        defaultString = `${prop.async ? "async " : ""}${prop.kind !== "method" ? `${prop.kind} ` : ""}default(${paramsString}) ${ctx.getString(prop.body)}`;
       }
     }
   }
@@ -23956,8 +24003,6 @@ function transformDestructuredProps(ctx, vueImportAliases) {
       } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
         if (stmt.declare || !stmt.id) continue;
         registerLocalBinding(stmt.id);
-      } else if ((stmt.type === "ForOfStatement" || stmt.type === "ForInStatement") && stmt.left.type === "VariableDeclaration") {
-        walkVariableDeclaration(stmt.left);
       } else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration && stmt.declaration.type === "VariableDeclaration") {
         walkVariableDeclaration(stmt.declaration, isRoot);
       } else if (stmt.type === "LabeledStatement" && stmt.body.type === "VariableDeclaration") {
@@ -24036,6 +24081,17 @@ function transformDestructuredProps(ctx, vueImportAliases) {
         walkScope(node.body);
         return;
       }
+      if (node.type === "ForOfStatement" || node.type === "ForInStatement" || node.type === "ForStatement") {
+        pushScope();
+        const varDecl = node.type === "ForStatement" ? node.init : node.left;
+        if (varDecl && varDecl.type === "VariableDeclaration") {
+          walkVariableDeclaration(varDecl);
+        }
+        if (node.body.type === "BlockStatement") {
+          walkScope(node.body);
+        }
+        return;
+      }
       if (node.type === "BlockStatement" && !CompilerDOM.isFunctionType(parent)) {
         pushScope();
         walkScope(node);
@@ -24051,7 +24107,7 @@ function transformDestructuredProps(ctx, vueImportAliases) {
     },
     leave(node, parent) {
       parent && parentStack.pop();
-      if (node.type === "BlockStatement" && !CompilerDOM.isFunctionType(parent) || CompilerDOM.isFunctionType(node) || node.type === "CatchClause") {
+      if (node.type === "BlockStatement" && !CompilerDOM.isFunctionType(parent) || CompilerDOM.isFunctionType(node) || node.type === "CatchClause" || node.type === "ForOfStatement" || node.type === "ForInStatement" || node.type === "ForStatement") {
         popScope();
       }
     }
@@ -25143,7 +25199,7 @@ function mergeSourceMaps(scriptMap, templateMap, templateLineOffset) {
   return generator.toJSON();
 }
 
-const version = "3.5.26";
+const version = "3.5.28";
 const parseCache = parseCache$1;
 const errorMessages = {
   ...CompilerDOM.errorMessages,

package/dist/compiler-sfc.d.ts

@@ -415,11 +415,13 @@ export type SimpleTypeResolveOptions = Partial<Pick<SFCScriptCompileOptions, 'gl
  * }
  * ```
  */
-export type SimpleTypeResolveContext = Pick<ScriptCompileContext, 'source' | 'filename' | 'error' | 'helper' | 'getString' | 'propsTypeDecl' | 'propsRuntimeDefaults' | 'propsDestructuredBindings' | 'emitsTypeDecl' | 'isCE'> & Partial<Pick<ScriptCompileContext, 'scope' | 'globalScopes' | 'deps' | 'fs'>> & {
+export type SimpleTypeResolveContext = Pick<ScriptCompileContext, 'source' | 'filename' | 'error' | 'warn' | 'helper' | 'getString' | 'propsTypeDecl' | 'propsRuntimeDefaults' | 'propsDestructuredBindings' | 'emitsTypeDecl' | 'isCE'> & Partial<Pick<ScriptCompileContext, 'scope' | 'globalScopes' | 'deps' | 'fs'>> & {
     ast: Statement[];
     options: SimpleTypeResolveOptions;
 };
-export type TypeResolveContext = ScriptCompileContext | SimpleTypeResolveContext;
+export type TypeResolveContext = (ScriptCompileContext | SimpleTypeResolveContext) & {
+    silentOnExtendsFailure?: boolean;
+};
 type Import = Pick<ImportBinding, 'source' | 'imported'>;
 interface WithScope {
     _ownerScope: TypeScope;