@openpkg-ts/sdk 0.38.0 → 0.39.0

package/dist/index.d.ts

@@ -1551,7 +1551,7 @@ interface ProgramResult {
 	/** Resolved project references (workspace packages) */
 	projectReferences?: ts7.ResolvedProjectReference[];
 }
-declare function createProgram({ entryFile, baseDir, content }: ProgramOptions): ProgramResult;
+declare function createProgram(options: ProgramOptions): ProgramResult;
 import * as TS from "typescript";
 /**
 * A schema adapter can detect and extract output types from a specific

package/dist/index.js

@@ -1298,6 +1298,7 @@ function filterSpec(spec, criteria) {
 import ts11 from "typescript";
 
 // src/ast/utils.ts
+import * as path2 from "node:path";
 import ts from "typescript";
 function parseExamplesFromTags(tags) {
   const examples = [];
@@ -1442,8 +1443,10 @@ function getJSDocComment(node, symbol, checker) {
 }
 function getSourceLocation(node, sourceFile) {
   const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  const relative2 = path2.relative(process.cwd(), sourceFile.fileName);
+  const file = relative2.startsWith("..") ? sourceFile.fileName : relative2;
   return {
-    file: sourceFile.fileName,
+    file,
     line: line + 1
   };
 }
@@ -1614,7 +1617,7 @@ function getExportKind(declaration, type) {
 
 // src/compiler/program.ts
 import * as fs3 from "node:fs";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 import ts2 from "typescript";
 function isJsFile(file) {
   return /\.(js|mjs|cjs|jsx)$/.test(file);
@@ -1635,21 +1638,37 @@ var DEFAULT_COMPILER_OPTIONS = {
   declaration: true,
   moduleResolution: ts2.ModuleResolutionKind.NodeJs
 };
+function resolveWorkspaceEntry(pkgDir) {
+  const candidates = [
+    path3.join(pkgDir, "src", "index.ts"),
+    path3.join(pkgDir, "src", "index.tsx"),
+    path3.join(pkgDir, "index.ts")
+  ];
+  try {
+    const pkg = JSON.parse(fs3.readFileSync(path3.join(pkgDir, "package.json"), "utf-8"));
+    for (const field of [pkg.types, pkg.typings]) {
+      if (typeof field === "string") {
+        candidates.push(path3.resolve(pkgDir, field));
+      }
+    }
+  } catch {}
+  return candidates.find((c) => fs3.existsSync(c));
+}
 function resolveProjectReferences(configPath, parsedConfig) {
   const additionalFiles = [];
   if (!parsedConfig.projectReferences?.length) {
     return additionalFiles;
   }
-  const configDir = path2.dirname(configPath);
+  const configDir = path3.dirname(configPath);
   for (const ref of parsedConfig.projectReferences) {
-    const refPath = path2.resolve(configDir, ref.path);
-    const refConfigPath = fs3.existsSync(path2.join(refPath, "tsconfig.json")) ? path2.join(refPath, "tsconfig.json") : refPath;
+    const refPath = path3.resolve(configDir, ref.path);
+    const refConfigPath = fs3.existsSync(path3.join(refPath, "tsconfig.json")) ? path3.join(refPath, "tsconfig.json") : refPath;
     if (!fs3.existsSync(refConfigPath))
       continue;
     const refConfigFile = ts2.readConfigFile(refConfigPath, ts2.sys.readFile);
     if (refConfigFile.error)
       continue;
-    const refParsed = ts2.parseJsonConfigFileContent(refConfigFile.config, ts2.sys, path2.dirname(refConfigPath));
+    const refParsed = ts2.parseJsonConfigFileContent(refConfigFile.config, ts2.sys, path3.dirname(refConfigPath));
     additionalFiles.push(...refParsed.fileNames);
   }
   return additionalFiles;
@@ -1682,7 +1701,7 @@ function buildWorkspaceMap(baseDir) {
   let rootDir;
   let workspaceGlobs = [];
   for (let i = 0;i < 10; i++) {
-    const pnpmPath = path2.join(currentDir, "pnpm-workspace.yaml");
+    const pnpmPath = path3.join(currentDir, "pnpm-workspace.yaml");
     if (fs3.existsSync(pnpmPath)) {
       try {
         const yamlContent = fs3.readFileSync(pnpmPath, "utf-8");
@@ -1693,7 +1712,7 @@ function buildWorkspaceMap(baseDir) {
         }
       } catch {}
     }
-    const pkgPath = path2.join(currentDir, "package.json");
+    const pkgPath = path3.join(currentDir, "package.json");
     if (fs3.existsSync(pkgPath)) {
       try {
         const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
@@ -1704,7 +1723,7 @@ function buildWorkspaceMap(baseDir) {
         }
       } catch {}
     }
-    const parent = path2.dirname(currentDir);
+    const parent = path3.dirname(currentDir);
     if (parent === currentDir)
       break;
     currentDir = parent;
@@ -1713,33 +1732,31 @@ function buildWorkspaceMap(baseDir) {
     return;
   const packages = new Map;
   for (const glob of workspaceGlobs) {
-    const globDir = path2.join(rootDir, glob.replace(/\/\*$/, ""));
+    const globDir = path3.join(rootDir, glob.replace(/\/\*$/, ""));
     if (!fs3.existsSync(globDir) || !fs3.statSync(globDir).isDirectory())
       continue;
     const entries = fs3.readdirSync(globDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const pkgDir = path2.join(globDir, entry.name);
-      const pkgJsonPath = path2.join(pkgDir, "package.json");
+      const pkgDir = path3.join(globDir, entry.name);
+      const pkgJsonPath = path3.join(pkgDir, "package.json");
       if (!fs3.existsSync(pkgJsonPath))
         continue;
       try {
         const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
         if (pkg.name) {
-          const srcDir = fs3.existsSync(path2.join(pkgDir, "src")) ? path2.join(pkgDir, "src") : pkgDir;
-          packages.set(pkg.name, srcDir);
+          packages.set(pkg.name, pkgDir);
         }
       } catch {}
     }
   }
   return packages.size > 0 ? { packages, rootDir } : undefined;
 }
-function createProgram({
-  entryFile,
-  baseDir = path2.dirname(entryFile),
-  content
-}) {
+function createProgram(options) {
+  const { content } = options;
+  const entryFile = path3.resolve(options.entryFile);
+  const baseDir = path3.resolve(options.baseDir ?? path3.dirname(entryFile));
   let configPath = ts2.findConfigFile(baseDir, ts2.sys.fileExists, "tsconfig.json");
   if (!configPath) {
     configPath = ts2.findConfigFile(baseDir, ts2.sys.fileExists, "jsconfig.json");
@@ -1748,7 +1765,7 @@ function createProgram({
   let additionalRootFiles = [];
   if (configPath) {
     const configFile = ts2.readConfigFile(configPath, ts2.sys.readFile);
-    const parsedConfig = ts2.parseJsonConfigFileContent(configFile.config, ts2.sys, path2.dirname(configPath));
+    const parsedConfig = ts2.parseJsonConfigFileContent(configFile.config, ts2.sys, path3.dirname(configPath));
     compilerOptions = { ...compilerOptions, ...parsedConfig.options };
     additionalRootFiles = resolveProjectReferences(configPath, parsedConfig);
     const sourceFiles = parsedConfig.fileNames.filter((f) => !f.includes(".test.") && !f.includes(".spec.") && !f.includes("/dist/") && !f.includes("/node_modules/"));
@@ -1772,20 +1789,20 @@ function createProgram({
   let inMemorySource;
   if (workspaceMap) {
     const originalResolveModuleNames = compilerHost.resolveModuleNames?.bind(compilerHost);
-    compilerHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options) => {
+    compilerHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options2) => {
       return moduleNames.map((moduleName) => {
-        const srcDir = workspaceMap.packages.get(moduleName);
-        if (srcDir) {
-          const indexFile = path2.join(srcDir, "index.ts");
-          if (fs3.existsSync(indexFile)) {
-            return { resolvedFileName: indexFile, isExternalLibraryImport: false };
+        const pkgDir = workspaceMap.packages.get(moduleName);
+        if (pkgDir) {
+          const entryPath = resolveWorkspaceEntry(pkgDir);
+          if (entryPath) {
+            return { resolvedFileName: entryPath, isExternalLibraryImport: false };
           }
         }
         if (originalResolveModuleNames) {
-          const result = originalResolveModuleNames([moduleName], containingFile, _reusedNames, redirectedReference, options);
+          const result = originalResolveModuleNames([moduleName], containingFile, _reusedNames, redirectedReference, options2);
           return result[0];
         }
-        const resolved = ts2.resolveModuleName(moduleName, containingFile, options, compilerHost);
+        const resolved = ts2.resolveModuleName(moduleName, containingFile, options2, compilerHost);
         return resolved.resolvedModule;
       });
     };
@@ -1893,6 +1910,18 @@ var BUILTIN_GENERICS = new Set([
   "InstanceType",
   "Awaited"
 ]);
+var RESOLVED_UTILITY_TYPES = new Set([
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Record",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "Awaited"
+]);
 var BUILTIN_TYPES = new Set([
   "Date",
   "RegExp",
@@ -2318,6 +2347,13 @@ function buildSchemaInternal(type, checker, ctx) {
       if (BUILTIN_TYPES.has(name)) {
         return { $ref: `#/types/${name}` };
       }
+      if (RESOLVED_UTILITY_TYPES.has(name) && type.flags & ts3.TypeFlags.Object) {
+        const props = type.getProperties();
+        const hasIndex = checker.getIndexInfosOfType(type).length > 0;
+        if (props.length > 0 || hasIndex) {
+          return buildObjectSchema(props, checker, ctx, type);
+        }
+      }
       if (isBuiltinGeneric(name) || !name.startsWith("__")) {
         const packageOrigin = getTypeOrigin(type, checker);
         if (ctx) {
@@ -2432,7 +2468,11 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       properties: props,
       ...required.length > 0 ? { required } : {}
     };
-    if (Object.keys(props).length === 0 && originalType) {
+    const stringIndex = originalType ? checker.getIndexInfosOfType(originalType).find((i) => i.keyType.flags & ts3.TypeFlags.String) : undefined;
+    if (stringIndex) {
+      schema.additionalProperties = buildSchema(stringIndex.type, checker, ctx);
+    }
+    if (Object.keys(props).length === 0 && originalType && !stringIndex) {
       setSchemaExtension(schema, "x-ts-type", checker.typeToString(originalType));
     }
     return schema;
@@ -2947,7 +2987,8 @@ class TypeRegistry {
   }
   buildObjectSchemaFromProperties(type, checker, ctx) {
     const properties = type.getProperties();
-    if (properties.length === 0) {
+    const stringIndex = checker.getIndexInfosOfType(type).find((i) => i.keyType.flags & ts5.TypeFlags.String);
+    if (properties.length === 0 && !stringIndex) {
       return { type: checker.typeToString(type) };
     }
     const props = {};
@@ -2980,7 +3021,8 @@ class TypeRegistry {
     return {
       type: "object",
       properties: props,
-      ...required.length > 0 ? { required } : {}
+      ...required.length > 0 ? { required } : {},
+      ...stringIndex ? { additionalProperties: buildSchema(stringIndex.type, checker, ctx) } : {}
     };
   }
 }
@@ -4628,7 +4670,7 @@ function detectExternalPackage(symbol, checker) {
   return;
 }
 // src/primitives/list.ts
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 import ts12 from "typescript";
 async function listExports(options) {
   const { entryFile, baseDir, content } = options;
@@ -4689,7 +4731,7 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
     return {
       name,
       kind: "namespace",
-      file: path3.relative(path3.dirname(entryFile), declaration.fileName),
+      file: path4.relative(path4.dirname(entryFile), declaration.fileName),
       line: 1,
       reexport: true
     };
@@ -4703,7 +4745,7 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
   return {
     name,
     kind,
-    file: path3.relative(path3.dirname(entryFile), sourceFile.fileName),
+    file: path4.relative(path4.dirname(entryFile), sourceFile.fileName),
     line: line + 1,
     ...description ? { description } : {},
     ...deprecated ? { deprecated: true } : {},
@@ -4725,7 +4767,7 @@ function getDescriptionPreview(symbol, checker) {
 }
 // src/builder/spec-builder.ts
 import * as fs6 from "node:fs";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 import { SCHEMA_URL, SCHEMA_VERSION } from "@openpkg-ts/spec";
 import ts16 from "typescript";
 
@@ -4763,7 +4805,7 @@ function resolveExportTarget2(symbol, checker) {
 import { spawn, spawnSync } from "node:child_process";
 import * as fs4 from "node:fs";
 import * as os from "node:os";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 var MAX_BUFFER_SIZE = 10 * 1024 * 1024;
 function isStandardJSONSchema(obj) {
   if (typeof obj !== "object" || obj === null)
@@ -5022,7 +5064,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
     return result;
   }
   const tempDir = os.tmpdir();
-  const workerPath = path4.join(tempDir, `openpkg-extract-worker-${Date.now()}.ts`);
+  const workerPath = path5.join(tempDir, `openpkg-extract-worker-${Date.now()}.ts`);
   try {
     fs4.writeFileSync(workerPath, TS_WORKER_SCRIPT);
     const optionsJson = JSON.stringify({ target, libraryOptions });
@@ -5031,7 +5073,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
       const child = spawn(runtime.cmd, args, {
         timeout,
         stdio: ["ignore", "pipe", "pipe"],
-        cwd: path4.dirname(tsFilePath)
+        cwd: path5.dirname(tsFilePath)
       });
       let stdout = "";
       let stderr = "";
@@ -5132,7 +5174,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
   }
 }
 function readTsconfigOutDir(baseDir) {
-  const tsconfigPath = path4.join(baseDir, "tsconfig.json");
+  const tsconfigPath = path5.join(baseDir, "tsconfig.json");
   try {
     if (!fs4.existsSync(tsconfigPath)) {
       return null;
@@ -5147,7 +5189,7 @@ function readTsconfigOutDir(baseDir) {
   return null;
 }
 function resolveCompiledPath(tsPath, baseDir) {
-  const relativePath = path4.relative(baseDir, tsPath);
+  const relativePath = path5.relative(baseDir, tsPath);
   const withoutExt = relativePath.replace(/\.tsx?$/, "");
   const srcPrefix = withoutExt.replace(/^src\//, "");
   const tsconfigOutDir = readTsconfigOutDir(baseDir);
@@ -5155,7 +5197,7 @@ function resolveCompiledPath(tsPath, baseDir) {
   const candidates = [];
   if (tsconfigOutDir) {
     for (const ext of extensions) {
-      candidates.push(path4.join(baseDir, tsconfigOutDir, `${srcPrefix}${ext}`));
+      candidates.push(path5.join(baseDir, tsconfigOutDir, `${srcPrefix}${ext}`));
     }
   }
   const commonOutDirs = ["dist", "build", "lib", "out"];
@@ -5163,17 +5205,17 @@ function resolveCompiledPath(tsPath, baseDir) {
     if (outDir === tsconfigOutDir)
       continue;
     for (const ext of extensions) {
-      candidates.push(path4.join(baseDir, outDir, `${srcPrefix}${ext}`));
+      candidates.push(path5.join(baseDir, outDir, `${srcPrefix}${ext}`));
     }
   }
   for (const ext of extensions) {
-    candidates.push(path4.join(baseDir, `${withoutExt}${ext}`));
+    candidates.push(path5.join(baseDir, `${withoutExt}${ext}`));
   }
   const workspaceMatch = baseDir.match(/^(.+\/packages\/[^/]+)$/);
   if (workspaceMatch) {
     const pkgRoot = workspaceMatch[1];
     for (const ext of extensions) {
-      candidates.push(path4.join(pkgRoot, "dist", `${srcPrefix}${ext}`));
+      candidates.push(path5.join(pkgRoot, "dist", `${srcPrefix}${ext}`));
     }
   }
   for (const candidate of candidates) {
@@ -5307,7 +5349,7 @@ async function extractStandardSchemasFromProject(entryFile, baseDir, options = {
 
 // src/builder/external-resolver.ts
 import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 import picomatch from "picomatch";
 import ts14 from "typescript";
 function matchesExternalPattern(packageName, include, exclude) {
@@ -5341,11 +5383,11 @@ function findPackageJson(resolvedPath, packageName) {
   const isScoped = packageName.startsWith("@");
   const packageParts = isScoped ? packageName.split("/").slice(0, 2) : [packageName.split("/")[0]];
   const packageDir = packageParts.join("/");
-  let dir = path5.dirname(resolvedPath);
+  let dir = path6.dirname(resolvedPath);
   const maxDepth = 10;
   for (let i = 0;i < maxDepth; i++) {
     if (dir.endsWith(`node_modules/${packageDir}`)) {
-      const pkgPath = path5.join(dir, "package.json");
+      const pkgPath = path6.join(dir, "package.json");
       if (fs5.existsSync(pkgPath)) {
         try {
           return JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
@@ -5354,7 +5396,7 @@ function findPackageJson(resolvedPath, packageName) {
         }
       }
     }
-    const parent = path5.dirname(dir);
+    const parent = path6.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -5598,7 +5640,7 @@ function hasInternalTag(typeName, program, sourceFile) {
 }
 
 // src/builder/verification.ts
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 var BUILTIN_TYPES2 = new Set([
   "Array",
   "ArrayBuffer",
@@ -5687,8 +5729,8 @@ function isExternalType2(definedIn, baseDir) {
     return true;
   if (definedIn.includes("node_modules"))
     return true;
-  const normalizedDefined = path6.resolve(definedIn);
-  const normalizedBase = path6.resolve(baseDir);
+  const normalizedDefined = path7.resolve(definedIn);
+  const normalizedBase = path7.resolve(baseDir);
   return !normalizedDefined.startsWith(normalizedBase);
 }
 function shouldSkipDanglingRef(name) {
@@ -6027,7 +6069,7 @@ async function extract(options) {
       }
     }
     const types = ctx.typeRegistry.getAll();
-    const projectBaseDir = baseDir ?? path7.dirname(entryFile);
+    const projectBaseDir = baseDir ?? path8.dirname(entryFile);
     const definedTypes = new Set(types.map((t) => t.id));
     const forgottenExports = collectForgottenExports(exports, types, program, sourceFile, exportedIds, projectBaseDir, definedTypes);
     for (const forgotten of forgottenExports) {
@@ -6060,7 +6102,7 @@ async function extract(options) {
     }
     let runtimeMetadata;
     if (options.schemaExtraction === "hybrid") {
-      const projectBaseDir2 = baseDir || path7.dirname(entryFile);
+      const projectBaseDir2 = baseDir || path8.dirname(entryFile);
       const runtimeResult = await extractStandardSchemasFromProject(entryFile, projectBaseDir2, {
         target: options.schemaTarget || "draft-2020-12",
         timeout: 15000
@@ -6349,7 +6391,7 @@ function createEmptySpec(entryFile, includeSchema, isDtsSource) {
   return {
     ...includeSchema ? { $schema: SCHEMA_URL } : {},
     openpkg: SCHEMA_VERSION,
-    meta: { name: path7.basename(entryFile, path7.extname(entryFile)) },
+    meta: { name: path8.basename(entryFile, path8.extname(entryFile)) },
     exports: [],
     generation: {
       generator: "@openpkg-ts/sdk",
@@ -6365,7 +6407,7 @@ function findTypeInProgram(name, checker, program, sourceFile, symFlags) {
   const localSym = checker.resolveName(name, sourceFile, symFlags, false);
   if (localSym)
     return checker.getDeclaredTypeOfSymbol(localSym);
-  const entryDir = path7.dirname(sourceFile.fileName);
+  const entryDir = path8.dirname(sourceFile.fileName);
   for (const sf of program.getSourceFiles()) {
     const fn = sf.fileName;
     if (fn.includes("/typescript/lib/lib.") || fn.includes("\\typescript\\lib\\lib."))
@@ -6381,22 +6423,22 @@ function findTypeInProgram(name, checker, program, sourceFile, symFlags) {
   return;
 }
 async function getPackageMeta(entryFile, baseDir) {
-  let dir = baseDir ?? path7.dirname(entryFile);
-  while (dir !== path7.dirname(dir)) {
-    const pkgPath = path7.join(dir, "package.json");
+  let dir = baseDir ?? path8.dirname(entryFile);
+  while (dir !== path8.dirname(dir)) {
+    const pkgPath = path8.join(dir, "package.json");
     try {
       if (fs6.existsSync(pkgPath)) {
         const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
         return {
-          name: pkg.name ?? path7.basename(dir),
+          name: pkg.name ?? path8.basename(dir),
           version: pkg.version,
           description: pkg.description
         };
       }
     } catch {}
-    dir = path7.dirname(dir);
+    dir = path8.dirname(dir);
   }
-  return { name: path7.basename(baseDir ?? path7.dirname(entryFile)) };
+  return { name: path8.basename(baseDir ?? path8.dirname(entryFile)) };
 }
 
 // src/primitives/spec.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/sdk",
-  "version": "0.38.0",
+  "version": "0.39.0",
   "description": "TypeScript API extraction SDK - programmatic primitives for OpenPkg specs",
   "keywords": [
     "openpkg",