praxis-kit 5.0.0 → 6.1.0

package/dist/{chunk-SKAY22CZ.js → chunk-VUULGK5M.js}

@@ -420,6 +420,19 @@ function makeResolveTag(defaultTag) {
   };
 }
 
+// ../../lib/primitive/src/rule/rule-brand.ts
+var RULE_BRAND = /* @__PURE__ */ Symbol("praxis-kit/dynamic-rule");
+
+// ../../lib/primitive/src/rule/is-dynamic-rule.ts
+function isDynamicRule(rule) {
+  return isObject(rule, true) && rule[RULE_BRAND] === true;
+}
+
+// ../../lib/primitive/src/rule/resolve-rule.ts
+function resolveRule(rule, context) {
+  return isDynamicRule(rule) ? rule.resolve(context) : rule;
+}
+
 // ../../lib/primitive/src/utils/assert-never.ts
 function assertNever(value) {
   throw new Error(`Unexpected value: ${String(value)}`);
@@ -601,6 +614,58 @@ var iterate = Object.freeze({
   values
 });
 
+// ../../lib/primitive/src/utils/lazy.ts
+function lazy(factory) {
+  let initialized = false;
+  let value;
+  return () => {
+    if (!initialized) {
+      value = factory();
+      initialized = true;
+    }
+    return value;
+  };
+}
+
+// ../../lib/primitive/src/utils/lru-cache.ts
+var LRUCache = class {
+  #maxSize;
+  #store = /* @__PURE__ */ new Map();
+  constructor(maxSize) {
+    if (!Number.isInteger(maxSize) || maxSize < 1) {
+      throw new RangeError("LRUCache maxSize must be a positive integer.");
+    }
+    this.#maxSize = maxSize;
+  }
+  get(key) {
+    if (!this.#store.has(key)) return void 0;
+    const value = this.#store.get(key);
+    this.#store.delete(key);
+    this.#store.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    this.#store.delete(key);
+    this.#store.set(key, value);
+    if (this.#store.size > this.#maxSize) {
+      const lru = this.#store.keys().next().value;
+      if (lru !== void 0) this.#store.delete(lru);
+    }
+  }
+  has(key) {
+    return this.#store.has(key);
+  }
+  delete(key) {
+    return this.#store.delete(key);
+  }
+  get size() {
+    return this.#store.size;
+  }
+  clear() {
+    this.#store.clear();
+  }
+};
+
 // ../../lib/primitive/src/utils/merge-refs.ts
 function mergeRefsCore(...refs) {
   const active = refs.filter((r) => r != null);
@@ -662,28 +727,6 @@ function isTag(...args) {
   return tag !== void 0 && set2.has(tag);
 }
 
-// ../../lib/contract/src/strict/invariant-base.ts
-var InvariantBase = class {
-  diagnostics;
-  constructor(diagnostics) {
-    this.diagnostics = diagnostics;
-  }
-  get active() {
-    return this.diagnostics.active;
-  }
-  violate(input) {
-    this.diagnostics.error(input);
-  }
-  // Always caps at warn — never throws. ARIA 'warning' violations route here
-  // so they surface even in strict='throw' mode without aborting a render.
-  warn(input) {
-    this.diagnostics.warn(input);
-  }
-  invariant(condition, input) {
-    if (!condition) this.violate(input);
-  }
-};
-
 // ../../lib/contract/src/diagnostics/aria.ts
 import { DiagnosticCategory, DiagnosticCode } from "./_shared/diagnostics.js";
 var AriaDiagnostics = {
@@ -1040,6 +1083,28 @@ var SlotDiagnostics = {
   }
 };
 
+// ../../lib/contract/src/strict/invariant-base.ts
+var InvariantBase = class {
+  diagnostics;
+  constructor(diagnostics) {
+    this.diagnostics = diagnostics;
+  }
+  get active() {
+    return this.diagnostics.active;
+  }
+  violate(input) {
+    this.diagnostics.error(input);
+  }
+  // Always caps at warn — never throws. ARIA 'warning' violations route here
+  // so they surface even in strict='throw' mode without aborting a render.
+  warn(input) {
+    this.diagnostics.warn(input);
+  }
+  invariant(condition, input) {
+    if (!condition) this.violate(input);
+  }
+};
+
 // ../../lib/contract/src/aria/polymorphic-validator.ts
 var VALID = [{ valid: true }];
 function isIntrinsicTag(tag) {
@@ -1051,8 +1116,7 @@ function omitProp(obj, key) {
 }
 var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
   #extraRules;
-  #planCache = /* @__PURE__ */ new Map();
-  static #MAX_CACHE = 100;
+  #planCache = new LRUCache(100);
   // Memoized AriaFix objects keyed by attribute name — the ARIA attribute set is
   // finite so this Map is bounded and avoids recreating closures on every cache miss.
   static #removeAttributeFixCache = /* @__PURE__ */ new Map();
@@ -1208,8 +1272,6 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     if (!isNull(key)) {
       const cached = this.#planCache.get(key);
       if (cached !== void 0) {
-        this.#planCache.delete(key);
-        this.#planCache.set(key, cached);
         if (cached.violations.length > 0) this.report(cached.violations);
         return {
           props: _AriaPolicyEngine.#applyPlan(props, cached.removals, cached.updates),
@@ -1226,10 +1288,6 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
       );
       const plan = { removals, updates, violations: result.violations };
       this.#planCache.set(key, plan);
-      if (this.#planCache.size > _AriaPolicyEngine.#MAX_CACHE) {
-        const lru = this.#planCache.keys().next().value;
-        if (lru !== void 0) this.#planCache.delete(lru);
-      }
     }
     return result;
   }
@@ -1885,10 +1943,22 @@ var RuleValidator = class _RuleValidator extends InvariantBase {
 
 // ../../lib/contract/src/children/children-evaluator.ts
 var isTextLike = (child) => isString(child) || isNumber(child);
+function checkPositionCardinalityInvariant(rules, context) {
+  iterate.forEach(rules, (rule) => {
+    const { name, position, cardinality } = rule;
+    if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
+      throw new RangeError(
+        `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
+      );
+    }
+  });
+}
 var ChildrenEvaluator = class extends InvariantBase {
   #context;
-  #rules;
-  #ruleNames;
+  /** Rules with a static cardinality — normalized once, reused on every evaluate() call. */
+  #staticRules;
+  /** Rules whose cardinality is `dynamic(...)` — re-resolved against a ChildRuleContext per call. */
+  #dynamicRuleInputs;
   #matcher;
   #ruleValidator;
   #exclusiveChildren;
@@ -1896,29 +1966,39 @@ var ChildrenEvaluator = class extends InvariantBase {
   constructor(rules, diagnostics, context = "Component", options = {}) {
     super(diagnostics);
     this.#context = context;
-    this.#rules = rules.map((r) => normalizeChildRule(r));
-    this.#ruleNames = this.#rules.map((r) => r.name);
     this.#exclusiveChildren = options.exclusiveChildren ?? false;
     this.#allowText = options.allowText ?? true;
-    iterate.forEach(this.#rules, (rule) => {
-      const { name, position, cardinality } = rule;
-      if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
-        throw new RangeError(
-          `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
-        );
-      }
+    const staticRuleInputs = [];
+    const dynamicRuleInputs = [];
+    iterate.forEach(rules, (rule) => {
+      if (isDynamicRule(rule.cardinality)) dynamicRuleInputs.push(rule);
+      else staticRuleInputs.push(rule);
     });
-    this.#matcher = new RuleMatcher(this.#rules);
+    this.#dynamicRuleInputs = dynamicRuleInputs;
+    this.#staticRules = staticRuleInputs.map(
+      (r) => normalizeChildRule(r)
+    );
     this.#ruleValidator = new RuleValidator(context, diagnostics);
+    if (this.#dynamicRuleInputs.length === 0) {
+      checkPositionCardinalityInvariant(this.#staticRules, context);
+      this.#matcher = new RuleMatcher(this.#staticRules);
+    } else {
+      this.#matcher = void 0;
+    }
   }
-  evaluate(children) {
+  /**
+   * @param context Required when any rule has a `dynamic(...)` cardinality —
+   *   supplies the resolved tag/props those rules are evaluated against.
+   */
+  evaluate(children, context) {
     if (!this.active) return;
+    const { rules, matcher } = this.#resolveRules(context);
     const {
       matrix,
       unexpectedIndices: rawUnexpectedIndices,
       ambiguousIndices
-    } = this.#matcher.match(children);
-    this.#ruleValidator.validate(this.#rules, matrix, children.length);
+    } = matcher.match(children);
+    this.#ruleValidator.validate(rules, matrix, children.length);
     const unexpectedIndices = new Set(
       [...rawUnexpectedIndices].filter(
         (ci) => isTextLike(children[ci]) ? this.#allowText === false : this.#exclusiveChildren
@@ -1932,11 +2012,28 @@ var ChildrenEvaluator = class extends InvariantBase {
         this.violate(ContractDiagnostics.unexpectedChild(typeName, ci, this.#context));
       } else {
         const matches = matrix.childToRules.forward.get(ci);
-        const names = [...matches].map((ri) => this.#ruleNames[ri] ?? `#${ri}`);
+        const names = [...matches].map((ri) => rules[ri]?.name ?? `#${ri}`);
         this.violate(ContractDiagnostics.ambiguousChild(typeName, ci, names, this.#context));
       }
     });
   }
+  #resolveRules(context) {
+    if (this.#dynamicRuleInputs.length === 0) {
+      return { rules: this.#staticRules, matcher: this.#matcher };
+    }
+    if (context === void 0) {
+      throw new RangeError(
+        `ChildrenEvaluator [${this.#context}]: rule(s) have a dynamic(...) cardinality \u2014 evaluate() requires a context argument to resolve them.`
+      );
+    }
+    const resolvedDynamicRules = this.#dynamicRuleInputs.map((r) => {
+      const cardinality = resolveRule(r.cardinality, context);
+      return normalizeChildRule({ ...r, cardinality });
+    });
+    checkPositionCardinalityInvariant(resolvedDynamicRules, this.#context);
+    const rules = [...this.#staticRules, ...resolvedDynamicRules];
+    return { rules, matcher: new RuleMatcher(rules) };
+  }
 };
 
 // ../../lib/contract/src/props/get-disabled-props.ts
@@ -2265,7 +2362,7 @@ function cva2(base, config) {
 // ../../lib/styling/src/static-class-resolver.ts
 var StaticClassResolver = class {
   #baseClass;
-  #cache = /* @__PURE__ */ new Map();
+  #cache = new LRUCache(200);
   #resolveTag;
   constructor(baseClass, tagMap) {
     this.#baseClass = Array.isArray(baseClass) ? baseClass.join(" ") : baseClass;
@@ -2279,17 +2376,9 @@ var StaticClassResolver = class {
   resolve(tag, skipTagMap = false) {
     if (typeof tag !== "string" || skipTagMap) return this.#baseClass;
     const cached = this.#cache.get(tag);
-    if (cached !== void 0) {
-      this.#cache.delete(tag);
-      this.#cache.set(tag, cached);
-      return cached;
-    }
+    if (cached !== void 0) return cached;
     const result = this.#resolveTag(tag);
     this.#cache.set(tag, result);
-    if (this.#cache.size > 200) {
-      const lru = this.#cache.keys().next().value;
-      if (lru !== void 0) this.#cache.delete(lru);
-    }
     return result;
   }
 };
@@ -2300,7 +2389,7 @@ var VariantClassResolver = class _VariantClassResolver {
   #recipeMap;
   #variantKeys;
   #precomputedClasses;
-  #cache = /* @__PURE__ */ new Map();
+  #cache = new LRUCache(1e3);
   constructor(cvaFn, recipeMap, variantKeys, precomputedClasses) {
     this.#cvaFn = cvaFn ?? null;
     this.#recipeMap = Object.freeze(recipeMap ?? {});
@@ -2315,17 +2404,9 @@ var VariantClassResolver = class _VariantClassResolver {
       if (precomputed !== void 0) return precomputed;
     }
     const cached = this.#cache.get(cacheKey);
-    if (cached !== void 0) {
-      this.#cache.delete(cacheKey);
-      this.#cache.set(cacheKey, cached);
-      return cached;
-    }
+    if (cached !== void 0) return cached;
     const result = this.#compute(props, recipe);
     this.#cache.set(cacheKey, result);
-    if (this.#cache.size > 1e3) {
-      const lru = this.#cache.keys().next().value;
-      if (lru !== void 0) this.#cache.delete(lru);
-    }
     return result;
   }
   #compute(props, recipe) {
@@ -2846,8 +2927,14 @@ function applyDisplayName(component, name) {
 // ../../adapters/react/src/shared/render.ts
 import { createElement as createElement2 } from "react";
 import { jsx as jsx2 } from "react/jsx-runtime";
-function buildRenderState(tag, directives, props, className, children) {
-  const state = { tag, directives, props, className };
+function buildRenderState(tag, directives, props, normalizedProps, className, children) {
+  const state = {
+    tag,
+    directives,
+    props,
+    normalizedProps,
+    className
+  };
   if (children !== void 0) state.children = children;
   return state;
 }
@@ -2872,7 +2959,7 @@ function prepareRenderState(runtime, props, filterProps) {
     ...as !== void 0 && { as },
     ...asChild !== void 0 && { asChild }
   };
-  return buildRenderState(tag, directives, filteredProps, resolvedClass, children);
+  return buildRenderState(tag, directives, filteredProps, normalizedProps, resolvedClass, children);
 }
 function warnDiscardedChildren(originalChildren, normalizedChildren, validator) {
   if (!Array.isArray(originalChildren)) return;
@@ -2947,10 +3034,12 @@ function render({
   childrenEvaluator
 }) {
   const state = prepareRenderState(runtime, props, filterProps);
-  let cached;
-  const getNormalizedChildren = () => cached ??= normalizeChildren(state.children);
+  const getNormalizedChildren = lazy(() => normalizeChildren(state.children));
   if (process.env.NODE_ENV !== "production") {
-    childrenEvaluator?.evaluate(getNormalizedChildren());
+    childrenEvaluator?.evaluate(getNormalizedChildren(), {
+      tag: state.tag,
+      props: state.normalizedProps
+    });
     runtime.options.htmlChildrenEvaluatorFn?.(state.tag)?.evaluate(getNormalizedChildren());
   }
   if (typeof props.render === "function") {

package/dist/contract/index.d.ts

@@ -29,6 +29,26 @@ type MinMax = {
 };
 type CardinalityInput = Partial<MinMax>;
 
+/**
+ * Resolved per-instance state available to a dynamic (`dynamic(...)`) child
+ * rule field — the same tag/props every adapter already computes before
+ * evaluating children, exposed so a rule can vary by them (e.g. cardinality
+ * that depends on the resolved `as` tag).
+ */
+type ChildRuleContext = {
+    readonly tag: unknown;
+    readonly props: Readonly<AnyRecord>;
+};
+
+declare const RULE_BRAND: unique symbol;
+
+type DynamicRule<T, C = unknown> = {
+    readonly [RULE_BRAND]: true;
+    resolve(context: C): T;
+};
+
+type Rule<T, C = unknown> = T | DynamicRule<T, C>;
+
 type ChildRuleMatch<T, U extends T = T> = (child: T) => child is U;
 
 type ChildRulePosition = 'first' | 'last' | 'any';
@@ -36,7 +56,13 @@ type ChildRulePosition = 'first' | 'last' | 'any';
 type ChildRuleInput<T = unknown, U extends T = T> = {
     name: string;
     match: ChildRuleMatch<T, U>;
-    cardinality?: CardinalityInput;
+    /**
+     * Either a static cardinality, or `dynamic((ctx) => ...)` to derive it from
+     * the resolved tag/props (e.g. a different max depending on `as`). `match`
+     * stays static-only — it's already a function, so a dynamic wrapper would
+     * be indistinguishable from the predicate itself without one.
+     */
+    cardinality?: Rule<CardinalityInput, ChildRuleContext>;
     position?: ChildRulePosition;
     /**
      * Optional component-type reference for O(1) dispatch index.

package/dist/lit/index.d.ts

@@ -30,6 +30,26 @@ type MinMax = {
 };
 type CardinalityInput = Partial<MinMax>;
 
+/**
+ * Resolved per-instance state available to a dynamic (`dynamic(...)`) child
+ * rule field — the same tag/props every adapter already computes before
+ * evaluating children, exposed so a rule can vary by them (e.g. cardinality
+ * that depends on the resolved `as` tag).
+ */
+type ChildRuleContext = {
+    readonly tag: unknown;
+    readonly props: Readonly<AnyRecord>;
+};
+
+declare const RULE_BRAND: unique symbol;
+
+type DynamicRule<T, C = unknown> = {
+    readonly [RULE_BRAND]: true;
+    resolve(context: C): T;
+};
+
+type Rule<T, C = unknown> = T | DynamicRule<T, C>;
+
 type ChildRuleMatch<T, U extends T = T> = (child: T) => child is U;
 
 type ChildRulePosition = 'first' | 'last' | 'any';
@@ -37,7 +57,13 @@ type ChildRulePosition = 'first' | 'last' | 'any';
 type ChildRuleInput<T = unknown, U extends T = T> = {
     name: string;
     match: ChildRuleMatch<T, U>;
-    cardinality?: CardinalityInput;
+    /**
+     * Either a static cardinality, or `dynamic((ctx) => ...)` to derive it from
+     * the resolved tag/props (e.g. a different max depending on `as`). `match`
+     * stays static-only — it's already a function, so a dynamic wrapper would
+     * be indistinguishable from the predicate itself without one.
+     */
+    cardinality?: Rule<CardinalityInput, ChildRuleContext>;
     position?: ChildRulePosition;
     /**
      * Optional component-type reference for O(1) dispatch index.