@openpkg-ts/sdk 0.54.5 → 0.54.7

package/dist/index.js

@@ -2464,6 +2464,9 @@ function createProgram(options) {
     const configFile = ts3.readConfigFile(configPath, ts3.sys.readFile);
     const parsedConfig = ts3.parseJsonConfigFileContent(configFile.config, ts3.sys, path5.dirname(configPath));
     compilerOptions = { ...compilerOptions, ...parsedConfig.options };
+    if (parsedConfig.options.module !== undefined && parsedConfig.options.moduleResolution === undefined) {
+      delete compilerOptions.moduleResolution;
+    }
     additionalRootFiles = resolveProjectReferences(configPath, parsedConfig);
     let sourceFiles = parsedConfig.fileNames.filter((f) => !f.includes(".test.") && !f.includes(".spec.") && !f.includes("/dist/") && !f.includes("/node_modules/"));
     if (/\.d\.[cm]?ts$/.test(entryFile)) {
@@ -3210,6 +3213,88 @@ function isFluentThisType(type) {
     return false;
   return declarations.some((decl) => ts5.isClassDeclaration(decl) || ts5.isClassExpression(decl) || ts5.isInterfaceDeclaration(decl));
 }
+function containsUnresolvedTypeParameter(type, seen = new Set) {
+  if (seen.has(type))
+    return false;
+  seen.add(type);
+  if (type.flags & ts5.TypeFlags.TypeParameter) {
+    return !isFluentThisType(type);
+  }
+  if (type.isUnionOrIntersection()) {
+    return type.types.some((t) => containsUnresolvedTypeParameter(t, seen));
+  }
+  if (type.aliasTypeArguments) {
+    for (const arg of type.aliasTypeArguments) {
+      if (containsUnresolvedTypeParameter(arg, seen))
+        return true;
+    }
+  }
+  const targs = type.typeArguments;
+  if (targs) {
+    for (const arg of targs) {
+      if (containsUnresolvedTypeParameter(arg, seen))
+        return true;
+    }
+  }
+  if (type.flags & ts5.TypeFlags.IndexedAccess) {
+    const ia = type;
+    return containsUnresolvedTypeParameter(ia.objectType, seen) || containsUnresolvedTypeParameter(ia.indexType, seen);
+  }
+  return false;
+}
+function isUtilityOverTypeParameter(type) {
+  const name = type.aliasSymbol?.getName();
+  if (!name || !RESOLVED_UTILITY_TYPES.has(name))
+    return false;
+  const args = type.aliasTypeArguments;
+  if (!args || args.length === 0)
+    return false;
+  return args.some((t) => containsUnresolvedTypeParameter(t));
+}
+function writtenUtilityText(type, checker, typeNode) {
+  let node = typeNode;
+  while (node && ts5.isParenthesizedTypeNode(node))
+    node = node.type;
+  const fromNode = writtenTypeText(node);
+  if (fromNode)
+    return fromNode;
+  if (node) {
+    try {
+      const text = scrubImportQualifiers(node.getText().replace(/\s+/g, " ").trim());
+      if (text)
+        return text;
+    } catch {}
+  }
+  const name = type.aliasSymbol?.getName();
+  const args = type.aliasTypeArguments;
+  if (name && args && args.length > 0) {
+    const inner = args.map((t) => scrubImportQualifiers(checker.typeToString(t))).join(", ");
+    return `${name}<${inner}>`;
+  }
+  return renderTypeText(type, checker);
+}
+function isReadonlyArrayType(type, typeNode) {
+  let node = typeNode;
+  while (node && ts5.isParenthesizedTypeNode(node))
+    node = node.type;
+  if (node && ts5.isTypeOperatorNode(node) && node.operator === ts5.SyntaxKind.ReadonlyKeyword) {
+    return true;
+  }
+  if (node && ts5.isTypeReferenceNode(node) && typeRefName(node) === "ReadonlyArray") {
+    return true;
+  }
+  const ref = type;
+  const name = ref.target?.getSymbol()?.getName() ?? type.getSymbol()?.getName();
+  return name === "ReadonlyArray";
+}
+function withReadonlyArrayHint(schema, type, typeNode) {
+  if (!isReadonlyArrayType(type, typeNode))
+    return schema;
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema))
+    return schema;
+  setSchemaExtension(schema, "x-ts-readonly", true);
+  return schema;
+}
 function withDepth(ctx, fn) {
   ctx.currentDepth++;
   try {
@@ -3366,6 +3451,9 @@ function buildSchemaInternal(type, checker, ctx, typeNode) {
     if (type.flags & ts5.TypeFlags.TypeParameter) {
       return { "x-ts-type": checker.typeToString(type) };
     }
+    if (isUtilityOverTypeParameter(type)) {
+      return { "x-ts-type": writtenUtilityText(type, checker, typeNode) };
+    }
     if (type.flags & ts5.TypeFlags.StringLiteral) {
       const literal = type.value;
       return { type: "string", enum: [literal] };
@@ -3465,15 +3553,10 @@ function buildSchemaInternal(type, checker, ctx, typeNode) {
       const arrayTypeArgs = checker.getTypeArguments(arrayTypeRef);
       const elementType = arrayTypeArgs?.[0];
       if (elementType) {
-        if (ctx) {
-          return withDepth(ctx, () => ({
-            type: "array",
-            items: buildSchema(elementType, checker, ctx)
-          }));
-        }
-        return { type: "array", items: buildSchema(elementType, checker, ctx) };
+        const build = () => withReadonlyArrayHint({ type: "array", items: buildSchema(elementType, checker, ctx) }, type, typeNode);
+        return ctx ? withDepth(ctx, build) : build();
       }
-      return { type: "array" };
+      return withReadonlyArrayHint({ type: "array" }, type, typeNode);
     }
     if (checker.isTupleType(type)) {
       const tupleTypeRef = type;
@@ -3995,8 +4078,11 @@ function applyDefault(param, initializer) {
     if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
       param.schema.default = extracted.value;
     }
-  } else if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
-    param.schema["x-ts-default"] = extracted.text;
+  } else {
+    param.default = extracted.text;
+    if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
+      param.schema["x-ts-default"] = extracted.text;
+    }
   }
 }
 function registerReferencedTypes(type, ctx, depth = 0) {

package/package.json

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