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

package/dist/cli.js

@@ -71,11 +71,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) {
@@ -99,6 +128,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,
@@ -424,8 +462,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) {
@@ -1032,6 +1132,20 @@ var init_program = __esm({
   }
 });
 
+// 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
 import * as ts2 from "typescript";
 import {
@@ -1044,11 +1158,10 @@ import {
   TextRange
 } from "@microsoft/tsdoc";
 import {
-  BUILTIN_CONSTRAINT_DEFINITIONS
+  BUILTIN_CONSTRAINT_DEFINITIONS,
+  normalizeConstraintTagName,
+  isBuiltinConstraintName
 } from "@formspec/core";
-function isBuiltinConstraintName(tagName) {
-  return tagName in BUILTIN_CONSTRAINT_DEFINITIONS;
-}
 function createFormSpecTSDocConfig() {
   const config = new TSDocConfiguration();
   for (const tagName of Object.keys(BUILTIN_CONSTRAINT_DEFINITIONS)) {
@@ -1087,7 +1200,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;
@@ -1108,7 +1221,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;
@@ -1156,6 +1269,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);
 }
@@ -1178,9 +1300,12 @@ function parseConstraintValue(tagName, text, provenance) {
   if (!isBuiltinConstraintName(tagName)) {
     return null;
   }
+  const pathResult = extractPathTarget(text);
+  const effectiveText = pathResult ? pathResult.remainingText : text;
+  const path4 = 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;
     }
@@ -1190,6 +1315,7 @@ function parseConstraintValue(tagName, text, provenance) {
         kind: "constraint",
         constraintKind: numericKind,
         value,
+        ...path4 && { path: path4 },
         provenance
       };
     }
@@ -1199,42 +1325,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
   };
 }
@@ -1272,24 +1397,30 @@ var NUMERIC_CONSTRAINT_MAP, LENGTH_CONSTRAINT_MAP, TAGS_REQUIRING_RAW_TEXT, shar
 var init_tsdoc_parser = __esm({
   "src/analyzer/tsdoc-parser.ts"() {
     "use strict";
+    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"]);
   }
 });
 
 // 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";
 function extractJSDocConstraintNodes(node, file = "") {
   const result = parseTSDocTags(node, file);
@@ -1336,6 +1467,7 @@ var init_jsdoc_constraints = __esm({
   "src/analyzer/jsdoc-constraints.ts"() {
     "use strict";
     init_tsdoc_parser();
+    init_json_utils();
   }
 });
 
@@ -1693,14 +1825,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();
@@ -1773,10 +1913,12 @@ function detectFormSpecReference(typeNode) {
   }
   return null;
 }
+var MAX_ALIAS_CHAIN_DEPTH;
 var init_class_analyzer = __esm({
   "src/analyzer/class-analyzer.ts"() {
     "use strict";
     init_jsdoc_constraints();
+    MAX_ALIAS_CHAIN_DEPTH = 8;
   }
 });