@doccov/sdk 0.5.8 → 0.5.9

package/dist/index.js

@@ -1989,6 +1989,199 @@ var BUILTIN_TYPE_SCHEMAS = {
   BigInt64Array: { type: "string", format: "byte" },
   BigUint64Array: { type: "string", format: "byte" }
 };
+var TYPEBOX_PRIMITIVE_MAP = {
+  TString: { type: "string" },
+  TNumber: { type: "number" },
+  TBoolean: { type: "boolean" },
+  TInteger: { type: "integer" },
+  TNull: { type: "null" },
+  TAny: {},
+  TUnknown: {},
+  TNever: { not: {} },
+  TVoid: { type: "null" },
+  TUndefined: { type: "null" }
+};
+function isTypeBoxSchemaType(symbolName) {
+  return /^T[A-Z][a-zA-Z]*$/.test(symbolName);
+}
+function formatTypeBoxSchema(type, typeChecker, typeRefs, referencedTypes, visited) {
+  const symbol = type.getSymbol();
+  if (!symbol)
+    return null;
+  const symbolName = symbol.getName();
+  if (TYPEBOX_PRIMITIVE_MAP[symbolName]) {
+    return { ...TYPEBOX_PRIMITIVE_MAP[symbolName] };
+  }
+  const objectType = type;
+  if (!(objectType.objectFlags & ts2.ObjectFlags.Reference)) {
+    return null;
+  }
+  const typeRef = type;
+  const typeArgs = typeRef.typeArguments;
+  switch (symbolName) {
+    case "TObject": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { type: "object" };
+      }
+      const propsType = typeArgs[0];
+      const properties = {};
+      const required = [];
+      for (const prop of propsType.getProperties()) {
+        const propName = prop.getName();
+        const propType = getPropertyType(prop, propsType, typeChecker);
+        const propSymbol = propType.getSymbol();
+        const propSymbolName = propSymbol?.getName();
+        if (propSymbolName && typeRefs.has(propSymbolName)) {
+          properties[propName] = { $ref: `#/types/${propSymbolName}` };
+        } else if (propSymbolName && isTypeBoxSchemaType(propSymbolName)) {
+          const nested = formatTypeBoxSchema(propType, typeChecker, typeRefs, referencedTypes, visited);
+          properties[propName] = nested ?? { type: "object" };
+        } else {
+          properties[propName] = formatTypeReference(propType, typeChecker, typeRefs, referencedTypes, visited);
+        }
+        if (propSymbolName !== "TOptional") {
+          required.push(propName);
+        }
+      }
+      const schema = { type: "object", properties };
+      if (required.length > 0) {
+        schema.required = required;
+      }
+      return schema;
+    }
+    case "TArray": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { type: "array" };
+      }
+      const itemType = typeArgs[0];
+      const itemSymbol = itemType.getSymbol();
+      const itemSymbolName = itemSymbol?.getName();
+      let items;
+      if (itemSymbolName && typeRefs.has(itemSymbolName)) {
+        items = { $ref: `#/types/${itemSymbolName}` };
+      } else if (itemSymbolName && isTypeBoxSchemaType(itemSymbolName)) {
+        items = formatTypeBoxSchema(itemType, typeChecker, typeRefs, referencedTypes, visited) ?? { type: "object" };
+      } else {
+        items = formatTypeReference(itemType, typeChecker, typeRefs, referencedTypes, visited);
+      }
+      return { type: "array", items };
+    }
+    case "TUnion": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { anyOf: [] };
+      }
+      const tupleType = typeArgs[0];
+      const members = [];
+      if (tupleType.isUnion()) {
+        for (const memberType of tupleType.types) {
+          const memberSymbol = memberType.getSymbol();
+          const memberSymbolName = memberSymbol?.getName();
+          if (memberSymbolName && typeRefs.has(memberSymbolName)) {
+            members.push({ $ref: `#/types/${memberSymbolName}` });
+          } else if (memberSymbolName && isTypeBoxSchemaType(memberSymbolName)) {
+            members.push(formatTypeBoxSchema(memberType, typeChecker, typeRefs, referencedTypes, visited) ?? { type: "object" });
+          } else {
+            members.push(formatTypeReference(memberType, typeChecker, typeRefs, referencedTypes, visited));
+          }
+        }
+      } else if (tupleType.typeArguments) {
+        for (const memberType of tupleType.typeArguments) {
+          const memberSymbol = memberType.getSymbol();
+          const memberSymbolName = memberSymbol?.getName();
+          if (memberSymbolName && typeRefs.has(memberSymbolName)) {
+            members.push({ $ref: `#/types/${memberSymbolName}` });
+          } else if (memberSymbolName && isTypeBoxSchemaType(memberSymbolName)) {
+            members.push(formatTypeBoxSchema(memberType, typeChecker, typeRefs, referencedTypes, visited) ?? { type: "object" });
+          } else {
+            members.push(formatTypeReference(memberType, typeChecker, typeRefs, referencedTypes, visited));
+          }
+        }
+      }
+      return { anyOf: members };
+    }
+    case "TIntersect": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { allOf: [] };
+      }
+      const tupleType = typeArgs[0];
+      const members = [];
+      if (tupleType.typeArguments) {
+        for (const memberType of tupleType.typeArguments) {
+          const memberSymbol = memberType.getSymbol();
+          const memberSymbolName = memberSymbol?.getName();
+          if (memberSymbolName && typeRefs.has(memberSymbolName)) {
+            members.push({ $ref: `#/types/${memberSymbolName}` });
+          } else if (memberSymbolName && isTypeBoxSchemaType(memberSymbolName)) {
+            members.push(formatTypeBoxSchema(memberType, typeChecker, typeRefs, referencedTypes, visited) ?? { type: "object" });
+          } else {
+            members.push(formatTypeReference(memberType, typeChecker, typeRefs, referencedTypes, visited));
+          }
+        }
+      }
+      return { allOf: members };
+    }
+    case "TOptional": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return {};
+      }
+      const innerType = typeArgs[0];
+      const innerSymbol = innerType.getSymbol();
+      const innerSymbolName = innerSymbol?.getName();
+      if (innerSymbolName && typeRefs.has(innerSymbolName)) {
+        return { $ref: `#/types/${innerSymbolName}` };
+      } else if (innerSymbolName && isTypeBoxSchemaType(innerSymbolName)) {
+        return formatTypeBoxSchema(innerType, typeChecker, typeRefs, referencedTypes, visited) ?? { type: "object" };
+      }
+      return formatTypeReference(innerType, typeChecker, typeRefs, referencedTypes, visited);
+    }
+    case "TLiteral": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { enum: [] };
+      }
+      const literalType = typeArgs[0];
+      if (literalType.isLiteral()) {
+        const value = literalType.value;
+        return { enum: [value] };
+      }
+      const literalStr = typeChecker.typeToString(literalType);
+      if (literalStr.startsWith('"') && literalStr.endsWith('"')) {
+        return { enum: [literalStr.slice(1, -1)] };
+      }
+      return { enum: [literalStr] };
+    }
+    case "TRecord": {
+      if (!typeArgs || typeArgs.length < 2) {
+        return { type: "object", additionalProperties: true };
+      }
+      const valueType = typeArgs[1];
+      const valueSymbol = valueType.getSymbol();
+      const valueSymbolName = valueSymbol?.getName();
+      let additionalProperties;
+      if (valueSymbolName && typeRefs.has(valueSymbolName)) {
+        additionalProperties = { $ref: `#/types/${valueSymbolName}` };
+      } else if (valueSymbolName && isTypeBoxSchemaType(valueSymbolName)) {
+        additionalProperties = formatTypeBoxSchema(valueType, typeChecker, typeRefs, referencedTypes, visited) ?? true;
+      } else {
+        additionalProperties = formatTypeReference(valueType, typeChecker, typeRefs, referencedTypes, visited);
+      }
+      return { type: "object", additionalProperties };
+    }
+    case "TRef": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { $ref: "#/types/unknown" };
+      }
+      const refType = typeArgs[0];
+      const refSymbol = refType.getSymbol();
+      const refSymbolName = refSymbol?.getName();
+      if (refSymbolName) {
+        return { $ref: `#/types/${refSymbolName}` };
+      }
+      return { type: "object" };
+    }
+    default:
+      return null;
+  }
+}
 function isObjectLiteralType(type) {
   if (!(type.getFlags() & ts2.TypeFlags.Object)) {
     return false;
@@ -2404,6 +2597,12 @@ function formatTypeReference(type, typeChecker, typeRefs, referencedTypes, visit
       if (builtInSchema) {
         return { ...builtInSchema };
       }
+      if (isTypeBoxSchemaType(symbolName)) {
+        const typeBoxSchema = formatTypeBoxSchema(type, typeChecker, typeRefs, referencedTypes, visited);
+        if (typeBoxSchema) {
+          return typeBoxSchema;
+        }
+      }
       if (referencedTypes && !isBuiltInType(symbolName)) {
         referencedTypes.add(symbolName);
         return { $ref: `#/types/${symbolName}` };

package/package.json

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