@openpkg-ts/extract 0.1.0 → 0.11.1

package/dist/bin/tspec.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   extract
-} from "../shared/chunk-esvc8n1x.js";
+} from "../shared/chunk-570ne82m.js";
 
 // src/cli/spec.ts
-import { Command } from "commander";
-import { normalize, validateSpec } from "@openpkg-ts/spec";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { normalize, validateSpec } from "@openpkg-ts/spec";
+import { Command } from "commander";
 function createProgram() {
   const program = new Command("tspec").description("Extract TypeScript package API to OpenPkg spec").argument("[entry]", "Entry point file").option("-o, --output <file>", "Output file", "openpkg.json").option("--max-depth <n>", "Max type depth", "20").option("--skip-resolve", "Skip external type resolution").option("--runtime", "Enable Standard Schema runtime extraction").action(async (entry, options) => {
     const entryFile = entry || findEntryPoint(process.cwd());

package/dist/shared/{chunk-esvc8n1x.js → chunk-570ne82m.js}

@@ -1,52 +1,3 @@
-// src/compiler/program.ts
-import * as path from "node:path";
-import ts from "typescript";
-var DEFAULT_COMPILER_OPTIONS = {
-  target: ts.ScriptTarget.Latest,
-  module: ts.ModuleKind.CommonJS,
-  lib: ["lib.es2021.d.ts"],
-  declaration: true,
-  moduleResolution: ts.ModuleResolutionKind.NodeJs
-};
-function createProgram({
-  entryFile,
-  baseDir = path.dirname(entryFile),
-  content
-}) {
-  const configPath = ts.findConfigFile(baseDir, ts.sys.fileExists, "tsconfig.json");
-  let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
-  if (configPath) {
-    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
-    compilerOptions = { ...compilerOptions, ...parsedConfig.options };
-  }
-  const allowJsVal = compilerOptions.allowJs;
-  if (typeof allowJsVal === "boolean" && allowJsVal) {
-    compilerOptions = { ...compilerOptions, allowJs: false, checkJs: false };
-  }
-  const compilerHost = ts.createCompilerHost(compilerOptions, true);
-  let inMemorySource;
-  if (content !== undefined) {
-    inMemorySource = ts.createSourceFile(entryFile, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const originalGetSourceFile = compilerHost.getSourceFile.bind(compilerHost);
-    compilerHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-      if (fileName === entryFile) {
-        return inMemorySource;
-      }
-      return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
-    };
-  }
-  const program = ts.createProgram([entryFile], compilerOptions, compilerHost);
-  const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
-  return {
-    program,
-    compilerHost,
-    compilerOptions,
-    sourceFile,
-    configPath
-  };
-}
-
 // src/ast/registry.ts
 class TypeRegistry {
   types = new Map;
@@ -77,19 +28,19 @@ class TypeRegistry {
 }
 
 // src/ast/utils.ts
-import ts2 from "typescript";
+import ts from "typescript";
 function getJSDocComment(node) {
-  const jsDocTags = ts2.getJSDocTags(node);
+  const jsDocTags = ts.getJSDocTags(node);
   const tags = jsDocTags.map((tag) => ({
     name: tag.tagName.text,
-    text: typeof tag.comment === "string" ? tag.comment : ts2.getTextOfJSDocComment(tag.comment) ?? ""
+    text: typeof tag.comment === "string" ? tag.comment : ts.getTextOfJSDocComment(tag.comment) ?? ""
   }));
   const jsDocComments = node.jsDoc;
   let description;
   if (jsDocComments && jsDocComments.length > 0) {
     const firstDoc = jsDocComments[0];
     if (firstDoc.comment) {
-      description = typeof firstDoc.comment === "string" ? firstDoc.comment : ts2.getTextOfJSDocComment(firstDoc.comment);
+      description = typeof firstDoc.comment === "string" ? firstDoc.comment : ts.getTextOfJSDocComment(firstDoc.comment);
     }
   }
   return { description, tags };
@@ -102,6 +53,104 @@ function getSourceLocation(node, sourceFile) {
   };
 }
 
+// src/compiler/program.ts
+import * as path from "node:path";
+import ts2 from "typescript";
+var DEFAULT_COMPILER_OPTIONS = {
+  target: ts2.ScriptTarget.Latest,
+  module: ts2.ModuleKind.CommonJS,
+  lib: ["lib.es2021.d.ts"],
+  declaration: true,
+  moduleResolution: ts2.ModuleResolutionKind.NodeJs
+};
+function createProgram({
+  entryFile,
+  baseDir = path.dirname(entryFile),
+  content
+}) {
+  const configPath = ts2.findConfigFile(baseDir, ts2.sys.fileExists, "tsconfig.json");
+  let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
+  if (configPath) {
+    const configFile = ts2.readConfigFile(configPath, ts2.sys.readFile);
+    const parsedConfig = ts2.parseJsonConfigFileContent(configFile.config, ts2.sys, path.dirname(configPath));
+    compilerOptions = { ...compilerOptions, ...parsedConfig.options };
+  }
+  const allowJsVal = compilerOptions.allowJs;
+  if (typeof allowJsVal === "boolean" && allowJsVal) {
+    compilerOptions = { ...compilerOptions, allowJs: false, checkJs: false };
+  }
+  const compilerHost = ts2.createCompilerHost(compilerOptions, true);
+  let inMemorySource;
+  if (content !== undefined) {
+    inMemorySource = ts2.createSourceFile(entryFile, content, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
+    const originalGetSourceFile = compilerHost.getSourceFile.bind(compilerHost);
+    compilerHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+      if (fileName === entryFile) {
+        return inMemorySource;
+      }
+      return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+    };
+  }
+  const program = ts2.createProgram([entryFile], compilerOptions, compilerHost);
+  const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
+  return {
+    program,
+    compilerHost,
+    compilerOptions,
+    sourceFile,
+    configPath
+  };
+}
+
+// src/serializers/classes.ts
+function serializeClass(node, ctx) {
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  return {
+    id: name,
+    name,
+    kind: "class",
+    description,
+    tags,
+    source,
+    members: []
+  };
+}
+
+// src/serializers/enums.ts
+function serializeEnum(node, ctx) {
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  const members = node.members.map((member) => {
+    const memberSymbol = ctx.typeChecker.getSymbolAtLocation(member.name);
+    const memberName = memberSymbol?.getName() ?? member.name.getText();
+    return {
+      id: memberName,
+      name: memberName,
+      kind: "enum-member"
+    };
+  });
+  return {
+    id: name,
+    name,
+    kind: "enum",
+    description,
+    tags,
+    source,
+    members
+  };
+}
+
 // src/types/parameters.ts
 function extractParameters(signature, checker) {
   return signature.getParameters().map((param) => {
@@ -146,26 +195,6 @@ function serializeFunctionExport(node, ctx) {
   };
 }
 
-// src/serializers/classes.ts
-function serializeClass(node, ctx) {
-  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
-  const name = symbol?.getName() ?? node.name?.getText();
-  if (!name)
-    return null;
-  const declSourceFile = node.getSourceFile();
-  const { description, tags } = getJSDocComment(node);
-  const source = getSourceLocation(node, declSourceFile);
-  return {
-    id: name,
-    name,
-    kind: "class",
-    description,
-    tags,
-    source,
-    members: []
-  };
-}
-
 // src/serializers/interfaces.ts
 function serializeInterface(node, ctx) {
   const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
@@ -208,35 +237,6 @@ function serializeTypeAlias(node, ctx) {
   };
 }
 
-// src/serializers/enums.ts
-function serializeEnum(node, ctx) {
-  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
-  const name = symbol?.getName() ?? node.name?.getText();
-  if (!name)
-    return null;
-  const declSourceFile = node.getSourceFile();
-  const { description, tags } = getJSDocComment(node);
-  const source = getSourceLocation(node, declSourceFile);
-  const members = node.members.map((member) => {
-    const memberSymbol = ctx.typeChecker.getSymbolAtLocation(member.name);
-    const memberName = memberSymbol?.getName() ?? member.name.getText();
-    return {
-      id: memberName,
-      name: memberName,
-      kind: "enum-member"
-    };
-  });
-  return {
-    id: name,
-    name,
-    kind: "enum",
-    description,
-    tags,
-    source,
-    members
-  };
-}
-
 // src/serializers/variables.ts
 function serializeVariable(node, statement, ctx) {
   const symbol = ctx.typeChecker.getSymbolAtLocation(node.name);
@@ -260,8 +260,10 @@ function serializeVariable(node, statement, ctx) {
 }
 
 // src/builder/spec-builder.ts
-import ts3 from "typescript";
+import * as fs from "node:fs";
+import * as path2 from "node:path";
 import { SCHEMA_VERSION } from "@openpkg-ts/spec";
+import ts3 from "typescript";
 
 // src/serializers/context.ts
 function createContext(program, sourceFile, options = {}) {
@@ -276,8 +278,6 @@ function createContext(program, sourceFile, options = {}) {
 }
 
 // src/builder/spec-builder.ts
-import * as path2 from "node:path";
-import * as fs from "node:fs";
 async function extract(options) {
   const { entryFile, baseDir, content, maxTypeDepth, resolveExternalTypes } = options;
   const diagnostics = [];
@@ -400,4 +400,4 @@ async function getPackageMeta(entryFile, baseDir) {
   } catch {}
   return { name: path2.basename(searchDir) };
 }
-export { createProgram, TypeRegistry, getJSDocComment, getSourceLocation, extractParameters, serializeFunctionExport, serializeClass, serializeInterface, serializeTypeAlias, serializeEnum, serializeVariable, extract };
+export { TypeRegistry, getJSDocComment, getSourceLocation, createProgram, serializeClass, serializeEnum, extractParameters, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };

package/dist/src/index.d.ts

@@ -1,3 +1,20 @@
+import { SpecType } from "@openpkg-ts/spec";
+import ts from "typescript";
+declare class TypeRegistry {
+	private types;
+	add(type: SpecType): void;
+	get(id: string): SpecType | undefined;
+	has(id: string): boolean;
+	getAll(): SpecType[];
+	registerFromSymbol(symbol: ts.Symbol, checker: ts.TypeChecker): SpecType | undefined;
+}
+import { SpecSource, SpecTag } from "@openpkg-ts/spec";
+import ts2 from "typescript";
+declare function getJSDocComment(node: ts2.Node): {
+	description?: string;
+	tags: SpecTag[];
+};
+declare function getSourceLocation(node: ts2.Node, sourceFile: ts2.SourceFile): SpecSource;
 import { OpenPkg } from "@openpkg-ts/spec";
 interface ExtractOptions {
 	entryFile: string;
@@ -28,96 +45,79 @@ interface SerializerContext {
 	resolveExternalTypes: boolean;
 }
 declare function extract(options: ExtractOptions): Promise<ExtractResult>;
-import ts from "typescript";
+import ts3 from "typescript";
+interface ProgramOptions {
+	entryFile: string;
+	baseDir?: string;
+	content?: string;
+}
+interface ProgramResult {
+	program: ts3.Program;
+	compilerHost: ts3.CompilerHost;
+	compilerOptions: ts3.CompilerOptions;
+	sourceFile?: ts3.SourceFile;
+	configPath?: string;
+}
+declare function createProgram({ entryFile, baseDir, content }: ProgramOptions): ProgramResult;
 import { SpecSchema } from "@openpkg-ts/spec";
+import ts4 from "typescript";
 type SchemaAdapter = {
 	name: string;
-	detect: (node: ts.Node, checker: ts.TypeChecker) => boolean;
-	extract: (node: ts.Node, checker: ts.TypeChecker) => SpecSchema | null;
+	detect: (node: ts4.Node, checker: ts4.TypeChecker) => boolean;
+	extract: (node: ts4.Node, checker: ts4.TypeChecker) => SpecSchema | null;
 };
 declare function registerAdapter(adapter: SchemaAdapter): void;
-declare function findAdapter(node: ts.Node, checker: ts.TypeChecker): SchemaAdapter | undefined;
-declare function isSchemaType(node: ts.Node, checker: ts.TypeChecker): boolean;
-declare function extractSchemaType(node: ts.Node, checker: ts.TypeChecker): SpecSchema | null;
-declare const zodAdapter: SchemaAdapter;
-declare const typeboxAdapter: SchemaAdapter;
+declare function findAdapter(node: ts4.Node, checker: ts4.TypeChecker): SchemaAdapter | undefined;
+declare function isSchemaType(node: ts4.Node, checker: ts4.TypeChecker): boolean;
+declare function extractSchemaType(node: ts4.Node, checker: ts4.TypeChecker): SpecSchema | null;
 declare const arktypeAdapter: SchemaAdapter;
+declare const typeboxAdapter: SchemaAdapter;
 declare const valibotAdapter: SchemaAdapter;
-import ts2 from "typescript";
+declare const zodAdapter: SchemaAdapter;
 import { SpecSchema as SpecSchema2 } from "@openpkg-ts/spec";
+import ts5 from "typescript";
 interface StandardSchemaResult {
 	schema: SpecSchema2;
 	vendor: string;
 }
-declare function extractStandardSchemas(_program: ts2.Program, _entryFile: string): StandardSchemaResult[];
-import ts3 from "typescript";
-declare function formatTypeReference(type: ts3.Type, checker: ts3.TypeChecker): string;
-declare function collectReferencedTypes(type: ts3.Type, checker: ts3.TypeChecker, visited?: Set<string>): string[];
-import ts4 from "typescript";
-declare function isExported(node: ts4.Node): boolean;
-declare function getNodeName(node: ts4.Node): string | undefined;
-import ts5 from "typescript";
-import { SpecSignatureParameter } from "@openpkg-ts/spec";
-declare function extractParameters(signature: ts5.Signature, checker: ts5.TypeChecker): SpecSignatureParameter[];
-import ts6 from "typescript";
-import { SpecSchema as SpecSchema3 } from "@openpkg-ts/spec";
-declare function buildSchema(type: ts6.Type, checker: ts6.TypeChecker, depth?: number): SpecSchema3;
-import ts7 from "typescript";
-import { SpecSource, SpecTag } from "@openpkg-ts/spec";
-declare function getJSDocComment(node: ts7.Node): {
-	description?: string;
-	tags: SpecTag[];
-};
-declare function getSourceLocation(node: ts7.Node, sourceFile: ts7.SourceFile): SpecSource;
-import ts8 from "typescript";
-import { SpecType } from "@openpkg-ts/spec";
-declare class TypeRegistry {
-	private types;
-	add(type: SpecType): void;
-	get(id: string): SpecType | undefined;
-	has(id: string): boolean;
-	getAll(): SpecType[];
-	registerFromSymbol(symbol: ts8.Symbol, checker: ts8.TypeChecker): SpecType | undefined;
-}
-import ts10 from "typescript";
+declare function extractStandardSchemas(_program: ts5.Program, _entryFile: string): StandardSchemaResult[];
 import { SpecExport } from "@openpkg-ts/spec";
-import ts9 from "typescript";
+import ts7 from "typescript";
+import ts6 from "typescript";
 interface SerializerContext2 {
-	typeChecker: ts9.TypeChecker;
-	program: ts9.Program;
-	sourceFile: ts9.SourceFile;
+	typeChecker: ts6.TypeChecker;
+	program: ts6.Program;
+	sourceFile: ts6.SourceFile;
 	maxTypeDepth: number;
 	resolveExternalTypes: boolean;
 	typeRegistry: TypeRegistry;
 }
-declare function serializeFunctionExport(node: ts10.FunctionDeclaration | ts10.ArrowFunction, ctx: SerializerContext2): SpecExport | null;
-import ts11 from "typescript";
+declare function serializeClass(node: ts7.ClassDeclaration, ctx: SerializerContext2): SpecExport | null;
 import { SpecExport as SpecExport2 } from "@openpkg-ts/spec";
-declare function serializeClass(node: ts11.ClassDeclaration, ctx: SerializerContext2): SpecExport2 | null;
-import ts12 from "typescript";
+import ts8 from "typescript";
+declare function serializeEnum(node: ts8.EnumDeclaration, ctx: SerializerContext2): SpecExport2 | null;
 import { SpecExport as SpecExport3 } from "@openpkg-ts/spec";
-declare function serializeInterface(node: ts12.InterfaceDeclaration, ctx: SerializerContext2): SpecExport3 | null;
-import ts13 from "typescript";
+import ts9 from "typescript";
+declare function serializeFunctionExport(node: ts9.FunctionDeclaration | ts9.ArrowFunction, ctx: SerializerContext2): SpecExport3 | null;
 import { SpecExport as SpecExport4 } from "@openpkg-ts/spec";
-declare function serializeTypeAlias(node: ts13.TypeAliasDeclaration, ctx: SerializerContext2): SpecExport4 | null;
-import ts14 from "typescript";
+import ts10 from "typescript";
+declare function serializeInterface(node: ts10.InterfaceDeclaration, ctx: SerializerContext2): SpecExport4 | null;
 import { SpecExport as SpecExport5 } from "@openpkg-ts/spec";
-declare function serializeEnum(node: ts14.EnumDeclaration, ctx: SerializerContext2): SpecExport5 | null;
-import ts15 from "typescript";
+import ts11 from "typescript";
+declare function serializeTypeAlias(node: ts11.TypeAliasDeclaration, ctx: SerializerContext2): SpecExport5 | null;
 import { SpecExport as SpecExport6 } from "@openpkg-ts/spec";
-declare function serializeVariable(node: ts15.VariableDeclaration, statement: ts15.VariableStatement, ctx: SerializerContext2): SpecExport6 | null;
+import ts12 from "typescript";
+declare function serializeVariable(node: ts12.VariableDeclaration, statement: ts12.VariableStatement, ctx: SerializerContext2): 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, checker: ts14.TypeChecker): SpecSignatureParameter[];
+import { SpecSchema as SpecSchema3 } from "@openpkg-ts/spec";
+import ts15 from "typescript";
+declare function buildSchema(type: ts15.Type, checker: ts15.TypeChecker, depth?: number): SpecSchema3;
 import ts16 from "typescript";
-interface ProgramOptions {
-	entryFile: string;
-	baseDir?: string;
-	content?: string;
-}
-interface ProgramResult {
-	program: ts16.Program;
-	compilerHost: ts16.CompilerHost;
-	compilerOptions: ts16.CompilerOptions;
-	sourceFile?: ts16.SourceFile;
-	configPath?: string;
-}
-declare function createProgram({ entryFile, baseDir, content }: ProgramOptions): ProgramResult;
+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, 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 };

package/dist/src/index.js

@@ -11,10 +11,10 @@ import {
   serializeInterface,
   serializeTypeAlias,
   serializeVariable
-} from "../shared/chunk-esvc8n1x.js";
-// src/schema/adapters/zod.ts
-var zodAdapter = {
-  name: "zod",
+} from "../shared/chunk-570ne82m.js";
+// src/schema/adapters/arktype.ts
+var arktypeAdapter = {
+  name: "arktype",
   detect: () => false,
   extract: () => null
 };
@@ -24,18 +24,18 @@ var typeboxAdapter = {
   detect: () => false,
   extract: () => null
 };
-// src/schema/adapters/arktype.ts
-var arktypeAdapter = {
-  name: "arktype",
-  detect: () => false,
-  extract: () => null
-};
 // src/schema/adapters/valibot.ts
 var valibotAdapter = {
   name: "valibot",
   detect: () => false,
   extract: () => null
 };
+// src/schema/adapters/zod.ts
+var zodAdapter = {
+  name: "zod",
+  detect: () => false,
+  extract: () => null
+};
 // src/schema/registry.ts
 var adapters = [];
 function registerAdapter(adapter) {
@@ -69,20 +69,6 @@ function collectReferencedTypes(type, checker, visited = new Set) {
   visited.add(name);
   return [name];
 }
-// src/types/utils.ts
-function isExported(node) {
-  const modifiers = node.modifiers;
-  if (!modifiers)
-    return false;
-  return modifiers.some((m) => m.kind === 95);
-}
-function getNodeName(node) {
-  if ("name" in node && node.name) {
-    const name = node.name;
-    return name.text;
-  }
-  return;
-}
 // src/types/schema-builder.ts
 function buildSchema(type, checker, depth = 0) {
   if (depth > 10) {
@@ -109,6 +95,20 @@ function buildSchema(type, checker, depth = 0) {
     return { type: "never" };
   return { type: typeString };
 }
+// src/types/utils.ts
+function isExported(node) {
+  const modifiers = node.modifiers;
+  if (!modifiers)
+    return false;
+  return modifiers.some((m) => m.kind === 95);
+}
+function getNodeName(node) {
+  if ("name" in node && node.name) {
+    const name = node.name;
+    return name.text;
+  }
+  return;
+}
 export {
   zodAdapter,
   valibotAdapter,

package/package.json

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