praxis-kit 5.0.0 → 6.1.0

package/dist/svelte/index.js

@@ -313,6 +313,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)}`);
@@ -494,6 +507,45 @@ var iterate = Object.freeze({
   values
 });
 
+// ../../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-props.ts
 function mergeProps(defaultProps, props) {
   return {
@@ -538,28 +590,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 = {
@@ -916,6 +946,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) {
@@ -927,8 +979,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();
@@ -1084,8 +1135,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),
@@ -1102,10 +1151,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;
   }
@@ -1761,10 +1806,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;
@@ -1772,29 +1829,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
@@ -1808,11 +1875,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
@@ -2141,7 +2225,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;
@@ -2155,17 +2239,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;
   }
 };
@@ -2176,7 +2252,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 ?? {});
@@ -2191,17 +2267,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) {

package/dist/tailwind/index.d.ts

@@ -1,5 +1,21 @@
 import { Diagnostics } from '../_shared/diagnostics.js';
-import { RequireAtLeastOne, Simplify } from 'type-fest';
+import { RequireAtLeastOne, Simplify, ValueOf } from 'type-fest';
+
+/**
+ * Canonical list of reserved layout prop names.
+ *
+ * This array is the single source of truth for every supported CSS `display`
+ * value exposed as a boolean prop. The `LayoutKey` type is derived directly
+ * from this list.
+ *
+ * To add a new display mode:
+ *   1. Add the display value here.
+ *   2. Register its layout family in `LAYOUT_FAMILY_MAP`.
+ *
+ * Prop names intentionally match the corresponding Tailwind/CSS display
+ * utilities, so no additional prop-to-class mapping is required.
+ */
+declare const layoutKeys: readonly ["flex", "inline-flex", "grid", "inline-grid", "block", "inline-block", "inline", "hidden", "contents", "flow-root", "list-item", "table", "inline-table", "table-caption", "table-cell", "table-column", "table-column-group", "table-footer-group", "table-header-group", "table-row-group", "table-row"];
 
 type StringMap<T = unknown> = Record<string, T>;
 type AnyRecord = StringMap<unknown>;
@@ -94,35 +110,19 @@ type ClassPlugin<TProps extends AnyRecord = EmptyRecord> = Readonly<{
     readonly _pluginProps?: TProps;
 }>;
 
-/**
- * Canonical list of reserved layout prop names.
- *
- * This array is the single source of truth for every supported CSS `display`
- * value exposed as a boolean prop. The `LayoutKey` type is derived directly
- * from this list.
- *
- * To add a new display mode:
- *   1. Add the display value here.
- *   2. Register its layout family in `LAYOUT_FAMILY_MAP`.
- *
- * Prop names intentionally match the corresponding Tailwind/CSS display
- * utilities, so no additional prop-to-class mapping is required.
- */
-declare const layoutKeys: readonly ["flex", "inline-flex", "grid", "inline-grid", "block", "inline-block", "inline", "hidden", "contents", "flow-root", "list-item", "table", "inline-table", "table-caption", "table-cell", "table-column", "table-column-group", "table-footer-group", "table-header-group", "table-row-group", "table-row"];
-
 type TupleValues<T extends readonly unknown[]> = T[number];
-type ValueOf<T> = T[keyof T];
 type LayoutKey<T extends readonly string[]> = TupleValues<T>;
 type LayoutFamily<M extends StringMap<string>> = ValueOf<M>;
-type LayoutMode<T extends readonly string[]> = LayoutKey<T> | 'none';
+type ResolvedLayout<T extends readonly string[]> = LayoutKey<T> | 'none';
 type ExclusiveTrueProp<K extends PropertyKey> = {
     [P in K]: Simplify<Record<P, true> & Partial<Record<Exclude<K, P>, never>>>;
 }[K];
 /**
- * Mutually exclusive display shorthand props.
+ * Mutually exclusive layout shorthand props.
  *
- * At most one key may be `true`. Passing multiple is a compile-time error; the
- * runtime also warns and lets the first key in declaration order take precedence.
+ * Exactly one layout prop may be `true`, or none at all. Multiple `true`
+ * props produce a compile-time error. If invalid props reach runtime, the
+ * resolver warns and uses the first declared layout.
  */
 type LayoutProps<T extends readonly string[]> = ExclusiveTrueProp<LayoutKey<T>> | Partial<Record<LayoutKey<T>, never>>;
 
@@ -155,23 +155,76 @@ type Token<TKind extends string, TData extends object = EmptyRecord> = {
     kind: TKind;
     raw: string;
 } & TData;
-type LayoutToken = Token<'layout', {
-    value: LayoutKey<typeof layoutKeys>;
-}>;
-type ConditionalToken = Token<'conditional', {
-    requires: Exclude<LayoutFamily<typeof LAYOUT_FAMILY_MAP>, 'none'>;
-}>;
-type GapToken = Token<'gap'>;
-type UtilityToken = Token<'utility', {
-    base: string;
-}>;
-type ClassifiedToken = Simplify<LayoutToken | ConditionalToken | GapToken | UtilityToken>;
-
-type VariantSelection = Record<string, string>;
+type TokenData = {
+    layout: {
+        value: LayoutKey<typeof layoutKeys>;
+    };
+    conditional: {
+        requires: Exclude<LayoutFamily<typeof LAYOUT_FAMILY_MAP>, 'none'>;
+    };
+    gap: EmptyRecord;
+    shared: EmptyRecord;
+    utility: {
+        base: string;
+    };
+};
+type TokenMap = {
+    [K in keyof TokenData]: Token<K, TokenData[K]>;
+};
+type LayoutToken = TokenMap['layout'];
+type ConditionalToken = TokenMap['conditional'];
+type GapToken = TokenMap['gap'];
+type SharedToken = TokenMap['shared'];
+type UtilityToken = TokenMap['utility'];
+type ClassifiedToken = Simplify<ValueOf<TokenMap>>;
+
+type VariantSelection = StringMap<string>;
 type CompoundVariant = {
     class?: unknown;
 } & AnyRecord;
 
+/**
+ * The resolved display mode for a single render.
+ *
+ * Mode is owned by the display props; a display class literal in the resolved
+ * class string is a reserved-literal authoring mistake. Defaults to `'none'`
+ * when no prop is set.
+ *
+ * `family` is derived from mode: `'flex'` for flex/inline-flex, `'grid'` for
+ * grid/inline-grid, `'none'` for all other values (and when no prop is set).
+ * The evaluator uses family — not mode — for utility and gap filtering.
+ */
+declare class LayoutState {
+    #private;
+    constructor(mode: ResolvedLayout<typeof layoutKeys>);
+    get mode(): ResolvedLayout<typeof layoutKeys>;
+    get family(): LayoutFamily<typeof LAYOUT_FAMILY_MAP>;
+}
+
+type PipelineLayoutProps = LayoutProps<typeof layoutKeys>;
+type PipelineLayout = ResolvedLayout<typeof layoutKeys>;
+type PipelineProps = PipelineLayoutProps & AnyRecord;
+interface PipelineInputs {
+    readonly props: PipelineProps;
+    readonly recipe: string | undefined;
+}
+interface PipelineResolution {
+    readonly mode: PipelineLayout;
+    readonly state: LayoutState;
+}
+interface PipelineTokens {
+    readonly filtered: ClassifiedToken[];
+    readonly tokens: ClassifiedToken[];
+}
+type TailwindPipelineArgs = [
+    tag: unknown,
+    props: PipelineInputs['props'],
+    className: ClassName | undefined,
+    recipe: PipelineInputs['recipe']
+];
+interface TailwindPipelineContext extends PipelineInputs, PipelineResolution, PipelineTokens {
+}
+
 /**
  * Layout-aware class pipeline for Tailwind CSS utility class strings.
  *
@@ -220,28 +273,10 @@ declare class ClassClassifier {
 type DependencyRules = Record<Exclude<LayoutFamily<typeof LAYOUT_FAMILY_MAP>, 'none'>, readonly RegExp[]>;
 declare const defaultDependencyRules: DependencyRules;
 
-/**
- * The resolved display mode for a single render.
- *
- * Mode is owned by the display props; a display class literal in the resolved
- * class string is a reserved-literal authoring mistake. Defaults to `'none'`
- * when no prop is set.
- *
- * `family` is derived from mode: `'flex'` for flex/inline-flex, `'grid'` for
- * grid/inline-grid, `'none'` for all other values (and when no prop is set).
- * The evaluator uses family — not mode — for utility and gap filtering.
- */
-declare class LayoutState {
-    #private;
-    constructor(mode: LayoutMode<typeof layoutKeys>);
-    get mode(): LayoutMode<typeof layoutKeys>;
-    get family(): LayoutFamily<typeof LAYOUT_FAMILY_MAP>;
-}
-
 declare class DependencyEvaluator {
     private readonly rules;
     constructor(rules: DependencyRules);
     evaluate(token: ClassifiedToken, state: LayoutState): boolean;
 }
 
-export { ClassBuilder, ClassClassifier, type ClassToken, type ClassifiedToken, type CompoundVariant, type ConditionalToken, DependencyEvaluator, type DependencyRules, type GapToken, type LayoutFamily, type LayoutKey, type LayoutMode, type LayoutProps, LayoutState, type LayoutToken, type UtilityToken, type VariantSelection, createTailwindPipeline, defaultDependencyRules, layoutKeys };
+export { ClassBuilder, ClassClassifier, type ClassToken, type ClassifiedToken, type CompoundVariant, type ConditionalToken, DependencyEvaluator, type DependencyRules, type GapToken, type LayoutFamily, type LayoutKey, type LayoutProps, LayoutState, type LayoutToken, type ResolvedLayout, type SharedToken, type TailwindPipelineArgs, type TailwindPipelineContext, type UtilityToken, type VariantSelection, createTailwindPipeline, defaultDependencyRules, layoutKeys };