@vue/compiler-sfc 3.3.0-alpha.11 → 3.3.0-alpha.13

package/dist/compiler-sfc.cjs.js

@@ -15876,6 +15876,7 @@ function resolveTypeElements(ctx, node, scope) {
   );
 }
 function innerResolveTypeElements(ctx, node, scope) {
+  var _a, _b;
   switch (node.type) {
     case "TSTypeLiteral":
       return typeElementsToMap(ctx, node.members, scope);
@@ -15904,22 +15905,65 @@ function innerResolveTypeElements(ctx, node, scope) {
     }
     case "TSExpressionWithTypeArguments":
     case "TSTypeReference": {
+      const typeName = getReferenceName(node);
+      if (typeName === "ExtractPropTypes" && node.typeParameters && ((_a = scope.imports[typeName]) == null ? void 0 : _a.source) === "vue") {
+        return resolveExtractPropTypes(
+          resolveTypeElements(ctx, node.typeParameters.params[0], scope),
+          scope
+        );
+      }
       const resolved = resolveTypeReference(ctx, node, scope);
       if (resolved) {
         return resolveTypeElements(ctx, resolved, resolved._ownerScope);
       } else {
-        const typeName = getReferenceName(node);
-        if (typeof typeName === "string" && // @ts-ignore
-        SupportedBuiltinsSet.has(typeName)) {
-          return resolveBuiltin(ctx, node, typeName, scope);
+        if (typeof typeName === "string") {
+          if (
+            // @ts-ignore
+            SupportedBuiltinsSet.has(typeName)
+          ) {
+            return resolveBuiltin(ctx, node, typeName, scope);
+          } else if (typeName === "ReturnType" && node.typeParameters) {
+            const ret = resolveReturnType(
+              ctx,
+              node.typeParameters.params[0],
+              scope
+            );
+            if (ret) {
+              return resolveTypeElements(ctx, ret, scope);
+            }
+          }
         }
         return ctx.error(
-          `Unresolvable type reference or unsupported built-in utlility type`,
+          `Unresolvable type reference or unsupported built-in utility type`,
           node,
           scope
         );
       }
     }
+    case "TSImportType": {
+      if (getId(node.argument) === "vue" && ((_b = node.qualifier) == null ? void 0 : _b.type) === "Identifier" && node.qualifier.name === "ExtractPropTypes" && node.typeParameters) {
+        return resolveExtractPropTypes(
+          resolveTypeElements(ctx, node.typeParameters.params[0], scope),
+          scope
+        );
+      }
+      const sourceScope = importSourceToScope(
+        ctx,
+        node.argument,
+        scope,
+        node.argument.value
+      );
+      const resolved = resolveTypeReference(ctx, node, sourceScope);
+      if (resolved) {
+        return resolveTypeElements(ctx, resolved, resolved._ownerScope);
+      }
+    }
+    case "TSTypeQuery": {
+      const resolved = resolveTypeReference(ctx, node, scope);
+      if (resolved) {
+        return resolveTypeElements(ctx, resolved, resolved._ownerScope);
+      }
+    }
   }
   return ctx.error(`Unresolvable type: ${node.type}`, node, scope);
 }
@@ -15965,7 +16009,8 @@ function mergeElements(maps, type) {
             // @ts-ignore
             types: [baseProps[key], props[key]]
           },
-          baseProps[key]._ownerScope
+          baseProps[key]._ownerScope,
+          baseProps[key].optional || props[key].optional
         );
       }
     }
@@ -15975,11 +16020,12 @@ function mergeElements(maps, type) {
   }
   return res;
 }
-function createProperty(key, typeAnnotation, scope) {
+function createProperty(key, typeAnnotation, scope, optional) {
   return {
     type: "TSPropertySignature",
     key,
     kind: "get",
+    optional,
     typeAnnotation: {
       type: "TSTypeAnnotation",
       typeAnnotation
@@ -16011,7 +16057,8 @@ function resolveMappedType(ctx, node, scope) {
         name: key
       },
       node.typeAnnotation,
-      scope
+      scope,
+      !!node.optional
     );
   }
   return res;
@@ -16194,47 +16241,49 @@ function innerResolveTypeReference(ctx, scope, name, node, onlyExported) {
     if (scope.imports[name]) {
       return resolveTypeFromImport(ctx, node, name, scope);
     } else {
-      const types = onlyExported ? scope.exportedTypes : scope.types;
-      if (types[name]) {
-        return types[name];
+      const lookupSource = node.type === "TSTypeQuery" ? onlyExported ? scope.exportedDeclares : scope.declares : onlyExported ? scope.exportedTypes : scope.types;
+      if (lookupSource[name]) {
+        return lookupSource[name];
       } else {
         const globalScopes = resolveGlobalScope(ctx);
         if (globalScopes) {
           for (const s of globalScopes) {
-            if (s.types[name]) {
+            const src = node.type === "TSTypeQuery" ? s.declares : s.types;
+            if (src[name]) {
               (ctx.deps || (ctx.deps = /* @__PURE__ */ new Set())).add(s.filename);
-              return s.types[name];
+              return src[name];
             }
           }
         }
       }
     }
   } else {
-    const ns = innerResolveTypeReference(
-      ctx,
-      scope,
-      name[0],
-      node,
-      onlyExported
-    );
-    if (ns && ns.type === "TSModuleDeclaration") {
-      const childScope = moduleDeclToScope(ns, scope);
-      return innerResolveTypeReference(
-        ctx,
-        childScope,
-        name.length > 2 ? name.slice(1) : name[name.length - 1],
-        node,
-        !ns.declare
-      );
+    let ns = innerResolveTypeReference(ctx, scope, name[0], node, onlyExported);
+    if (ns) {
+      if (ns.type !== "TSModuleDeclaration") {
+        ns = ns._ns;
+      }
+      if (ns) {
+        const childScope = moduleDeclToScope(ctx, ns, ns._ownerScope || scope);
+        return innerResolveTypeReference(
+          ctx,
+          childScope,
+          name.length > 2 ? name.slice(1) : name[name.length - 1],
+          node,
+          !ns.declare
+        );
+      }
     }
   }
 }
 function getReferenceName(node) {
-  const ref = node.type === "TSTypeReference" ? node.typeName : node.expression;
-  if (ref.type === "Identifier") {
+  const ref = node.type === "TSTypeReference" ? node.typeName : node.type === "TSExpressionWithTypeArguments" ? node.expression : node.type === "TSImportType" ? node.qualifier : node.exprName;
+  if ((ref == null ? void 0 : ref.type) === "Identifier") {
     return ref.name;
-  } else {
+  } else if ((ref == null ? void 0 : ref.type) === "TSQualifiedName") {
     return qualifiedNameToPath(ref);
+  } else {
+    return "default";
   }
 }
 function qualifiedNameToPath(node) {
@@ -16251,7 +16300,7 @@ function resolveGlobalScope(ctx) {
       throw new Error("[vue/compiler-sfc] globalTypeFiles requires fs access.");
     }
     return ctx.options.globalTypeFiles.map(
-      (file) => fileToScope(normalizePath(file), fs, ctx.options.babelParserPlugins, true)
+      (file) => fileToScope(ctx, normalizePath(file), true)
     );
   }
 }
@@ -16260,46 +16309,39 @@ function registerTS(_ts) {
   ts = _ts;
 }
 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);
   if (!fs) {
     ctx.error(
       `No fs option provided to \`compileScript\` in non-Node environment. File system access is required for resolving imported types.`,
-      node
+      node,
+      scope
     );
   }
-  const containingFile = scope.filename;
-  const { source, imported } = scope.imports[name];
   let resolved;
   if (source.startsWith(".")) {
-    const filename = path$2.join(containingFile, "..", source);
+    const filename = path$2.join(scope.filename, "..", source);
     resolved = resolveExt(filename, fs);
   } else {
     if (!ts) {
       ctx.error(
-        `Failed to resolve type ${imported} from module ${JSON.stringify(
-          source
-        )}. typescript is required as a peer dep for vue in order to support resolving types from module imports.`,
+        `Failed to resolve import source ${JSON.stringify(source)}. typescript is required as a peer dep for vue in order to support resolving types from module imports.`,
         node,
         scope
       );
     }
-    resolved = resolveWithTS(containingFile, source, fs);
+    resolved = resolveWithTS(scope.filename, source, fs);
   }
   if (resolved) {
-    resolved = normalizePath(resolved);
     (ctx.deps || (ctx.deps = /* @__PURE__ */ new Set())).add(resolved);
-    return resolveTypeReference(
-      ctx,
-      node,
-      fileToScope(resolved, fs, ctx.options.babelParserPlugins),
-      imported,
-      true
-    );
+    return fileToScope(ctx, normalizePath(resolved));
   } else {
-    ctx.error(
-      `Failed to resolve import source ${JSON.stringify(
-        source
-      )} for type ${name}`,
+    return ctx.error(
+      `Failed to resolve import source ${JSON.stringify(source)}.`,
       node,
       scope
     );
@@ -16349,25 +16391,29 @@ function resolveWithTS(containingFile, source, fs) {
 }
 const fileToScopeCache = createCache();
 function invalidateTypeCache(filename) {
+  filename = normalizePath(filename);
   fileToScopeCache.delete(filename);
   tsConfigCache.delete(filename);
 }
-function fileToScope(filename, fs, parserPlugins, asGlobal = false) {
+function fileToScope(ctx, filename, asGlobal = false) {
   const cached = fileToScopeCache.get(filename);
   if (cached) {
     return cached;
   }
+  const fs = ctx.options.fs || (ts == null ? void 0 : ts.sys);
   const source = fs.readFile(filename) || "";
-  const body = parseFile(filename, source, parserPlugins);
+  const body = parseFile(filename, source, ctx.options.babelParserPlugins);
   const scope = {
     filename,
     source,
     offset: 0,
     imports: recordImports(body),
     types: /* @__PURE__ */ Object.create(null),
-    exportedTypes: /* @__PURE__ */ Object.create(null)
+    exportedTypes: /* @__PURE__ */ Object.create(null),
+    declares: /* @__PURE__ */ Object.create(null),
+    exportedDeclares: /* @__PURE__ */ Object.create(null)
   };
-  recordTypes(body, scope, asGlobal);
+  recordTypes(ctx, body, scope, asGlobal);
   fileToScopeCache.set(filename, scope);
   return scope;
 }
@@ -16412,48 +16458,60 @@ function ctxToScope(ctx) {
     offset: "startOffset" in ctx ? ctx.startOffset : 0,
     imports: "userImports" in ctx ? Object.create(ctx.userImports) : recordImports(body),
     types: /* @__PURE__ */ Object.create(null),
-    exportedTypes: /* @__PURE__ */ Object.create(null)
+    exportedTypes: /* @__PURE__ */ Object.create(null),
+    declares: /* @__PURE__ */ Object.create(null),
+    exportedDeclares: /* @__PURE__ */ Object.create(null)
   };
-  recordTypes(body, scope);
+  recordTypes(ctx, body, scope);
   return ctx.scope = scope;
 }
-function moduleDeclToScope(node, parentScope) {
+function moduleDeclToScope(ctx, node, parentScope) {
   if (node._resolvedChildScope) {
     return node._resolvedChildScope;
   }
   const scope = {
     ...parentScope,
+    imports: Object.create(parentScope.imports),
     types: Object.create(parentScope.types),
-    imports: Object.create(parentScope.imports)
+    declares: Object.create(parentScope.declares),
+    exportedTypes: /* @__PURE__ */ Object.create(null),
+    exportedDeclares: /* @__PURE__ */ Object.create(null)
   };
-  recordTypes(node.body.body, scope);
+  if (node.body.type === "TSModuleDeclaration") {
+    const decl = node.body;
+    decl._ownerScope = scope;
+    const id = getId(decl.id);
+    scope.types[id] = scope.exportedTypes[id] = decl;
+  } else {
+    recordTypes(ctx, node.body.body, scope);
+  }
   return node._resolvedChildScope = scope;
 }
 const importExportRE = /^Import|^Export/;
-function recordTypes(body, scope, asGlobal = false) {
-  const { types, exportedTypes, imports } = scope;
+function recordTypes(ctx, body, scope, asGlobal = false) {
+  const { types, declares, exportedTypes, exportedDeclares, imports } = scope;
   const isAmbient = asGlobal ? !body.some((s) => importExportRE.test(s.type)) : false;
   for (const stmt of body) {
     if (asGlobal) {
       if (isAmbient) {
         if (stmt.declare) {
-          recordType(stmt, types);
+          recordType(stmt, types, declares);
         }
       } else if (stmt.type === "TSModuleDeclaration" && stmt.global) {
         for (const s of stmt.body.body) {
-          recordType(s, types);
+          recordType(s, types, declares);
         }
       }
     } else {
-      recordType(stmt, types);
+      recordType(stmt, types, declares);
     }
   }
   if (!asGlobal) {
     for (const stmt of body) {
       if (stmt.type === "ExportNamedDeclaration") {
         if (stmt.declaration) {
-          recordType(stmt.declaration, types);
-          recordType(stmt.declaration, exportedTypes);
+          recordType(stmt.declaration, types, declares);
+          recordType(stmt.declaration, exportedTypes, exportedDeclares);
         } else {
           for (const spec of stmt.specifiers) {
             if (spec.type === "ExportSpecifier") {
@@ -16478,31 +16536,76 @@ function recordTypes(body, scope, asGlobal = false) {
             }
           }
         }
+      } else if (stmt.type === "ExportAllDeclaration") {
+        const sourceScope = importSourceToScope(
+          ctx,
+          stmt.source,
+          scope,
+          stmt.source.value
+        );
+        Object.assign(scope.exportedTypes, sourceScope.exportedTypes);
       }
     }
   }
   for (const key of Object.keys(types)) {
-    types[key]._ownerScope = scope;
+    const node = types[key];
+    node._ownerScope = scope;
+    if (node._ns)
+      node._ns._ownerScope = scope;
+  }
+  for (const key of Object.keys(declares)) {
+    declares[key]._ownerScope = scope;
   }
 }
-function recordType(node, types) {
+function recordType(node, types, declares) {
   switch (node.type) {
     case "TSInterfaceDeclaration":
     case "TSEnumDeclaration":
-    case "TSModuleDeclaration":
-    case "ClassDeclaration": {
-      const id = node.id.type === "Identifier" ? node.id.name : node.id.value;
-      types[id] = node;
+    case "TSModuleDeclaration": {
+      const id = getId(node.id);
+      let existing = types[id];
+      if (existing) {
+        if (node.type === "TSModuleDeclaration") {
+          if (existing.type === "TSModuleDeclaration") {
+            mergeNamespaces(existing, node);
+          } else {
+            attachNamespace(existing, node);
+          }
+          break;
+        }
+        if (existing.type === "TSModuleDeclaration") {
+          types[id] = node;
+          attachNamespace(node, existing);
+          break;
+        }
+        if (existing.type !== node.type) {
+          break;
+        }
+        if (node.type === "TSInterfaceDeclaration") {
+          existing.body.body.push(...node.body.body);
+        } else {
+          existing.members.push(...node.members);
+        }
+      } else {
+        types[id] = node;
+      }
       break;
     }
+    case "ClassDeclaration":
+      types[getId(node.id)] = node;
+      break;
     case "TSTypeAliasDeclaration":
       types[node.id.name] = node.typeAnnotation;
       break;
+    case "TSDeclareFunction":
+      if (node.id)
+        declares[node.id.name] = node;
+      break;
     case "VariableDeclaration": {
       if (node.declare) {
         for (const decl of node.declarations) {
           if (decl.id.type === "Identifier" && decl.id.typeAnnotation) {
-            types[decl.id.name] = decl.id.typeAnnotation.typeAnnotation;
+            declares[decl.id.name] = decl.id.typeAnnotation.typeAnnotation;
           }
         }
       }
@@ -16510,6 +16613,38 @@ function recordType(node, types) {
     }
   }
 }
+function mergeNamespaces(to, from) {
+  const toBody = to.body;
+  const fromBody = from.body;
+  if (toBody.type === "TSModuleDeclaration") {
+    if (fromBody.type === "TSModuleDeclaration") {
+      mergeNamespaces(toBody, fromBody);
+    } else {
+      fromBody.body.push({
+        type: "ExportNamedDeclaration",
+        declaration: toBody,
+        exportKind: "type",
+        specifiers: []
+      });
+    }
+  } else if (fromBody.type === "TSModuleDeclaration") {
+    toBody.body.push({
+      type: "ExportNamedDeclaration",
+      declaration: fromBody,
+      exportKind: "type",
+      specifiers: []
+    });
+  } else {
+    toBody.body.push(...fromBody.body);
+  }
+}
+function attachNamespace(to, ns) {
+  if (!to._ns) {
+    to._ns = ns;
+  } else {
+    mergeNamespaces(to._ns, ns);
+  }
+}
 function recordImports(body) {
   const imports = /* @__PURE__ */ Object.create(null);
   for (const s of body) {
@@ -16575,12 +16710,12 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
         default:
           return [UNKNOWN_TYPE];
       }
-    case "TSTypeReference":
+    case "TSTypeReference": {
+      const resolved = resolveTypeReference(ctx, node, scope);
+      if (resolved) {
+        return inferRuntimeType(ctx, resolved, resolved._ownerScope);
+      }
       if (node.typeName.type === "Identifier") {
-        const resolved = resolveTypeReference(ctx, node, scope);
-        if (resolved) {
-          return inferRuntimeType(ctx, resolved, resolved._ownerScope);
-        }
         switch (node.typeName.name) {
           case "Array":
           case "Function":
@@ -16630,7 +16765,8 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
             break;
         }
       }
-      return [UNKNOWN_TYPE];
+      break;
+    }
     case "TSParenthesizedType":
       return inferRuntimeType(ctx, node.typeAnnotation, scope);
     case "TSUnionType":
@@ -16649,14 +16785,39 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
         const types = resolveIndexType(ctx, node, scope);
         return flattenTypes(ctx, types, scope);
       } catch (e) {
-        return [UNKNOWN_TYPE];
+        break;
       }
     }
     case "ClassDeclaration":
       return ["Object"];
-    default:
-      return [UNKNOWN_TYPE];
+    case "TSImportType": {
+      try {
+        const sourceScope = importSourceToScope(
+          ctx,
+          node.argument,
+          scope,
+          node.argument.value
+        );
+        const resolved = resolveTypeReference(ctx, node, sourceScope);
+        if (resolved) {
+          return inferRuntimeType(ctx, resolved, resolved._ownerScope);
+        }
+      } catch (e) {
+      }
+      break;
+    }
+    case "TSTypeQuery": {
+      const id = node.exprName;
+      if (id.type === "Identifier") {
+        const matched = scope.declares[id.name];
+        if (matched) {
+          return inferRuntimeType(ctx, matched, matched._ownerScope);
+        }
+      }
+      break;
+    }
   }
+  return [UNKNOWN_TYPE];
 }
 function flattenTypes(ctx, types, scope) {
   if (types.length === 1) {
@@ -16686,6 +16847,91 @@ function inferEnumType(node) {
   }
   return types.size ? [...types] : ["Number"];
 }
+function resolveExtractPropTypes({ props }, scope) {
+  const res = { props: {} };
+  for (const key in props) {
+    const raw = props[key];
+    res.props[key] = reverseInferType(
+      raw.key,
+      raw.typeAnnotation.typeAnnotation,
+      scope
+    );
+  }
+  return res;
+}
+function reverseInferType(key, node, scope, optional = true, checkObjectSyntax = true) {
+  if (checkObjectSyntax && node.type === "TSTypeLiteral") {
+    const typeType = findStaticPropertyType(node, "type");
+    if (typeType) {
+      const requiredType = findStaticPropertyType(node, "required");
+      const optional2 = requiredType && requiredType.type === "TSLiteralType" && requiredType.literal.type === "BooleanLiteral" ? !requiredType.literal.value : true;
+      return reverseInferType(key, typeType, scope, optional2, false);
+    }
+  } else if (node.type === "TSTypeReference" && node.typeName.type === "Identifier") {
+    if (node.typeName.name.endsWith("Constructor")) {
+      return createProperty(
+        key,
+        ctorToType(node.typeName.name),
+        scope,
+        optional
+      );
+    } else if (node.typeName.name === "PropType" && node.typeParameters) {
+      return createProperty(key, node.typeParameters.params[0], scope, optional);
+    }
+  }
+  if ((node.type === "TSTypeReference" || node.type === "TSImportType") && node.typeParameters) {
+    for (const t of node.typeParameters.params) {
+      const inferred = reverseInferType(key, t, scope, optional);
+      if (inferred)
+        return inferred;
+    }
+  }
+  return createProperty(key, { type: `TSNullKeyword` }, scope, optional);
+}
+function ctorToType(ctorType) {
+  const ctor = ctorType.slice(0, -11);
+  switch (ctor) {
+    case "String":
+    case "Number":
+    case "Boolean":
+      return { type: `TS${ctor}Keyword` };
+    case "Array":
+    case "Function":
+    case "Object":
+    case "Set":
+    case "Map":
+    case "WeakSet":
+    case "WeakMap":
+    case "Date":
+    case "Promise":
+      return {
+        type: "TSTypeReference",
+        typeName: { type: "Identifier", name: ctor }
+      };
+  }
+  return { type: `TSNullKeyword` };
+}
+function findStaticPropertyType(node, key) {
+  const prop = node.members.find(
+    (m) => m.type === "TSPropertySignature" && !m.computed && getId(m.key) === key && m.typeAnnotation
+  );
+  return prop && prop.typeAnnotation.typeAnnotation;
+}
+function resolveReturnType(ctx, arg, scope) {
+  var _a;
+  let resolved = arg;
+  if (arg.type === "TSTypeReference" || arg.type === "TSTypeQuery" || arg.type === "TSImportType") {
+    resolved = resolveTypeReference(ctx, arg, scope);
+  }
+  if (!resolved)
+    return;
+  if (resolved.type === "TSFunctionType") {
+    return (_a = resolved.typeAnnotation) == null ? void 0 : _a.typeAnnotation;
+  }
+  if (resolved.type === "TSDeclareFunction") {
+    return resolved.returnType;
+  }
+}
 
 const DEFINE_MODEL = "defineModel";
 function processDefineModel(ctx, node, declId) {
@@ -18193,7 +18439,7 @@ function isStaticNode(node) {
   }
 }
 
-const version = "3.3.0-alpha.11";
+const version = "3.3.0-alpha.13";
 const walk = estreeWalker.walk;
 
 exports.babelParse = parser$2.parse;