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

package/dist/index.cjs

@@ -125,11 +125,40 @@ function canonicalizeField(field) {
 }
 function canonicalizeTextField(field) {
   const type = { kind: "primitive", primitiveKind: "string" };
+  const constraints = [];
+  if (field.minLength !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "minLength",
+      value: field.minLength,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  if (field.maxLength !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "maxLength",
+      value: field.maxLength,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  if (field.pattern !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "pattern",
+      pattern: field.pattern,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
   return buildFieldNode(
     field.name,
     type,
     field.required,
-    buildAnnotations(field.label, field.placeholder)
+    buildAnnotations(field.label, field.placeholder),
+    constraints
   );
 }
 function canonicalizeNumberField(field) {
@@ -153,6 +182,15 @@ function canonicalizeNumberField(field) {
     };
     constraints.push(c);
   }
+  if (field.multipleOf !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "multipleOf",
+      value: field.multipleOf,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
   return buildFieldNode(
     field.name,
     type,
@@ -452,8 +490,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) {
@@ -1028,20 +1128,31 @@ var import_core4 = require("@formspec/core");
 var ts2 = __toESM(require("typescript"), 1);
 var import_tsdoc = require("@microsoft/tsdoc");
 var import_core3 = require("@formspec/core");
+
+// src/analyzer/json-utils.ts
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+// src/analyzer/tsdoc-parser.ts
 var NUMERIC_CONSTRAINT_MAP = {
-  Minimum: "minimum",
-  Maximum: "maximum",
-  ExclusiveMinimum: "exclusiveMinimum",
-  ExclusiveMaximum: "exclusiveMaximum"
+  minimum: "minimum",
+  maximum: "maximum",
+  exclusiveMinimum: "exclusiveMinimum",
+  exclusiveMaximum: "exclusiveMaximum",
+  multipleOf: "multipleOf"
 };
 var LENGTH_CONSTRAINT_MAP = {
-  MinLength: "minLength",
-  MaxLength: "maxLength"
+  minLength: "minLength",
+  maxLength: "maxLength",
+  minItems: "minItems",
+  maxItems: "maxItems"
 };
-var TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["Pattern", "EnumOptions"]);
-function isBuiltinConstraintName(tagName) {
-  return tagName in import_core3.BUILTIN_CONSTRAINT_DEFINITIONS;
-}
+var TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["pattern", "enumOptions"]);
 function createFormSpecTSDocConfig() {
   const config = new import_tsdoc.TSDocConfiguration();
   for (const tagName of Object.keys(import_core3.BUILTIN_CONSTRAINT_DEFINITIONS)) {
@@ -1081,7 +1192,7 @@ function parseTSDocTags(node, file = "") {
       );
       const docComment = parserContext.docComment;
       for (const block of docComment.customBlocks) {
-        const tagName = block.blockTag.tagName.substring(1);
+        const tagName = (0, import_core3.normalizeConstraintTagName)(block.blockTag.tagName.substring(1));
         if (TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
         const text = extractBlockText(block).trim();
         if (text === "") continue;
@@ -1102,7 +1213,7 @@ function parseTSDocTags(node, file = "") {
   }
   const jsDocTagsAll = ts2.getJSDocTags(node);
   for (const tag of jsDocTagsAll) {
-    const tagName = tag.tagName.text;
+    const tagName = (0, import_core3.normalizeConstraintTagName)(tag.tagName.text);
     if (!TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
     const commentText = getTagCommentText(tag);
     if (commentText === void 0 || commentText.trim() === "") continue;
@@ -1150,6 +1261,15 @@ function parseTSDocTags(node, file = "") {
   }
   return { constraints, annotations };
 }
+function extractPathTarget(text) {
+  const trimmed = text.trimStart();
+  const match = /^:([a-zA-Z_]\w*)\s+([\s\S]*)$/.exec(trimmed);
+  if (!match?.[1] || !match[2]) return null;
+  return {
+    path: { segments: [match[1]] },
+    remainingText: match[2]
+  };
+}
 function extractBlockText(block) {
   return extractPlainText(block.content);
 }
@@ -1169,12 +1289,15 @@ function extractPlainText(node) {
   return result;
 }
 function parseConstraintValue(tagName, text, provenance) {
-  if (!isBuiltinConstraintName(tagName)) {
+  if (!(0, import_core3.isBuiltinConstraintName)(tagName)) {
     return null;
   }
+  const pathResult = extractPathTarget(text);
+  const effectiveText = pathResult ? pathResult.remainingText : text;
+  const path3 = pathResult?.path;
   const expectedType = import_core3.BUILTIN_CONSTRAINT_DEFINITIONS[tagName];
   if (expectedType === "number") {
-    const value = Number(text);
+    const value = Number(effectiveText);
     if (Number.isNaN(value)) {
       return null;
     }
@@ -1184,6 +1307,7 @@ function parseConstraintValue(tagName, text, provenance) {
         kind: "constraint",
         constraintKind: numericKind,
         value,
+        ...path3 && { path: path3 },
         provenance
       };
     }
@@ -1193,42 +1317,41 @@ function parseConstraintValue(tagName, text, provenance) {
         kind: "constraint",
         constraintKind: lengthKind,
         value,
+        ...path3 && { path: path3 },
         provenance
       };
     }
     return null;
   }
   if (expectedType === "json") {
-    try {
-      const parsed = JSON.parse(text);
-      if (!Array.isArray(parsed)) {
-        return null;
-      }
-      const members = [];
-      for (const item of parsed) {
-        if (typeof item === "string" || typeof item === "number") {
-          members.push(item);
-        } else if (typeof item === "object" && item !== null && "id" in item) {
-          const id = item["id"];
-          if (typeof id === "string" || typeof id === "number") {
-            members.push(id);
-          }
+    const parsed = tryParseJson(effectiveText);
+    if (!Array.isArray(parsed)) {
+      return null;
+    }
+    const members = [];
+    for (const item of parsed) {
+      if (typeof item === "string" || typeof item === "number") {
+        members.push(item);
+      } else if (typeof item === "object" && item !== null && "id" in item) {
+        const id = item["id"];
+        if (typeof id === "string" || typeof id === "number") {
+          members.push(id);
         }
       }
-      return {
-        kind: "constraint",
-        constraintKind: "allowedMembers",
-        members,
-        provenance
-      };
-    } catch {
-      return null;
     }
+    return {
+      kind: "constraint",
+      constraintKind: "allowedMembers",
+      members,
+      ...path3 && { path: path3 },
+      provenance
+    };
   }
   return {
     kind: "constraint",
     constraintKind: "pattern",
-    pattern: text,
+    pattern: effectiveText,
+    ...path3 && { path: path3 },
     provenance
   };
 }
@@ -1659,14 +1782,23 @@ function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting) {
   }
   return map;
 }
-function extractTypeAliasConstraintNodes(typeNode, checker, file) {
+var MAX_ALIAS_CHAIN_DEPTH = 8;
+function extractTypeAliasConstraintNodes(typeNode, checker, file, depth = 0) {
   if (!ts4.isTypeReferenceNode(typeNode)) return [];
+  if (depth >= MAX_ALIAS_CHAIN_DEPTH) {
+    const aliasName = typeNode.typeName.getText();
+    throw new Error(
+      `Type alias chain exceeds maximum depth of ${String(MAX_ALIAS_CHAIN_DEPTH)} at alias "${aliasName}" in ${file}. Simplify the alias chain or check for circular references.`
+    );
+  }
   const symbol = checker.getSymbolAtLocation(typeNode.typeName);
   if (!symbol?.declarations) return [];
   const aliasDecl = symbol.declarations.find(ts4.isTypeAliasDeclaration);
   if (!aliasDecl) return [];
   if (ts4.isTypeLiteralNode(aliasDecl.type)) return [];
-  return extractJSDocConstraintNodes(aliasDecl, file);
+  const constraints = extractJSDocConstraintNodes(aliasDecl, file);
+  constraints.push(...extractTypeAliasConstraintNodes(aliasDecl.type, checker, file, depth + 1));
+  return constraints;
 }
 function provenanceForNode(node, file) {
   const sourceFile = node.getSourceFile();