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

package/dist/cli.cjs

@@ -1018,20 +1018,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: {},
@@ -1239,21 +1248,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;
@@ -2072,6 +2091,11 @@ function buildConstraintTagSources(extensions) {
   }));
 }
 function createExtensionRegistry(extensions) {
+  const registryLog = (0, import_internal.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();
@@ -2203,6 +2227,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),
@@ -2851,56 +2883,82 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
   if (definition === null) {
     return [];
   }
+  const nonNullPlacement = placement;
+  const log2 = (0, import_internal4.getBuildLogger)();
+  const broadeningLog = (0, import_internal4.getBroadeningLogger)();
+  const syntheticLog = (0, import_internal4.getSyntheticLogger)();
+  const logsEnabled = log2 !== import_core4.noopLogger || broadeningLog !== import_core4.noopLogger;
+  const syntheticTraceEnabled = syntheticLog !== import_core4.noopLogger;
+  const logStart = logsEnabled ? (0, import_internal4.nowMicros)() : 0;
+  const subjectTypeKind = logsEnabled ? (0, import_internal4.describeTypeKind)(subjectType, checker) : "";
+  function emit(outcome, result2) {
+    if (!logsEnabled) {
+      return result2;
+    }
+    const entry = {
+      consumer: "build",
+      tag: tagName,
+      placement: nonNullPlacement,
+      subjectTypeKind,
+      roleOutcome: outcome,
+      elapsedMicros: (0, import_internal4.elapsedMicros)(logStart)
+    };
+    (0, import_internal4.logTagApplication)(log2, entry);
+    if (outcome === "bypass" || outcome === "D1" || outcome === "D2") {
+      (0, import_internal4.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 = (0, import_internal3.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;
@@ -2929,13 +2987,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(
@@ -2943,14 +3001,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 = (0, import_internal3.checkSyntheticTagApplication)({
     tagName,
     placement,
@@ -2977,26 +3044,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 [
@@ -3308,7 +3375,7 @@ function getTagCommentText(tag) {
   }
   return ts4.getTextOfJSDocComment(tag.comment);
 }
-var ts4, import_internal3, import_internals4, import_internals5, SYNTHETIC_TYPE_FORMAT_FLAGS, MAX_HINT_CANDIDATES, MAX_HINT_DEPTH, parseResultCache;
+var ts4, import_internal3, import_internals4, import_internals5, import_core4, import_internal4, SYNTHETIC_TYPE_FORMAT_FLAGS, MAX_HINT_CANDIDATES, MAX_HINT_DEPTH, parseResultCache;
 var init_tsdoc_parser = __esm({
   "src/analyzer/tsdoc-parser.ts"() {
     "use strict";
@@ -3316,8 +3383,10 @@ var init_tsdoc_parser = __esm({
     import_internal3 = require("@formspec/analysis/internal");
     import_internals4 = require("@formspec/core/internals");
     import_internals5 = require("@formspec/core/internals");
+    import_core4 = require("@formspec/core");
     init_resolve_custom_type();
     init_builtin_brands();
+    import_internal4 = require("@formspec/analysis/internal");
     SYNTHETIC_TYPE_FORMAT_FLAGS = ts4.TypeFormatFlags.NoTruncation | ts4.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
     MAX_HINT_CANDIDATES = 5;
     MAX_HINT_DEPTH = 3;
@@ -3424,7 +3493,7 @@ function createAnalyzerMetadataPolicy(input, discriminator) {
   };
 }
 function resolveNodeMetadata(metadataPolicy, declarationKind, logicalName, node, checker, extensionRegistry, buildContext) {
-  const analysis = (0, import_internal4.analyzeMetadataForNodeWithChecker)({
+  const analysis = (0, import_internal5.analyzeMetadataForNodeWithChecker)({
     checker,
     node,
     logicalName,
@@ -3765,7 +3834,7 @@ function getLeadingParsedTags(node) {
     if (!commentText.startsWith("/**")) {
       continue;
     }
-    parsedTags.push(...(0, import_internal4.parseCommentBlock)(commentText, { offset: range.pos }).tags);
+    parsedTags.push(...(0, import_internal5.parseCommentBlock)(commentText, { offset: range.pos }).tags);
   }
   return parsedTags;
 }
@@ -4174,6 +4243,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(
@@ -4440,22 +4525,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(
@@ -4639,6 +4712,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;
@@ -4697,8 +4785,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: [] };
   }
@@ -4730,6 +4833,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,
@@ -5377,12 +5484,12 @@ function detectFormSpecReference(typeNode) {
   }
   return null;
 }
-var ts6, import_internal4, RESOLVING_TYPE_PLACEHOLDER, MAX_ALIAS_CHAIN_DEPTH;
+var ts6, import_internal5, RESOLVING_TYPE_PLACEHOLDER, MAX_ALIAS_CHAIN_DEPTH;
 var init_class_analyzer = __esm({
   "src/analyzer/class-analyzer.ts"() {
     "use strict";
     ts6 = __toESM(require("typescript"), 1);
-    import_internal4 = require("@formspec/analysis/internal");
+    import_internal5 = require("@formspec/analysis/internal");
     init_jsdoc_constraints();
     init_tsdoc_parser();
     init_resolve_custom_type();
@@ -5889,7 +5996,7 @@ var init_symbol_registry = __esm({
 
 // src/validate/constraint-validator.ts
 function validateFieldNode(ctx, field) {
-  const analysis = (0, import_internal5.analyzeConstraintTargets)(
+  const analysis = (0, import_internal6.analyzeConstraintTargets)(
     field.name,
     field.type,
     field.constraints,
@@ -5907,7 +6014,7 @@ function validateFieldNode(ctx, field) {
 }
 function validateObjectProperty(ctx, parentName, property) {
   const qualifiedName = `${parentName}.${property.name}`;
-  const analysis = (0, import_internal5.analyzeConstraintTargets)(
+  const analysis = (0, import_internal6.analyzeConstraintTargets)(
     qualifiedName,
     property.type,
     property.constraints,
@@ -5958,11 +6065,11 @@ function validateIR(ir, options) {
     valid: ctx.diagnostics.every((diagnostic) => diagnostic.severity !== "error")
   };
 }
-var import_internal5;
+var import_internal6;
 var init_constraint_validator = __esm({
   "src/validate/constraint-validator.ts"() {
     "use strict";
-    import_internal5 = require("@formspec/analysis/internal");
+    import_internal6 = require("@formspec/analysis/internal");
   }
 });
 
@@ -6710,7 +6817,7 @@ function generateSchemasFromReturnType(options) {
 }
 function resolveDeclarationMetadata(options) {
   const resolved = resolveStaticOptions(options);
-  const analysis = (0, import_internal6.analyzeMetadataForNodeWithChecker)({
+  const analysis = (0, import_internal7.analyzeMetadataForNodeWithChecker)({
     checker: options.context.checker,
     node: options.declaration,
     metadata: resolved.metadata,
@@ -6756,12 +6863,12 @@ function unwrapPromiseTypeNode(typeNode) {
 function isPromiseTypeReferenceNode(typeNode) {
   return ts11.isTypeReferenceNode(typeNode) && ts11.isIdentifier(typeNode.typeName) && typeNode.typeName.text === "Promise" && typeNode.typeArguments !== void 0 && typeNode.typeArguments.length > 0;
 }
-var ts11, import_internal6, import_internals6;
+var ts11, import_internal7, import_internals6;
 var init_discovered_schema = __esm({
   "src/generators/discovered-schema.ts"() {
     "use strict";
     ts11 = __toESM(require("typescript"), 1);
-    import_internal6 = require("@formspec/analysis/internal");
+    import_internal7 = require("@formspec/analysis/internal");
     init_class_analyzer();
     init_class_schema();
     init_ir_generator();
@@ -7003,7 +7110,7 @@ __export(index_exports, {
   writeSchemas: () => writeSchemas
 });
 function buildFormSchemas(form, options) {
-  const logger = options?.logger ?? import_core4.noopLogger;
+  const logger = options?.logger ?? import_core5.noopLogger;
   logger.debug("buildFormSchemas: starting schema generation");
   return {
     jsonSchema: generateJsonSchema(form, options),
@@ -7020,7 +7127,7 @@ function writeSchemas(form, options) {
     metadata,
     logger: rawLogger
   } = options;
-  const logger = (rawLogger ?? import_core4.noopLogger).child({ stage: "write" });
+  const logger = (rawLogger ?? import_core5.noopLogger).child({ stage: "write" });
   const buildOptions = vendorPrefix === void 0 && enumSerialization === void 0 && metadata === void 0 ? { logger: rawLogger } : {
     ...vendorPrefix !== void 0 && { vendorPrefix },
     ...enumSerialization !== void 0 && { enumSerialization },
@@ -7039,11 +7146,11 @@ function writeSchemas(form, options) {
   fs.writeFileSync(uiSchemaPath, JSON.stringify(uiSchema2, null, indent));
   return { jsonSchemaPath, uiSchemaPath };
 }
-var import_core4, fs, path3;
+var import_core5, fs, path3;
 var init_index = __esm({
   "src/index.ts"() {
     "use strict";
-    import_core4 = require("@formspec/core");
+    import_core5 = require("@formspec/core");
     init_generator();
     init_generator2();
     init_ir_generator();
@@ -7105,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
 
@@ -7157,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;