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

package/dist/internals.cjs

@@ -852,7 +852,7 @@ var path = __toESM(require("path"), 1);
 
 // src/analyzer/class-analyzer.ts
 var ts6 = __toESM(require("typescript"), 1);
-var import_internal3 = require("@formspec/analysis/internal");
+var import_internal4 = require("@formspec/analysis/internal");
 
 // src/analyzer/jsdoc-constraints.ts
 var ts5 = __toESM(require("typescript"), 1);
@@ -862,6 +862,7 @@ var ts4 = __toESM(require("typescript"), 1);
 var import_internal2 = require("@formspec/analysis/internal");
 var import_internals3 = require("@formspec/core/internals");
 var import_internals4 = require("@formspec/core/internals");
+var import_core = require("@formspec/core");
 
 // src/extensions/resolve-custom-type.ts
 var ts2 = __toESM(require("typescript"), 1);
@@ -989,6 +990,7 @@ function isIntegerBrandedType(type) {
 }
 
 // src/analyzer/tsdoc-parser.ts
+var import_internal3 = require("@formspec/analysis/internal");
 function sharedTagValueOptions(options) {
   return {
     ...options?.extensionRegistry !== void 0 ? { registry: options.extensionRegistry } : {},
@@ -1395,56 +1397,82 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
   if (definition === null) {
     return [];
   }
+  const nonNullPlacement = placement;
+  const log = (0, import_internal3.getBuildLogger)();
+  const broadeningLog = (0, import_internal3.getBroadeningLogger)();
+  const syntheticLog = (0, import_internal3.getSyntheticLogger)();
+  const logsEnabled = log !== import_core.noopLogger || broadeningLog !== import_core.noopLogger;
+  const syntheticTraceEnabled = syntheticLog !== import_core.noopLogger;
+  const logStart = logsEnabled ? (0, import_internal3.nowMicros)() : 0;
+  const subjectTypeKind = logsEnabled ? (0, import_internal3.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_internal3.elapsedMicros)(logStart)
+    };
+    (0, import_internal3.logTagApplication)(log, entry);
+    if (outcome === "bypass" || outcome === "D1" || outcome === "D2") {
+      (0, import_internal3.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_internal2.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;
@@ -1473,13 +1501,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(
@@ -1487,14 +1515,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_internal2.checkSyntheticTagApplication)({
     tagName,
     placement,
@@ -1521,26 +1558,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
     )
-  ];
+  ]);
 }
 var parseResultCache = /* @__PURE__ */ new Map();
 function getExtensionTagNames(options) {
@@ -1950,7 +1987,7 @@ function createAnalyzerMetadataPolicy(input, discriminator) {
   };
 }
 function resolveNodeMetadata(metadataPolicy, declarationKind, logicalName, node, checker, extensionRegistry, buildContext) {
-  const analysis = (0, import_internal3.analyzeMetadataForNodeWithChecker)({
+  const analysis = (0, import_internal4.analyzeMetadataForNodeWithChecker)({
     checker,
     node,
     logicalName,
@@ -2291,7 +2328,7 @@ function getLeadingParsedTags(node) {
     if (!commentText.startsWith("/**")) {
       continue;
     }
-    parsedTags.push(...(0, import_internal3.parseCommentBlock)(commentText, { offset: range.pos }).tags);
+    parsedTags.push(...(0, import_internal4.parseCommentBlock)(commentText, { offset: range.pos }).tags);
   }
   return parsedTags;
 }
@@ -2700,6 +2737,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(
@@ -2966,22 +3019,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(
@@ -3165,6 +3206,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;
@@ -3223,8 +3279,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: [] };
   }
@@ -3256,6 +3327,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,
@@ -4364,20 +4439,29 @@ function assertNoSerializedNameCollisions(ir) {
 }
 
 // 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: {},
@@ -4585,21 +4669,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;
@@ -5080,19 +5174,24 @@ function assignVendorPrefixedExtensionKeywords(schema, extensionSchema, vendorPr
 
 // src/extensions/registry.ts
 var import_internals5 = require("@formspec/core/internals");
-var import_internal4 = require("@formspec/analysis/internal");
+var import_internal5 = require("@formspec/analysis/internal");
 var BUILTIN_METADATA_TAGS = /* @__PURE__ */ new Set(["apiName", "displayName"]);
 function buildConstraintTagSources(extensions) {
   return extensions.map((extension) => ({
     extensionId: extension.extensionId,
     ...extension.constraintTags !== void 0 ? {
       constraintTags: extension.constraintTags.map((tag) => ({
-        tagName: (0, import_internal4.normalizeFormSpecTagName)(tag.tagName)
+        tagName: (0, import_internal5.normalizeFormSpecTagName)(tag.tagName)
       }))
     } : {}
   }));
 }
 function createExtensionRegistry(extensions) {
+  const registryLog = (0, import_internal5.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();
@@ -5160,7 +5259,7 @@ function createExtensionRegistry(extensions) {
     }
     if (ext.constraintTags !== void 0) {
       for (const tag of ext.constraintTags) {
-        const canonicalTagName = (0, import_internal4.normalizeFormSpecTagName)(tag.tagName);
+        const canonicalTagName = (0, import_internal5.normalizeFormSpecTagName)(tag.tagName);
         if (constraintTagMap.has(canonicalTagName)) {
           throw new Error(`Duplicate custom constraint tag: "@${canonicalTagName}"`);
         }
@@ -5185,7 +5284,7 @@ function createExtensionRegistry(extensions) {
           throw new Error(`Duplicate metadata slot ID: "${slot.slotId}"`);
         }
         metadataSlotMap.set(slot.slotId, true);
-        const canonicalTagName = (0, import_internal4.normalizeFormSpecTagName)(slot.tagName);
+        const canonicalTagName = (0, import_internal5.normalizeFormSpecTagName)(slot.tagName);
         if (slot.allowBare === false && (slot.qualifiers?.length ?? 0) === 0) {
           throw new Error(
             `Metadata tag "@${canonicalTagName}" must allow bare usage or declare at least one qualifier.`
@@ -5212,7 +5311,7 @@ function createExtensionRegistry(extensions) {
             `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${(0, import_internals5.normalizeConstraintTagName)(canonicalTagName)}".`
           );
         }
-        const existingTag = (0, import_internal4.getTagDefinition)(canonicalTagName, reservedTagSources);
+        const existingTag = (0, import_internal5.getTagDefinition)(canonicalTagName, reservedTagSources);
         if (existingTag !== null) {
           throw BUILTIN_METADATA_TAGS.has(existingTag.canonicalName) ? new Error(
             `Metadata tag "@${canonicalTagName}" conflicts with built-in metadata tags.`
@@ -5224,6 +5323,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),
@@ -5234,7 +5341,7 @@ function createExtensionRegistry(extensions) {
       symbolMap = map;
     },
     findConstraint: (constraintId) => constraintMap.get(constraintId),
-    findConstraintTag: (tagName) => constraintTagMap.get((0, import_internal4.normalizeFormSpecTagName)(tagName)),
+    findConstraintTag: (tagName) => constraintTagMap.get((0, import_internal5.normalizeFormSpecTagName)(tagName)),
     findBuiltinConstraintBroadening: (typeId, tagName) => builtinBroadeningMap.get(`${typeId}:${tagName}`),
     findAnnotation: (annotationId) => annotationMap.get(annotationId)
   };
@@ -5502,9 +5609,9 @@ function collectFieldNameMap(elements) {
 }
 
 // src/validate/constraint-validator.ts
-var import_internal5 = require("@formspec/analysis/internal");
+var import_internal6 = require("@formspec/analysis/internal");
 function validateFieldNode(ctx, field) {
-  const analysis = (0, import_internal5.analyzeConstraintTargets)(
+  const analysis = (0, import_internal6.analyzeConstraintTargets)(
     field.name,
     field.type,
     field.constraints,
@@ -5522,7 +5629,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,