@doccov/sdk 0.3.5 → 0.3.7

package/dist/index.js

@@ -1299,101 +1299,6 @@ var resolvedTypeScriptModule = (() => {
 })();
 var ts2 = resolvedTypeScriptModule;
 
-// src/analysis/context.ts
-import * as path2 from "node:path";
-
-// src/options.ts
-var DEFAULT_OPTIONS = {
-  includePrivate: false,
-  followImports: true
-};
-function normalizeDocCovOptions(options = {}) {
-  return {
-    ...DEFAULT_OPTIONS,
-    ...options
-  };
-}
-var normalizeOpenPkgOptions = normalizeDocCovOptions;
-
-// src/analysis/program.ts
-import * as path from "node:path";
-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/analysis/context.ts
-function createAnalysisContext({
-  entryFile,
-  packageDir,
-  content,
-  options
-}) {
-  const baseDir = packageDir ?? path2.dirname(entryFile);
-  const normalizedOptions = normalizeOpenPkgOptions(options);
-  const programResult = createProgram({ entryFile, baseDir, content });
-  if (!programResult.sourceFile) {
-    throw new Error(`Could not load ${entryFile}`);
-  }
-  return {
-    entryFile,
-    baseDir,
-    program: programResult.program,
-    checker: programResult.program.getTypeChecker(),
-    sourceFile: programResult.sourceFile,
-    compilerOptions: programResult.compilerOptions,
-    compilerHost: programResult.compilerHost,
-    options: normalizedOptions,
-    configPath: programResult.configPath
-  };
-}
-
-// src/analysis/spec-builder.ts
-import * as fs from "node:fs";
-import * as path3 from "node:path";
-import { SCHEMA_URL } from "@openpkg-ts/spec";
-
 // src/utils/type-utils.ts
 function getTypeId(type, typeChecker) {
   const internalId = type.id;
@@ -1515,6 +1420,30 @@ function collectReferencedTypesFromNode(node, typeChecker, referencedTypes) {
   });
 }
 function isBuiltInType(name) {
+  if (name.length === 1 && /^[A-Z]$/.test(name)) {
+    return true;
+  }
+  if (/^T[A-Z][a-zA-Z]*$/.test(name)) {
+    return true;
+  }
+  const libraryInternals = [
+    "UnionStatic",
+    "IntersectStatic",
+    "ObjectStatic",
+    "ArrayStatic",
+    "StaticDecode",
+    "StaticEncode",
+    "ZodType",
+    "ZodObject",
+    "ZodString",
+    "ZodNumber",
+    "ZodArray",
+    "ZodUnion",
+    "ZodIntersection"
+  ];
+  if (libraryInternals.includes(name)) {
+    return true;
+  }
   const builtIns = [
     "string",
     "number",
@@ -1523,6 +1452,8 @@ function isBuiltInType(name) {
     "symbol",
     "undefined",
     "null",
+    "true",
+    "false",
     "any",
     "unknown",
     "never",
@@ -1566,11 +1497,125 @@ function isBuiltInType(name) {
     "Proxy",
     "Intl",
     "globalThis",
+    "Record",
+    "Partial",
+    "Required",
+    "Readonly",
+    "Pick",
+    "Omit",
+    "Exclude",
+    "Extract",
+    "NonNullable",
+    "ReturnType",
+    "Parameters",
+    "InstanceType",
+    "ConstructorParameters",
+    "Awaited",
+    "ThisType",
+    "Uppercase",
+    "Lowercase",
+    "Capitalize",
+    "Uncapitalize",
     "__type"
   ];
   return builtIns.includes(name);
 }
 
+// src/analysis/context.ts
+import * as path2 from "node:path";
+
+// src/options.ts
+var DEFAULT_OPTIONS = {
+  includePrivate: false,
+  followImports: true
+};
+function normalizeDocCovOptions(options = {}) {
+  return {
+    ...DEFAULT_OPTIONS,
+    ...options
+  };
+}
+var normalizeOpenPkgOptions = normalizeDocCovOptions;
+
+// src/analysis/program.ts
+import * as path from "node:path";
+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/analysis/context.ts
+function createAnalysisContext({
+  entryFile,
+  packageDir,
+  content,
+  options
+}) {
+  const baseDir = packageDir ?? path2.dirname(entryFile);
+  const normalizedOptions = normalizeOpenPkgOptions(options);
+  const programResult = createProgram({ entryFile, baseDir, content });
+  if (!programResult.sourceFile) {
+    throw new Error(`Could not load ${entryFile}`);
+  }
+  return {
+    entryFile,
+    baseDir,
+    program: programResult.program,
+    checker: programResult.program.getTypeChecker(),
+    sourceFile: programResult.sourceFile,
+    compilerOptions: programResult.compilerOptions,
+    compilerHost: programResult.compilerHost,
+    options: normalizedOptions,
+    configPath: programResult.configPath
+  };
+}
+
+// src/analysis/spec-builder.ts
+import * as fs from "node:fs";
+import * as path3 from "node:path";
+import { SCHEMA_URL } from "@openpkg-ts/spec";
+
 // src/utils/parameter-utils.ts
 var BUILTIN_TYPE_SCHEMAS = {
   Date: { type: "string", format: "date-time" },
@@ -1870,6 +1915,16 @@ function schemasAreEqual(left, right) {
   };
   return JSON.stringify(normalize(left)) === JSON.stringify(normalize(right));
 }
+function deduplicateSchemas(schemas) {
+  const result = [];
+  for (const schema of schemas) {
+    const isDuplicate = result.some((existing) => schemasAreEqual(existing, schema));
+    if (!isDuplicate) {
+      result.push(schema);
+    }
+  }
+  return result;
+}
 function formatTypeReference(type, typeChecker, typeRefs, referencedTypes, visitedAliases) {
   const visited = visitedAliases ?? new Set;
   const aliasSymbol = type.aliasSymbol;
@@ -1929,15 +1984,19 @@ function formatTypeReference(type, typeChecker, typeRefs, referencedTypes, visit
     if (type.isUnion()) {
       const unionType = type;
       const parts = unionType.types.map((t) => formatTypeReference(t, typeChecker, typeRefs, referencedTypes, visited));
+      const uniqueParts = deduplicateSchemas(parts);
+      if (uniqueParts.length === 1) {
+        return uniqueParts[0];
+      }
       const discriminatorProp = findDiscriminatorProperty(unionType.types, typeChecker);
       if (discriminatorProp) {
         return {
-          anyOf: parts,
+          anyOf: uniqueParts,
           discriminator: { propertyName: discriminatorProp }
         };
       }
       return {
-        anyOf: parts
+        anyOf: uniqueParts
       };
     }
     if (type.isIntersection()) {
@@ -3691,10 +3750,10 @@ function collectDanglingRefs(spec) {
   const referencedTypes = new Set;
   collectAllRefs(spec.exports, referencedTypes);
   collectAllRefs(spec.types, referencedTypes);
-  return Array.from(referencedTypes).filter((ref) => !definedTypes.has(ref));
+  return Array.from(referencedTypes).filter((ref) => !definedTypes.has(ref) && !isBuiltInType(ref));
 }
 function collectExternalTypes(spec) {
-  return (spec.types ?? []).filter((t) => t.kind === "external").map((t) => t.id);
+  return (spec.types ?? []).filter((t) => t.kind === "external").map((t) => t.id).filter((id) => !isBuiltInType(id));
 }
 function hasExternalImports(sourceFile) {
   let found = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccov/sdk",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "DocCov SDK - Documentation coverage and drift detection for TypeScript",
   "keywords": [
     "typescript",