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

package/dist/internals.js

@@ -66,11 +66,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) {
@@ -94,6 +123,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,
@@ -423,7 +461,9 @@ import * as ts4 from "typescript";
 // src/analyzer/jsdoc-constraints.ts
 import * as ts3 from "typescript";
 import {
-  BUILTIN_CONSTRAINT_DEFINITIONS as BUILTIN_CONSTRAINT_DEFINITIONS2
+  BUILTIN_CONSTRAINT_DEFINITIONS as BUILTIN_CONSTRAINT_DEFINITIONS2,
+  isBuiltinConstraintName as isBuiltinConstraintName2,
+  normalizeConstraintTagName as normalizeConstraintTagName2
 } from "@formspec/core";
 
 // src/analyzer/tsdoc-parser.ts
@@ -438,22 +478,35 @@ import {
   TextRange
 } from "@microsoft/tsdoc";
 import {
-  BUILTIN_CONSTRAINT_DEFINITIONS
+  BUILTIN_CONSTRAINT_DEFINITIONS,
+  normalizeConstraintTagName,
+  isBuiltinConstraintName
 } from "@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 BUILTIN_CONSTRAINT_DEFINITIONS;
-}
+var TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["pattern", "enumOptions"]);
 function createFormSpecTSDocConfig() {
   const config = new TSDocConfiguration();
   for (const tagName of Object.keys(BUILTIN_CONSTRAINT_DEFINITIONS)) {
@@ -493,7 +546,7 @@ function parseTSDocTags(node, file = "") {
       );
       const docComment = parserContext.docComment;
       for (const block of docComment.customBlocks) {
-        const tagName = block.blockTag.tagName.substring(1);
+        const tagName = normalizeConstraintTagName(block.blockTag.tagName.substring(1));
         if (TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
         const text = extractBlockText(block).trim();
         if (text === "") continue;
@@ -514,7 +567,7 @@ function parseTSDocTags(node, file = "") {
   }
   const jsDocTagsAll = ts2.getJSDocTags(node);
   for (const tag of jsDocTagsAll) {
-    const tagName = tag.tagName.text;
+    const tagName = normalizeConstraintTagName(tag.tagName.text);
     if (!TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
     const commentText = getTagCommentText(tag);
     if (commentText === void 0 || commentText.trim() === "") continue;
@@ -562,6 +615,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);
 }
@@ -584,9 +646,12 @@ function parseConstraintValue(tagName, text, provenance) {
   if (!isBuiltinConstraintName(tagName)) {
     return null;
   }
+  const pathResult = extractPathTarget(text);
+  const effectiveText = pathResult ? pathResult.remainingText : text;
+  const path2 = pathResult?.path;
   const expectedType = BUILTIN_CONSTRAINT_DEFINITIONS[tagName];
   if (expectedType === "number") {
-    const value = Number(text);
+    const value = Number(effectiveText);
     if (Number.isNaN(value)) {
       return null;
     }
@@ -596,6 +661,7 @@ function parseConstraintValue(tagName, text, provenance) {
         kind: "constraint",
         constraintKind: numericKind,
         value,
+        ...path2 && { path: path2 },
         provenance
       };
     }
@@ -605,42 +671,41 @@ function parseConstraintValue(tagName, text, provenance) {
         kind: "constraint",
         constraintKind: lengthKind,
         value,
+        ...path2 && { path: path2 },
         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,
+      ...path2 && { path: path2 },
+      provenance
+    };
   }
   return {
     kind: "constraint",
     constraintKind: "pattern",
-    pattern: text,
+    pattern: effectiveText,
+    ...path2 && { path: path2 },
     provenance
   };
 }
@@ -1071,14 +1136,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();
@@ -1200,8 +1274,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) {
@@ -1648,14 +1784,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(
@@ -1779,6 +1911,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":