praxis-kit 4.1.3 → 6.0.0

package/dist/tailwind/index.js

@@ -358,6 +358,14 @@ function createClassPipeline(resolved) {
   };
 }
 
+// ../../lib/pipeline-kit/src/core/compose-pipelines.ts
+function composePipelines(first, second) {
+  return (...args) => second(first(...args));
+}
+
+// ../../lib/tailwind/src/create-tailwind-pipeline.ts
+import { ConsoleReporter, DefaultPolicy, Diagnostics, Severity } from "../_shared/diagnostics.js";
+
 // ../../lib/tailwind/src/class-builder.ts
 var ClassBuilder = class {
   build(tokens) {
@@ -371,6 +379,7 @@ var ClassBuilder = class {
         }
         case "utility":
         case "gap":
+        case "shared":
         case "conditional": {
           normal.push(token.raw);
           break;
@@ -444,6 +453,16 @@ var CONDITIONALS = {
   "[&.flex": "flex",
   "[&.grid": "grid"
 };
+var SHARED_PREFIXES = [
+  /^order/,
+  /^justify-(?!items-|self-)/,
+  /^content-/,
+  /^items-/,
+  /^self-/,
+  /^place-content-/,
+  /^place-items-/,
+  /^place-self-/
+];
 var ClassClassifier = class _ClassClassifier {
   static #getBaseUtility(token) {
     let depth = 0;
@@ -476,23 +495,16 @@ var ClassClassifier = class _ClassClassifier {
       }
     );
     if (conditional !== null) return conditional;
-    return base === "gap" || base.startsWith("gap-") ? {
-      kind: "gap",
-      raw: token
-    } : {
-      kind: "utility",
-      base,
-      raw: token
-    };
+    if (base === "gap" || base.startsWith("gap-")) {
+      return { kind: "gap", raw: token };
+    }
+    if (SHARED_PREFIXES.some((rule) => rule.test(base))) {
+      return { kind: "shared", raw: token };
+    }
+    return { kind: "utility", base, raw: token };
   }
 };
 
-// ../../lib/tailwind/src/dependency-rules.ts
-var defaultDependencyRules = {
-  flex: [/^flex-/, /^grow/, /^shrink/, /^basis-/],
-  grid: [/^grid-/, /^col-/, /^row-/, /^auto-cols-/, /^auto-rows-/]
-};
-
 // ../../lib/tailwind/src/dependency-evaluator.ts
 var DependencyEvaluator = class {
   constructor(rules) {
@@ -513,7 +525,8 @@ var DependencyEvaluator = class {
           (layout) => this.rules[layout].some((rule) => rule.test(token.base)) ? state.family === layout : null
         ) ?? true;
       }
-      case "gap": {
+      case "gap":
+      case "shared": {
         return state.family !== "none";
       }
       default:
@@ -522,26 +535,22 @@ var DependencyEvaluator = class {
   }
 };
 
-// ../../lib/tailwind/src/layout-state.ts
-var LayoutState = class {
-  #mode;
-  #family;
-  constructor(mode) {
-    this.#mode = mode;
-    this.#family = mode === "none" ? "none" : LAYOUT_FAMILY_MAP[mode];
-    Object.freeze(this);
-  }
-  get mode() {
-    return this.#mode;
-  }
-  get family() {
-    return this.#family;
-  }
+// ../../lib/tailwind/src/dependency-rules.ts
+var defaultDependencyRules = {
+  flex: [/^flex-/, /^grow/, /^shrink/, /^basis-/],
+  grid: [
+    /^grid-/,
+    /^col-/,
+    /^row-/,
+    /^auto-cols-/,
+    /^auto-rows-/,
+    // justify-items/-self are no-ops on flex containers per the CSS box
+    // alignment spec (flex items ignore them), so treat as grid-only.
+    /^justify-items-/,
+    /^justify-self-/
+  ]
 };
 
-// ../../lib/tailwind/src/create-tailwind-pipeline.ts
-import { ConsoleReporter, Diagnostics, DefaultPolicy, Severity } from "../_shared/diagnostics.js";
-
 // ../../lib/tailwind/src/diagnostics.ts
 import { DiagnosticCategory, DiagnosticCode } from "../_shared/diagnostics.js";
 var TailwindDiagnostics = {
@@ -568,6 +577,23 @@ var TailwindDiagnostics = {
   }
 };
 
+// ../../lib/tailwind/src/layout-state.ts
+var LayoutState = class {
+  #mode;
+  #family;
+  constructor(mode) {
+    this.#mode = mode;
+    this.#family = mode === "none" ? "none" : LAYOUT_FAMILY_MAP[mode];
+    Object.freeze(this);
+  }
+  get mode() {
+    return this.#mode;
+  }
+  get family() {
+    return this.#family;
+  }
+};
+
 // ../../lib/tailwind/src/create-tailwind-pipeline.ts
 var DEV = process.env.NODE_ENV !== "production";
 var devDiagnostics = new Diagnostics(
@@ -648,23 +674,36 @@ function warnDeadVariants(diagnostics, options, compoundDims, props, recipe, sta
   });
 }
 function createTailwindPipeline(options, diagnostics) {
-  const pipeline = createClassPipeline(options);
+  const innerPipeline = createClassPipeline(options);
   const compoundDims = compoundDimensions(getCompoundVariants(options));
+  const resolveLayoutContext = (tag, props, className, recipe) => {
+    const mode = resolveLayout(devDiagnostics, props);
+    const resolvedClasses = innerPipeline(tag, props, className, recipe);
+    const tokens = classifyTokens(resolvedClasses);
+    const state = new LayoutState(mode);
+    const filtered = tokens.filter((token) => evaluator.evaluate(token, state));
+    return { mode, state, filtered, tokens, props, recipe };
+  };
+  const buildClassString = (ctx) => {
+    const built = builder.build(ctx.filtered);
+    if (ctx.mode === "none") return built;
+    return ctx.filtered.some((t) => t.kind === "layout" && t.value === ctx.mode) ? built : cn(ctx.mode, built);
+  };
+  const emitDiagnosticsFromContext = (ctx) => {
+    if (!DEV) return;
+    warnReservedLayoutLiterals(diagnostics, ctx.tokens);
+    warnDeadVariants(diagnostics, options, compoundDims, ctx.props, ctx.recipe, ctx.state);
+  };
+  const combined = (ctx) => {
+    const built = buildClassString(ctx);
+    emitDiagnosticsFromContext(ctx);
+    return built;
+  };
+  const mainPipeline = composePipelines(resolveLayoutContext, combined);
   return {
     ownedKeys: LAYOUT_OWNED_KEYS,
     pipeline(tag, props, className, recipe) {
-      const mode = resolveLayout(devDiagnostics, props);
-      const raw = pipeline(tag, props, className, recipe);
-      const tokens = classifyTokens(raw);
-      const state = new LayoutState(mode);
-      if (DEV) {
-        warnReservedLayoutLiterals(diagnostics, tokens);
-        warnDeadVariants(diagnostics, options, compoundDims, props, recipe, state);
-      }
-      const filtered = tokens.filter((token) => evaluator.evaluate(token, state));
-      const built = builder.build(filtered);
-      if (mode === "none") return built;
-      return filtered.some((t) => t.kind === "layout" && t.value === mode) ? built : cn(mode, built);
+      return mainPipeline(tag, props, className, recipe);
     }
   };
 }

package/dist/vite-plugin/index.d.ts

@@ -165,6 +165,13 @@ type ComponentConstraint = {
     defaultTag?: string;
     /** True when `enforcement.aria` is a non-empty array literal in the factory call. */
     hasAriaRules: boolean;
+    /**
+     * True when `enforcement.exclusiveChildren` is statically `true` in the factory call.
+     * Only when this is true does an "over the max" child count constitute a real
+     * violation — enforcement.children is open-by-default, so extra unmatched children
+     * are otherwise allowed regardless of `totalMax`.
+     */
+    exclusiveChildren: boolean;
 };
 
 /** A diagnostic produced by the static analysis pass. */
@@ -208,6 +215,11 @@ type PluginOptions = {
  *   are skipped — their child count is unknowable at build time.
  * - Named const declarations: `export const X = factory(...)` and destructured
  *   patterns are not collected; cross-file analysis is future work.
+ *
+ * @example
+ * ```ts
+ * const diagnostics = analyze(source, 'Button.tsx', { severity: 'error' })
+ * ```
  */
 declare function analyze(code: string, filename: string, options?: PluginOptions): Diagnostic[];
 
@@ -228,6 +240,25 @@ declare function analyze(code: string, filename: string, options?: PluginOptions
  * - `styling.compounds` contains non-literal conditions or class values
  * - The total number of combinations exceeds MAX_COMBINATIONS
  * - The styling object already has a `precomputedClasses` property
+ *
+ * @example
+ * Before:
+ * ```ts
+ * styling: {
+ *   variants: { size: { sm: 'text-sm', lg: 'text-lg' } },
+ * }
+ * ```
+ * After:
+ * ```ts
+ * styling: {
+ *   variants: { size: { sm: 'text-sm', lg: 'text-lg' } },
+ *   precomputedClasses: {
+ *     '__none__:': '',
+ *     '__none__:size:s:sm': 'text-sm',
+ *     '__none__:size:s:lg': 'text-lg',
+ *   },
+ * }
+ * ```
  */
 
 /**

package/dist/vite-plugin/index.js

@@ -189,7 +189,7 @@ function asArray(node) {
   if (!node) return void 0;
   return ts.isArrayLiteralExpression(node) ? node : void 0;
 }
-function asPositiveInt(node) {
+function asNonNegativeInt(node) {
   if (!node) return void 0;
   if (ts.isNumericLiteral(node)) {
     const n = Number(node.text);
@@ -197,6 +197,17 @@ function asPositiveInt(node) {
   }
   return void 0;
 }
+function asBooleanLiteral(node) {
+  if (!node) return void 0;
+  switch (node.kind) {
+    case ts.SyntaxKind.TrueKeyword:
+      return true;
+    case ts.SyntaxKind.FalseKeyword:
+      return false;
+    default:
+      return void 0;
+  }
+}
 function isFactoryCall(call, names) {
   const { expression } = call;
   if (ts.isIdentifier(expression)) return names.has(expression.text);
@@ -204,7 +215,7 @@ function isFactoryCall(call, names) {
   return false;
 }
 function firstObjectArg(call) {
-  const [first] = call.arguments;
+  const first = call.arguments[0];
   return first && ts.isObjectLiteralExpression(first) ? first : void 0;
 }
 function* walk(node) {
@@ -316,11 +327,11 @@ function enumerateCombinations(variantMap) {
     return total <= MAX_COMBINATIONS;
   });
   if (!totalUnderMaxLimit) return null;
-  function rec(remaining) {
+  function enumerateRecursive(remaining) {
     if (remaining.length === 0) return [{}];
     const first = remaining[0];
     const rest = remaining.slice(1);
-    const restCombos = rec(rest);
+    const restCombos = enumerateRecursive(rest);
     const valueKeys = Object.keys(variantMap[first]);
     const out = [];
     iterate.forEach(restCombos, (combo) => {
@@ -331,7 +342,7 @@ function enumerateCombinations(variantMap) {
     });
     return out;
   }
-  return rec(keys2);
+  return enumerateRecursive(keys2);
 }
 function buildCacheKey(props) {
   const parts = Object.keys(props).sort().map((k) => `${k}:s:${props[k]}`);
@@ -459,8 +470,8 @@ function extractBound(element) {
   if (cardObj) {
     const minNode = getProperty(cardObj, "min");
     const maxNode = getProperty(cardObj, "max");
-    const min = asPositiveInt(minNode) ?? 0;
-    const max = asPositiveInt(maxNode);
+    const min = asNonNegativeInt(minNode) ?? 0;
+    const max = asNonNegativeInt(maxNode);
     if (min === 0 && max === void 0) {
       cardinality = { kind: "unbounded" };
     } else {
@@ -497,6 +508,8 @@ function processVariableStatement(node, calleeNames, out) {
     const ariaNode = enfObj ? getProperty(enfObj, "aria") : void 0;
     const ariaArr = asArray(ariaNode);
     const hasAriaRules = ariaArr !== void 0 && ariaArr.elements.length > 0;
+    const exclusiveChildrenNode = enfObj ? getProperty(enfObj, "exclusiveChildren") : void 0;
+    const exclusiveChildren = asBooleanLiteral(exclusiveChildrenNode) ?? false;
     const childrenProp = enfObj ? getProperty(enfObj, "children") : void 0;
     const childrenArr = asArray(childrenProp);
     const rules = [];
@@ -506,7 +519,7 @@ function processVariableStatement(node, calleeNames, out) {
         if (bound) rules.push(bound);
       });
     }
-    if (rules.length === 0 && !hasAriaRules && !defaultTag) return;
+    if (rules.length === 0 && !hasAriaRules && !defaultTag && !exclusiveChildren) return;
     let totalMin = 0;
     let totalMax = 0;
     iterate.forEach(rules, (rule) => {
@@ -522,7 +535,8 @@ function processVariableStatement(node, calleeNames, out) {
       totalMin,
       totalMax,
       ...defaultTag !== void 0 && { defaultTag },
-      hasAriaRules
+      hasAriaRules,
+      exclusiveChildren
     });
   });
 }
@@ -734,7 +748,7 @@ function analyzeJsxSites(source, constraints, severity) {
     const getPos = () => pos ??= source.getLineAndCharacterOfPosition(node.getStart(source));
     if (count !== void 0) {
       const c = byName.get(tagName);
-      if (c && (count.max < c.totalMin || count.min > c.totalMax)) {
+      if (c && (count.max < c.totalMin || c.exclusiveChildren && count.min > c.totalMax)) {
         const { line, character } = getPos();
         diagnostics.push({
           diagnostic: ViteDiagnostics.cardinalityViolation(
@@ -868,8 +882,8 @@ function diagnoseUsages(source, constraints, severity) {
     const constraint = byName.get(tagName);
     if (!constraint) return;
     if (count === void 0) return;
-    const { totalMin, totalMax, name } = constraint;
-    if (count.max < totalMin || count.min > totalMax) {
+    const { totalMin, totalMax, name, exclusiveChildren } = constraint;
+    if (count.max < totalMin || exclusiveChildren && count.min > totalMax) {
       const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
       diagnostics.push({
         diagnostic: ViteDiagnostics.cardinalityViolation(
@@ -948,9 +962,11 @@ var ConstraintRegistry = class {
         if (count === void 0) return;
         const constraint = this.resolveConstraint(fileId, tagName);
         if (!constraint) return;
-        const { totalMin, totalMax, name } = constraint;
+        const { totalMin, totalMax, name, exclusiveChildren } = constraint;
         const { min, max } = count;
-        if (max >= totalMin && min <= totalMax) return;
+        const tooFew = max < totalMin;
+        const tooMany = exclusiveChildren && min > totalMax;
+        if (!tooFew && !tooMany) return;
         result.push({
           fileId,
           diagnostic: ViteDiagnostics.cardinalityViolation(name, totalMin, totalMax, min, max),
@@ -1379,8 +1395,9 @@ function composeStatically(source, calleeNames, importedComponents = /* @__PURE_
 }
 
 // ../../plugins/vite/src/analyze.ts
+import { extname } from "path";
 function analyze(code, filename, options) {
-  const ext = filename.split(".").pop() ?? "";
+  const ext = extname(filename).slice(1);
   if (!JSX_EXTS.has(ext)) return [];
   const calleeNames = new Set(options?.calleeNames ?? DEFAULT_CALLEE_NAMES);
   const severity = options?.severity ?? "warning";

package/dist/vue/index.d.ts

@@ -1,5 +1,5 @@
 import { RequireAtLeastOne, Simplify, ReadonlyDeep } from 'type-fest';
-import { Diagnostics, DiagnosticInput } from '../_shared/diagnostics.js';
+import { Diagnostics, DiagnosticInput, DiagnosticsMode } from '../_shared/diagnostics.js';
 import * as vue from 'vue';
 import { AllowedComponentProps } from 'vue';
 
@@ -31,6 +31,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';
@@ -38,7 +58,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.
@@ -214,9 +240,25 @@ type AriaRule<C extends AriaContext = AriaContext> = (context: C) => readonly Ar
 type PropNormalizer = (props: Readonly<AnyRecord & IntrinsicProps>) => Partial<AnyRecord & IntrinsicProps>;
 
 type EnforcementOptions<TAllowed extends ElementType = ElementType> = {
-    readonly diagnostics?: Diagnostics;
+    /**
+     * Accepts a preset name (`'warn'`, `'throw'`, `'silent'`) or a full `Diagnostics`
+     * instance for custom reporting/policy. The string form needs no import from
+     * `@praxis-kit/diagnostics`.
+     */
+    readonly diagnostics?: Diagnostics | DiagnosticsMode;
     readonly aria?: readonly AriaRule[];
     readonly children?: readonly ChildRuleInput[];
+    /**
+     * When true, only children matching a `children` rule (or text, per `allowText`)
+     * are valid — anything else is rejected. Default: false (open — children not
+     * matching any rule are allowed).
+     */
+    readonly exclusiveChildren?: boolean;
+    /**
+     * When false, text/number child nodes are rejected regardless of exclusiveChildren
+     * or any listed rule. Default: true.
+     */
+    readonly allowText?: boolean;
     readonly props?: readonly PropNormalizer[];
     /** Restricts the `as` prop to this set of tags. Violations route through diagnostics. */
     readonly allowedAs?: readonly TAllowed[];