@formspec/build 0.1.0-alpha.40 → 0.1.0-alpha.41

package/dist/internals.cjs

@@ -106,11 +106,35 @@ function normalizeDeclarationPolicy(input) {
     displayName: normalizeScalarPolicy(input?.displayName)
   };
 }
+function normalizeEnumMemberDisplayNamePolicy(input) {
+  if (input?.mode === "infer-if-missing") {
+    return {
+      mode: "infer-if-missing",
+      infer: input.infer
+    };
+  }
+  if (input?.mode === "require-explicit") {
+    return {
+      mode: "require-explicit",
+      infer: () => ""
+    };
+  }
+  return {
+    mode: "disabled",
+    infer: () => ""
+  };
+}
+function normalizeEnumMemberPolicy(input) {
+  return {
+    displayName: normalizeEnumMemberDisplayNamePolicy(input?.displayName)
+  };
+}
 function normalizeMetadataPolicy(input) {
   return {
     type: normalizeDeclarationPolicy(input?.type),
     field: normalizeDeclarationPolicy(input?.field),
-    method: normalizeDeclarationPolicy(input?.method)
+    method: normalizeDeclarationPolicy(input?.method),
+    enumMember: normalizeEnumMemberPolicy(input?.enumMember)
   };
 }
 function getDeclarationMetadataPolicy(policy, declarationKind) {
@@ -207,6 +231,40 @@ function resolveResolvedMetadata(current, policy, context) {
     ...displayNamePlural !== void 0 && { displayNamePlural }
   };
 }
+function resolveEnumMemberDisplayName(current, policy, context) {
+  if (current !== void 0) {
+    return current;
+  }
+  if (policy.mode === "require-explicit") {
+    throw new Error(
+      `Metadata policy requires explicit displayName for enum member "${context.logicalName}" on the ${context.surface} surface.`
+    );
+  }
+  if (policy.mode !== "infer-if-missing") {
+    return void 0;
+  }
+  const inferredValue = policy.infer(context).trim();
+  return inferredValue !== "" ? inferredValue : void 0;
+}
+function resolveEnumTypeMetadata(type, options) {
+  const members = type.members.map((member) => {
+    const displayName = resolveEnumMemberDisplayName(
+      member.displayName,
+      options.policy.enumMember.displayName,
+      {
+        surface: options.surface,
+        logicalName: String(member.value),
+        memberValue: member.value,
+        ...options.buildContext !== void 0 && { buildContext: options.buildContext }
+      }
+    );
+    if (displayName === member.displayName) {
+      return member;
+    }
+    return displayName === void 0 ? { value: member.value } : { value: member.value, displayName };
+  });
+  return members.some((member, index) => member !== type.members[index]) ? { ...type, members } : type;
+}
 function resolveTypeNodeMetadata(type, options) {
   switch (type.kind) {
     case "array":
@@ -229,9 +287,10 @@ function resolveTypeNodeMetadata(type, options) {
         ...type,
         members: type.members.map((member) => resolveTypeNodeMetadata(member, options))
       };
+    case "enum":
+      return resolveEnumTypeMetadata(type, options);
     case "reference":
     case "primitive":
-    case "enum":
     case "dynamic":
     case "custom":
       return type;
@@ -310,11 +369,10 @@ function getDisplayName(metadata) {
   return metadata?.displayName?.value;
 }
 function resolveFormIRMetadata(ir, options) {
-  const rootLogicalName = options.rootLogicalName ?? ir.name ?? "FormSpec";
-  const metadata = resolveResolvedMetadata(ir.metadata, options.policy.type, {
+  const metadata = options.resolveRootTypeMetadata === false ? ir.metadata : resolveResolvedMetadata(ir.metadata, options.policy.type, {
     surface: options.surface,
     declarationKind: "type",
-    logicalName: rootLogicalName,
+    logicalName: options.rootLogicalName ?? ir.name ?? "FormSpec",
     ...options.buildContext !== void 0 && { buildContext: options.buildContext }
   });
   return {
@@ -350,7 +408,7 @@ function canonicalizeChainDSL(form, options) {
   const metadataPolicy = normalizeMetadataPolicy(
     options?.metadata ?? (0, import_internals._getFormSpecMetadataPolicy)(form)
   );
-  return {
+  const ir = {
     kind: "form-ir",
     irVersion: import_internals.IR_VERSION,
     elements: canonicalizeElements(form.elements, metadataPolicy),
@@ -358,6 +416,13 @@ function canonicalizeChainDSL(form, options) {
     typeRegistry: {},
     provenance: CHAIN_DSL_PROVENANCE
   };
+  return resolveFormIRMetadata(ir, {
+    policy: metadataPolicy,
+    surface: "chain-dsl",
+    // Chain DSL has no root/type-metadata authoring surface, so only resolve
+    // field/type-registry metadata and enum-member labels here.
+    resolveRootTypeMetadata: false
+  });
 }
 function canonicalizeElements(elements, metadataPolicy) {
   return elements.map((element) => canonicalizeElement(element, metadataPolicy));
@@ -4197,17 +4262,25 @@ function assertNoSerializedNameCollisions(ir) {
 // src/json-schema/ir-generator.ts
 function makeContext(options) {
   const vendorPrefix = options?.vendorPrefix ?? "x-formspec";
+  const rawEnumSerialization = 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: {},
     typeRegistry: {},
     extensionRegistry: options?.extensionRegistry,
-    vendorPrefix
+    vendorPrefix,
+    enumSerialization
   };
 }
 function generateJsonSchemaFromIR(ir, options) {
@@ -4381,7 +4454,7 @@ function generateTypeNode(type, ctx) {
     case "primitive":
       return generatePrimitiveType(type);
     case "enum":
-      return generateEnumType(type);
+      return generateEnumType(type, ctx);
     case "array":
       return generateArrayType(type, ctx);
     case "object":
@@ -4407,20 +4480,37 @@ function generatePrimitiveType(type) {
     type: type.primitiveKind === "integer" || type.primitiveKind === "bigint" ? "integer" : type.primitiveKind
   };
 }
-function generateEnumType(type) {
-  const hasDisplayNames = type.members.some((m) => m.displayName !== void 0);
-  if (hasDisplayNames) {
+function generateEnumType(type, ctx) {
+  if (ctx.enumSerialization === "oneOf") {
     return {
-      oneOf: type.members.map((m) => {
-        const entry = { const: m.value };
-        if (m.displayName !== void 0) {
-          entry.title = m.displayName;
-        }
-        return entry;
-      })
+      oneOf: type.members.map((m) => ({
+        const: m.value,
+        title: m.displayName ?? String(m.value)
+      }))
     };
   }
-  return { enum: type.members.map((m) => m.value) };
+  const schema = { enum: type.members.map((m) => m.value) };
+  const displayNames = buildEnumDisplayNameExtension(type);
+  if (displayNames !== void 0) {
+    schema[`${ctx.vendorPrefix}-display-names`] = displayNames;
+  }
+  return schema;
+}
+function buildEnumDisplayNameExtension(type) {
+  if (!type.members.some((member) => member.displayName !== void 0)) {
+    return void 0;
+  }
+  const displayNames = /* @__PURE__ */ Object.create(null);
+  for (const member of type.members) {
+    const key = String(member.value);
+    if (Object.hasOwn(displayNames, key)) {
+      throw new Error(
+        `Enum display-name key "${key}" is ambiguous after stringification. Use oneOf serialization for mixed string/number enum values that collide.`
+      );
+    }
+    displayNames[key] = member.displayName ?? key;
+  }
+  return displayNames;
 }
 function generateArrayType(type, ctx) {
   return {
@@ -5337,7 +5427,7 @@ function createExtensionRegistry(extensions) {
 
 // src/generators/method-schema.ts
 var import_internals6 = require("@formspec/core/internals");
-function typeToJsonSchema(type, checker) {
+function typeToJsonSchema(type, checker, options) {
   const typeRegistry = {};
   const visiting = /* @__PURE__ */ new Set();
   const diagnostics = [];
@@ -5377,7 +5467,10 @@ function typeToJsonSchema(type, checker) {
     typeRegistry,
     provenance: fieldProvenance
   };
-  const schema = generateJsonSchemaFromIR(ir);
+  const schema = generateJsonSchemaFromIR(
+    ir,
+    options?.enumSerialization === void 0 ? void 0 : { enumSerialization: options.enumSerialization }
+  );
   const fieldSchema = schema.properties?.["__result"];
   if (fieldSchema) {
     if (schema.$defs && Object.keys(schema.$defs).length > 0) {
@@ -5387,16 +5480,16 @@ function typeToJsonSchema(type, checker) {
   }
   return { type: "object" };
 }
-function generateMethodSchemas(method, checker, loadedFormSpecs) {
-  const returnType = typeToJsonSchema(method.returnType, checker);
-  const params = generateParamsSchemas(method.parameters, checker, loadedFormSpecs);
+function generateMethodSchemas(method, checker, loadedFormSpecs, options) {
+  const returnType = typeToJsonSchema(method.returnType, checker, options);
+  const params = generateParamsSchemas(method.parameters, checker, loadedFormSpecs, options);
   return {
     name: method.name,
     params,
     returnType
   };
 }
-function generateParamsSchemas(parameters, checker, loadedFormSpecs) {
+function generateParamsSchemas(parameters, checker, loadedFormSpecs, options) {
   if (parameters.length === 0) {
     return null;
   }
@@ -5417,7 +5510,7 @@ function generateParamsSchemas(parameters, checker, loadedFormSpecs) {
   }
   if (parameters.length === 1 && parameters[0]) {
     const param = parameters[0];
-    const jsonSchema = typeToJsonSchema(param.type, checker);
+    const jsonSchema = typeToJsonSchema(param.type, checker, options);
     return {
       jsonSchema,
       uiSchema: null,
@@ -5427,7 +5520,7 @@ function generateParamsSchemas(parameters, checker, loadedFormSpecs) {
   const properties = {};
   const required = [];
   for (const param of parameters) {
-    const paramSchema = typeToJsonSchema(param.type, checker);
+    const paramSchema = typeToJsonSchema(param.type, checker, options);
     properties[param.name] = paramSchema;
     if (!param.optional) {
       required.push(param.name);