@arcteninc/core 0.0.53 → 0.0.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcteninc/core",
-  "version": "0.0.53",
+  "version": "0.0.54",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

package/scripts/cli-extract-types-auto.ts

@@ -731,54 +731,18 @@ function serializeTypeCustom(
           }
           
           // Build the schema for this type
-          // For interfaces, get properties from both the type and the declaration
           const props = checker.getPropertiesOfType(type);
-          const properties: Record<string, JsonSchemaProperty> = {};
-          const required: string[] = [];
-          
-          // Extract properties from the interface/type alias declaration
-          if (ts.isInterfaceDeclaration(firstDecl)) {
-            for (const member of firstDecl.members) {
-              if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
-                const propName = member.name.text;
-                const isOptional = member.questionToken !== undefined;
-                
-                if (member.type) {
-                  const propType = checker.getTypeFromTypeNode(member.type);
-                  const propResult = serializeTypeCustom(propType, checker, defs, visited, depth + 1);
-                  properties[propName] = propResult.schema;
-                  
-                  if (!isOptional && !propResult.isOptional) {
-                    required.push(propName);
-                  }
-                }
-              }
-            }
-          } else if (ts.isTypeAliasDeclaration(firstDecl) && firstDecl.type) {
-            // For type aliases, resolve the underlying type
-            const underlyingType = checker.getTypeFromTypeNode(firstDecl.type);
-            if (underlyingType.flags & ts.TypeFlags.Object) {
-              const aliasProps = checker.getPropertiesOfType(underlyingType);
-              for (const prop of aliasProps) {
-                const propName = prop.getName();
-                const propType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations?.[0] || null as any);
-                const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
-                
-                const propResult = serializeTypeCustom(propType, checker, defs, visited, depth + 1);
-                properties[propName] = propResult.schema;
-                
-                if (!isOptional && !propResult.isOptional) {
-                  required.push(propName);
-                }
-              }
-            }
-          } else if (props.length > 0) {
-            // Fallback: use getPropertiesOfType if declaration parsing didn't work
+          if (props.length > 0) {
+            const properties: Record<string, JsonSchemaProperty> = {};
+            const required: string[] = [];
+            
+            // Use the same visited set for properties to detect recursion
             for (const prop of props) {
               const propName = prop.getName();
-              const propType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations?.[0] || null as any);
+              const propType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations?.[0] || checker.getDeclaredTypeOfSymbol(prop).symbol?.valueDeclaration || null as any);
               const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
               
+              // Recursively serialize the property type (will detect recursion via visited set)
               const propResult = serializeTypeCustom(propType, checker, defs, visited, depth + 1);
               properties[propName] = propResult.schema;
               
@@ -786,15 +750,15 @@ function serializeTypeCustom(
                 required.push(propName);
               }
             }
+            
+            // Update the placeholder with the actual schema
+            defs[defsKey] = {
+              type: 'object',
+              properties,
+              ...(required.length > 0 && { required })
+            };
           }
           
-          // Update the placeholder with the actual schema (even if empty, to avoid infinite loops)
-          defs[defsKey] = {
-            type: 'object',
-            properties,
-            ...(required.length > 0 && { required })
-          };
-          
           // Return reference
           return { isOptional: false, schema: { $ref: `#/$defs/${defsKey}` } };
         }
@@ -860,6 +824,73 @@ function serializeTypeCustom(
     }
   }
 
+  // Handle arrays
+  if (checker.isArrayType(type)) {
+    const typeArgs = (type as ts.TypeReference).typeArguments;
+    if (typeArgs && typeArgs.length > 0) {
+      const itemResult = serializeTypeCustom(typeArgs[0], checker, defs, visited, depth + 1);
+      return {
+        isOptional: false,
+        schema: { type: 'array', items: itemResult.schema }
+      };
+    }
+    return { isOptional: false, schema: { type: 'array' } };
+  }
+
+  // Handle union types (like "file" | "folder" or string | null)
+  if (type.isUnion()) {
+    const types = type.types;
+    const hasNull = types.some(t => t.flags & ts.TypeFlags.Null);
+    const hasUndefined = types.some(t => t.flags & ts.TypeFlags.Undefined);
+    const nonNullUndefinedTypes = types.filter(
+      t => !(t.flags & ts.TypeFlags.Null) && !(t.flags & ts.TypeFlags.Undefined)
+    );
+
+    // If it's just T | undefined, make it optional
+    if (hasUndefined && nonNullUndefinedTypes.length === 1 && !hasNull) {
+      const result = serializeTypeCustom(nonNullUndefinedTypes[0], checker, defs, visited, depth + 1);
+      return { isOptional: true, schema: result.schema };
+    }
+
+    // Check if union is all string/number literals (enum-like union)
+    const allStringLiterals = nonNullUndefinedTypes.every(t => t.flags & ts.TypeFlags.StringLiteral);
+    const allNumberLiterals = nonNullUndefinedTypes.every(t => t.flags & ts.TypeFlags.NumberLiteral);
+    
+    if (allStringLiterals && nonNullUndefinedTypes.length > 0) {
+      const enumValues = nonNullUndefinedTypes.map(t => {
+        const literalType = t as ts.StringLiteralType;
+        return literalType.value;
+      });
+      const schema: JsonSchemaProperty = { enum: enumValues };
+      return { isOptional: hasNull || hasUndefined, schema };
+    }
+    
+    if (allNumberLiterals && nonNullUndefinedTypes.length > 0) {
+      const enumValues = nonNullUndefinedTypes.map(t => {
+        const literalType = t as ts.NumberLiteralType;
+        return literalType.value;
+      });
+      const schema: JsonSchemaProperty = { enum: enumValues };
+      return { isOptional: hasNull || hasUndefined, schema };
+    }
+
+    // Build anyOf for unions
+    if (nonNullUndefinedTypes.length > 0 || hasNull) {
+      const anyOf: JsonSchemaProperty[] = [];
+      if (hasNull || hasUndefined) {
+        anyOf.push({ type: 'null' });
+      }
+      for (const unionType of nonNullUndefinedTypes) {
+        const result = serializeTypeCustom(unionType, checker, defs, visited, depth + 1);
+        anyOf.push(result.schema);
+      }
+      if (anyOf.length === 1) {
+        return { isOptional: hasNull || hasUndefined, schema: anyOf[0] };
+      }
+      return { isOptional: false, schema: { anyOf } };
+    }
+  }
+
   // Handle object types with properties (anonymous types)
   if (type.flags & ts.TypeFlags.Object) {
     const props = checker.getPropertiesOfType(type);
@@ -873,7 +904,7 @@ function serializeTypeCustom(
         const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
 
         // Recursively serialize the property type
-        const propResult = serializeTypeCustom(propType, checker, defs, new Set(visited), depth + 1);
+        const propResult = serializeTypeCustom(propType, checker, defs, visited, depth + 1);
         properties[propName] = propResult.schema;
 
         if (!isOptional && !propResult.isOptional) {