@formspec/build 0.1.0-alpha.30 → 0.1.0-alpha.31

package/dist/browser.js

@@ -707,9 +707,9 @@ function collectFields(elements, properties, required, ctx) {
   for (const element of elements) {
     switch (element.kind) {
       case "field":
-        properties[getSerializedName(element.name, element.metadata)] = generateFieldSchema(element, ctx);
+        properties[getSerializedFieldName(element)] = generateFieldSchema(element, ctx);
         if (element.required) {
-          required.push(getSerializedName(element.name, element.metadata));
+          required.push(getSerializedFieldName(element));
         }
         break;
       case "group":
@@ -780,19 +780,21 @@ function applyPathTargetedConstraints(schema, pathConstraints, ctx, typeNode) {
     schema.items = applyPathTargetedConstraints(schema.items, pathConstraints, ctx, nestedType);
     return schema;
   }
-  const byTarget = /* @__PURE__ */ new Map();
-  for (const c of pathConstraints) {
-    const target = c.path?.segments[0];
-    if (!target) continue;
-    const group = byTarget.get(target) ?? [];
-    group.push(c);
-    byTarget.set(target, group);
-  }
-  const propertyOverrides = {};
-  for (const [target, constraints] of byTarget) {
-    const subSchema = {};
-    applyConstraints(subSchema, constraints, ctx);
-    propertyOverrides[resolveSerializedPropertyName(target, typeNode, ctx)] = subSchema;
+  const propertyOverrides = buildPropertyOverrides(pathConstraints, typeNode, ctx);
+  const nullableValueBranch = getNullableUnionValueSchema(schema);
+  if (nullableValueBranch !== void 0) {
+    const updatedNullableValueBranch = applyPathTargetedConstraints(
+      nullableValueBranch,
+      pathConstraints,
+      ctx,
+      resolveTraversableTypeNode(typeNode, ctx)
+    );
+    if (schema.oneOf !== void 0) {
+      schema.oneOf = schema.oneOf.map(
+        (branch) => branch === nullableValueBranch ? updatedNullableValueBranch : branch
+      );
+    }
+    return schema;
   }
   if (schema.$ref) {
     const { $ref, ...rest } = schema;
@@ -807,7 +809,7 @@ function applyPathTargetedConstraints(schema, pathConstraints, ctx, typeNode) {
     const missingOverrides = {};
     for (const [target, overrideSchema] of Object.entries(propertyOverrides)) {
       if (schema.properties[target]) {
-        Object.assign(schema.properties[target], overrideSchema);
+        mergeSchemaOverride(schema.properties[target], overrideSchema);
       } else {
         missingOverrides[target] = overrideSchema;
       }
@@ -881,7 +883,7 @@ function generateObjectType(type, ctx) {
   const properties = {};
   const required = [];
   for (const prop of type.properties) {
-    const propertyName = getSerializedName(prop.name, prop.metadata);
+    const propertyName = getSerializedObjectPropertyName(prop);
     properties[propertyName] = generatePropertySchema(prop, ctx);
     if (!prop.optional) {
       required.push(propertyName);
@@ -935,7 +937,16 @@ function isNullableUnion(type) {
   return nullCount === 1;
 }
 function generateReferenceType(type, ctx) {
-  return { $ref: `#/$defs/${ctx.typeNameMap[type.name] ?? type.name}` };
+  return { $ref: `#/$defs/${getSerializedTypeName(type.name, ctx)}` };
+}
+function getSerializedFieldName(field) {
+  return getSerializedName(field.name, field.metadata);
+}
+function getSerializedObjectPropertyName(property) {
+  return getSerializedName(property.name, property.metadata);
+}
+function getSerializedTypeName(logicalName, ctx) {
+  return ctx.typeNameMap[logicalName] ?? logicalName;
 }
 function applyResolvedMetadata(schema, metadata) {
   const displayName = getDisplayName(metadata);
@@ -946,17 +957,148 @@ function applyResolvedMetadata(schema, metadata) {
 function resolveReferencedType(type, ctx) {
   return ctx.typeRegistry[type.name]?.type;
 }
+function dereferenceTypeNode(typeNode, ctx) {
+  if (typeNode?.kind !== "reference") {
+    return typeNode;
+  }
+  return resolveReferencedType(typeNode, ctx);
+}
+function unwrapNullableTypeNode(typeNode) {
+  if (typeNode?.kind !== "union" || !isNullableUnion(typeNode)) {
+    return typeNode;
+  }
+  return typeNode.members.find(
+    (member) => !(member.kind === "primitive" && member.primitiveKind === "null")
+  );
+}
+function resolveTraversableTypeNode(typeNode, ctx) {
+  const dereferenced = dereferenceTypeNode(typeNode, ctx);
+  const unwrapped = unwrapNullableTypeNode(dereferenced);
+  if (unwrapped !== dereferenced) {
+    return resolveTraversableTypeNode(unwrapped, ctx);
+  }
+  return dereferenced;
+}
 function resolveSerializedPropertyName(logicalName, typeNode, ctx) {
-  if (typeNode?.kind === "object") {
-    const property = typeNode.properties.find((candidate) => candidate.name === logicalName);
-    return property === void 0 ? logicalName : getSerializedName(property.name, property.metadata);
+  const effectiveType = resolveTraversableTypeNode(typeNode, ctx);
+  if (effectiveType?.kind === "array") {
+    return resolveSerializedPropertyName(logicalName, effectiveType.items, ctx);
   }
-  if (typeNode?.kind === "reference") {
-    const referencedType = resolveReferencedType(typeNode, ctx);
-    return referencedType === void 0 ? logicalName : resolveSerializedPropertyName(logicalName, referencedType, ctx);
+  if (effectiveType?.kind === "object") {
+    const property = effectiveType.properties.find((candidate) => candidate.name === logicalName);
+    return property === void 0 ? logicalName : getSerializedObjectPropertyName(property);
   }
   return logicalName;
 }
+function resolveTargetTypeNode(logicalName, typeNode, ctx) {
+  const effectiveType = resolveTraversableTypeNode(typeNode, ctx);
+  if (effectiveType?.kind === "array") {
+    return resolveTargetTypeNode(logicalName, effectiveType.items, ctx);
+  }
+  if (effectiveType?.kind !== "object") {
+    return void 0;
+  }
+  return effectiveType.properties.find((candidate) => candidate.name === logicalName)?.type;
+}
+function buildPropertyOverrides(pathConstraints, typeNode, ctx) {
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const constraint of pathConstraints) {
+    const target = constraint.path?.segments[0];
+    if (!target) {
+      continue;
+    }
+    const grouped = byTarget.get(target) ?? [];
+    grouped.push(constraint);
+    byTarget.set(target, grouped);
+  }
+  const overrides = {};
+  for (const [target, constraints] of byTarget) {
+    overrides[resolveSerializedPropertyName(target, typeNode, ctx)] = buildPathOverrideSchema(
+      constraints.map(stripLeadingPathSegment),
+      resolveTargetTypeNode(target, typeNode, ctx),
+      ctx
+    );
+  }
+  return overrides;
+}
+function buildPathOverrideSchema(constraints, typeNode, ctx) {
+  const schema = {};
+  const directConstraints = [];
+  const nestedConstraints = [];
+  for (const constraint of constraints) {
+    if (constraint.path === void 0 || constraint.path.segments.length === 0) {
+      directConstraints.push(constraint);
+    } else {
+      nestedConstraints.push(constraint);
+    }
+  }
+  applyConstraints(schema, directConstraints, ctx);
+  if (nestedConstraints.length === 0) {
+    return schema;
+  }
+  const effectiveType = resolveTraversableTypeNode(typeNode, ctx);
+  if (effectiveType?.kind === "array") {
+    schema.items = buildPathOverrideSchema(nestedConstraints, effectiveType.items, ctx);
+    return schema;
+  }
+  schema.properties = buildPropertyOverrides(nestedConstraints, effectiveType, ctx);
+  return schema;
+}
+function mergeSchemaOverride(target, override) {
+  const nullableValueBranch = getNullableUnionValueSchema(target);
+  if (nullableValueBranch !== void 0) {
+    mergeSchemaOverride(nullableValueBranch, override);
+    return;
+  }
+  if (override.properties !== void 0) {
+    const mergedProperties = target.properties ?? {};
+    for (const [name, propertyOverride] of Object.entries(override.properties)) {
+      const existing = mergedProperties[name];
+      if (existing === void 0) {
+        mergedProperties[name] = propertyOverride;
+      } else {
+        mergeSchemaOverride(existing, propertyOverride);
+      }
+    }
+    target.properties = mergedProperties;
+  }
+  if (override.items !== void 0) {
+    if (target.items === void 0) {
+      target.items = override.items;
+    } else {
+      mergeSchemaOverride(target.items, override.items);
+    }
+  }
+  for (const [key, value] of Object.entries(override)) {
+    if (key === "properties" || key === "items") {
+      continue;
+    }
+    target[key] = value;
+  }
+}
+function stripLeadingPathSegment(constraint) {
+  const segments = constraint.path?.segments;
+  if (segments === void 0 || segments.length === 0) {
+    return constraint;
+  }
+  const [, ...rest] = segments;
+  if (rest.length === 0) {
+    const { path: _path, ...stripped } = constraint;
+    return stripped;
+  }
+  return {
+    ...constraint,
+    path: { segments: rest }
+  };
+}
+function getNullableUnionValueSchema(schema) {
+  if (schema.oneOf?.length !== 2) {
+    return void 0;
+  }
+  const valueSchema = schema.oneOf.find((branch) => branch.type !== "null");
+  const nullSchema = schema.oneOf.find((branch) => branch.type === "null");
+  return valueSchema !== void 0 && nullSchema !== void 0 ? valueSchema : void 0;
+}
 function generateDynamicType(type) {
   if (type.dynamicKind === "enum") {
     const schema = {