@formspec/build 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/browser.cjs

@@ -70,6 +70,7 @@ function canonicalizeChainDSL(form) {
     kind: "form-ir",
     irVersion: import_core.IR_VERSION,
     elements: canonicalizeElements(form.elements),
+    rootAnnotations: [],
     typeRegistry: {},
     provenance: CHAIN_DSL_PROVENANCE
   };
@@ -380,6 +381,9 @@ function generateJsonSchemaFromIR(ir, options) {
   const ctx = makeContext(options);
   for (const [name, typeDef] of Object.entries(ir.typeRegistry)) {
     ctx.defs[name] = generateTypeNode(typeDef.type, ctx);
+    if (typeDef.constraints && typeDef.constraints.length > 0) {
+      applyConstraints(ctx.defs[name], typeDef.constraints, ctx);
+    }
     if (typeDef.annotations && typeDef.annotations.length > 0) {
       applyAnnotations(ctx.defs[name], typeDef.annotations, ctx);
     }
@@ -548,7 +552,9 @@ function generateTypeNode(type, ctx) {
   }
 }
 function generatePrimitiveType(type) {
-  return { type: type.primitiveKind };
+  return {
+    type: type.primitiveKind === "integer" || type.primitiveKind === "bigint" ? "integer" : type.primitiveKind
+  };
 }
 function generateEnumType(type) {
   const hasDisplayNames = type.members.some((m) => m.displayName !== void 0);
@@ -721,7 +727,7 @@ function applyAnnotations(schema, annotations, ctx) {
       case "deprecated":
         schema.deprecated = true;
         if (annotation.message !== void 0 && annotation.message !== "") {
-          schema["x-formspec-deprecation-description"] = annotation.message;
+          schema[`${ctx.vendorPrefix}-deprecation-description`] = annotation.message;
         }
         break;
       case "placeholder":
@@ -1651,6 +1657,26 @@ function dereferenceType(ctx, type) {
   }
   return current;
 }
+function collectReferencedTypeConstraints(ctx, type) {
+  const collected = [];
+  let current = type;
+  const seen = /* @__PURE__ */ new Set();
+  while (current.kind === "reference") {
+    if (seen.has(current.name)) {
+      break;
+    }
+    seen.add(current.name);
+    const definition = ctx.typeRegistry[current.name];
+    if (definition === void 0) {
+      break;
+    }
+    if (definition.constraints !== void 0) {
+      collected.push(...definition.constraints);
+    }
+    current = definition.type;
+  }
+  return collected;
+}
 function resolvePathTargetType(ctx, type, segments) {
   const effectiveType = dereferenceType(ctx, type);
   if (segments.length === 0) {
@@ -1672,12 +1698,33 @@ function resolvePathTargetType(ctx, type, segments) {
   }
   return { kind: "unresolvable", type: effectiveType };
 }
+function isNullType(type) {
+  return type.kind === "primitive" && type.primitiveKind === "null";
+}
+function collectCustomConstraintCandidateTypes(ctx, type) {
+  const effectiveType = dereferenceType(ctx, type);
+  const candidates = [effectiveType];
+  if (effectiveType.kind === "array") {
+    candidates.push(...collectCustomConstraintCandidateTypes(ctx, effectiveType.items));
+  }
+  if (effectiveType.kind === "union") {
+    const memberTypes = effectiveType.members.map((member) => dereferenceType(ctx, member));
+    const nonNullMembers = memberTypes.filter((member) => !isNullType(member));
+    if (nonNullMembers.length === 1 && nonNullMembers.length < memberTypes.length) {
+      const [nullableMember] = nonNullMembers;
+      if (nullableMember !== void 0) {
+        candidates.push(...collectCustomConstraintCandidateTypes(ctx, nullableMember));
+      }
+    }
+  }
+  return candidates;
+}
 function formatPathTargetFieldName(fieldName, path) {
   return path.length === 0 ? fieldName : `${fieldName}.${path.join(".")}`;
 }
 function checkConstraintOnType(ctx, fieldName, type, constraint) {
   const effectiveType = dereferenceType(ctx, type);
-  const isNumber = effectiveType.kind === "primitive" && effectiveType.primitiveKind === "number";
+  const isNumber = effectiveType.kind === "primitive" && ["number", "integer", "bigint"].includes(effectiveType.primitiveKind);
   const isString = effectiveType.kind === "primitive" && effectiveType.primitiveKind === "string";
   const isArray = effectiveType.kind === "array";
   const isEnum = effectiveType.kind === "enum";
@@ -1735,7 +1782,9 @@ function checkConstraintOnType(ctx, fieldName, type, constraint) {
       break;
     }
     case "const": {
-      const isPrimitiveConstType = effectiveType.kind === "primitive" && ["string", "number", "boolean", "null"].includes(effectiveType.primitiveKind) || effectiveType.kind === "enum";
+      const isPrimitiveConstType = effectiveType.kind === "primitive" && ["string", "number", "integer", "bigint", "boolean", "null"].includes(
+        effectiveType.primitiveKind
+      ) || effectiveType.kind === "enum";
       if (!isPrimitiveConstType) {
         addTypeMismatch(
           ctx,
@@ -1746,7 +1795,8 @@ function checkConstraintOnType(ctx, fieldName, type, constraint) {
       }
       if (effectiveType.kind === "primitive") {
         const valueType = constraint.value === null ? "null" : Array.isArray(constraint.value) ? "array" : typeof constraint.value;
-        if (valueType !== effectiveType.primitiveKind) {
+        const expectedValueType = effectiveType.primitiveKind === "integer" || effectiveType.primitiveKind === "bigint" ? "number" : effectiveType.primitiveKind;
+        if (valueType !== expectedValueType) {
           addTypeMismatch(
             ctx,
             `Field "${fieldName}": @const value type "${valueType}" is incompatible with field type "${effectiveType.primitiveKind}"`,
@@ -1815,11 +1865,14 @@ function checkCustomConstraint(ctx, fieldName, type, constraint) {
     );
     return;
   }
+  const candidateTypes = collectCustomConstraintCandidateTypes(ctx, type);
   const normalizedTagName = constraint.provenance.tagName === void 0 ? void 0 : (0, import_core3.normalizeConstraintTagName)(constraint.provenance.tagName.replace(/^@/, ""));
   if (normalizedTagName !== void 0) {
     const tagRegistration = ctx.extensionRegistry.findConstraintTag(normalizedTagName);
     const extensionId = getExtensionIdFromConstraintId(constraint.constraintId);
-    if (extensionId !== null && tagRegistration?.extensionId === extensionId && tagRegistration.registration.constraintName === registration.constraintName && tagRegistration.registration.isApplicableToType?.(type) === false) {
+    if (extensionId !== null && tagRegistration?.extensionId === extensionId && tagRegistration.registration.constraintName === registration.constraintName && !candidateTypes.some(
+      (candidateType) => tagRegistration.registration.isApplicableToType?.(candidateType) !== false
+    )) {
       addTypeMismatch(
         ctx,
         `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
@@ -1829,7 +1882,7 @@ function checkCustomConstraint(ctx, fieldName, type, constraint) {
     }
   }
   if (registration.applicableTypes === null) {
-    if (registration.isApplicableToType?.(type) === false) {
+    if (!candidateTypes.some((candidateType) => registration.isApplicableToType?.(candidateType) !== false)) {
       addTypeMismatch(
         ctx,
         `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
@@ -1838,7 +1891,11 @@ function checkCustomConstraint(ctx, fieldName, type, constraint) {
     }
     return;
   }
-  if (!registration.applicableTypes.includes(type.kind) || registration.isApplicableToType?.(type) === false) {
+  const applicableTypes = registration.applicableTypes;
+  const matchesApplicableType = candidateTypes.some(
+    (candidateType) => applicableTypes.includes(candidateType.kind) && registration.isApplicableToType?.(candidateType) !== false
+  );
+  if (!matchesApplicableType) {
     addTypeMismatch(
       ctx,
       `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
@@ -1847,7 +1904,10 @@ function checkCustomConstraint(ctx, fieldName, type, constraint) {
   }
 }
 function validateFieldNode(ctx, field) {
-  validateConstraints(ctx, field.name, field.type, field.constraints);
+  validateConstraints(ctx, field.name, field.type, [
+    ...collectReferencedTypeConstraints(ctx, field.type),
+    ...field.constraints
+  ]);
   if (field.type.kind === "object") {
     for (const prop of field.type.properties) {
       validateObjectProperty(ctx, field.name, prop);
@@ -1856,7 +1916,10 @@ function validateFieldNode(ctx, field) {
 }
 function validateObjectProperty(ctx, parentName, prop) {
   const qualifiedName = `${parentName}.${prop.name}`;
-  validateConstraints(ctx, qualifiedName, prop.type, prop.constraints);
+  validateConstraints(ctx, qualifiedName, prop.type, [
+    ...collectReferencedTypeConstraints(ctx, prop.type),
+    ...prop.constraints
+  ]);
   if (prop.type.kind === "object") {
     for (const nestedProp of prop.type.properties) {
       validateObjectProperty(ctx, qualifiedName, nestedProp);