@vue/compiler-sfc 3.5.17 → 3.5.19

package/dist/compiler-sfc.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.17
+* @vue/compiler-sfc v3.5.19
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -127,7 +127,14 @@ const CSS_VARS_HELPER = `useCssVars`;
 function genCssVarsFromList(vars, id, isProd, isSSR = false) {
   return `{
   ${vars.map(
-    (key) => `"${isSSR ? `--` : ``}${genVarName(id, key, isProd, isSSR)}": (${key})`
+    (key) => (
+      // The `:` prefix here is used in `ssrRenderStyle` to distinguish whether
+      // a custom property comes from `ssrCssVars`. If it does, we need to reset
+      // its value to `initial` on the component instance to avoid unintentionally
+      // inheriting the same property value from a different instance of the same
+      // component in the outer scope.
+      `"${isSSR ? `:--` : ``}${genVarName(id, key, isProd, isSSR)}": (${key})`
+    )
   ).join(",\n  ")}
 }`;
 }
@@ -2213,7 +2220,7 @@ const transformSrcset = (node, context, options = defaultAssetUrlOptions) => {
             }
           }
           const shouldProcessUrl = (url) => {
-            return !isExternalUrl(url) && !isDataUrl(url) && (options.includeAbsolute || isRelativeUrl(url));
+            return url && !isExternalUrl(url) && !isDataUrl(url) && (options.includeAbsolute || isRelativeUrl(url));
           };
           if (!imageCandidates.some(({ url }) => shouldProcessUrl(url))) {
             return;
@@ -7980,6 +7987,7 @@ var selectorParser = /*@__PURE__*/getDefaultExportFromCjs(distExports);
 
 const animationNameRE = /^(-\w+-)?animation-name$/;
 const animationRE = /^(-\w+-)?animation$/;
+const keyframesRE = /^(?:-\w+-)?keyframes$/;
 const scopedPlugin = (id = "") => {
   const keyframes = /* @__PURE__ */ Object.create(null);
   const shortId = id.replace(/^data-v-/, "");
@@ -7989,7 +7997,7 @@ const scopedPlugin = (id = "") => {
       processRule(id, rule);
     },
     AtRule(node) {
-      if (/-?keyframes$/.test(node.name) && !node.params.endsWith(`-${shortId}`)) {
+      if (keyframesRE.test(node.name) && !node.params.endsWith(`-${shortId}`)) {
         keyframes[node.params] = node.params = node.params + "-" + shortId;
       }
     },
@@ -8018,7 +8026,7 @@ const scopedPlugin = (id = "") => {
 };
 const processedRules = /* @__PURE__ */ new WeakSet();
 function processRule(id, rule) {
-  if (processedRules.has(rule) || rule.parent && rule.parent.type === "atrule" && /-?keyframes$/.test(rule.parent.name)) {
+  if (processedRules.has(rule) || rule.parent && rule.parent.type === "atrule" && keyframesRE.test(rule.parent.name)) {
     return;
   }
   processedRules.add(rule);
@@ -22998,7 +23006,7 @@ function recordImport(node, imports) {
     };
   }
 }
-function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx), isKeyOf = false) {
+function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx), isKeyOf = false, typeParameters) {
   try {
     switch (node.type) {
       case "TSStringKeyword":
@@ -23071,12 +23079,38 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
       case "TSTypeReference": {
         const resolved = resolveTypeReference(ctx, node, scope);
         if (resolved) {
-          if (resolved.type === "TSTypeAliasDeclaration" && resolved.typeAnnotation.type === "TSFunctionType") {
-            return ["Function"];
+          if (resolved.type === "TSTypeAliasDeclaration") {
+            if (resolved.typeAnnotation.type === "TSFunctionType") {
+              return ["Function"];
+            }
+            if (node.typeParameters) {
+              const typeParams = /* @__PURE__ */ Object.create(null);
+              if (resolved.typeParameters) {
+                resolved.typeParameters.params.forEach((p, i) => {
+                  typeParams[p.name] = node.typeParameters.params[i];
+                });
+              }
+              return inferRuntimeType(
+                ctx,
+                resolved.typeAnnotation,
+                resolved._ownerScope,
+                isKeyOf,
+                typeParams
+              );
+            }
           }
           return inferRuntimeType(ctx, resolved, resolved._ownerScope, isKeyOf);
         }
         if (node.typeName.type === "Identifier") {
+          if (typeParameters && typeParameters[node.typeName.name]) {
+            return inferRuntimeType(
+              ctx,
+              typeParameters[node.typeName.name],
+              scope,
+              isKeyOf,
+              typeParameters
+            );
+          }
           if (isKeyOf) {
             switch (node.typeName.name) {
               case "String":
@@ -23199,11 +23233,15 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
       case "TSParenthesizedType":
         return inferRuntimeType(ctx, node.typeAnnotation, scope);
       case "TSUnionType":
-        return flattenTypes(ctx, node.types, scope, isKeyOf);
+        return flattenTypes(ctx, node.types, scope, isKeyOf, typeParameters);
       case "TSIntersectionType": {
-        return flattenTypes(ctx, node.types, scope, isKeyOf).filter(
-          (t) => t !== UNKNOWN_TYPE
-        );
+        return flattenTypes(
+          ctx,
+          node.types,
+          scope,
+          isKeyOf,
+          typeParameters
+        ).filter((t) => t !== UNKNOWN_TYPE);
       }
       case "TSEnumDeclaration":
         return inferEnumType(node);
@@ -23258,14 +23296,16 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
   }
   return [UNKNOWN_TYPE];
 }
-function flattenTypes(ctx, types, scope, isKeyOf = false) {
+function flattenTypes(ctx, types, scope, isKeyOf = false, typeParameters = void 0) {
   if (types.length === 1) {
-    return inferRuntimeType(ctx, types[0], scope, isKeyOf);
+    return inferRuntimeType(ctx, types[0], scope, isKeyOf, typeParameters);
   }
   return [
     ...new Set(
       [].concat(
-        ...types.map((t) => inferRuntimeType(ctx, t, scope, isKeyOf))
+        ...types.map(
+          (t) => inferRuntimeType(ctx, t, scope, isKeyOf, typeParameters)
+        )
       )
     )
   ];
@@ -24150,23 +24190,23 @@ function compileScript(sfc, options) {
 Upgrade your vite or vue-loader version for compatibility with the latest experimental proposals.`
     );
   }
-  const ctx = new ScriptCompileContext(sfc, options);
   const { script, scriptSetup, source, filename } = sfc;
   const hoistStatic = options.hoistStatic !== false && !script;
   const scopeId = options.id ? options.id.replace(/^data-v-/, "") : "";
   const scriptLang = script && script.lang;
   const scriptSetupLang = scriptSetup && scriptSetup.lang;
+  if (script && scriptSetup && scriptLang !== scriptSetupLang) {
+    throw new Error(
+      `[@vue/compiler-sfc] <script> and <script setup> must have the same language type.`
+    );
+  }
+  const ctx = new ScriptCompileContext(sfc, options);
   if (!scriptSetup) {
     if (!script) {
       throw new Error(`[@vue/compiler-sfc] SFC contains no <script> tags.`);
     }
     return processNormalScript(ctx, scopeId);
   }
-  if (script && scriptLang !== scriptSetupLang) {
-    throw new Error(
-      `[@vue/compiler-sfc] <script> and <script setup> must have the same language type.`
-    );
-  }
   if (scriptSetupLang && !ctx.isJS && !ctx.isTS) {
     return scriptSetup;
   }
@@ -24974,7 +25014,7 @@ function mergeSourceMaps(scriptMap, templateMap, templateLineOffset) {
   return generator.toJSON();
 }
 
-const version = "3.5.17";
+const version = "3.5.19";
 const parseCache = parseCache$1;
 const errorMessages = {
   ...CompilerDOM.errorMessages,

package/dist/compiler-sfc.d.ts

@@ -464,7 +464,7 @@ export declare function registerTS(_loadTS: () => typeof TS): void;
  * @private
  */
 export declare function invalidateTypeCache(filename: string): void;
-export declare function inferRuntimeType(ctx: TypeResolveContext, node: Node & MaybeWithScope, scope?: TypeScope, isKeyOf?: boolean): string[];
+export declare function inferRuntimeType(ctx: TypeResolveContext, node: Node & MaybeWithScope, scope?: TypeScope, isKeyOf?: boolean, typeParameters?: Record<string, Node>): string[];
 
 export declare function extractRuntimeEmits(ctx: TypeResolveContext): Set<string>;