@formspec/build 0.1.0-alpha.13 → 0.1.0-alpha.14

package/dist/browser.js

@@ -360,8 +360,70 @@ function collectFields(elements, properties, required, ctx) {
 }
 function generateFieldSchema(field, ctx) {
   const schema = generateTypeNode(field.type, ctx);
-  applyConstraints(schema, field.constraints);
+  const directConstraints = [];
+  const pathConstraints = [];
+  for (const c of field.constraints) {
+    if (c.path) {
+      pathConstraints.push(c);
+    } else {
+      directConstraints.push(c);
+    }
+  }
+  applyConstraints(schema, directConstraints);
   applyAnnotations(schema, field.annotations);
+  if (pathConstraints.length === 0) {
+    return schema;
+  }
+  return applyPathTargetedConstraints(schema, pathConstraints);
+}
+function applyPathTargetedConstraints(schema, pathConstraints) {
+  if (schema.type === "array" && schema.items) {
+    schema.items = applyPathTargetedConstraints(schema.items, pathConstraints);
+    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);
+    propertyOverrides[target] = subSchema;
+  }
+  if (schema.$ref) {
+    const { $ref, ...rest } = schema;
+    const refPart = { $ref };
+    const overridePart = {
+      properties: propertyOverrides,
+      ...rest
+    };
+    return { allOf: [refPart, overridePart] };
+  }
+  if (schema.type === "object" && schema.properties) {
+    const missingOverrides = {};
+    for (const [target, overrideSchema] of Object.entries(propertyOverrides)) {
+      if (schema.properties[target]) {
+        Object.assign(schema.properties[target], overrideSchema);
+      } else {
+        missingOverrides[target] = overrideSchema;
+      }
+    }
+    if (Object.keys(missingOverrides).length === 0) {
+      return schema;
+    }
+    return {
+      allOf: [schema, { properties: missingOverrides }]
+    };
+  }
+  if (schema.allOf) {
+    schema.allOf = [...schema.allOf, { properties: propertyOverrides }];
+    return schema;
+  }
   return schema;
 }
 function generateTypeNode(type, ctx) {
@@ -881,14 +943,10 @@ function addUnknownExtension(ctx, message, primary) {
   });
 }
 function findNumeric(constraints, constraintKind) {
-  return constraints.find(
-    (c) => c.constraintKind === constraintKind
-  );
+  return constraints.find((c) => c.constraintKind === constraintKind);
 }
 function findLength(constraints, constraintKind) {
-  return constraints.find(
-    (c) => c.constraintKind === constraintKind
-  );
+  return constraints.find((c) => c.constraintKind === constraintKind);
 }
 function findAllowedMembers(constraints) {
   return constraints.filter(
@@ -1012,6 +1070,17 @@ function checkTypeApplicability(ctx, fieldName, type, constraints) {
   const isEnum = type.kind === "enum";
   const label = typeLabel(type);
   for (const constraint of constraints) {
+    if (constraint.path) {
+      const isTraversable = type.kind === "object" || type.kind === "array" || type.kind === "reference";
+      if (!isTraversable) {
+        addTypeMismatch(
+          ctx,
+          `Field "${fieldName}": path-targeted constraint "${constraint.constraintKind}" is invalid because type "${label}" cannot be traversed`,
+          constraint.provenance
+        );
+      }
+      continue;
+    }
     const ck = constraint.constraintKind;
     switch (ck) {
       case "minimum":