@openpkg-ts/extract 0.24.0 → 0.25.0

package/dist/bin/tspec.js

@@ -3,7 +3,7 @@ import {
   detectTsRuntime,
   extract,
   resolveCompiledPath
-} from "../shared/chunk-bh378f7b.js";
+} from "../shared/chunk-2zvzqxtn.js";
 
 // src/cli/spec.ts
 import * as fs from "node:fs";

package/dist/shared/{chunk-bh378f7b.js → chunk-2zvzqxtn.js}

@@ -1722,13 +1722,14 @@ function getInheritedMembers(classType, ownMemberNames, ctx, isStatic = false) {
   const { typeChecker: checker } = ctx;
   const inherited = [];
   const visited = new Set;
+  const inheritedNames = new Set;
   const typeToWalk = isStatic ? classType.getSymbol()?.valueDeclaration && checker.getTypeOfSymbolAtLocation(classType.getSymbol(), classType.getSymbol().valueDeclaration) : classType;
   if (!typeToWalk)
     return inherited;
-  walkBaseTypes(typeToWalk, ownMemberNames, inherited, visited, ctx, isStatic);
+  walkBaseTypes(typeToWalk, ownMemberNames, inherited, inheritedNames, visited, ctx, isStatic);
   return inherited;
 }
-function walkBaseTypes(type, ownMemberNames, inherited, visited, ctx, isStatic) {
+function walkBaseTypes(type, ownMemberNames, inherited, inheritedNames, visited, ctx, isStatic) {
   if (visited.has(type))
     return;
   visited.add(type);
@@ -1742,16 +1743,17 @@ function walkBaseTypes(type, ownMemberNames, inherited, visited, ctx, isStatic)
       const propName = prop.getName();
       if (ownMemberNames.has(propName))
         continue;
-      if (inherited.some((m) => m.name === propName))
+      if (inheritedNames.has(propName))
         continue;
       if (propName.startsWith("#") || propName.startsWith("__"))
         continue;
       const member = serializeInheritedMember(prop, baseName, ctx, isStatic);
       if (member) {
         inherited.push(member);
+        inheritedNames.add(propName);
       }
     }
-    walkBaseTypes(baseType, ownMemberNames, inherited, visited, ctx, isStatic);
+    walkBaseTypes(baseType, ownMemberNames, inherited, inheritedNames, visited, ctx, isStatic);
   }
 }
 function getStaticMembers(classType, checker) {
@@ -3092,6 +3094,25 @@ function mergeRuntimeSchemas(staticExports, runtimeSchemas) {
 }
 
 // src/builder/spec-builder.ts
+var typeDefinitionCache = null;
+function getTypeDefinitionCache() {
+  if (!typeDefinitionCache) {
+    typeDefinitionCache = new Map;
+  }
+  return typeDefinitionCache;
+}
+var internalTagCache = null;
+function getInternalTagCache() {
+  if (!internalTagCache) {
+    internalTagCache = new Map;
+  }
+  return internalTagCache;
+}
+function clearTypeDefinitionCache() {
+  typeDefinitionCache = null;
+  internalTagCache = null;
+}
+var YIELD_BATCH_SIZE = 5;
 var BUILTIN_TYPES2 = new Set([
   "Array",
   "ArrayBuffer",
@@ -3176,6 +3197,7 @@ function shouldSkipDanglingRef(name) {
   return false;
 }
 async function extract(options) {
+  clearTypeDefinitionCache();
   const {
     entryFile,
     baseDir,
@@ -3185,7 +3207,8 @@ async function extract(options) {
     resolveExternalTypes,
     includeSchema,
     only,
-    ignore
+    ignore,
+    onProgress
   } = options;
   const diagnostics = [];
   let exports = [];
@@ -3216,10 +3239,15 @@ async function extract(options) {
     resolveExternalTypes
   });
   ctx.exportedIds = exportedIds;
-  for (const symbol of exportedSymbols) {
+  const filteredSymbols = exportedSymbols.filter((s) => shouldIncludeExport(s.getName(), only, ignore));
+  const total = filteredSymbols.length;
+  for (let i = 0;i < filteredSymbols.length; i++) {
+    const symbol = filteredSymbols[i];
     const exportName = symbol.getName();
-    if (!shouldIncludeExport(exportName, only, ignore))
-      continue;
+    onProgress?.(i + 1, total, exportName);
+    if (i > 0 && i % YIELD_BATCH_SIZE === 0) {
+      await new Promise((r) => setImmediate(r));
+    }
     try {
       const { declaration, targetSymbol } = resolveExportTarget(symbol, typeChecker);
       if (!declaration)
@@ -3237,7 +3265,8 @@ async function extract(options) {
   const meta = await getPackageMeta(entryFile, baseDir);
   const types = ctx.typeRegistry.getAll();
   const projectBaseDir = baseDir ?? path3.dirname(entryFile);
-  const forgottenExports = collectForgottenExports(exports, types, program, sourceFile, exportedIds, projectBaseDir);
+  const definedTypes = new Set(types.map((t) => t.id));
+  const forgottenExports = collectForgottenExports(exports, types, program, sourceFile, exportedIds, projectBaseDir, definedTypes);
   for (const forgotten of forgottenExports) {
     const refSummary = forgotten.referencedBy.slice(0, 3).map((r) => `${r.exportName} (${r.location})`).join(", ");
     const moreRefs = forgotten.referencedBy.length > 3 ? ` +${forgotten.referencedBy.length - 3} more` : "";
@@ -3320,10 +3349,9 @@ function collectAllRefsWithContext(obj, refs, state) {
     return;
   if (Array.isArray(obj)) {
     for (let i = 0;i < obj.length; i++) {
-      collectAllRefsWithContext(obj[i], refs, {
-        ...state,
-        path: [...state.path, `[${i}]`]
-      });
+      state.path.push(`[${i}]`);
+      collectAllRefsWithContext(obj[i], refs, state);
+      state.path.pop();
     }
     return;
   }
@@ -3336,31 +3364,34 @@ function collectAllRefsWithContext(obj, refs, state) {
         typeName,
         exportName: state.exportName,
         location: state.location,
-        path: state.path.join(".") || undefined
+        path: state.path.length > 0 ? state.path.join(".") : undefined
       });
       refs.set(typeName, existing);
     }
+    const prevLocation = state.location;
     for (const [key, value] of Object.entries(record)) {
-      let newLocation = state.location;
       if (key === "returnType" || key === "returns")
-        newLocation = "return";
+        state.location = "return";
       else if (key === "parameters" || key === "params")
-        newLocation = "parameter";
+        state.location = "parameter";
       else if (key === "properties" || key === "members")
-        newLocation = "property";
+        state.location = "property";
       else if (key === "extends" || key === "implements")
-        newLocation = "extends";
+        state.location = "extends";
       else if (key === "typeParameters" || key === "typeParams")
-        newLocation = "type-parameter";
-      collectAllRefsWithContext(value, refs, {
-        ...state,
-        location: newLocation,
-        path: [...state.path, key]
-      });
+        state.location = "type-parameter";
+      state.path.push(key);
+      collectAllRefsWithContext(value, refs, state);
+      state.path.pop();
+      state.location = prevLocation;
     }
   }
 }
 function findTypeDefinition(typeName, program, sourceFile) {
+  const cache = getTypeDefinitionCache();
+  if (cache.has(typeName)) {
+    return cache.get(typeName);
+  }
   const checker = program.getTypeChecker();
   const findInNode = (node) => {
     if ((ts11.isInterfaceDeclaration(node) || ts11.isTypeAliasDeclaration(node) || ts11.isClassDeclaration(node) || ts11.isEnumDeclaration(node)) && node.name?.text === typeName) {
@@ -3370,19 +3401,26 @@ function findTypeDefinition(typeName, program, sourceFile) {
     return ts11.forEachChild(node, findInNode);
   };
   const entryResult = findInNode(sourceFile);
-  if (entryResult)
+  if (entryResult) {
+    cache.set(typeName, entryResult);
     return entryResult;
+  }
   for (const sf of program.getSourceFiles()) {
     if (sf.isDeclarationFile && !sf.fileName.includes("node_modules")) {
       const result = findInNode(sf);
-      if (result)
+      if (result) {
+        cache.set(typeName, result);
         return result;
+      }
     }
   }
   const symbol = checker.resolveName(typeName, sourceFile, ts11.SymbolFlags.Type, false);
   if (symbol?.declarations?.[0]) {
-    return symbol.declarations[0].getSourceFile().fileName;
+    const result = symbol.declarations[0].getSourceFile().fileName;
+    cache.set(typeName, result);
+    return result;
   }
+  cache.set(typeName, undefined);
   return;
 }
 function isExternalType2(definedIn, baseDir) {
@@ -3395,15 +3433,23 @@ function isExternalType2(definedIn, baseDir) {
   return !normalizedDefined.startsWith(normalizedBase);
 }
 function hasInternalTag(typeName, program, sourceFile) {
+  const cache = getInternalTagCache();
+  const cached = cache.get(typeName);
+  if (cached !== undefined) {
+    return cached;
+  }
   const checker = program.getTypeChecker();
   const symbol = checker.resolveName(typeName, sourceFile, ts11.SymbolFlags.Type, false);
-  if (!symbol)
+  if (!symbol) {
+    cache.set(typeName, false);
     return false;
+  }
   const jsTags = symbol.getJsDocTags();
-  return jsTags.some((tag) => tag.name === "internal");
+  const isInternal = jsTags.some((tag) => tag.name === "internal");
+  cache.set(typeName, isInternal);
+  return isInternal;
 }
-function collectForgottenExports(exports, types, program, sourceFile, exportedIds, baseDir) {
-  const definedTypes = new Set(types.map((t) => t.id));
+function collectForgottenExports(exports, types, program, sourceFile, exportedIds, baseDir, definedTypes) {
   const referencedTypes = new Map;
   for (const exp of exports) {
     collectAllRefsWithContext(exp, referencedTypes, {

package/dist/src/index.d.ts

@@ -237,6 +237,8 @@ interface ExtractOptions {
 	only?: string[];
 	/** Ignore these exports (supports * wildcards) */
 	ignore?: string[];
+	/** Progress callback for tracking extraction progress */
+	onProgress?: (current: number, total: number, item: string) => void;
 }
 interface ExtractResult {
 	spec: OpenPkg;

package/dist/src/index.js

@@ -48,7 +48,7 @@ import {
   valibotAdapter,
   withDescription,
   zodAdapter
-} from "../shared/chunk-bh378f7b.js";
+} from "../shared/chunk-2zvzqxtn.js";
 // src/types/utils.ts
 function isExported(node) {
   const modifiers = node.modifiers;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/extract",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "TypeScript export extraction to OpenPkg spec",
   "keywords": [
     "openpkg",