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

package/dist/cli.cjs

@@ -484,8 +484,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) {
@@ -1094,10 +1156,21 @@ var init_program = __esm({
   }
 });
 
-// src/analyzer/tsdoc-parser.ts
-function isBuiltinConstraintName(tagName) {
-  return tagName in import_core3.BUILTIN_CONSTRAINT_DEFINITIONS;
+// src/analyzer/json-utils.ts
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
 }
+var init_json_utils = __esm({
+  "src/analyzer/json-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/analyzer/tsdoc-parser.ts
 function createFormSpecTSDocConfig() {
   const config = new import_tsdoc.TSDocConfiguration();
   for (const tagName of Object.keys(import_core3.BUILTIN_CONSTRAINT_DEFINITIONS)) {
@@ -1136,7 +1209,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;
@@ -1157,7 +1230,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;
@@ -1205,6 +1278,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);
 }
@@ -1224,12 +1306,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 path4 = 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;
     }
@@ -1239,6 +1324,7 @@ function parseConstraintValue(tagName, text, provenance) {
         kind: "constraint",
         constraintKind: numericKind,
         value,
+        ...path4 && { path: path4 },
         provenance
       };
     }
@@ -1248,42 +1334,41 @@ function parseConstraintValue(tagName, text, provenance) {
         kind: "constraint",
         constraintKind: lengthKind,
         value,
+        ...path4 && { path: path4 },
         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,
+      ...path4 && { path: path4 },
+      provenance
+    };
   }
   return {
     kind: "constraint",
     constraintKind: "pattern",
-    pattern: text,
+    pattern: effectiveText,
+    ...path4 && { path: path4 },
     provenance
   };
 }
@@ -1324,17 +1409,21 @@ var init_tsdoc_parser = __esm({
     ts2 = __toESM(require("typescript"), 1);
     import_tsdoc = require("@microsoft/tsdoc");
     import_core3 = require("@formspec/core");
+    init_json_utils();
     NUMERIC_CONSTRAINT_MAP = {
-      Minimum: "minimum",
-      Maximum: "maximum",
-      ExclusiveMinimum: "exclusiveMinimum",
-      ExclusiveMaximum: "exclusiveMaximum"
+      minimum: "minimum",
+      maximum: "maximum",
+      exclusiveMinimum: "exclusiveMinimum",
+      exclusiveMaximum: "exclusiveMaximum",
+      multipleOf: "multipleOf"
     };
     LENGTH_CONSTRAINT_MAP = {
-      MinLength: "minLength",
-      MaxLength: "maxLength"
+      minLength: "minLength",
+      maxLength: "maxLength",
+      minItems: "minItems",
+      maxItems: "maxItems"
     };
-    TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["Pattern", "EnumOptions"]);
+    TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["pattern", "enumOptions"]);
   }
 });
 
@@ -1387,6 +1476,7 @@ var init_jsdoc_constraints = __esm({
     ts3 = __toESM(require("typescript"), 1);
     import_core4 = require("@formspec/core");
     init_tsdoc_parser();
+    init_json_utils();
   }
 });
 
@@ -1743,14 +1833,22 @@ function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting) {
   }
   return map;
 }
-function extractTypeAliasConstraintNodes(typeNode, checker, file) {
+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();
@@ -1823,12 +1921,13 @@ function detectFormSpecReference(typeNode) {
   }
   return null;
 }
-var ts4;
+var ts4, MAX_ALIAS_CHAIN_DEPTH;
 var init_class_analyzer = __esm({
   "src/analyzer/class-analyzer.ts"() {
     "use strict";
     ts4 = __toESM(require("typescript"), 1);
     init_jsdoc_constraints();
+    MAX_ALIAS_CHAIN_DEPTH = 8;
   }
 });