praxis-kit 3.1.1 → 4.0.0

package/dist/eslint/index.js

@@ -35,8 +35,8 @@ var require_deepMerge = __commonJS({
       return typeof obj === "object" && obj != null && !Array.isArray(obj);
     }
     function deepMerge(first = {}, second = {}) {
-      const keys = /* @__PURE__ */ new Set([...Object.keys(first), ...Object.keys(second)]);
-      return Object.fromEntries([...keys].map((key) => {
+      const keys2 = /* @__PURE__ */ new Set([...Object.keys(first), ...Object.keys(second)]);
+      return Object.fromEntries([...keys2].map((key) => {
         const firstHasKey = key in first;
         const secondHasKey = key in second;
         const firstValue = first[key];
@@ -237,19 +237,185 @@ var require_eslint_utils = __commonJS({
   }
 });
 
-// ../eslint-plugin/src/rules/no-dead-compound.ts
+// ../../plugins/eslint/src/rules/no-dead-compound.ts
 var import_eslint_utils = __toESM(require_eslint_utils(), 1);
 
-// ../eslint-plugin/src/utils/ast.ts
-function getObjectProperty(obj, key) {
-  return obj.properties.find((prop) => {
-    if (prop.type !== "Property" || prop.kind !== "init" || prop.computed) {
+// ../../lib/primitive/src/utils/is-object.ts
+function isString(value) {
+  return typeof value === "string";
+}
+
+// ../../lib/primitive/src/utils/iterate.ts
+function find(iterable, callback) {
+  for (const value of iterable) {
+    const result = callback(value);
+    if (result != null) {
+      return result;
+    }
+  }
+  return null;
+}
+function some(iterable, predicate) {
+  for (const value of iterable) {
+    if (predicate(value)) return true;
+  }
+  return false;
+}
+function every(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (!predicate(value, index++)) {
       return false;
     }
-    const { key: propKey } = prop;
-    return propKey.type === "Identifier" && propKey.name === key || propKey.type === "Literal" && propKey.value === key;
-  });
+  }
+  return true;
+}
+function* filter(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (predicate(value, index++)) {
+      yield value;
+    }
+  }
+}
+function* map(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    yield callback(value, index++);
+  }
+}
+function forEach(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    callback(value, index++);
+  }
+}
+function reduce(iterable, initial, callback) {
+  let accumulator = initial;
+  let index = 0;
+  for (const value of iterable) {
+    accumulator = callback(accumulator, value, index++);
+  }
+  return accumulator;
+}
+function collect(iterable, callback) {
+  const result = {};
+  let index = 0;
+  for (const value of iterable) {
+    const entry = callback(value, index++);
+    if (entry === null) {
+      return null;
+    }
+    result[entry[0]] = entry[1];
+  }
+  return result;
+}
+function findLast(value, callback) {
+  for (let index = value.length - 1; index >= 0; index--) {
+    const result = callback(value[index], index);
+    if (result != null) {
+      return result;
+    }
+  }
+  return null;
+}
+function* items(collection) {
+  for (let i = 0; i < collection.length; i++) {
+    const item = collection.item(i);
+    if (item !== null) {
+      yield item;
+    }
+  }
+}
+function nodeList(list) {
+  return {
+    *[Symbol.iterator]() {
+      for (let i = 0; i < list.length; i++) {
+        const node = list.item(i);
+        if (node !== null) {
+          yield node;
+        }
+      }
+    }
+  };
+}
+function mapEntries(m) {
+  return m.entries();
+}
+function set(s) {
+  return s.values();
 }
+function hasOwn(object, key) {
+  return Object.hasOwn(object, key);
+}
+function* entries(object) {
+  for (const key in object) {
+    if (!hasOwn(object, key)) continue;
+    yield [key, object[key]];
+  }
+}
+function* keys(object) {
+  for (const [key] of entries(object)) {
+    yield key;
+  }
+}
+function* values(object) {
+  for (const [, value] of entries(object)) {
+    yield value;
+  }
+}
+function mapValues(object, callback) {
+  const result = {};
+  for (const [key, value] of entries(object)) {
+    result[key] = callback(value, key);
+  }
+  return result;
+}
+function forEachEntry(object, callback) {
+  for (const [key, value] of entries(object)) {
+    callback(key, value);
+  }
+}
+function forEachKey(object, callback) {
+  for (const key of keys(object)) {
+    callback(key);
+  }
+}
+function forEachValue(object, callback) {
+  for (const value of values(object)) {
+    callback(value);
+  }
+}
+function forEachSet(s, callback) {
+  for (const value of s) {
+    callback(value);
+  }
+}
+var iterate = Object.freeze({
+  entries,
+  filter,
+  find,
+  findLast,
+  forEach,
+  forEachEntry,
+  forEachKey,
+  forEachSet,
+  forEachValue,
+  items,
+  keys,
+  map,
+  mapEntries,
+  mapValues,
+  nodeList,
+  reduce,
+  collect,
+  set,
+  some,
+  every,
+  values
+});
+
+// ../../plugins/eslint/src/utils/ast.ts
 function asObjectExpression(node) {
   return node?.type === "ObjectExpression" ? node : void 0;
 }
@@ -271,6 +437,30 @@ function asNumericLiteral(node) {
   }
   return void 0;
 }
+function asStringLiteral(node) {
+  if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+  return void 0;
+}
+function getPropertyKey(prop) {
+  const { key } = prop;
+  if (prop.computed) return void 0;
+  if (key.type === "Identifier") return key.name;
+  if (key.type === "Literal" && typeof key.value === "string") return key.value;
+  return void 0;
+}
+function getObjectProperty(obj, key) {
+  return obj.properties.find((prop) => {
+    if (prop.type !== "Property" || prop.kind !== "init" || prop.computed) {
+      return false;
+    }
+    const { key: propKey } = prop;
+    return propKey.type === "Identifier" && propKey.name === key || propKey.type === "Literal" && propKey.value === key;
+  });
+}
+function getFirstObjectArg(node) {
+  const [first] = node.arguments;
+  return first?.type === "ObjectExpression" ? first : void 0;
+}
 function isFactoryCall(node, calleeNames) {
   const { callee } = node;
   if (callee.type === "Identifier") {
@@ -282,43 +472,59 @@ function isFactoryCall(node, calleeNames) {
   }
   return false;
 }
-function getFirstObjectArg(node) {
-  const [first] = node.arguments;
-  return first?.type === "ObjectExpression" ? first : void 0;
-}
-function asStringLiteral(node) {
-  if (node?.type === "Literal" && typeof node.value === "string") return node.value;
-  return void 0;
-}
-function getPropertyKey(prop) {
-  const { key } = prop;
-  if (prop.computed) return void 0;
-  if (key.type === "Identifier") return key.name;
-  if (key.type === "Literal" && typeof key.value === "string") return key.value;
-  return void 0;
+function extractVariantValues(node) {
+  const valuesObj = asObjectExpression(node);
+  if (!valuesObj) return void 0;
+  const values2 = /* @__PURE__ */ new Set();
+  iterate.forEach(valuesObj.properties, (prop) => {
+    if (prop.type !== "Property") return;
+    const key = getPropertyKey(prop);
+    if (key) values2.add(key);
+  });
+  return values2;
 }
 function extractVariantMap(variantsNode) {
   const variantsObj = asObjectExpression(variantsNode);
   if (!variantsObj) return void 0;
-  const map = /* @__PURE__ */ new Map();
-  for (const prop of variantsObj.properties) {
-    if (prop.type !== "Property") continue;
+  const map2 = /* @__PURE__ */ new Map();
+  iterate.forEach(variantsObj.properties, (prop) => {
+    if (prop.type !== "Property") return;
     const key = getPropertyKey(prop);
-    if (!key) continue;
-    const valuesObj = asObjectExpression(prop.value);
-    if (!valuesObj) continue;
-    const values = /* @__PURE__ */ new Set();
-    for (const vProp of valuesObj.properties) {
-      if (vProp.type !== "Property") continue;
-      const vKey = getPropertyKey(vProp);
-      if (vKey !== void 0) values.add(vKey);
-    }
-    map.set(key, values);
-  }
-  return map;
+    if (!key) return;
+    const values2 = extractVariantValues(prop.value);
+    if (!values2) return;
+    map2.set(key, values2);
+  });
+  return map2;
 }
 
-// ../eslint-plugin/src/rules/no-dead-compound.ts
+// ../../plugins/eslint/src/diagnostics.ts
+var EslintDiagnosticTemplates = {
+  // HTML structural rules
+  redundantRole: 'role="{{ role }}" is redundant on <{{ tag }}>: the element already carries this implicit ARIA role. Remove the attribute.',
+  invalidChild: "<{{ child }}> is not a valid direct child of <{{ parent }}>. Allowed: {{ allowed }}.",
+  // Compound variant rules
+  deadCompoundKey: '"{{ key }}" is not a variant defined in styling.variants. This compound condition can never match.',
+  deadCompoundValue: '"{{ value }}" is not a valid value for variant "{{ key }}". Expected one of: {{ allowed }}. This compound condition can never match.',
+  deadCompoundNonLiteral: 'Compound value for "{{ key }}" is not a string literal and cannot be statically validated.',
+  // Enforcement rules
+  missingStrict: "enforcement.{{ field }} is defined but enforcement.diagnostics is not explicitly set. Pass a Diagnostics instance (e.g. warnDiagnostics, throwDiagnostics) so the enforcement behavior is clear at the call site.",
+  // Default value rules
+  invalidDefaultKey: '"{{ key }}" is not a variant defined in styling.variants. This default will have no effect.',
+  invalidDefaultValue: '"{{ value }}" is not a valid value for variant "{{ key }}". Expected one of: {{ allowed }}. This default will have no effect.',
+  invalidDefaultNonLiteral: 'Default value for "{{ key }}" is not a string literal and cannot be statically validated.',
+  // Cardinality rules
+  negativeMin: "cardinality.min must be >= 0 (got {{ value }}).",
+  negativeMax: "cardinality.max must be >= 0 (got {{ value }}).",
+  maxLessThanMin: "cardinality.max ({{ max }}) must be >= cardinality.min ({{ min }}). This rule can never be satisfied.",
+  zeroMax: "cardinality.max of 0 means no children of this type are allowed. Use 0 intentionally or remove the rule.",
+  // Children config rules
+  multipleFirst: 'Multiple enforcement.children rules require position: "first". Only one child can occupy the first position.',
+  multipleLast: 'Multiple enforcement.children rules require position: "last". Only one child can occupy the last position.',
+  minSumExceedsCapacity: 'A rule with position: "only" requires min >= 1, but {{ count }} other rule(s) also require min >= 1. These constraints cannot be satisfied simultaneously.'
+};
+
+// ../../plugins/eslint/src/rules/no-dead-compound.ts
 var createRule = (0, import_eslint_utils.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
 var noDeadCompound = createRule({
   name: "no-dead-compound",
@@ -328,9 +534,9 @@ var noDeadCompound = createRule({
       description: "Disallow compound variant conditions that reference unknown variant keys or values \u2014 compounds that can never fire."
     },
     messages: {
-      unknownVariantKey: '"{{ key }}" is not a variant defined in styling.variants. This compound condition can never match.',
-      unknownVariantValue: '"{{ value }}" is not a valid value for variant "{{ key }}". Expected one of: {{ allowed }}. This compound condition can never match.',
-      nonLiteralValue: 'Compound value for "{{ key }}" is not a string literal and cannot be statically validated.'
+      unknownVariantKey: EslintDiagnosticTemplates.deadCompoundKey,
+      unknownVariantValue: EslintDiagnosticTemplates.deadCompoundValue,
+      nonLiteralValue: EslintDiagnosticTemplates.deadCompoundNonLiteral
     },
     schema: [
       {
@@ -364,43 +570,52 @@ var noDeadCompound = createRule({
         if (!compoundsProp) return;
         const compounds = asArrayExpression(compoundsProp.value);
         if (!compounds) return;
-        for (const element of compounds.elements) {
-          if (!element || element.type !== "ObjectExpression") continue;
-          for (const prop of element.properties) {
-            if (prop.type !== "Property") continue;
-            const key = getPropertyKey(prop);
-            if (!key || key === "class" || key === "className") continue;
+        iterate.forEach(compounds.elements, (element) => {
+          if (!element || element.type !== "ObjectExpression") return;
+          iterate.forEach(element.properties, (prop) => {
+            if (prop.type !== "Property") return;
+            const literalProp = prop;
+            const key = getPropertyKey(literalProp);
+            if (!key || key === "class" || key === "className") return;
             if (!variantMap.has(key)) {
               context.report({
                 node: prop,
                 messageId: "unknownVariantKey",
                 data: { key }
               });
-              continue;
+              return;
             }
-            const value = asStringLiteral(prop.value);
+            const value = asStringLiteral(literalProp.value);
             if (value === void 0) {
               if (reportNonLiteral) {
                 context.report({ node: prop, messageId: "nonLiteralValue", data: { key } });
               }
-              continue;
+              return;
             }
             const allowed = variantMap.get(key);
             if (!allowed.has(value)) {
               context.report({
                 node: prop,
                 messageId: "unknownVariantValue",
-                data: { key, value, allowed: [...allowed].map((v) => `"${v}"`).join(", ") }
+                data: {
+                  key,
+                  value,
+                  allowed: iterate.reduce(
+                    [...allowed],
+                    "",
+                    (acc, value2, index) => index === 0 ? `"${value2}"` : `${acc}, "${value2}"`
+                  )
+                }
               });
             }
-          }
-        }
+          });
+        });
       }
     };
   }
 });
 
-// ../eslint-plugin/src/rules/no-enforcement-without-strict.ts
+// ../../plugins/eslint/src/rules/no-enforcement-without-strict.ts
 var import_eslint_utils2 = __toESM(require_eslint_utils(), 1);
 var createRule2 = (0, import_eslint_utils2.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
 var noEnforcementWithoutStrict = createRule2({
@@ -411,7 +626,7 @@ var noEnforcementWithoutStrict = createRule2({
       description: "Require enforcement.strict when enforcement.children or enforcement.aria is defined."
     },
     messages: {
-      missingStrict: "enforcement.{{ field }} is defined but enforcement.strict is not explicitly set. Adapter defaults vary \u2014 declare strict explicitly so the behavior is clear at the call site."
+      missingStrict: EslintDiagnosticTemplates.missingStrict
     },
     schema: [
       {
@@ -435,26 +650,38 @@ var noEnforcementWithoutStrict = createRule2({
         if (!enfProp) return;
         const enf = asObjectExpression(enfProp.value);
         if (!enf) return;
-        const hasStrict = getObjectProperty(enf, "strict") !== void 0;
-        for (const field of ["children", "aria"]) {
-          const fieldProp = getObjectProperty(enf, field);
-          if (!fieldProp) continue;
-          if (field === "children") {
-            const arr = asArrayExpression(fieldProp.value);
-            if (!arr || arr.elements.length === 0) continue;
+        const hasDiagnostics = getObjectProperty(enf, "diagnostics") !== void 0;
+        if (hasDiagnostics) return;
+        const field = iterate.find(["children", "aria"], (field2) => {
+          const fieldProp = getObjectProperty(enf, field2);
+          if (!fieldProp) {
+            return null;
           }
-          if (!hasStrict) {
-            context.report({ node, messageId: "missingStrict", data: { field } });
-            return;
+          if (field2 === "children") {
+            const arr = asArrayExpression(fieldProp.value);
+            if (!arr || arr.elements.length === 0) {
+              return null;
+            }
           }
+          return field2;
+        });
+        if (field) {
+          context.report({
+            node,
+            messageId: "missingStrict",
+            data: { field }
+          });
         }
       }
     };
   }
 });
 
-// ../eslint-plugin/src/rules/no-invalid-default.ts
+// ../../plugins/eslint/src/rules/no-invalid-default.ts
 var import_eslint_utils3 = __toESM(require_eslint_utils(), 1);
+function formatAllowedValues(values2) {
+  return Array.from(values2, (value) => `"${value}"`).join(", ");
+}
 var createRule3 = (0, import_eslint_utils3.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
 var noInvalidDefault = createRule3({
   name: "no-invalid-default",
@@ -464,9 +691,9 @@ var noInvalidDefault = createRule3({
       description: "Disallow styling.defaults entries whose keys or values do not exist in styling.variants."
     },
     messages: {
-      unknownDefaultKey: '"{{ key }}" is not a variant defined in styling.variants. This default will have no effect.',
-      unknownDefaultValue: '"{{ value }}" is not a valid value for variant "{{ key }}". Expected one of: {{ allowed }}. This default will have no effect.',
-      nonLiteralValue: 'Default value for "{{ key }}" is not a string literal and cannot be statically validated.'
+      unknownDefaultKey: EslintDiagnosticTemplates.invalidDefaultKey,
+      unknownDefaultValue: EslintDiagnosticTemplates.invalidDefaultValue,
+      nonLiteralValue: EslintDiagnosticTemplates.invalidDefaultNonLiteral
     },
     schema: [
       {
@@ -500,39 +727,39 @@ var noInvalidDefault = createRule3({
         if (!defaultsProp) return;
         const defaults = asObjectExpression(defaultsProp.value);
         if (!defaults) return;
-        for (const prop of defaults.properties) {
-          if (prop.type !== "Property") continue;
+        iterate.forEach(defaults.properties, (prop) => {
+          if (prop.type !== "Property") return;
           const key = getPropertyKey(prop);
-          if (!key) continue;
+          if (!key) return;
           if (!variantMap.has(key)) {
             context.report({ node: prop, messageId: "unknownDefaultKey", data: { key } });
-            continue;
+            return;
           }
           const value = asStringLiteral(prop.value);
           if (value === void 0) {
             if (reportNonLiteral) {
               context.report({ node: prop, messageId: "nonLiteralValue", data: { key } });
             }
-            continue;
+            return;
           }
           const allowed = variantMap.get(key);
           if (!allowed.has(value)) {
             context.report({
               node: prop,
               messageId: "unknownDefaultValue",
-              data: { key, value, allowed: [...allowed].map((v) => `"${v}"`).join(", ") }
+              data: { key, value, allowed: formatAllowedValues(allowed) }
             });
           }
-        }
+        });
       }
     };
   }
 });
 
-// ../eslint-plugin/src/rules/no-invalid-html-nesting.ts
+// ../../plugins/eslint/src/rules/no-invalid-html-nesting.ts
 var import_eslint_utils4 = __toESM(require_eslint_utils(), 1);
 
-// ../eslint-plugin/src/utils/html-nesting.ts
+// ../../plugins/eslint/src/utils/html-nesting.ts
 var TAG_CATEGORIES = {
   // Phrasing + flow
   abbr: /* @__PURE__ */ new Set(["flow", "phrasing"]),
@@ -691,7 +918,7 @@ var HTML_CONTENT_MODELS = {
   summary: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing", "heading"]) }
 };
 
-// ../eslint-plugin/src/rules/no-invalid-html-nesting.ts
+// ../../plugins/eslint/src/rules/no-invalid-html-nesting.ts
 var createRule4 = (0, import_eslint_utils4.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
 var ALLOWED_TEXT = Object.fromEntries(
   Object.entries(HTML_CONTENT_MODELS).map(([tag, model]) => [
@@ -717,7 +944,7 @@ var noInvalidHtmlNesting = createRule4({
       description: "Disallow HTML children that violate the HTML5 content model for their parent element."
     },
     messages: {
-      invalidChild: "<{{ child }}> is not a valid direct child of <{{ parent }}>. Allowed: {{ allowed }}."
+      invalidChild: EslintDiagnosticTemplates.invalidChild
     },
     schema: []
   },
@@ -729,11 +956,11 @@ var noInvalidHtmlNesting = createRule4({
         if (!parentTag) return;
         const model = HTML_CONTENT_MODELS[parentTag];
         if (!model) return;
-        for (const child of node.children) {
-          if (child.type !== "JSXElement") continue;
+        iterate.forEach(node.children, (child) => {
+          if (child.type !== "JSXElement") return;
           const childTag = getIntrinsicTag(child.openingElement.name);
-          if (childTag === void 0) continue;
-          if (isAllowed(childTag, model)) continue;
+          if (childTag === void 0) return;
+          if (isAllowed(childTag, model)) return;
           context.report({
             node: child,
             messageId: "invalidChild",
@@ -743,16 +970,16 @@ var noInvalidHtmlNesting = createRule4({
               allowed: ALLOWED_TEXT[parentTag] ?? ""
             }
           });
-        }
+        });
       }
     };
   }
 });
 
-// ../eslint-plugin/src/rules/no-redundant-role.ts
+// ../../plugins/eslint/src/rules/no-redundant-role.ts
 var import_eslint_utils5 = __toESM(require_eslint_utils(), 1);
 
-// ../eslint-plugin/src/utils/implicit-roles.ts
+// ../../plugins/eslint/src/utils/implicit-roles.ts
 var IMPLICIT_ROLES = {
   article: "article",
   aside: "complementary",
@@ -795,28 +1022,31 @@ var IMPLICIT_ROLES = {
   ul: "list"
 };
 
-// ../eslint-plugin/src/rules/no-redundant-role.ts
+// ../../plugins/eslint/src/rules/no-redundant-role.ts
 var createRule5 = (0, import_eslint_utils5.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+function isRedundantRole(explicit, implicit) {
+  return explicit === implicit;
+}
 function getJsxTagName(node) {
   const name = node.name;
   if (name.type === "JSXIdentifier") return name.name;
   return void 0;
 }
 function getJsxStringAttribute(node, attrName) {
-  for (const attr of node.attributes) {
-    if (attr.type !== "JSXAttribute") continue;
-    const key = attr.name;
-    if (key.type !== "JSXIdentifier" || key.name !== attrName) continue;
-    const val = attr.value;
-    if (val === null) continue;
-    if (val.type === "Literal" && typeof val.value === "string") {
+  return iterate.find(node.attributes, (attr) => {
+    if (attr.type !== "JSXAttribute") return null;
+    const { name: key } = attr;
+    if (key.type !== "JSXIdentifier" || key.name !== attrName) return null;
+    const { value: val } = attr;
+    if (val === null) return null;
+    if (val.type === "Literal" && isString(val.value)) {
       return { node: attr, value: val.value };
     }
-    if (val.type === "JSXExpressionContainer" && val.expression.type === "Literal" && typeof val.expression.value === "string") {
+    if (val.type === "JSXExpressionContainer" && val.expression.type === "Literal" && isString(val.expression.value)) {
       return { node: attr, value: val.expression.value };
     }
-  }
-  return void 0;
+    return null;
+  }) ?? void 0;
 }
 var noRedundantRole = createRule5({
   name: "no-redundant-role",
@@ -827,7 +1057,7 @@ var noRedundantRole = createRule5({
     },
     fixable: "code",
     messages: {
-      redundantRole: 'role="{{ role }}" is redundant on <{{ tag }}>: the element already carries this implicit ARIA role. Remove the attribute.'
+      redundantRole: EslintDiagnosticTemplates.redundantRole
     },
     schema: []
   },
@@ -841,11 +1071,11 @@ var noRedundantRole = createRule5({
         if (!implicitRole) return;
         const roleAttr = getJsxStringAttribute(node, "role");
         if (!roleAttr) return;
-        if (roleAttr.value === implicitRole) {
+        if (isRedundantRole(roleAttr.value, implicitRole)) {
           context.report({
             node: roleAttr.node,
             messageId: "redundantRole",
-            data: { role: roleAttr.value, tag },
+            data: { tag, role: roleAttr.value },
             fix(fixer) {
               return fixer.remove(roleAttr.node);
             }
@@ -856,7 +1086,7 @@ var noRedundantRole = createRule5({
   }
 });
 
-// ../eslint-plugin/src/rules/valid-cardinality.ts
+// ../../plugins/eslint/src/rules/valid-cardinality.ts
 var import_eslint_utils6 = __toESM(require_eslint_utils(), 1);
 var createRule6 = (0, import_eslint_utils6.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
 var validCardinality = createRule6({
@@ -867,10 +1097,10 @@ var validCardinality = createRule6({
       description: "Enforce valid min/max values in enforcement.children cardinality rules."
     },
     messages: {
-      negativeMin: "cardinality.min must be >= 0 (got {{ value }}).",
-      negativeMax: "cardinality.max must be >= 0 (got {{ value }}).",
-      maxLessThanMin: "cardinality.max ({{ max }}) must be >= cardinality.min ({{ min }}). This rule can never be satisfied.",
-      zeroMax: "cardinality.max of 0 means no children of this type are allowed. Use 0 intentionally or remove the rule."
+      negativeMin: EslintDiagnosticTemplates.negativeMin,
+      negativeMax: EslintDiagnosticTemplates.negativeMax,
+      maxLessThanMin: EslintDiagnosticTemplates.maxLessThanMin,
+      zeroMax: EslintDiagnosticTemplates.zeroMax
     },
     schema: [
       {
@@ -885,6 +1115,30 @@ var validCardinality = createRule6({
   defaultOptions: [{}],
   create(context) {
     const calleeNames = new Set(context.options[0]?.calleeNames ?? ["createContractComponent"]);
+    function validateCardinality(cardProp) {
+      const card = asObjectExpression(cardProp.value);
+      if (!card) return;
+      const minProp = getObjectProperty(card, "min");
+      const maxProp = getObjectProperty(card, "max");
+      const min = minProp ? asNumericLiteral(minProp.value) : void 0;
+      const max = maxProp ? asNumericLiteral(maxProp.value) : void 0;
+      if (minProp && min !== void 0 && min < 0) {
+        context.report({ node: minProp, messageId: "negativeMin", data: { value: String(min) } });
+      }
+      if (maxProp && max !== void 0 && max < 0) {
+        context.report({ node: maxProp, messageId: "negativeMax", data: { value: String(max) } });
+      }
+      if (maxProp && max === 0) {
+        context.report({ node: maxProp, messageId: "zeroMax" });
+      }
+      if (min !== void 0 && max !== void 0 && min >= 0 && max > 0 && max < min) {
+        context.report({
+          node: cardProp,
+          messageId: "maxLessThanMin",
+          data: { min: String(min), max: String(max) }
+        });
+      }
+    }
     return {
       CallExpression(node) {
         if (!isFactoryCall(node, calleeNames)) return;
@@ -898,49 +1152,44 @@ var validCardinality = createRule6({
         if (!childrenProp) return;
         const arr = asArrayExpression(childrenProp.value);
         if (!arr) return;
-        for (const element of arr.elements) {
-          if (!element || element.type !== "ObjectExpression") continue;
+        iterate.forEach(arr.elements, (element) => {
+          if (!element || element.type !== "ObjectExpression") return;
           const cardProp = getObjectProperty(element, "cardinality");
-          if (!cardProp) continue;
-          const card = asObjectExpression(cardProp.value);
-          if (!card) continue;
-          const minProp = getObjectProperty(card, "min");
-          const maxProp = getObjectProperty(card, "max");
-          const min = minProp ? asNumericLiteral(minProp.value) : void 0;
-          const max = maxProp ? asNumericLiteral(maxProp.value) : void 0;
-          if (min !== void 0 && min < 0) {
-            context.report({
-              node: minProp,
-              messageId: "negativeMin",
-              data: { value: String(min) }
-            });
-          }
-          if (max !== void 0 && max < 0) {
-            context.report({
-              node: maxProp,
-              messageId: "negativeMax",
-              data: { value: String(max) }
-            });
-          }
-          if (max !== void 0 && max === 0) {
-            context.report({ node: maxProp, messageId: "zeroMax" });
-          }
-          if (min !== void 0 && max !== void 0 && min >= 0 && max > 0 && max < min) {
-            context.report({
-              node: cardProp,
-              messageId: "maxLessThanMin",
-              data: { min: String(min), max: String(max) }
-            });
-          }
-        }
+          if (!cardProp) return;
+          validateCardinality(cardProp);
+        });
       }
     };
   }
 });
 
-// ../eslint-plugin/src/rules/valid-children-config.ts
+// ../../plugins/eslint/src/rules/valid-children-config.ts
 var import_eslint_utils7 = __toESM(require_eslint_utils(), 1);
 var createRule7 = (0, import_eslint_utils7.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+function analyzeChildrenRules(elements) {
+  const firstPositionProps = [];
+  const lastPositionProps = [];
+  let onlyWithMinProp = null;
+  let requiredRuleCount = 0;
+  iterate.forEach(elements, (element) => {
+    if (!element || element.type !== "ObjectExpression") return;
+    const positionProp = getObjectProperty(element, "position");
+    const position = positionProp ? asStringLiteral(positionProp.value) : void 0;
+    const cardProp = getObjectProperty(element, "cardinality");
+    const card = cardProp ? asObjectExpression(cardProp.value) : void 0;
+    const minProp = card ? getObjectProperty(card, "min") : void 0;
+    const min = minProp ? asNumericLiteral(minProp.value) ?? 0 : 0;
+    if (position === "first" && positionProp) firstPositionProps.push(positionProp);
+    if (position === "last" && positionProp) lastPositionProps.push(positionProp);
+    if (min >= 1) {
+      requiredRuleCount++;
+      if (position === "only" && positionProp && !onlyWithMinProp) {
+        onlyWithMinProp = positionProp;
+      }
+    }
+  });
+  return { firstPositionProps, lastPositionProps, onlyWithMinProp, requiredRuleCount };
+}
 var validChildrenConfig = createRule7({
   name: "valid-children-config",
   meta: {
@@ -949,9 +1198,9 @@ var validChildrenConfig = createRule7({
       description: "Enforce cross-rule consistency of enforcement.children \u2014 detect positional conflicts and cardinality impossibilities."
     },
     messages: {
-      multipleFirst: 'Multiple enforcement.children rules require position: "first". Only one child can occupy the first position.',
-      multipleLast: 'Multiple enforcement.children rules require position: "last". Only one child can occupy the last position.',
-      minSumExceedsCapacity: 'A rule with position: "only" requires min >= 1, but {{ count }} other rule(s) also require min >= 1. These constraints cannot be satisfied simultaneously.'
+      multipleFirst: EslintDiagnosticTemplates.multipleFirst,
+      multipleLast: EslintDiagnosticTemplates.multipleLast,
+      minSumExceedsCapacity: EslintDiagnosticTemplates.minSumExceedsCapacity
     },
     schema: [
       {
@@ -979,42 +1228,18 @@ var validChildrenConfig = createRule7({
         if (!childrenProp) return;
         const arr = asArrayExpression(childrenProp.value);
         if (!arr) return;
-        const firstPositionProps = [];
-        const lastPositionProps = [];
-        let onlyWithMinProp = null;
-        let rulesWithMinCount = 0;
-        for (const element of arr.elements) {
-          if (!element || element.type !== "ObjectExpression") continue;
-          const positionProp = getObjectProperty(element, "position");
-          const position = positionProp ? asStringLiteral(positionProp.value) : void 0;
-          const cardProp = getObjectProperty(element, "cardinality");
-          const card = cardProp ? asObjectExpression(cardProp.value) : void 0;
-          const minProp = card ? getObjectProperty(card, "min") : void 0;
-          const min = minProp ? asNumericLiteral(minProp.value) ?? 0 : 0;
-          if (position === "first" && positionProp) {
-            firstPositionProps.push(positionProp);
-          }
-          if (position === "last" && positionProp) {
-            lastPositionProps.push(positionProp);
-          }
-          if (min >= 1) {
-            rulesWithMinCount++;
-            if (position === "only" && positionProp && !onlyWithMinProp) {
-              onlyWithMinProp = positionProp;
-            }
-          }
-        }
-        for (const prop of firstPositionProps.slice(1)) {
+        const { firstPositionProps, lastPositionProps, onlyWithMinProp, requiredRuleCount } = analyzeChildrenRules(arr.elements);
+        iterate.forEach(firstPositionProps.slice(1), (prop) => {
           context.report({ node: prop, messageId: "multipleFirst" });
-        }
-        for (const prop of lastPositionProps.slice(1)) {
+        });
+        iterate.forEach(lastPositionProps.slice(1), (prop) => {
           context.report({ node: prop, messageId: "multipleLast" });
-        }
-        if (onlyWithMinProp && rulesWithMinCount > 1) {
+        });
+        if (onlyWithMinProp && requiredRuleCount > 1) {
           context.report({
             node: onlyWithMinProp,
             messageId: "minSumExceedsCapacity",
-            data: { count: String(rulesWithMinCount - 1) }
+            data: { count: String(requiredRuleCount - 1) }
           });
         }
       }
@@ -1022,7 +1247,7 @@ var validChildrenConfig = createRule7({
   }
 });
 
-// ../eslint-plugin/src/index.ts
+// ../../plugins/eslint/src/index.ts
 var plugin = {
   meta: {
     name: "@praxis-kit/eslint-plugin",