@openpkg-ts/extract 0.11.4 → 0.13.0

package/dist/shared/chunk-twaykyxs.js

@@ -1,681 +0,0 @@
-// src/ast/registry.ts
-import ts from "typescript";
-var PRIMITIVES = new Set([
-  "string",
-  "number",
-  "boolean",
-  "void",
-  "any",
-  "undefined",
-  "null",
-  "never",
-  "unknown",
-  "object",
-  "symbol",
-  "bigint"
-]);
-var BUILTINS = new Set([
-  "Array",
-  "ArrayBuffer",
-  "ArrayBufferLike",
-  "ArrayLike",
-  "Promise",
-  "Map",
-  "Set",
-  "WeakMap",
-  "WeakSet",
-  "Date",
-  "RegExp",
-  "Error",
-  "Function",
-  "Object",
-  "String",
-  "Number",
-  "Boolean",
-  "Symbol",
-  "BigInt",
-  "Uint8Array",
-  "Int8Array",
-  "Uint16Array",
-  "Int16Array",
-  "Uint32Array",
-  "Int32Array",
-  "Float32Array",
-  "Float64Array",
-  "BigInt64Array",
-  "BigUint64Array",
-  "DataView",
-  "ReadonlyArray",
-  "Readonly",
-  "Partial",
-  "Required",
-  "Pick",
-  "Omit",
-  "Record",
-  "Exclude",
-  "Extract",
-  "NonNullable",
-  "Parameters",
-  "ReturnType",
-  "ConstructorParameters",
-  "InstanceType",
-  "ThisType",
-  "Awaited",
-  "PromiseLike",
-  "Iterable",
-  "Iterator",
-  "IterableIterator",
-  "Generator",
-  "AsyncGenerator",
-  "AsyncIterable",
-  "AsyncIterator",
-  "AsyncIterableIterator",
-  "SharedArrayBuffer",
-  "Atomics",
-  "JSON",
-  "Math",
-  "console",
-  "globalThis"
-]);
-function isGenericTypeParameter(name) {
-  if (/^[A-Z]$/.test(name))
-    return true;
-  if (/^T[A-Z]/.test(name))
-    return true;
-  if (["Key", "Value", "Item", "Element"].includes(name))
-    return true;
-  return false;
-}
-
-class TypeRegistry {
-  types = new Map;
-  processing = new Set;
-  add(type) {
-    this.types.set(type.id, type);
-  }
-  get(id) {
-    return this.types.get(id);
-  }
-  has(id) {
-    return this.types.has(id);
-  }
-  getAll() {
-    return Array.from(this.types.values());
-  }
-  registerType(type, checker, exportedIds) {
-    const symbol = type.getSymbol() || type.aliasSymbol;
-    if (!symbol)
-      return;
-    const name = symbol.getName();
-    if (PRIMITIVES.has(name))
-      return;
-    if (BUILTINS.has(name))
-      return;
-    if (name.startsWith("__"))
-      return;
-    if (symbol.flags & ts.SymbolFlags.EnumMember)
-      return;
-    if (symbol.flags & ts.SymbolFlags.TypeParameter)
-      return;
-    if (isGenericTypeParameter(name))
-      return;
-    if (this.has(name))
-      return name;
-    if (exportedIds.has(name))
-      return name;
-    if (this.processing.has(name))
-      return name;
-    this.processing.add(name);
-    try {
-      const specType = this.buildSpecType(symbol, type, checker);
-      if (specType) {
-        this.add(specType);
-        return specType.id;
-      }
-    } finally {
-      this.processing.delete(name);
-    }
-    return;
-  }
-  buildSpecType(symbol, type, checker) {
-    const name = symbol.getName();
-    const decl = symbol.declarations?.[0];
-    let kind = "type";
-    if (decl) {
-      if (ts.isClassDeclaration(decl))
-        kind = "class";
-      else if (ts.isInterfaceDeclaration(decl))
-        kind = "interface";
-      else if (ts.isEnumDeclaration(decl))
-        kind = "enum";
-    }
-    const typeString = checker.typeToString(type);
-    return {
-      id: name,
-      name,
-      kind,
-      type: typeString !== name ? typeString : undefined
-    };
-  }
-  registerFromSymbol(symbol, checker) {
-    const name = symbol.getName();
-    if (this.has(name))
-      return this.get(name);
-    const type = checker.getDeclaredTypeOfSymbol(symbol);
-    const specType = this.buildSpecType(symbol, type, checker);
-    if (specType) {
-      this.add(specType);
-      return specType;
-    }
-    return;
-  }
-}
-
-// src/ast/utils.ts
-import ts2 from "typescript";
-function parseExamplesFromTags(tags) {
-  const examples = [];
-  for (const tag of tags) {
-    if (tag.name !== "example")
-      continue;
-    const text = tag.text.trim();
-    const fenceMatch = text.match(/^```(\w*)\n([\s\S]*?)\n?```$/);
-    if (fenceMatch) {
-      const lang = fenceMatch[1] || undefined;
-      const code = fenceMatch[2].trim();
-      const example = { code };
-      if (lang && ["ts", "js", "tsx", "jsx", "shell", "json"].includes(lang)) {
-        example.language = lang;
-      }
-      examples.push(example);
-    } else if (text) {
-      examples.push({ code: text });
-    }
-  }
-  return examples;
-}
-function getJSDocComment(node) {
-  const jsDocTags = ts2.getJSDocTags(node);
-  const tags = jsDocTags.map((tag) => ({
-    name: tag.tagName.text,
-    text: typeof tag.comment === "string" ? tag.comment : ts2.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);
-    }
-  }
-  const examples = parseExamplesFromTags(tags);
-  return { description, tags, examples };
-}
-function getSourceLocation(node, sourceFile) {
-  const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-  return {
-    file: sourceFile.fileName,
-    line: line + 1
-  };
-}
-
-// src/compiler/program.ts
-import * as path from "node:path";
-import ts3 from "typescript";
-var DEFAULT_COMPILER_OPTIONS = {
-  target: ts3.ScriptTarget.Latest,
-  module: ts3.ModuleKind.CommonJS,
-  lib: ["lib.es2021.d.ts"],
-  declaration: true,
-  moduleResolution: ts3.ModuleResolutionKind.NodeJs
-};
-function createProgram({
-  entryFile,
-  baseDir = path.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));
-    compilerOptions = { ...compilerOptions, ...parsedConfig.options };
-  }
-  const allowJsVal = compilerOptions.allowJs;
-  if (typeof allowJsVal === "boolean" && allowJsVal) {
-    compilerOptions = { ...compilerOptions, allowJs: false, checkJs: false };
-  }
-  const compilerHost = ts3.createCompilerHost(compilerOptions, true);
-  let inMemorySource;
-  if (content !== undefined) {
-    inMemorySource = ts3.createSourceFile(entryFile, content, ts3.ScriptTarget.Latest, true, ts3.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 = ts3.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, examples } = getJSDocComment(node);
-  const source = getSourceLocation(node, declSourceFile);
-  return {
-    id: name,
-    name,
-    kind: "class",
-    description,
-    tags,
-    source,
-    members: [],
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// 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, examples } = 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,
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// src/types/parameters.ts
-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)
-    };
-  });
-}
-function registerReferencedTypes(type, ctx) {
-  if (ctx.visitedTypes.has(type))
-    return;
-  ctx.visitedTypes.add(type);
-  const { typeChecker: checker, typeRegistry, exportedIds } = ctx;
-  typeRegistry.registerType(type, checker, exportedIds);
-  const typeArgs = type.typeArguments;
-  if (typeArgs) {
-    for (const arg of typeArgs) {
-      registerReferencedTypes(arg, ctx);
-    }
-  }
-  if (type.isUnion()) {
-    for (const t of type.types) {
-      registerReferencedTypes(t, ctx);
-    }
-  }
-  if (type.isIntersection()) {
-    for (const t of type.types) {
-      registerReferencedTypes(t, ctx);
-    }
-  }
-}
-
-// src/serializers/functions.ts
-function serializeFunctionExport(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, examples } = getJSDocComment(node);
-  const source = getSourceLocation(node, declSourceFile);
-  const type = ctx.typeChecker.getTypeAtLocation(node);
-  const callSignatures = type.getCallSignatures();
-  const signatures = callSignatures.map((sig) => {
-    const params = extractParameters(sig, ctx);
-    const returnType = ctx.typeChecker.getReturnTypeOfSignature(sig);
-    registerReferencedTypes(returnType, ctx);
-    return {
-      parameters: params,
-      returns: {
-        schema: { type: ctx.typeChecker.typeToString(returnType) }
-      }
-    };
-  });
-  return {
-    id: name,
-    name,
-    kind: "function",
-    description,
-    tags,
-    source,
-    signatures,
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// src/serializers/interfaces.ts
-function serializeInterface(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, examples } = getJSDocComment(node);
-  const source = getSourceLocation(node, declSourceFile);
-  return {
-    id: name,
-    name,
-    kind: "interface",
-    description,
-    tags,
-    source,
-    members: [],
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// src/serializers/type-aliases.ts
-function serializeTypeAlias(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, examples } = getJSDocComment(node);
-  const source = getSourceLocation(node, declSourceFile);
-  const type = ctx.typeChecker.getTypeAtLocation(node);
-  const typeString = ctx.typeChecker.typeToString(type);
-  return {
-    id: name,
-    name,
-    kind: "type",
-    description,
-    tags,
-    source,
-    ...typeString !== name ? { type: typeString } : {},
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// src/serializers/variables.ts
-function serializeVariable(node, statement, ctx) {
-  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name);
-  const name = symbol?.getName() ?? node.name.getText();
-  if (!name)
-    return null;
-  const declSourceFile = node.getSourceFile();
-  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,
-    name,
-    kind: "variable",
-    description,
-    tags,
-    source,
-    ...typeString && typeString !== name ? { type: typeString } : {},
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// src/builder/spec-builder.ts
-import * as fs from "node:fs";
-import * as path2 from "node:path";
-import { SCHEMA_VERSION } from "@openpkg-ts/spec";
-import ts4 from "typescript";
-
-// src/serializers/context.ts
-function createContext(program, sourceFile, options = {}) {
-  return {
-    typeChecker: program.getTypeChecker(),
-    program,
-    sourceFile,
-    maxTypeDepth: options.maxTypeDepth ?? 20,
-    resolveExternalTypes: options.resolveExternalTypes ?? true,
-    typeRegistry: new TypeRegistry,
-    exportedIds: new Set,
-    visitedTypes: new Set
-  };
-}
-
-// src/builder/spec-builder.ts
-async function extract(options) {
-  const { entryFile, baseDir, content, maxTypeDepth, resolveExternalTypes } = options;
-  const diagnostics = [];
-  const exports = [];
-  const result = createProgram({ entryFile, baseDir, content });
-  const { program, sourceFile } = result;
-  if (!sourceFile) {
-    return {
-      spec: createEmptySpec(entryFile),
-      diagnostics: [{ message: `Could not load source file: ${entryFile}`, severity: "error" }]
-    };
-  }
-  const typeChecker = program.getTypeChecker();
-  const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
-  if (!moduleSymbol) {
-    return {
-      spec: createEmptySpec(entryFile),
-      diagnostics: [{ message: "Could not get module symbol", severity: "warning" }]
-    };
-  }
-  const exportedSymbols = typeChecker.getExportsOfModule(moduleSymbol);
-  const exportedIds = new Set;
-  for (const symbol of exportedSymbols) {
-    exportedIds.add(symbol.getName());
-  }
-  const ctx = createContext(program, sourceFile, { maxTypeDepth, resolveExternalTypes });
-  ctx.exportedIds = exportedIds;
-  for (const symbol of exportedSymbols) {
-    try {
-      const { declaration, targetSymbol } = resolveExportTarget(symbol, typeChecker);
-      if (!declaration)
-        continue;
-      const exportName = symbol.getName();
-      const exp = serializeDeclaration(declaration, symbol, targetSymbol, exportName, ctx);
-      if (exp)
-        exports.push(exp);
-    } catch (err) {
-      diagnostics.push({
-        message: `Failed to serialize ${symbol.getName()}: ${err}`,
-        severity: "warning"
-      });
-    }
-  }
-  const meta = await getPackageMeta(entryFile, baseDir);
-  const spec = {
-    openpkg: SCHEMA_VERSION,
-    meta,
-    exports,
-    types: ctx.typeRegistry.getAll(),
-    generation: {
-      generator: "@openpkg-ts/extract",
-      timestamp: new Date().toISOString()
-    }
-  };
-  return { spec, diagnostics };
-}
-function resolveExportTarget(symbol, checker) {
-  let targetSymbol = symbol;
-  if (symbol.flags & ts4.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];
-  return { declaration, targetSymbol };
-}
-function serializeDeclaration(declaration, exportSymbol, targetSymbol, exportName, ctx) {
-  let result = null;
-  if (ts4.isFunctionDeclaration(declaration)) {
-    result = serializeFunctionExport(declaration, ctx);
-  } else if (ts4.isClassDeclaration(declaration)) {
-    result = serializeClass(declaration, ctx);
-  } else if (ts4.isInterfaceDeclaration(declaration)) {
-    result = serializeInterface(declaration, ctx);
-  } else if (ts4.isTypeAliasDeclaration(declaration)) {
-    result = serializeTypeAlias(declaration, ctx);
-  } else if (ts4.isEnumDeclaration(declaration)) {
-    result = serializeEnum(declaration, ctx);
-  } else if (ts4.isVariableDeclaration(declaration)) {
-    const varStatement = declaration.parent?.parent;
-    if (varStatement && ts4.isVariableStatement(varStatement)) {
-      result = serializeVariable(declaration, varStatement, ctx);
-    }
-  } else if (ts4.isNamespaceExport(declaration) || ts4.isModuleDeclaration(declaration)) {
-    result = serializeNamespaceExport(exportSymbol, exportName, ctx);
-  } else if (ts4.isSourceFile(declaration)) {
-    result = serializeNamespaceExport(exportSymbol, exportName, ctx);
-  }
-  if (result) {
-    result = withExportName(result, exportName);
-  }
-  return result;
-}
-function serializeNamespaceExport(symbol, exportName, ctx) {
-  const { description, tags, examples } = getJSDocFromExportSymbol(symbol);
-  return {
-    id: exportName,
-    name: exportName,
-    kind: "namespace",
-    description,
-    tags,
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-function getJSDocFromExportSymbol(symbol) {
-  const tags = [];
-  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);
-      for (const doc of jsDocs) {
-        if (ts4.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 {
-              description: commentText,
-              tags: extractJSDocTags(doc),
-              examples: extractExamples(doc)
-            };
-          }
-        }
-      }
-    }
-  }
-  const docComment = symbol.getDocumentationComment(undefined);
-  const description = docComment.map((c) => c.text).join(`
-`) || undefined;
-  const jsTags = symbol.getJsDocTags();
-  for (const tag of jsTags) {
-    const text = tag.text?.map((t) => t.text).join("") ?? "";
-    if (tag.name === "example") {
-      examples.push(text);
-    } else {
-      tags.push({ name: tag.name, text });
-    }
-  }
-  return { description, tags, examples };
-}
-function extractJSDocTags(doc) {
-  const tags = [];
-  for (const tag of doc.tags ?? []) {
-    if (tag.tagName.text !== "example") {
-      const text = typeof tag.comment === "string" ? tag.comment : tag.comment?.map((c) => ("text" in c) ? c.text : "").join("") ?? "";
-      tags.push({ name: tag.tagName.text, text });
-    }
-  }
-  return tags;
-}
-function extractExamples(doc) {
-  const examples = [];
-  for (const tag of doc.tags ?? []) {
-    if (tag.tagName.text === "example") {
-      const text = typeof tag.comment === "string" ? tag.comment : tag.comment?.map((c) => ("text" in c) ? c.text : "").join("") ?? "";
-      if (text)
-        examples.push(text);
-    }
-  }
-  return examples;
-}
-function withExportName(entry, exportName) {
-  if (entry.name === exportName) {
-    return entry;
-  }
-  return {
-    ...entry,
-    id: exportName,
-    name: entry.name
-  };
-}
-function createEmptySpec(entryFile) {
-  return {
-    openpkg: SCHEMA_VERSION,
-    meta: { name: path2.basename(entryFile, path2.extname(entryFile)) },
-    exports: [],
-    generation: {
-      generator: "@openpkg-ts/extract",
-      timestamp: new Date().toISOString()
-    }
-  };
-}
-async function getPackageMeta(entryFile, baseDir) {
-  const searchDir = baseDir ?? path2.dirname(entryFile);
-  const pkgPath = path2.join(searchDir, "package.json");
-  try {
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-      return {
-        name: pkg.name ?? path2.basename(searchDir),
-        version: pkg.version,
-        description: pkg.description
-      };
-    }
-  } catch {}
-  return { name: path2.basename(searchDir) };
-}
-export { TypeRegistry, getJSDocComment, getSourceLocation, createProgram, serializeClass, serializeEnum, extractParameters, registerReferencedTypes, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };