@formspec/build 0.1.0-alpha.54 → 0.1.0-alpha.57

package/dist/cli.js

@@ -996,20 +996,29 @@ var init_collision_guards = __esm({
 });
 
 // src/json-schema/ir-generator.ts
+function parseEnumSerialization(value) {
+  switch (value) {
+    case void 0:
+    case "enum":
+      return "enum";
+    case "oneOf":
+      return "oneOf";
+    case "smart-size":
+      return "smart-size";
+    default:
+      throw new Error(
+        `Invalid enumSerialization "${String(value)}". Expected "enum", "oneOf", or "smart-size".`
+      );
+  }
+}
 function makeContext(options) {
   const vendorPrefix = options?.vendorPrefix ?? "x-formspec";
-  const rawEnumSerialization = options?.enumSerialization;
+  const enumSerialization = parseEnumSerialization(options?.enumSerialization);
   if (!vendorPrefix.startsWith("x-")) {
     throw new Error(
       `Invalid vendorPrefix "${vendorPrefix}". Extension JSON Schema keywords must start with "x-".`
     );
   }
-  if (rawEnumSerialization !== void 0 && rawEnumSerialization !== "enum" && rawEnumSerialization !== "oneOf") {
-    throw new Error(
-      `Invalid enumSerialization "${rawEnumSerialization}". Expected "enum" or "oneOf".`
-    );
-  }
-  const enumSerialization = rawEnumSerialization ?? "enum";
   return {
     defs: {},
     typeNameMap: {},
@@ -1217,21 +1226,31 @@ function generatePrimitiveType(type) {
   };
 }
 function generateEnumType(type, ctx) {
-  if (ctx.enumSerialization === "oneOf") {
+  if (ctx.enumSerialization === "oneOf" || ctx.enumSerialization === "smart-size" && shouldSerializeEnumAsOneOf(type)) {
     return {
-      oneOf: type.members.map((m) => ({
-        const: m.value,
-        title: m.displayName ?? String(m.value)
-      }))
+      oneOf: type.members.map((m) => {
+        const stringValue = String(m.value);
+        const title = m.displayName !== void 0 && m.displayName !== stringValue ? m.displayName : void 0;
+        return title !== void 0 ? { const: m.value, title } : { const: m.value };
+      })
     };
   }
   const schema = { enum: type.members.map((m) => m.value) };
+  if (ctx.enumSerialization === "smart-size") {
+    return schema;
+  }
   const displayNames = buildEnumDisplayNameExtension(type);
   if (displayNames !== void 0) {
     schema[`${ctx.vendorPrefix}-display-names`] = displayNames;
   }
   return schema;
 }
+function shouldSerializeEnumAsOneOf(type) {
+  return type.members.some((member) => {
+    const title = member.displayName ?? String(member.value);
+    return title !== String(member.value);
+  });
+}
 function buildEnumDisplayNameExtension(type) {
   if (!type.members.some((member) => member.displayName !== void 0)) {
     return void 0;
@@ -2042,7 +2061,8 @@ import {
 } from "@formspec/core/internals";
 import {
   getTagDefinition,
-  normalizeFormSpecTagName
+  normalizeFormSpecTagName,
+  getSyntheticLogger
 } from "@formspec/analysis/internal";
 function buildConstraintTagSources(extensions) {
   return extensions.map((extension) => ({
@@ -2055,6 +2075,11 @@ function buildConstraintTagSources(extensions) {
   }));
 }
 function createExtensionRegistry(extensions) {
+  const registryLog = getSyntheticLogger();
+  registryLog.debug("createExtensionRegistry: constructing", {
+    extensionCount: extensions.length,
+    extensionIds: extensions.map((e) => e.extensionId)
+  });
   const reservedTagSources = buildConstraintTagSources(extensions);
   let symbolMap = /* @__PURE__ */ new Map();
   const typeMap = /* @__PURE__ */ new Map();
@@ -2186,6 +2211,14 @@ function createExtensionRegistry(extensions) {
       }
     }
   }
+  registryLog.debug("createExtensionRegistry: complete", {
+    typeCount: typeMap.size,
+    constraintCount: constraintMap.size,
+    constraintTagCount: constraintTagMap.size,
+    broadeningCount: builtinBroadeningMap.size,
+    annotationCount: annotationMap.size,
+    metadataSlotCount: metadataSlotMap.size
+  });
   return {
     extensions,
     findType: (typeId) => typeMap.get(typeId),
@@ -2449,6 +2482,16 @@ import {
   isBuiltinConstraintName
 } from "@formspec/core/internals";
 import "@formspec/core/internals";
+import { noopLogger as noopLogger4 } from "@formspec/core";
+import {
+  getBuildLogger,
+  getBroadeningLogger,
+  getSyntheticLogger as getSyntheticLogger2,
+  describeTypeKind,
+  elapsedMicros,
+  nowMicros,
+  logTagApplication
+} from "@formspec/analysis/internal";
 function sharedTagValueOptions(options) {
   return {
     ...options?.extensionRegistry !== void 0 ? { registry: options.extensionRegistry } : {},
@@ -2852,56 +2895,82 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
   if (definition === null) {
     return [];
   }
+  const nonNullPlacement = placement;
+  const log2 = getBuildLogger();
+  const broadeningLog = getBroadeningLogger();
+  const syntheticLog = getSyntheticLogger2();
+  const logsEnabled = log2 !== noopLogger4 || broadeningLog !== noopLogger4;
+  const syntheticTraceEnabled = syntheticLog !== noopLogger4;
+  const logStart = logsEnabled ? nowMicros() : 0;
+  const subjectTypeKind = logsEnabled ? describeTypeKind(subjectType, checker) : "";
+  function emit(outcome, result2) {
+    if (!logsEnabled) {
+      return result2;
+    }
+    const entry = {
+      consumer: "build",
+      tag: tagName,
+      placement: nonNullPlacement,
+      subjectTypeKind,
+      roleOutcome: outcome,
+      elapsedMicros: elapsedMicros(logStart)
+    };
+    logTagApplication(log2, entry);
+    if (outcome === "bypass" || outcome === "D1" || outcome === "D2") {
+      logTagApplication(broadeningLog, entry);
+    }
+    return result2;
+  }
   if (!definition.placements.includes(placement)) {
-    return [
+    return emit("A-reject", [
       makeDiagnostic(
         "INVALID_TAG_PLACEMENT",
         `Tag "@${tagName}" is not allowed on ${placementLabel(placement)}.`,
         provenance
       )
-    ];
+    ]);
   }
   const target = parsedTag?.target ?? null;
   let evaluatedType = subjectType;
   let targetLabel = node.getText(sourceFile);
   if (target !== null) {
     if (target.kind !== "path") {
-      return [
+      return emit("B-reject", [
         makeDiagnostic(
           "UNSUPPORTED_TARGETING_SYNTAX",
           `Tag "@${tagName}" does not support ${target.kind} targeting syntax.`,
           provenance
         )
-      ];
+      ]);
     }
     if (!target.valid || target.path === null) {
-      return [
+      return emit("B-reject", [
         makeDiagnostic(
           "UNSUPPORTED_TARGETING_SYNTAX",
           `Tag "@${tagName}" has invalid path targeting syntax.`,
           provenance
         )
-      ];
+      ]);
     }
     const resolution = resolvePathTargetType(subjectType, checker, target.path.segments);
     if (resolution.kind === "missing-property") {
-      return [
+      return emit("B-reject", [
         makeDiagnostic(
           "UNKNOWN_PATH_TARGET",
           `Target "${target.rawText}": path-targeted constraint "${tagName}" references unknown path segment "${resolution.segment}"`,
           provenance
         )
-      ];
+      ]);
     }
     if (resolution.kind === "unresolvable") {
       const actualType = checker.typeToString(resolution.type, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
-      return [
+      return emit("B-reject", [
         makeDiagnostic(
           "TYPE_MISMATCH",
           `Target "${target.rawText}": path-targeted constraint "${tagName}" is invalid because type "${actualType}" cannot be traversed`,
           provenance
         )
-      ];
+      ]);
     }
     evaluatedType = resolution.type;
     targetLabel = target.rawText;
@@ -2930,13 +2999,13 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
         tagName,
         parsedTag?.argumentText
       ) : null;
-      return [
+      return emit("B-reject", [
         makeDiagnostic(
           "TYPE_MISMATCH",
           hint === null ? baseMessage : `${baseMessage}. ${hint}`,
           provenance
         )
-      ];
+      ]);
     }
   }
   const argumentExpression = renderSyntheticArgumentExpression(
@@ -2944,14 +3013,23 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
     parsedTag?.argumentText ?? ""
   );
   if (definition.requiresArgument && argumentExpression === null) {
-    return [];
+    return emit("A-pass", []);
   }
   if (hasBroadening) {
-    return [];
+    return emit("bypass", []);
   }
   const subjectTypeText = checker.typeToString(subjectType, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
   const hostType = options?.hostType ?? subjectType;
   const hostTypeText = checker.typeToString(hostType, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
+  if (syntheticTraceEnabled) {
+    syntheticLog.trace("invoking synthetic checker", {
+      consumer: "build",
+      tag: tagName,
+      placement,
+      subjectTypeKind,
+      subjectTypeText
+    });
+  }
   const result = checkSyntheticTagApplication({
     tagName,
     placement,
@@ -2978,26 +3056,26 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
     } : {}
   });
   if (result.diagnostics.length === 0) {
-    return [];
+    return emit("C-pass", []);
   }
   const setupDiagnostic = result.diagnostics.find((diagnostic) => diagnostic.kind !== "typescript");
   if (setupDiagnostic !== void 0) {
-    return [
+    return emit("C-reject", [
       makeDiagnostic(
         setupDiagnostic.kind === "unsupported-custom-type-override" ? "UNSUPPORTED_CUSTOM_TYPE_OVERRIDE" : "SYNTHETIC_SETUP_FAILURE",
         setupDiagnostic.message,
         provenance
       )
-    ];
+    ]);
   }
   const expectedLabel = definition.valueKind === null ? "compatible argument" : capabilityLabel(definition.valueKind);
-  return [
+  return emit("C-reject", [
     makeDiagnostic(
       "TYPE_MISMATCH",
       `Tag "@${tagName}" received an invalid argument for ${expectedLabel}.`,
       provenance
     )
-  ];
+  ]);
 }
 function getExtensionTagNames(options) {
   return [
@@ -4175,6 +4253,22 @@ function extractReferenceTypeArguments(type, checker, file, typeRegistry, visiti
   }
   return referenceTypeNode.typeArguments.map((argumentNode) => {
     const argumentType = checker.getTypeFromTypeNode(argumentNode);
+    const baseSymbol = argumentType.aliasSymbol ?? argumentType.getSymbol();
+    const argumentSymbol = baseSymbol !== void 0 && baseSymbol.flags & ts6.SymbolFlags.Alias ? checker.getAliasedSymbol(baseSymbol) : baseSymbol;
+    const argumentDecl = argumentSymbol?.declarations?.[0];
+    if (argumentDecl !== void 0 && argumentDecl.getSourceFile().fileName !== file) {
+      const argumentName = argumentSymbol?.getName() ?? baseSymbol?.getName();
+      if (argumentName !== void 0) {
+        return {
+          tsType: argumentType,
+          typeNode: {
+            kind: "reference",
+            name: argumentName,
+            typeArguments: []
+          }
+        };
+      }
+    }
     return {
       tsType: argumentType,
       typeNode: resolveTypeNode(
@@ -4441,22 +4535,10 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
     sourceNode
   );
   if (customTypeLookup !== null) {
-    const typeId = customTypeIdFromLookup(customTypeLookup);
-    let payload = null;
-    if (customTypeLookup.registration.extractPayload !== void 0) {
-      try {
-        payload = customTypeLookup.registration.extractPayload(type, checker) ?? null;
-      } catch (cause) {
-        throw new Error(
-          `extractPayload for custom type "${customTypeLookup.registration.typeName}" in extension "${customTypeLookup.extensionId}" threw`,
-          { cause }
-        );
-      }
-    }
     return {
       kind: "custom",
-      typeId,
-      payload
+      typeId: customTypeIdFromLookup(customTypeLookup),
+      payload: null
     };
   }
   const primitiveAlias = tryResolveNamedPrimitiveAlias(
@@ -4640,6 +4722,21 @@ function getReferencedTypeAliasDeclaration(sourceNode, checker) {
   }
   return getTypeAliasDeclarationFromTypeReference(typeNode, checker);
 }
+function resolveNamedTypeWithSourceRecovery(type, sourceNode, checker) {
+  const typeName = getNamedTypeName(type);
+  const namedDecl = getNamedTypeDeclaration(type);
+  if (typeName !== null && namedDecl !== void 0) {
+    return { typeName, namedDecl };
+  }
+  if (sourceNode === void 0) {
+    return null;
+  }
+  const refAliasDecl = getReferencedTypeAliasDeclaration(sourceNode, checker);
+  if (refAliasDecl === void 0) {
+    return null;
+  }
+  return { typeName: refAliasDecl.name.text, namedDecl: refAliasDecl };
+}
 function shouldEmitPrimitiveAliasDefinition(typeNode, checker) {
   if (!ts6.isTypeReferenceNode(typeNode)) {
     return false;
@@ -4698,8 +4795,23 @@ function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiti
   );
 }
 function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
-  const typeName = getNamedTypeName(type);
-  const namedDecl = getNamedTypeDeclaration(type);
+  const recovered = resolveNamedTypeWithSourceRecovery(type, sourceNode, checker);
+  let typeName = null;
+  let namedDecl;
+  if (recovered !== null) {
+    const recoveredAliasDecl = ts6.isTypeAliasDeclaration(recovered.namedDecl) ? recovered.namedDecl : void 0;
+    if (recoveredAliasDecl !== void 0) {
+      const aliasUnderlyingType = checker.getTypeFromTypeNode(recoveredAliasDecl.type);
+      const isNonGeneric = recoveredAliasDecl.typeParameters === void 0 || recoveredAliasDecl.typeParameters.length === 0;
+      if (isNonGeneric && (aliasUnderlyingType.isUnion() || isObjectType(aliasUnderlyingType))) {
+        typeName = recovered.typeName;
+        namedDecl = recovered.namedDecl;
+      }
+    } else {
+      typeName = recovered.typeName;
+      namedDecl = recovered.namedDecl;
+    }
+  }
   if (typeName && typeName in typeRegistry) {
     return { kind: "reference", name: typeName, typeArguments: [] };
   }
@@ -4731,6 +4843,10 @@ function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNod
     if (!typeName) {
       return result;
     }
+    const existing = typeRegistry[typeName];
+    if (existing !== void 0 && existing.type !== RESOLVING_TYPE_PLACEHOLDER) {
+      return { kind: "reference", name: typeName, typeArguments: [] };
+    }
     const annotations = namedDecl ? extractJSDocAnnotationNodes(namedDecl, file, makeParseOptions(extensionRegistry)) : void 0;
     const metadata = namedDecl !== void 0 ? resolveNodeMetadata(
       metadataPolicy,
@@ -6995,11 +7111,11 @@ __export(index_exports, {
   uiSchemaSchema: () => uiSchema,
   writeSchemas: () => writeSchemas
 });
-import { noopLogger as noopLogger4 } from "@formspec/core";
+import { noopLogger as noopLogger5 } from "@formspec/core";
 import * as fs from "fs";
 import * as path3 from "path";
 function buildFormSchemas(form, options) {
-  const logger = options?.logger ?? noopLogger4;
+  const logger = options?.logger ?? noopLogger5;
   logger.debug("buildFormSchemas: starting schema generation");
   return {
     jsonSchema: generateJsonSchema(form, options),
@@ -7016,7 +7132,7 @@ function writeSchemas(form, options) {
     metadata,
     logger: rawLogger
   } = options;
-  const logger = (rawLogger ?? noopLogger4).child({ stage: "write" });
+  const logger = (rawLogger ?? noopLogger5).child({ stage: "write" });
   const buildOptions = vendorPrefix === void 0 && enumSerialization === void 0 && metadata === void 0 ? { logger: rawLogger } : {
     ...vendorPrefix !== void 0 && { vendorPrefix },
     ...enumSerialization !== void 0 && { enumSerialization },
@@ -7096,7 +7212,7 @@ Usage:
 Options:
   -o, --out-dir <dir>   Output directory (default: ./generated)
   -n, --name <name>     Base name for output files (default: derived from input)
-  --enum-serialization <enum|oneOf>
+  --enum-serialization <enum|oneOf|smart-size>
                          Enum JSON Schema representation (default: enum)
   -h, --help            Show this help message
 
@@ -7148,8 +7264,10 @@ function parseArgs(args) {
         console.error("Error: --enum-serialization requires a value");
         return null;
       }
-      if (nextArg !== "enum" && nextArg !== "oneOf") {
-        console.error('Error: --enum-serialization must be "enum" or "oneOf"');
+      if (nextArg !== "enum" && nextArg !== "oneOf" && nextArg !== "smart-size") {
+        console.error(
+          'Error: --enum-serialization must be "enum", "oneOf", or "smart-size"'
+        );
         return null;
       }
       enumSerialization = nextArg;