@openpkg-ts/extract 0.11.4 → 0.12.0

package/dist/bin/tspec.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   extract
-} from "../shared/chunk-twaykyxs.js";
+} from "../shared/chunk-wddga8ye.js";
 
 // src/cli/spec.ts
 import * as fs from "node:fs";

package/dist/shared/{chunk-twaykyxs.js → chunk-wddga8ye.js}

@@ -1,4 +1,6 @@
 // src/ast/registry.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
 import ts from "typescript";
 var PRIMITIVES = new Set([
   "string",
@@ -86,6 +88,54 @@ function isGenericTypeParameter(name) {
     return true;
   return false;
 }
+function isExternalType(decl) {
+  const sourceFile = decl.getSourceFile();
+  if (!sourceFile)
+    return false;
+  return sourceFile.fileName.includes("node_modules");
+}
+function extractPackageName(filePath) {
+  const nmIndex = filePath.lastIndexOf("node_modules");
+  if (nmIndex === -1)
+    return;
+  const afterNm = filePath.slice(nmIndex + "node_modules/".length);
+  const parts = afterNm.split("/");
+  if (parts[0].startsWith("@") && parts.length >= 2) {
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0];
+}
+function getPackageVersion(filePath, packageName) {
+  const nmIndex = filePath.lastIndexOf("node_modules");
+  if (nmIndex === -1)
+    return;
+  const nmDir = filePath.slice(0, nmIndex + "node_modules".length);
+  const pkgJsonPath = path.join(nmDir, packageName, "package.json");
+  try {
+    if (fs.existsSync(pkgJsonPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+      return pkg.version;
+    }
+  } catch {}
+  return;
+}
+function buildExternalSource(decl) {
+  const sourceFile = decl.getSourceFile();
+  if (!sourceFile)
+    return;
+  const filePath = sourceFile.fileName;
+  if (!filePath.includes("node_modules"))
+    return;
+  const packageName = extractPackageName(filePath);
+  if (!packageName)
+    return;
+  const version = getPackageVersion(filePath, packageName);
+  return {
+    file: filePath,
+    package: packageName,
+    version
+  };
+}
 
 class TypeRegistry {
   types = new Map;
@@ -141,6 +191,7 @@ class TypeRegistry {
     const name = symbol.getName();
     const decl = symbol.declarations?.[0];
     let kind = "type";
+    const external = decl ? isExternalType(decl) : false;
     if (decl) {
       if (ts.isClassDeclaration(decl))
         kind = "class";
@@ -149,12 +200,18 @@ class TypeRegistry {
       else if (ts.isEnumDeclaration(decl))
         kind = "enum";
     }
+    if (external) {
+      kind = "external";
+    }
     const typeString = checker.typeToString(type);
+    const source = decl ? buildExternalSource(decl) : undefined;
     return {
       id: name,
       name,
       kind,
-      type: typeString !== name ? typeString : undefined
+      type: typeString !== name ? typeString : undefined,
+      ...external ? { external: true } : {},
+      ...source ? { source } : {}
     };
   }
   registerFromSymbol(symbol, checker) {
@@ -218,9 +275,23 @@ function getSourceLocation(node, sourceFile) {
     line: line + 1
   };
 }
+function getParamDescription(propertyName, jsdocTags, inferredAlias) {
+  for (const tag of jsdocTags) {
+    if (tag.tagName.text !== "param")
+      continue;
+    const paramTag = tag;
+    const tagParamName = paramTag.name?.getText() ?? "";
+    const isMatch = tagParamName === propertyName || inferredAlias && tagParamName === `${inferredAlias}.${propertyName}` || tagParamName.endsWith(`.${propertyName}`);
+    if (isMatch) {
+      const comment = typeof tag.comment === "string" ? tag.comment : ts2.getTextOfJSDocComment(tag.comment);
+      return comment?.trim() || undefined;
+    }
+  }
+  return;
+}
 
 // src/compiler/program.ts
-import * as path from "node:path";
+import * as path2 from "node:path";
 import ts3 from "typescript";
 var DEFAULT_COMPILER_OPTIONS = {
   target: ts3.ScriptTarget.Latest,
@@ -231,14 +302,14 @@ var DEFAULT_COMPILER_OPTIONS = {
 };
 function createProgram({
   entryFile,
-  baseDir = path.dirname(entryFile),
+  baseDir = path2.dirname(entryFile),
   content
 }) {
   const configPath = ts3.findConfigFile(baseDir, ts3.sys.fileExists, "tsconfig.json");
   let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
   if (configPath) {
     const configFile = ts3.readConfigFile(configPath, ts3.sys.readFile);
-    const parsedConfig = ts3.parseJsonConfigFileContent(configFile.config, ts3.sys, path.dirname(configPath));
+    const parsedConfig = ts3.parseJsonConfigFileContent(configFile.config, ts3.sys, path2.dirname(configPath));
     compilerOptions = { ...compilerOptions, ...parsedConfig.options };
   }
   const allowJsVal = compilerOptions.allowJs;
@@ -319,18 +390,413 @@ function serializeEnum(node, ctx) {
   };
 }
 
+// src/types/schema-builder.ts
+import ts4 from "typescript";
+var PRIMITIVES2 = new Set([
+  "string",
+  "number",
+  "boolean",
+  "void",
+  "undefined",
+  "null",
+  "any",
+  "unknown",
+  "never",
+  "object",
+  "symbol",
+  "bigint"
+]);
+var BUILTIN_GENERICS = new Set([
+  "Array",
+  "ReadonlyArray",
+  "Promise",
+  "PromiseLike",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Iterable",
+  "Iterator",
+  "IterableIterator",
+  "AsyncIterable",
+  "AsyncIterator",
+  "AsyncIterableIterator",
+  "Generator",
+  "AsyncGenerator",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Record",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "Parameters",
+  "ReturnType",
+  "ConstructorParameters",
+  "InstanceType",
+  "Awaited"
+]);
+var BUILTIN_TYPES = new Set([
+  "Date",
+  "RegExp",
+  "Error",
+  "Function",
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "DataView",
+  "Uint8Array",
+  "Int8Array",
+  "Uint16Array",
+  "Int16Array",
+  "Uint32Array",
+  "Int32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array"
+]);
+function isPrimitiveName(name) {
+  return PRIMITIVES2.has(name);
+}
+function isBuiltinGeneric(name) {
+  return BUILTIN_GENERICS.has(name);
+}
+function isAnonymous(type) {
+  const symbol = type.getSymbol() || type.aliasSymbol;
+  if (!symbol)
+    return true;
+  const name = symbol.getName();
+  return name.startsWith("__") || name === "";
+}
+function withDepth(ctx, fn) {
+  ctx.currentDepth++;
+  try {
+    return fn();
+  } finally {
+    ctx.currentDepth--;
+  }
+}
+function isAtMaxDepth(ctx) {
+  if (!ctx)
+    return false;
+  return ctx.currentDepth >= ctx.maxTypeDepth;
+}
+function buildSchema(type, checker, ctx, _depth = 0) {
+  if (isAtMaxDepth(ctx)) {
+    return { type: checker.typeToString(type) };
+  }
+  if (ctx && ctx.visitedTypes.has(type)) {
+    const symbol2 = type.getSymbol() || type.aliasSymbol;
+    if (symbol2) {
+      return { $ref: symbol2.getName() };
+    }
+    return { type: checker.typeToString(type) };
+  }
+  if (type.flags & ts4.TypeFlags.String)
+    return { type: "string" };
+  if (type.flags & ts4.TypeFlags.Number)
+    return { type: "number" };
+  if (type.flags & ts4.TypeFlags.Boolean)
+    return { type: "boolean" };
+  if (type.flags & ts4.TypeFlags.Undefined)
+    return { type: "undefined" };
+  if (type.flags & ts4.TypeFlags.Null)
+    return { type: "null" };
+  if (type.flags & ts4.TypeFlags.Void)
+    return { type: "void" };
+  if (type.flags & ts4.TypeFlags.Any)
+    return { type: "any" };
+  if (type.flags & ts4.TypeFlags.Unknown)
+    return { type: "unknown" };
+  if (type.flags & ts4.TypeFlags.Never)
+    return { type: "never" };
+  if (type.flags & ts4.TypeFlags.BigInt)
+    return { type: "bigint" };
+  if (type.flags & ts4.TypeFlags.ESSymbol)
+    return { type: "symbol" };
+  if (type.flags & ts4.TypeFlags.StringLiteral) {
+    const literal = type.value;
+    return { type: "string", enum: [literal] };
+  }
+  if (type.flags & ts4.TypeFlags.NumberLiteral) {
+    const literal = type.value;
+    return { type: "number", enum: [literal] };
+  }
+  if (type.flags & ts4.TypeFlags.BooleanLiteral) {
+    const intrinsicName = type.intrinsicName;
+    return { type: "boolean", enum: [intrinsicName === "true"] };
+  }
+  if (type.isUnion()) {
+    const types = type.types;
+    const allStringLiterals = types.every((t) => t.flags & ts4.TypeFlags.StringLiteral);
+    if (allStringLiterals) {
+      const enumValues = types.map((t) => t.value);
+      return { type: "string", enum: enumValues };
+    }
+    const allNumberLiterals = types.every((t) => t.flags & ts4.TypeFlags.NumberLiteral);
+    if (allNumberLiterals) {
+      const enumValues = types.map((t) => t.value);
+      return { type: "number", enum: enumValues };
+    }
+    if (ctx) {
+      return withDepth(ctx, () => ({
+        anyOf: types.map((t) => buildSchema(t, checker, ctx))
+      }));
+    }
+    return { anyOf: types.map((t) => buildSchema(t, checker, ctx)) };
+  }
+  if (type.isIntersection()) {
+    if (ctx) {
+      return withDepth(ctx, () => ({
+        allOf: type.types.map((t) => buildSchema(t, checker, ctx))
+      }));
+    }
+    return { allOf: type.types.map((t) => buildSchema(t, checker, ctx)) };
+  }
+  if (checker.isArrayType(type)) {
+    const typeRef2 = type;
+    const elementType = typeRef2.typeArguments?.[0];
+    if (elementType) {
+      if (ctx) {
+        return withDepth(ctx, () => ({
+          type: "array",
+          items: buildSchema(elementType, checker, ctx)
+        }));
+      }
+      return { type: "array", items: buildSchema(elementType, checker, ctx) };
+    }
+    return { type: "array" };
+  }
+  if (checker.isTupleType(type)) {
+    const typeRef2 = type;
+    const elementTypes = typeRef2.typeArguments ?? [];
+    if (ctx) {
+      return withDepth(ctx, () => ({
+        type: "tuple",
+        items: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+        minItems: elementTypes.length,
+        maxItems: elementTypes.length
+      }));
+    }
+    return {
+      type: "tuple",
+      items: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+      minItems: elementTypes.length,
+      maxItems: elementTypes.length
+    };
+  }
+  const typeRef = type;
+  if (typeRef.target && typeRef.typeArguments && typeRef.typeArguments.length > 0) {
+    const symbol2 = typeRef.target.getSymbol();
+    const name = symbol2?.getName();
+    if (name && (isBuiltinGeneric(name) || !isAnonymous(typeRef.target))) {
+      if (ctx) {
+        return withDepth(ctx, () => ({
+          $ref: name,
+          typeArguments: typeRef.typeArguments.map((t) => buildSchema(t, checker, ctx))
+        }));
+      }
+      return {
+        $ref: name,
+        typeArguments: typeRef.typeArguments.map((t) => buildSchema(t, checker, ctx))
+      };
+    }
+  }
+  const symbol = type.getSymbol() || type.aliasSymbol;
+  if (symbol && !isAnonymous(type)) {
+    const name = symbol.getName();
+    if (isPrimitiveName(name)) {
+      return { type: name };
+    }
+    if (BUILTIN_TYPES.has(name)) {
+      return { $ref: name };
+    }
+    if (!name.startsWith("__")) {
+      return { $ref: name };
+    }
+  }
+  if (type.flags & ts4.TypeFlags.Object) {
+    const objectType = type;
+    const callSignatures = type.getCallSignatures();
+    if (callSignatures.length > 0) {
+      return buildFunctionSchema(callSignatures, checker, ctx);
+    }
+    const properties = type.getProperties();
+    if (properties.length > 0 || objectType.objectFlags & ts4.ObjectFlags.Anonymous) {
+      return buildObjectSchema(properties, checker, ctx);
+    }
+  }
+  return { type: checker.typeToString(type) };
+}
+function buildFunctionSchema(callSignatures, checker, ctx) {
+  const buildSignatures = () => {
+    const signatures = callSignatures.map((sig) => {
+      const params = sig.getParameters().map((param) => {
+        const paramType = checker.getTypeOfSymbolAtLocation(param, param.valueDeclaration);
+        return {
+          name: param.getName(),
+          schema: buildSchema(paramType, checker, ctx),
+          required: !(param.flags & ts4.SymbolFlags.Optional)
+        };
+      });
+      const returnType = checker.getReturnTypeOfSignature(sig);
+      return {
+        parameters: params,
+        returns: {
+          schema: buildSchema(returnType, checker, ctx)
+        }
+      };
+    });
+    return signatures;
+  };
+  if (ctx) {
+    return withDepth(ctx, () => ({ type: "function", signatures: buildSignatures() }));
+  }
+  return { type: "function", signatures: buildSignatures() };
+}
+function buildObjectSchema(properties, checker, ctx) {
+  const buildProps = () => {
+    const props = {};
+    const required = [];
+    for (const prop of properties) {
+      const propName = prop.getName();
+      if (propName.startsWith("_"))
+        continue;
+      const propType = checker.getTypeOfSymbol(prop);
+      props[propName] = buildSchema(propType, checker, ctx);
+      if (!(prop.flags & ts4.SymbolFlags.Optional)) {
+        required.push(propName);
+      }
+    }
+    return {
+      type: "object",
+      properties: props,
+      ...required.length > 0 ? { required } : {}
+    };
+  };
+  if (ctx) {
+    return withDepth(ctx, buildProps);
+  }
+  return buildProps();
+}
+
 // src/types/parameters.ts
+import ts5 from "typescript";
 function extractParameters(signature, ctx) {
-  const { typeChecker: checker, typeRegistry, exportedIds } = ctx;
-  return signature.getParameters().map((param) => {
-    const type = checker.getTypeOfSymbolAtLocation(param, param.valueDeclaration);
-    registerReferencedTypes(type, ctx);
-    return {
-      name: param.getName(),
-      schema: { type: checker.typeToString(type) },
-      required: !(param.flags & 16777216)
+  const { typeChecker: checker } = ctx;
+  const result = [];
+  const signatureDecl = signature.getDeclaration();
+  const jsdocTags = signatureDecl ? ts5.getJSDocTags(signatureDecl) : [];
+  for (const param of signature.getParameters()) {
+    const decl = param.valueDeclaration;
+    const type = checker.getTypeOfSymbolAtLocation(param, decl ?? param.valueDeclaration);
+    if (decl && ts5.isObjectBindingPattern(decl.name)) {
+      const expandedParams = expandBindingPattern(decl, type, jsdocTags, ctx);
+      result.push(...expandedParams);
+    } else {
+      registerReferencedTypes(type, ctx);
+      result.push({
+        name: param.getName(),
+        schema: buildSchema(type, checker, ctx),
+        required: !(param.flags & 16777216)
+      });
+    }
+  }
+  return result;
+}
+function expandBindingPattern(paramDecl, paramType, jsdocTags, ctx) {
+  const { typeChecker: checker } = ctx;
+  const result = [];
+  const bindingPattern = paramDecl.name;
+  const allProperties = getEffectiveProperties(paramType, checker);
+  const inferredAlias = inferParamAlias(jsdocTags);
+  for (const element of bindingPattern.elements) {
+    if (!ts5.isBindingElement(element))
+      continue;
+    const propertyName = element.propertyName ? ts5.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText() : ts5.isIdentifier(element.name) ? element.name.text : element.name.getText();
+    const propSymbol = allProperties.get(propertyName);
+    if (!propSymbol)
+      continue;
+    const propType = checker.getTypeOfSymbol(propSymbol);
+    registerReferencedTypes(propType, ctx);
+    const isOptional = !!(propSymbol.flags & ts5.SymbolFlags.Optional) || element.initializer !== undefined;
+    const description = getParamDescription(propertyName, jsdocTags, inferredAlias);
+    const param = {
+      name: propertyName,
+      schema: buildSchema(propType, checker, ctx),
+      required: !isOptional
     };
-  });
+    if (description) {
+      param.description = description;
+    }
+    if (element.initializer) {
+      param.default = extractDefaultValue(element.initializer);
+    }
+    result.push(param);
+  }
+  return result;
+}
+function getEffectiveProperties(type, _checker) {
+  const properties = new Map;
+  if (type.isIntersection()) {
+    for (const subType of type.types) {
+      for (const prop of subType.getProperties()) {
+        properties.set(prop.getName(), prop);
+      }
+    }
+  } else {
+    for (const prop of type.getProperties()) {
+      properties.set(prop.getName(), prop);
+    }
+  }
+  return properties;
+}
+function inferParamAlias(jsdocTags) {
+  const prefixes = [];
+  for (const tag of jsdocTags) {
+    if (tag.tagName.text !== "param")
+      continue;
+    const tagText = typeof tag.comment === "string" ? tag.comment : ts5.getTextOfJSDocComment(tag.comment) ?? "";
+    const paramTag = tag;
+    const paramName = paramTag.name?.getText() ?? "";
+    if (paramName.includes(".")) {
+      const prefix = paramName.split(".")[0];
+      if (prefix && !prefix.startsWith("__")) {
+        prefixes.push(prefix);
+      }
+    } else if (tagText.includes(".")) {
+      const match = tagText.match(/^(\w+)\./);
+      if (match && !match[1].startsWith("__")) {
+        prefixes.push(match[1]);
+      }
+    }
+  }
+  if (prefixes.length === 0)
+    return;
+  const counts = new Map;
+  for (const p of prefixes)
+    counts.set(p, (counts.get(p) ?? 0) + 1);
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
+}
+function extractDefaultValue(initializer) {
+  if (ts5.isStringLiteral(initializer)) {
+    return initializer.text;
+  }
+  if (ts5.isNumericLiteral(initializer)) {
+    return Number(initializer.text);
+  }
+  if (initializer.kind === ts5.SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (initializer.kind === ts5.SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  if (initializer.kind === ts5.SyntaxKind.NullKeyword) {
+    return null;
+  }
+  return initializer.getText();
 }
 function registerReferencedTypes(type, ctx) {
   if (ctx.visitedTypes.has(type))
@@ -374,7 +840,7 @@ function serializeFunctionExport(node, ctx) {
     return {
       parameters: params,
       returns: {
-        schema: { type: ctx.typeChecker.typeToString(returnType) }
+        schema: buildSchema(returnType, ctx.typeChecker, ctx)
       }
     };
   });
@@ -421,7 +887,7 @@ function serializeTypeAlias(node, ctx) {
   const { description, tags, examples } = getJSDocComment(node);
   const source = getSourceLocation(node, declSourceFile);
   const type = ctx.typeChecker.getTypeAtLocation(node);
-  const typeString = ctx.typeChecker.typeToString(type);
+  registerReferencedTypes(type, ctx);
   return {
     id: name,
     name,
@@ -429,7 +895,7 @@ function serializeTypeAlias(node, ctx) {
     description,
     tags,
     source,
-    ...typeString !== name ? { type: typeString } : {},
+    schema: buildSchema(type, ctx.typeChecker, ctx),
     ...examples.length > 0 ? { examples } : {}
   };
 }
@@ -444,7 +910,6 @@ function serializeVariable(node, statement, ctx) {
   const { description, tags, examples } = getJSDocComment(statement);
   const source = getSourceLocation(node, declSourceFile);
   const type = ctx.typeChecker.getTypeAtLocation(node);
-  const typeString = ctx.typeChecker.typeToString(type);
   registerReferencedTypes(type, ctx);
   return {
     id: name,
@@ -453,16 +918,16 @@ function serializeVariable(node, statement, ctx) {
     description,
     tags,
     source,
-    ...typeString && typeString !== name ? { type: typeString } : {},
+    schema: buildSchema(type, ctx.typeChecker, ctx),
     ...examples.length > 0 ? { examples } : {}
   };
 }
 
 // src/builder/spec-builder.ts
-import * as fs from "node:fs";
-import * as path2 from "node:path";
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
 import { SCHEMA_VERSION } from "@openpkg-ts/spec";
-import ts4 from "typescript";
+import ts6 from "typescript";
 
 // src/serializers/context.ts
 function createContext(program, sourceFile, options = {}) {
@@ -470,7 +935,9 @@ function createContext(program, sourceFile, options = {}) {
     typeChecker: program.getTypeChecker(),
     program,
     sourceFile,
-    maxTypeDepth: options.maxTypeDepth ?? 20,
+    maxTypeDepth: options.maxTypeDepth ?? 4,
+    maxExternalTypeDepth: options.maxExternalTypeDepth ?? 2,
+    currentDepth: 0,
     resolveExternalTypes: options.resolveExternalTypes ?? true,
     typeRegistry: new TypeRegistry,
     exportedIds: new Set,
@@ -480,7 +947,7 @@ function createContext(program, sourceFile, options = {}) {
 
 // src/builder/spec-builder.ts
 async function extract(options) {
-  const { entryFile, baseDir, content, maxTypeDepth, resolveExternalTypes } = options;
+  const { entryFile, baseDir, content, maxTypeDepth, maxExternalTypeDepth, resolveExternalTypes } = options;
   const diagnostics = [];
   const exports = [];
   const result = createProgram({ entryFile, baseDir, content });
@@ -504,7 +971,7 @@ async function extract(options) {
   for (const symbol of exportedSymbols) {
     exportedIds.add(symbol.getName());
   }
-  const ctx = createContext(program, sourceFile, { maxTypeDepth, resolveExternalTypes });
+  const ctx = createContext(program, sourceFile, { maxTypeDepth, maxExternalTypeDepth, resolveExternalTypes });
   ctx.exportedIds = exportedIds;
   for (const symbol of exportedSymbols) {
     try {
@@ -537,36 +1004,36 @@ async function extract(options) {
 }
 function resolveExportTarget(symbol, checker) {
   let targetSymbol = symbol;
-  if (symbol.flags & ts4.SymbolFlags.Alias) {
+  if (symbol.flags & ts6.SymbolFlags.Alias) {
     const aliasTarget = checker.getAliasedSymbol(symbol);
     if (aliasTarget && aliasTarget !== symbol) {
       targetSymbol = aliasTarget;
     }
   }
   const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts4.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts6.SyntaxKind.ExportSpecifier) || declarations[0];
   return { declaration, targetSymbol };
 }
 function serializeDeclaration(declaration, exportSymbol, targetSymbol, exportName, ctx) {
   let result = null;
-  if (ts4.isFunctionDeclaration(declaration)) {
+  if (ts6.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts4.isClassDeclaration(declaration)) {
+  } else if (ts6.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts4.isInterfaceDeclaration(declaration)) {
+  } else if (ts6.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts4.isTypeAliasDeclaration(declaration)) {
+  } else if (ts6.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts4.isEnumDeclaration(declaration)) {
+  } else if (ts6.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts4.isVariableDeclaration(declaration)) {
+  } else if (ts6.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
-    if (varStatement && ts4.isVariableStatement(varStatement)) {
+    if (varStatement && ts6.isVariableStatement(varStatement)) {
       result = serializeVariable(declaration, varStatement, ctx);
     }
-  } else if (ts4.isNamespaceExport(declaration) || ts4.isModuleDeclaration(declaration)) {
+  } else if (ts6.isNamespaceExport(declaration) || ts6.isModuleDeclaration(declaration)) {
     result = serializeNamespaceExport(exportSymbol, exportName, ctx);
-  } else if (ts4.isSourceFile(declaration)) {
+  } else if (ts6.isSourceFile(declaration)) {
     result = serializeNamespaceExport(exportSymbol, exportName, ctx);
   }
   if (result) {
@@ -590,11 +1057,11 @@ function getJSDocFromExportSymbol(symbol) {
   const examples = [];
   const decl = symbol.declarations?.[0];
   if (decl) {
-    const exportDecl = ts4.isNamespaceExport(decl) ? decl.parent : decl;
-    if (exportDecl && ts4.isExportDeclaration(exportDecl)) {
-      const jsDocs = ts4.getJSDocCommentsAndTags(exportDecl);
+    const exportDecl = ts6.isNamespaceExport(decl) ? decl.parent : decl;
+    if (exportDecl && ts6.isExportDeclaration(exportDecl)) {
+      const jsDocs = ts6.getJSDocCommentsAndTags(exportDecl);
       for (const doc of jsDocs) {
-        if (ts4.isJSDoc(doc) && doc.comment) {
+        if (ts6.isJSDoc(doc) && doc.comment) {
           const commentText = typeof doc.comment === "string" ? doc.comment : doc.comment.map((c) => ("text" in c) ? c.text : "").join("");
           if (commentText) {
             return {
@@ -655,7 +1122,7 @@ function withExportName(entry, exportName) {
 function createEmptySpec(entryFile) {
   return {
     openpkg: SCHEMA_VERSION,
-    meta: { name: path2.basename(entryFile, path2.extname(entryFile)) },
+    meta: { name: path3.basename(entryFile, path3.extname(entryFile)) },
     exports: [],
     generation: {
       generator: "@openpkg-ts/extract",
@@ -664,18 +1131,18 @@ function createEmptySpec(entryFile) {
   };
 }
 async function getPackageMeta(entryFile, baseDir) {
-  const searchDir = baseDir ?? path2.dirname(entryFile);
-  const pkgPath = path2.join(searchDir, "package.json");
+  const searchDir = baseDir ?? path3.dirname(entryFile);
+  const pkgPath = path3.join(searchDir, "package.json");
   try {
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (fs2.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
       return {
-        name: pkg.name ?? path2.basename(searchDir),
+        name: pkg.name ?? path3.basename(searchDir),
         version: pkg.version,
         description: pkg.description
       };
     }
   } catch {}
-  return { name: path2.basename(searchDir) };
+  return { name: path3.basename(searchDir) };
 }
-export { TypeRegistry, getJSDocComment, getSourceLocation, createProgram, serializeClass, serializeEnum, extractParameters, registerReferencedTypes, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };
+export { TypeRegistry, getJSDocComment, getSourceLocation, createProgram, serializeClass, serializeEnum, isPrimitiveName, isBuiltinGeneric, isAnonymous, buildSchema, extractParameters, registerReferencedTypes, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };

package/dist/src/index.d.ts

@@ -24,14 +24,12 @@ declare function getJSDocComment(node: ts2.Node): {
 };
 declare function getSourceLocation(node: ts2.Node, sourceFile: ts2.SourceFile): SpecSource;
 import { OpenPkg } from "@openpkg-ts/spec";
-import { TypeChecker as TypeChecker_lrgbhchnsl } from "typescript";
-import { Program as Program_jbfzpxflck } from "typescript";
-import { SourceFile as SourceFile_eubaywigwb } from "typescript";
 interface ExtractOptions {
 	entryFile: string;
 	baseDir?: string;
 	content?: string;
 	maxTypeDepth?: number;
+	maxExternalTypeDepth?: number;
 	resolveExternalTypes?: boolean;
 	schemaExtraction?: "static" | "hybrid";
 }
@@ -48,13 +46,6 @@ interface Diagnostic {
 		column?: number;
 	};
 }
-interface SerializerContext {
-	typeChecker: TypeChecker_lrgbhchnsl;
-	program: Program_jbfzpxflck;
-	sourceFile: SourceFile_eubaywigwb;
-	maxTypeDepth: number;
-	resolveExternalTypes: boolean;
-}
 declare function extract(options: ExtractOptions): Promise<ExtractResult>;
 import ts3 from "typescript";
 interface ProgramOptions {
@@ -95,48 +86,66 @@ declare function extractStandardSchemas(_program: ts5.Program, _entryFile: strin
 import { SpecExport } from "@openpkg-ts/spec";
 import ts7 from "typescript";
 import ts6 from "typescript";
-interface SerializerContext2 {
+interface SerializerContext {
 	typeChecker: ts6.TypeChecker;
 	program: ts6.Program;
 	sourceFile: ts6.SourceFile;
 	maxTypeDepth: number;
+	maxExternalTypeDepth: number;
+	currentDepth: number;
 	resolveExternalTypes: boolean;
 	typeRegistry: TypeRegistry;
 	exportedIds: Set<string>;
 	/** Track visited types to prevent infinite recursion */
 	visitedTypes: Set<ts6.Type>;
 }
-declare function serializeClass(node: ts7.ClassDeclaration, ctx: SerializerContext2): SpecExport | null;
+declare function serializeClass(node: ts7.ClassDeclaration, ctx: SerializerContext): SpecExport | null;
 import { SpecExport as SpecExport2 } from "@openpkg-ts/spec";
 import ts8 from "typescript";
-declare function serializeEnum(node: ts8.EnumDeclaration, ctx: SerializerContext2): SpecExport2 | null;
+declare function serializeEnum(node: ts8.EnumDeclaration, ctx: SerializerContext): SpecExport2 | null;
 import { SpecExport as SpecExport3 } from "@openpkg-ts/spec";
 import ts9 from "typescript";
-declare function serializeFunctionExport(node: ts9.FunctionDeclaration | ts9.ArrowFunction, ctx: SerializerContext2): SpecExport3 | null;
+declare function serializeFunctionExport(node: ts9.FunctionDeclaration | ts9.ArrowFunction, ctx: SerializerContext): SpecExport3 | null;
 import { SpecExport as SpecExport4 } from "@openpkg-ts/spec";
 import ts10 from "typescript";
-declare function serializeInterface(node: ts10.InterfaceDeclaration, ctx: SerializerContext2): SpecExport4 | null;
+declare function serializeInterface(node: ts10.InterfaceDeclaration, ctx: SerializerContext): SpecExport4 | null;
 import { SpecExport as SpecExport5 } from "@openpkg-ts/spec";
 import ts11 from "typescript";
-declare function serializeTypeAlias(node: ts11.TypeAliasDeclaration, ctx: SerializerContext2): SpecExport5 | null;
+declare function serializeTypeAlias(node: ts11.TypeAliasDeclaration, ctx: SerializerContext): SpecExport5 | null;
 import { SpecExport as SpecExport6 } from "@openpkg-ts/spec";
 import ts12 from "typescript";
-declare function serializeVariable(node: ts12.VariableDeclaration, statement: ts12.VariableStatement, ctx: SerializerContext2): SpecExport6 | null;
+declare function serializeVariable(node: ts12.VariableDeclaration, statement: ts12.VariableStatement, ctx: SerializerContext): SpecExport6 | null;
 import ts13 from "typescript";
 declare function formatTypeReference(type: ts13.Type, checker: ts13.TypeChecker): string;
 declare function collectReferencedTypes(type: ts13.Type, checker: ts13.TypeChecker, visited?: Set<string>): string[];
 import { SpecSignatureParameter } from "@openpkg-ts/spec";
 import ts14 from "typescript";
-declare function extractParameters(signature: ts14.Signature, ctx: SerializerContext2): SpecSignatureParameter[];
+declare function extractParameters(signature: ts14.Signature, ctx: SerializerContext): SpecSignatureParameter[];
 /**
 * Recursively register types referenced by a ts.Type.
 * Uses ctx.visitedTypes to prevent infinite recursion on circular types.
 */
-declare function registerReferencedTypes(type: ts14.Type, ctx: SerializerContext2): void;
+declare function registerReferencedTypes(type: ts14.Type, ctx: SerializerContext): void;
 import { SpecSchema as SpecSchema3 } from "@openpkg-ts/spec";
 import ts15 from "typescript";
-declare function buildSchema(type: ts15.Type, checker: ts15.TypeChecker, depth?: number): SpecSchema3;
+/**
+* Check if a name is a primitive type
+*/
+declare function isPrimitiveName(name: string): boolean;
+/**
+* Check if a name is a built-in generic type
+*/
+declare function isBuiltinGeneric(name: string): boolean;
+/**
+* Check if a type is anonymous (no meaningful symbol name)
+*/
+declare function isAnonymous(type: ts15.Type): boolean;
+/**
+* Build a structured SpecSchema from a TypeScript type.
+* Uses $ref for named types and typeArguments for generics.
+*/
+declare function buildSchema(type: ts15.Type, checker: ts15.TypeChecker, ctx?: SerializerContext, _depth?: number): SpecSchema3;
 import ts16 from "typescript";
 declare function isExported(node: ts16.Node): boolean;
 declare function getNodeName(node: ts16.Node): string | undefined;
-export { zodAdapter, valibotAdapter, typeboxAdapter, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, registerReferencedTypes, registerAdapter, isSchemaType, isExported, getSourceLocation, getNodeName, getJSDocComment, formatTypeReference, findAdapter, extractStandardSchemas, extractSchemaType, extractParameters, extract, createProgram, collectReferencedTypes, buildSchema, arktypeAdapter, TypeRegistry, StandardSchemaResult, SerializerContext, SchemaAdapter, ProgramResult, ProgramOptions, ExtractResult, ExtractOptions, Diagnostic };
+export { zodAdapter, valibotAdapter, typeboxAdapter, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, registerReferencedTypes, registerAdapter, isSchemaType, isPrimitiveName, isExported, isBuiltinGeneric, isAnonymous, getSourceLocation, getNodeName, getJSDocComment, formatTypeReference, findAdapter, extractStandardSchemas, extractSchemaType, extractParameters, extract, createProgram, collectReferencedTypes, buildSchema, arktypeAdapter, TypeRegistry, StandardSchemaResult, SerializerContext, SchemaAdapter, ProgramResult, ProgramOptions, ExtractResult, ExtractOptions, Diagnostic };

package/dist/src/index.js

@@ -1,10 +1,14 @@
 import {
   TypeRegistry,
+  buildSchema,
   createProgram,
   extract,
   extractParameters,
   getJSDocComment,
   getSourceLocation,
+  isAnonymous,
+  isBuiltinGeneric,
+  isPrimitiveName,
   registerReferencedTypes,
   serializeClass,
   serializeEnum,
@@ -12,7 +16,7 @@ import {
   serializeInterface,
   serializeTypeAlias,
   serializeVariable
-} from "../shared/chunk-twaykyxs.js";
+} from "../shared/chunk-wddga8ye.js";
 // src/schema/adapters/arktype.ts
 var arktypeAdapter = {
   name: "arktype",
@@ -70,32 +74,6 @@ function collectReferencedTypes(type, checker, visited = new Set) {
   visited.add(name);
   return [name];
 }
-// src/types/schema-builder.ts
-function buildSchema(type, checker, depth = 0) {
-  if (depth > 10) {
-    return { type: checker.typeToString(type) };
-  }
-  const typeString = checker.typeToString(type);
-  if (type.flags & 4)
-    return { type: "string" };
-  if (type.flags & 8)
-    return { type: "number" };
-  if (type.flags & 16)
-    return { type: "boolean" };
-  if (type.flags & 32768)
-    return { type: "undefined" };
-  if (type.flags & 65536)
-    return { type: "null" };
-  if (type.flags & 16384)
-    return { type: "void" };
-  if (type.flags & 1)
-    return { type: "any" };
-  if (type.flags & 2)
-    return { type: "unknown" };
-  if (type.flags & 131072)
-    return { type: "never" };
-  return { type: typeString };
-}
 // src/types/utils.ts
 function isExported(node) {
   const modifiers = node.modifiers;
@@ -123,7 +101,10 @@ export {
   registerReferencedTypes,
   registerAdapter,
   isSchemaType,
+  isPrimitiveName,
   isExported,
+  isBuiltinGeneric,
+  isAnonymous,
   getSourceLocation,
   getNodeName,
   getJSDocComment,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/extract",
-  "version": "0.11.4",
+  "version": "0.12.0",
   "description": "TypeScript export extraction to OpenPkg spec",
   "keywords": [
     "openpkg",
@@ -40,7 +40,7 @@
     "format": "biome format --write src/"
   },
   "dependencies": {
-    "@openpkg-ts/spec": "^0.11.1",
+    "@openpkg-ts/spec": "^0.12.0",
     "commander": "^12.0.0",
     "typescript": "^5.0.0"
   },