@openpkg-ts/extract 0.27.1 → 0.28.0

package/dist/bin/tspec.js

@@ -3,7 +3,7 @@ import {
   detectTsRuntime,
   extract,
   resolveCompiledPath
-} from "../shared/chunk-v9c97d62.js";
+} from "../shared/chunk-7hk4mmb3.js";
 
 // src/cli/spec.ts
 import * as fs from "node:fs";

package/dist/shared/{chunk-v9c97d62.js → chunk-7hk4mmb3.js}

@@ -228,6 +228,16 @@ function buildSchema(type, checker, ctx, _depth = 0) {
     return { type: "bigint" };
   if (type.flags & ts.TypeFlags.ESSymbol)
     return { type: "symbol" };
+  if (type.isThisType?.()) {
+    const constraint = type.getConstraint?.();
+    const symbol2 = constraint?.getSymbol() ?? type.getSymbol();
+    if (symbol2 && !isAnonymous(type)) {
+      return {
+        $ref: `#/types/${symbol2.getName()}`,
+        "x-ts-type": "this"
+      };
+    }
+  }
   if (type.flags & ts.TypeFlags.StringLiteral) {
     const literal = type.value;
     return { type: "string", enum: [literal] };
@@ -259,8 +269,10 @@ function buildSchema(type, checker, ctx, _depth = 0) {
     }
     return { anyOf: types.map((t) => buildSchema(t, checker, ctx)) };
   }
-  if (type.isIntersection()) {
-    const filteredTypes = type.types.filter((t) => !(t.flags & ts.TypeFlags.Never));
+  const isIntersectionType = type.isIntersection() || !!(type.flags & ts.TypeFlags.Intersection);
+  if (isIntersectionType && "types" in type) {
+    const intersectionType = type;
+    const filteredTypes = intersectionType.types.filter((t) => !(t.flags & ts.TypeFlags.Never));
     if (filteredTypes.length === 0) {
       return { type: "never" };
     }
@@ -283,8 +295,9 @@ function buildSchema(type, checker, ctx, _depth = 0) {
     return { type: "array", items: {} };
   }
   if (checker.isArrayType(type)) {
-    const typeRef2 = type;
-    const elementType = typeRef2.typeArguments?.[0];
+    const arrayTypeRef = type;
+    const arrayTypeArgs = checker.getTypeArguments(arrayTypeRef);
+    const elementType = arrayTypeArgs?.[0];
     if (elementType) {
       if (ctx) {
         return withDepth(ctx, () => ({
@@ -297,8 +310,8 @@ function buildSchema(type, checker, ctx, _depth = 0) {
     return { type: "array" };
   }
   if (checker.isTupleType(type)) {
-    const typeRef2 = type;
-    const elementTypes = typeRef2.typeArguments ?? [];
+    const tupleTypeRef = type;
+    const elementTypes = checker.getTypeArguments(tupleTypeRef) ?? [];
     if (ctx) {
       return withDepth(ctx, () => {
         const prevInTupleElement = ctx.inTupleElement;
@@ -323,7 +336,8 @@ function buildSchema(type, checker, ctx, _depth = 0) {
     };
   }
   const typeRef = type;
-  if (typeRef.target && typeRef.typeArguments && typeRef.typeArguments.length > 0) {
+  const typeArgs = typeRef.target ? checker.getTypeArguments(typeRef) : undefined;
+  if (typeRef.target && typeArgs && typeArgs.length > 0) {
     const symbol2 = typeRef.target.getSymbol();
     const name = symbol2?.getName();
     if (name && BUILTIN_TYPES.has(name)) {
@@ -335,7 +349,7 @@ function buildSchema(type, checker, ctx, _depth = 0) {
         return withDepth(ctx, () => {
           const schema2 = {
             $ref: `#/types/${name}`,
-            typeArguments: typeRef.typeArguments.map((t) => buildSchema(t, checker, ctx))
+            typeArguments: typeArgs.map((t) => buildSchema(t, checker, ctx))
           };
           if (packageOrigin) {
             schema2["x-ts-package"] = packageOrigin;
@@ -345,7 +359,7 @@ function buildSchema(type, checker, ctx, _depth = 0) {
       }
       const schema = {
         $ref: `#/types/${name}`,
-        typeArguments: typeRef.typeArguments.map((t) => buildSchema(t, checker, ctx))
+        typeArguments: typeArgs.map((t) => buildSchema(t, checker, ctx))
       };
       if (packageOrigin) {
         schema["x-ts-package"] = packageOrigin;
@@ -1557,6 +1571,16 @@ async function extractStandardSchemasFromProject(entryFile, baseDir, options = {
 
 // src/types/parameters.ts
 import ts5 from "typescript";
+function stripUndefinedFromType(type, checker) {
+  if (!type.isUnion())
+    return type;
+  const nonUndefinedTypes = type.types.filter((t) => !(t.flags & ts5.TypeFlags.Undefined));
+  if (nonUndefinedTypes.length === 0)
+    return type;
+  if (nonUndefinedTypes.length === 1)
+    return nonUndefinedTypes[0];
+  return checker.getUnionType(nonUndefinedTypes);
+}
 function extractParameters(signature, ctx) {
   const { typeChecker: checker } = ctx;
   const result = [];
@@ -1569,12 +1593,20 @@ function extractParameters(signature, ctx) {
       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)
-      });
+      const isOptional = !!(param.flags & 16777216);
+      const effectiveType = isOptional ? stripUndefinedFromType(type, checker) : type;
+      registerReferencedTypes(effectiveType, ctx);
+      const paramName = param.getName();
+      const description = getParamDescription(paramName, jsdocTags);
+      const paramResult = {
+        name: paramName,
+        schema: buildSchema(effectiveType, checker, ctx),
+        required: !isOptional
+      };
+      if (description) {
+        paramResult.description = description;
+      }
+      result.push(paramResult);
     }
   }
   return result;
@@ -1592,13 +1624,14 @@ function expandBindingPattern(paramDecl, paramType, jsdocTags, ctx) {
     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 propType = checker.getTypeOfSymbol(propSymbol);
+    const effectiveType = isOptional ? stripUndefinedFromType(propType, checker) : propType;
+    registerReferencedTypes(effectiveType, ctx);
     const description = getParamDescription(propertyName, jsdocTags, inferredAlias);
     const param = {
       name: propertyName,
-      schema: buildSchema(propType, checker, ctx),
+      schema: buildSchema(effectiveType, checker, ctx),
       required: !isOptional
     };
     if (description) {
@@ -1914,6 +1947,11 @@ function serializeClass(node, ctx) {
   members.push(...inheritedStatic);
   const extendsClause = getExtendsClause(node, checker);
   const implementsClause = getImplementsClause(node, checker);
+  const classFlags = {};
+  const classModifiers = ts7.getModifiers(node);
+  if (classModifiers?.some((m) => m.kind === ts7.SyntaxKind.AbstractKeyword)) {
+    classFlags.abstract = true;
+  }
   return {
     id: name,
     name,
@@ -1927,7 +1965,8 @@ function serializeClass(node, ctx) {
     extends: extendsClause,
     implements: implementsClause?.length ? implementsClause : undefined,
     ...deprecated ? { deprecated: true } : {},
-    ...examples.length > 0 ? { examples } : {}
+    ...examples.length > 0 ? { examples } : {},
+    ...Object.keys(classFlags).length > 0 ? { flags: classFlags } : {}
   };
 }
 function getMemberName(member) {
@@ -2026,6 +2065,9 @@ function serializeMethod(node, ctx) {
   if (modifiers?.some((m) => m.kind === ts7.SyntaxKind.AsyncKeyword)) {
     flags.async = true;
   }
+  if (modifiers?.some((m) => m.kind === ts7.SyntaxKind.AbstractKeyword)) {
+    flags.abstract = true;
+  }
   return {
     name,
     kind: "method",
@@ -2062,6 +2104,24 @@ function serializeAccessor(node, ctx) {
   const flags = {};
   if (isStatic(node))
     flags.static = true;
+  let signatures;
+  if (ts7.isSetAccessorDeclaration(node) && node.parameters.length > 0) {
+    const param = node.parameters[0];
+    const paramName = param.name.getText();
+    const paramType = checker.getTypeAtLocation(param);
+    registerReferencedTypes(paramType, ctx);
+    signatures = [
+      {
+        parameters: [
+          {
+            name: paramName,
+            schema: buildSchema(paramType, checker, ctx),
+            required: true
+          }
+        ]
+      }
+    ];
+  }
   return {
     name,
     kind,
@@ -2069,6 +2129,7 @@ function serializeAccessor(node, ctx) {
     tags: tags.length > 0 ? tags : undefined,
     visibility,
     schema,
+    signatures,
     flags: Object.keys(flags).length > 0 ? flags : undefined
   };
 }
@@ -2232,6 +2293,7 @@ function serializeInterface(node, ctx) {
   const typeParameters = extractTypeParameters(node, checker);
   const members = [];
   const methodsByName = new Map;
+  let callSignatureMember = null;
   for (const member of node.members) {
     if (ts9.isPropertySignature(member)) {
       const propMember = serializePropertySignature(member, ctx);
@@ -2239,23 +2301,60 @@ function serializeInterface(node, ctx) {
         members.push(propMember);
     } else if (ts9.isMethodSignature(member)) {
       const methodMember = serializeMethodSignature(member, ctx);
-      if (methodMember?.name) {
-        if (!methodsByName.has(methodMember.name)) {
+      if (methodMember?.name && methodMember.signatures) {
+        const existing = methodsByName.get(methodMember.name);
+        if (existing && existing.signatures) {
+          const startIndex = existing.signatures.length;
+          const newSigs = methodMember.signatures.map((sig, i) => ({
+            ...sig,
+            overloadIndex: startIndex + i
+          }));
+          if (existing.signatures.length > 0 && existing.signatures[0].overloadIndex === undefined) {
+            existing.signatures = existing.signatures.map((sig, i) => ({
+              ...sig,
+              overloadIndex: i
+            }));
+          }
+          existing.signatures.push(...newSigs);
+        } else {
           methodsByName.set(methodMember.name, methodMember);
         }
       }
     } else if (ts9.isCallSignatureDeclaration(member)) {
-      const callMember = serializeCallSignature(member, ctx);
-      if (callMember)
-        members.push(callMember);
+      const callSig = serializeCallSignature(member, ctx);
+      if (callSig && callSig.signatures) {
+        if (callSignatureMember && callSignatureMember.signatures) {
+          const startIndex = callSignatureMember.signatures.length;
+          const newSigs = callSig.signatures.map((sig, i) => ({
+            ...sig,
+            overloadIndex: startIndex + i
+          }));
+          if (callSignatureMember.signatures.length > 0 && callSignatureMember.signatures[0].overloadIndex === undefined) {
+            callSignatureMember.signatures = callSignatureMember.signatures.map((sig, i) => ({
+              ...sig,
+              overloadIndex: i
+            }));
+          }
+          callSignatureMember.signatures.push(...newSigs);
+          if (callSig.description && !callSignatureMember.description) {
+            callSignatureMember.description = callSig.description;
+          }
+        } else {
+          callSignatureMember = callSig;
+        }
+      }
     } else if (ts9.isIndexSignatureDeclaration(member)) {
       const indexMember = serializeIndexSignature(member, ctx);
       if (indexMember)
         members.push(indexMember);
     }
   }
+  if (callSignatureMember) {
+    members.push(callSignatureMember);
+  }
   members.push(...methodsByName.values());
   const extendsClause = getInterfaceExtends(node, checker);
+  const exportSignatures = callSignatureMember?.signatures && callSignatureMember.signatures.length > 0 ? callSignatureMember.signatures : undefined;
   return {
     id: name,
     name,
@@ -2265,6 +2364,7 @@ function serializeInterface(node, ctx) {
     source,
     typeParameters,
     members: members.length > 0 ? members : undefined,
+    signatures: exportSignatures,
     extends: extendsClause,
     ...deprecated ? { deprecated: true } : {},
     ...examples.length > 0 ? { examples } : {}
@@ -2366,10 +2466,7 @@ function serializeIndexSignature(node, ctx) {
     kind: "index-signature",
     description,
     tags: tags.length > 0 ? tags : undefined,
-    schema: {
-      type: "object",
-      additionalProperties: valueSchema
-    }
+    schema: valueSchema
   };
 }
 function getInterfaceExtends(node, checker) {
@@ -2639,10 +2736,10 @@ var SCHEMA_DIALECT_URLS = {
   "draft-07": "http://json-schema.org/draft-07/schema#"
 };
 var TS_PRIMITIVE_NORMALIZATIONS = {
-  void: () => ({ type: "null" }),
+  void: () => ({ type: "null", "x-ts-type": "void" }),
   never: () => ({ not: {} }),
   any: () => ({}),
-  unknown: () => ({}),
+  unknown: () => ({ "x-ts-type": "unknown" }),
   undefined: () => ({ type: "null" }),
   bigint: () => ({ type: "integer", "x-ts-type": "bigint" }),
   symbol: () => ({ type: "string", "x-ts-type": "symbol" })
@@ -3316,13 +3413,13 @@ async function extract(options) {
       await new Promise((r) => setImmediate(r));
     }
     try {
-      const { declaration, targetSymbol } = resolveExportTarget(symbol, typeChecker);
+      const { declaration, targetSymbol, isTypeOnly } = resolveExportTarget(symbol, typeChecker);
       if (!declaration) {
         tracker.status = "skipped";
         tracker.skipReason = "no-declaration";
         continue;
       }
-      const exp = serializeDeclaration(declaration, symbol, targetSymbol, exportName, ctx);
+      const exp = serializeDeclaration(declaration, symbol, targetSymbol, exportName, ctx, isTypeOnly);
       if (exp) {
         exports.push(exp);
         tracker.status = "success";
@@ -3586,8 +3683,23 @@ function collectForgottenExports(exports, types, program, sourceFile, exportedId
   }
   return forgottenExports;
 }
+function isTypeOnlyExport(symbol) {
+  const declarations = symbol.declarations ?? [];
+  for (const decl of declarations) {
+    if (ts11.isExportSpecifier(decl)) {
+      if (decl.isTypeOnly)
+        return true;
+      const exportDecl = decl.parent?.parent;
+      if (exportDecl && ts11.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 function resolveExportTarget(symbol, checker) {
   let targetSymbol = symbol;
+  const isTypeOnly = isTypeOnlyExport(symbol);
   if (symbol.flags & ts11.SymbolFlags.Alias) {
     const aliasTarget = checker.getAliasedSymbol(symbol);
     if (aliasTarget && aliasTarget !== symbol) {
@@ -3596,9 +3708,9 @@ function resolveExportTarget(symbol, checker) {
   }
   const declarations = targetSymbol.declarations ?? [];
   const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts11.SyntaxKind.ExportSpecifier) || declarations[0];
-  return { declaration, targetSymbol };
+  return { declaration, targetSymbol, isTypeOnly };
 }
-function serializeDeclaration(declaration, exportSymbol, _targetSymbol, exportName, ctx) {
+function serializeDeclaration(declaration, exportSymbol, _targetSymbol, exportName, ctx, isTypeOnly = false) {
   let result = null;
   if (ts11.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
@@ -3622,6 +3734,12 @@ function serializeDeclaration(declaration, exportSymbol, _targetSymbol, exportNa
   }
   if (result) {
     result = withExportName(result, exportName);
+    if (isTypeOnly) {
+      result = {
+        ...result,
+        flags: { ...result.flags ?? {}, typeOnly: true }
+      };
+    }
   }
   return result;
 }

package/dist/src/index.js

@@ -48,7 +48,7 @@ import {
   valibotAdapter,
   withDescription,
   zodAdapter
-} from "../shared/chunk-v9c97d62.js";
+} from "../shared/chunk-7hk4mmb3.js";
 // src/types/utils.ts
 function isExported(node) {
   const modifiers = node.modifiers;

package/package.json

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