praxis-kit 2.0.1 → 3.0.0

package/dist/svelte/index.js

@@ -1,4 +1,9 @@
-// ../core/dist/chunk-XFCAUPVZ.js
+// ../../lib/adapter-utils/src/define-component.ts
+function defineContractComponent(options) {
+  return (factory) => factory(options);
+}
+
+// ../core/dist/chunk-KKSHJDE7.js
 function makeResolveTag(defaultTag) {
   return function tag(as) {
     return as ?? defaultTag;
@@ -67,7 +72,7 @@ function resolveFactoryOptions(options = {}) {
     ...whenDefined("defaultProps", options.defaults),
     ...whenDefined("baseClassName", styling?.base),
     ...whenDefined("tagMap", styling?.tags),
-    ...whenDefined("presetMap", styling?.presets),
+    ...whenDefined("recipeMap", styling?.presets),
     ...whenDefined("variants", styling?.variants),
     ...whenDefined("defaultVariants", styling?.defaults),
     ...whenDefined("compoundVariants", styling?.compounds),
@@ -108,10 +113,10 @@ function validateFactoryOptions(resolved) {
       }
     }
   };
-  const { presetMap } = resolved;
-  if (presetMap) {
-    for (const presetKey in presetMap) {
-      checkSelection(`preset "${presetKey}"`, presetMap[presetKey]);
+  const { recipeMap } = resolved;
+  if (recipeMap) {
+    for (const recipeKey in recipeMap) {
+      checkSelection(`preset "${recipeKey}"`, recipeMap[recipeKey]);
     }
   }
   if (resolved.defaultVariants) checkSelection("defaults", resolved.defaultVariants);
@@ -147,12 +152,12 @@ function report2(strict, message) {
 function label(name) {
   return name ? `[${name}]` : "[createContractComponent]";
 }
-function validateRenderProps(options, props, presetKey) {
-  const { strict, presetMap, variants, displayName } = options;
+function validateRenderProps(options, props, recipeKey) {
+  const { strict, recipeMap, variants, displayName } = options;
   if (!strict) return;
   const tag = label(displayName);
-  if (presetKey !== void 0 && (!presetMap || !Object.hasOwn(presetMap, presetKey))) {
-    report2(strict, `${tag} Unknown presetKey "${presetKey}" \u2014 no preset with that name exists.`);
+  if (recipeKey !== void 0 && (!recipeMap || !Object.hasOwn(recipeMap, recipeKey))) {
+    report2(strict, `${tag} Unknown recipeKey "${recipeKey}" \u2014 no preset with that name exists.`);
   }
   if (variants) {
     for (const key in variants) {
@@ -190,8 +195,8 @@ function assertPluginShape(result) {
 }
 function guardPipeline(pipeline) {
   if (process.env.NODE_ENV === "production") return pipeline;
-  return function guardedPipeline(tag, props, className, variantKey) {
-    const result = pipeline(tag, props, className, variantKey);
+  return function guardedPipeline(tag, props, className, recipe) {
+    const result = pipeline(tag, props, className, recipe);
     if (typeof result !== "string")
       panic(`[praxis-kit] Plugin pipeline must return a string. Got: ${describe(result)}.`);
     return result;
@@ -216,11 +221,11 @@ function createRuntimeMethods(resolved, classPipeline, engine) {
     resolveProps(props) {
       return mergeProps(resolved.defaultProps, props);
     },
-    resolveClasses(tag, props, className, variantKey) {
+    resolveClasses(tag, props, className, recipe) {
       if (process.env.NODE_ENV !== "production") {
-        validateRenderProps(resolved, props, variantKey);
+        validateRenderProps(resolved, props, recipe);
       }
-      return classPipeline(tag, props, className, variantKey);
+      return classPipeline(tag, props, className, recipe);
     },
     resolveAria(tag, props) {
       if (!engine) return { props };
@@ -566,7 +571,7 @@ function isStandaloneTag(tag) {
   return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
 }
 
-// ../core/dist/chunk-VU44HAB7.js
+// ../core/dist/chunk-BNVYTMYV.js
 var IMPLICIT_ROLE_RECORD2 = {
   article: "article",
   aside: "complementary",
@@ -1501,7 +1506,7 @@ function getHtmlPropNormalizers(tag) {
   return typeof tag === "string" ? HTML_FORM_NORMALIZERS.get(tag) : void 0;
 }
 
-// ../core/dist/chunk-EHCOMLJ4.js
+// ../core/dist/chunk-3T4EM5FG.js
 var falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
 var cx = clsx;
 var cva = (base, config) => (props) => {
@@ -1578,18 +1583,18 @@ var StaticClassResolver = class {
 };
 var VariantClassResolver = class _VariantClassResolver {
   #cvaFn;
-  #presetMap;
+  #recipeMap;
   #variantKeys;
   #precomputedClasses;
   #cache = /* @__PURE__ */ new Map();
-  constructor(cvaFn, presetMap, variantKeys, precomputedClasses) {
+  constructor(cvaFn, recipeMap, variantKeys, precomputedClasses) {
     this.#cvaFn = cvaFn ?? null;
-    this.#presetMap = Object.freeze(presetMap ?? {});
+    this.#recipeMap = Object.freeze(recipeMap ?? {});
     this.#variantKeys = variantKeys ?? null;
     this.#precomputedClasses = precomputedClasses ?? null;
   }
-  resolve({ props, variantKey }) {
-    const normalizedKey = variantKey ?? "__none__";
+  resolve({ props, recipe }) {
+    const normalizedKey = recipe ?? "__none__";
     const cacheKey = this.#createCacheKey(props, normalizedKey);
     if (this.#precomputedClasses !== null) {
       const precomputed = this.#precomputedClasses[cacheKey];
@@ -1601,7 +1606,7 @@ var VariantClassResolver = class _VariantClassResolver {
       this.#cache.set(cacheKey, cached);
       return cached;
     }
-    const result = this.#compute(props, variantKey);
+    const result = this.#compute(props, recipe);
     this.#cache.set(cacheKey, result);
     if (this.#cache.size > 1e3) {
       const lru = this.#cache.keys().next().value;
@@ -1609,10 +1614,10 @@ var VariantClassResolver = class _VariantClassResolver {
     }
     return result;
   }
-  #compute(props, variantKey) {
+  #compute(props, recipe) {
     if (!this.#cvaFn) return "";
-    if (!variantKey) return this.#cvaFn(props);
-    const preset = this.#presetMap[variantKey];
+    if (!recipe) return this.#cvaFn(props);
+    const preset = this.#recipeMap[recipe];
     if (!preset) return this.#cvaFn(props);
     return this.#cvaFn({ ...preset, ...props });
   }
@@ -1620,15 +1625,15 @@ var VariantClassResolver = class _VariantClassResolver {
   // props (className, id, etc.) produce identical CVA output and must not fragment the cache.
   // Iterating #variantKeys directly (fixed Set insertion order) avoids Object.keys + filter + sort.
   // String is built incrementally to avoid a parts[] array allocation on every render.
-  #createCacheKey(props, variantKey) {
+  #createCacheKey(props, recipe) {
     if (this.#variantKeys !== null) {
-      let key2 = variantKey;
+      let key2 = recipe;
       for (const k of this.#variantKeys) {
         if (k in props) key2 += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
       }
       return key2;
     }
-    let key = variantKey;
+    let key = recipe;
     for (const k of Object.keys(props).sort()) {
       key += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
     }
@@ -1653,13 +1658,13 @@ function createClassPipeline(resolved) {
   const staticResolver = new StaticClassResolver(baseClass, resolved.tagMap);
   const variantResolver = new VariantClassResolver(
     cvaFn,
-    resolved.presetMap,
+    resolved.recipeMap,
     variantKeys,
     resolved.precomputedClasses
   );
-  return function resolveClasses(tag, props, className, variantKey) {
-    const staticClasses = staticResolver.resolve(tag, variantKey !== void 0);
-    const variantClasses = variantResolver.resolve({ props, variantKey });
+  return function resolveClasses(tag, props, className, recipe) {
+    const staticClasses = staticResolver.resolve(tag, recipe !== void 0);
+    const variantClasses = variantResolver.resolve({ props, recipe });
     if (!className)
       return staticClasses && variantClasses ? `${staticClasses} ${variantClasses}` : staticClasses || variantClasses;
     return cn(staticClasses, variantClasses, className);
@@ -1759,11 +1764,6 @@ function createContractComponent(options) {
     options
   );
 }
-
-// ../../adapters/svelte/src/define-contract-component.ts
-function defineContractComponent(options) {
-  return (factory) => factory(options);
-}
 export {
   createContractComponent,
   defineContractComponent

package/dist/tailwind/index.js

@@ -98,18 +98,18 @@ var StaticClassResolver = class {
 // ../../lib/styling/src/variant-class-resolver.ts
 var VariantClassResolver = class _VariantClassResolver {
   #cvaFn;
-  #presetMap;
+  #recipeMap;
   #variantKeys;
   #precomputedClasses;
   #cache = /* @__PURE__ */ new Map();
-  constructor(cvaFn, presetMap, variantKeys, precomputedClasses) {
+  constructor(cvaFn, recipeMap, variantKeys, precomputedClasses) {
     this.#cvaFn = cvaFn ?? null;
-    this.#presetMap = Object.freeze(presetMap ?? {});
+    this.#recipeMap = Object.freeze(recipeMap ?? {});
     this.#variantKeys = variantKeys ?? null;
     this.#precomputedClasses = precomputedClasses ?? null;
   }
-  resolve({ props, variantKey }) {
-    const normalizedKey = variantKey ?? "__none__";
+  resolve({ props, recipe }) {
+    const normalizedKey = recipe ?? "__none__";
     const cacheKey = this.#createCacheKey(props, normalizedKey);
     if (this.#precomputedClasses !== null) {
       const precomputed = this.#precomputedClasses[cacheKey];
@@ -121,7 +121,7 @@ var VariantClassResolver = class _VariantClassResolver {
       this.#cache.set(cacheKey, cached);
       return cached;
     }
-    const result = this.#compute(props, variantKey);
+    const result = this.#compute(props, recipe);
     this.#cache.set(cacheKey, result);
     if (this.#cache.size > 1e3) {
       const lru = this.#cache.keys().next().value;
@@ -129,10 +129,10 @@ var VariantClassResolver = class _VariantClassResolver {
     }
     return result;
   }
-  #compute(props, variantKey) {
+  #compute(props, recipe) {
     if (!this.#cvaFn) return "";
-    if (!variantKey) return this.#cvaFn(props);
-    const preset = this.#presetMap[variantKey];
+    if (!recipe) return this.#cvaFn(props);
+    const preset = this.#recipeMap[recipe];
     if (!preset) return this.#cvaFn(props);
     return this.#cvaFn({ ...preset, ...props });
   }
@@ -140,15 +140,15 @@ var VariantClassResolver = class _VariantClassResolver {
   // props (className, id, etc.) produce identical CVA output and must not fragment the cache.
   // Iterating #variantKeys directly (fixed Set insertion order) avoids Object.keys + filter + sort.
   // String is built incrementally to avoid a parts[] array allocation on every render.
-  #createCacheKey(props, variantKey) {
+  #createCacheKey(props, recipe) {
     if (this.#variantKeys !== null) {
-      let key2 = variantKey;
+      let key2 = recipe;
       for (const k of this.#variantKeys) {
         if (k in props) key2 += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
       }
       return key2;
     }
-    let key = variantKey;
+    let key = recipe;
     for (const k of Object.keys(props).sort()) {
       key += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
     }
@@ -175,13 +175,13 @@ function createClassPipeline(resolved) {
   const staticResolver = new StaticClassResolver(baseClass, resolved.tagMap);
   const variantResolver = new VariantClassResolver(
     cvaFn,
-    resolved.presetMap,
+    resolved.recipeMap,
     variantKeys,
     resolved.precomputedClasses
   );
-  return function resolveClasses(tag, props, className, variantKey) {
-    const staticClasses = staticResolver.resolve(tag, variantKey !== void 0);
-    const variantClasses = variantResolver.resolve({ props, variantKey });
+  return function resolveClasses(tag, props, className, recipe) {
+    const staticClasses = staticResolver.resolve(tag, recipe !== void 0);
+    const variantClasses = variantResolver.resolve({ props, recipe });
     if (!className)
       return staticClasses && variantClasses ? `${staticClasses} ${variantClasses}` : staticClasses || variantClasses;
     return cn(staticClasses, variantClasses, className);
@@ -446,8 +446,8 @@ function compoundDimensions(compounds) {
 function getDefaultVariants(options) {
   return options.defaultVariants;
 }
-function resolveActiveSelection(options, variants, props, variantKey) {
-  const preset = variantKey ? options.presetMap?.[variantKey] : void 0;
+function resolveActiveSelection(options, variants, props, recipe) {
+  const preset = recipe ? options.recipeMap?.[recipe] : void 0;
   const defaults = getDefaultVariants(options);
   const selection = {};
   for (const dim in variants) {
@@ -456,11 +456,11 @@ function resolveActiveSelection(options, variants, props, variantKey) {
   }
   return selection;
 }
-function warnDeadVariants(strict, options, compoundDims, props, variantKey, state) {
+function warnDeadVariants(strict, options, compoundDims, props, recipe, state) {
   if (!strict) return;
   const variants = getVariantConfig(options);
   if (!variants) return;
-  const selection = resolveActiveSelection(options, variants, props, variantKey);
+  const selection = resolveActiveSelection(options, variants, props, recipe);
   for (const dim in selection) {
     if (compoundDims.has(dim)) continue;
     const value = selection[dim];
@@ -482,14 +482,14 @@ function createTailwindPipeline(options, strict) {
   const compoundDims = compoundDimensions(getCompoundVariants(options));
   return {
     ownedKeys: LAYOUT_OWNED_KEYS,
-    pipeline(tag, props, className, variantKey) {
+    pipeline(tag, props, className, recipe) {
       const mode = resolveLayout(props);
-      const raw = pipeline(tag, props, className, variantKey);
+      const raw = pipeline(tag, props, className, recipe);
       const tokens = classifyTokens(raw);
       const state = new LayoutState(mode);
       if (DEV) {
         warnReservedLayoutLiterals(strict, tokens);
-        warnDeadVariants(strict, options, compoundDims, props, variantKey, state);
+        warnDeadVariants(strict, options, compoundDims, props, recipe, state);
       }
       const filtered = tokens.filter((token) => evaluator.evaluate(token, state));
       const built = builder.build(filtered);

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

@@ -108,6 +108,74 @@ type DesignTokensOptions = {
  */
 declare function designTokensPlugin(options?: DesignTokensOptions): Plugin;
 
+/**
+ * Compile-time static composition transform.
+ *
+ * For factory calls that have `precomputedClasses` injected (by classExtractPlugin),
+ * replaces static JSX usage sites with direct element creation — bypassing the
+ * runtime render pipeline entirely.
+ *
+ * Example:
+ *   // Source (same file defines Button and uses it)
+ *   const Button = createContractComponent({ tag: 'button', styling: { precomputedClasses: {...} } })
+ *   <Button size="lg">Click</Button>
+ *
+ *   // Output
+ *   const Button = createContractComponent({ ... }) // unchanged — still exported
+ *   <button className="btn btn-lg">Click</button>  // inlined!
+ *
+ * **Eligibility conditions** — a usage site is inlined only when:
+ *   1. The component is defined in the same file or imported from a file already
+ *      transformed by this plugin, with `precomputedClasses` injected
+ *   2. No `as`, `asChild`, `render`, or spread attributes at the usage site
+ *   3. All variant props are static string literals
+ *   4. `className` is absent or a static string literal
+ *   5. The factory config has no top-level `defaults` and no `enforcement`
+ *      (either would require runtime prop normalization that inlining skips)
+ *
+ * The factory call itself is intentionally left in the output so the component
+ * remains exportable for cross-file consumption that falls back to the runtime
+ * path. Dead-code elimination at the bundler level can remove it when no
+ * runtime path remains.
+ *
+ * **Cross-file known limitations:**
+ * - Barrel re-exports are not resolved (import from index.ts re-exporting ./Button)
+ * - Aliased imports are not matched (`export { Btn as Button }` won't be found)
+ * - Dev-mode ordering: definition file may not yet be transformed when consumer runs
+ * All three degrade gracefully to the runtime path — no error, no broken output.
+ */
+
+type StaticComponent = {
+    readonly defaultTag: string;
+    readonly variantKeys: ReadonlySet<string>;
+    readonly precomputedClasses: Readonly<Record<string, string>>;
+};
+/**
+ * Walks the source file and extracts metadata for each same-file factory call
+ * that is eligible for static composition.
+ */
+declare function extractStaticComponents(source: ts.SourceFile, calleeNames: ReadonlySet<string>): Map<string, StaticComponent>;
+/**
+ * Applies the static composition transform to the given source file.
+ *
+ * `importedComponents` contains cross-file metadata resolved by the plugin
+ * registry — components defined in other files that were already transformed.
+ * When empty (dev mode ordering race or barrel re-export), same-file components
+ * still inline normally; cross-file sites fall through to the runtime path.
+ *
+ * Returns null when:
+ * - No eligible factory calls or imported components are present
+ * - No eligible usage sites are found after analysis
+ */
+declare function composeStatically(source: ts.SourceFile, calleeNames: ReadonlySet<string>, importedComponents?: ReadonlyMap<string, StaticComponent>): string | null;
+
+type ImportBinding = {
+    /** The exported name in the source module (the name before `as`, if any). */
+    readonly importedName: string;
+    /** The module specifier string (e.g. `'./Button'`). */
+    readonly specifier: string;
+};
+
 /**
  * Pure analysis entry point. Parses `code` as TypeScript/TSX, extracts
  * enforcement.children constraints from factory calls, and validates JSX usage
@@ -220,49 +288,6 @@ declare function buildPrecomputedClasses(stylingObj: ts.ObjectLiteralExpression)
  */
 declare function injectPrecomputedClasses(source: ts.SourceFile, calleeNames: ReadonlySet<string>): string | null;
 
-/**
- * Compile-time static composition transform.
- *
- * For same-file factory calls that have `precomputedClasses` injected (by
- * classExtractPlugin), replaces static JSX usage sites with direct element
- * creation — bypassing the runtime render pipeline entirely.
- *
- * Example:
- *   // Source (same file defines Button and uses it)
- *   const Button = createContractComponent({ tag: 'button', styling: { precomputedClasses: {...} } })
- *   <Button size="lg">Click</Button>
- *
- *   // Output
- *   const Button = createContractComponent({ ... }) // unchanged — still exported
- *   <button className="btn btn-lg">Click</button>  // inlined!
- *
- * **Eligibility conditions** — a usage site is inlined only when:
- *   1. The component is defined in the same file via a factory call with
- *      `precomputedClasses` (classExtractPlugin must run first in the chain)
- *   2. No `as`, `asChild`, `render`, or spread attributes at the usage site
- *   3. All variant props are static string literals
- *   4. `className` is absent or a static string literal
- *   5. The factory config has no top-level `defaults` and no `enforcement`
- *      (either would require runtime prop normalization that inlining skips)
- *
- * The factory call itself is intentionally left in the output so the component
- * remains exportable for cross-file consumption that falls back to the runtime
- * path. Dead-code elimination at the bundler level can remove it when no
- * runtime path remains.
- *
- * **Deferred:** cross-file inlining (component defined in one module, used in
- * another) requires Vite module-graph traversal and is not yet implemented.
- */
-
-/**
- * Applies the static composition transform to the given source file.
- *
- * Returns null when:
- * - No eligible factory calls are found in the file
- * - No eligible usage sites are found after analysis
- */
-declare function composeStatically(source: ts.SourceFile, calleeNames: ReadonlySet<string>): string | null;
-
 /**
  * Vite plugin that performs static enforcement.children cardinality checks at
  * build time for components created with createContractComponent.
@@ -345,23 +370,24 @@ declare function classExtractPlugin(options?: Pick<PluginOptions, 'calleeNames'>
  */
 declare function slotTransformPlugin(): Plugin;
 /**
- * Vite plugin that replaces same-file polymorphic component usage sites with
- * direct element creation at build time, eliminating the runtime render
- * pipeline for statically-analyzable usages.
+ * Vite plugin that replaces polymorphic component usage sites with direct
+ * element creation at build time, eliminating the runtime render pipeline for
+ * statically-analyzable usages.
  *
  * **Requires classExtractPlugin to run first** so that `precomputedClasses` is
  * present in the factory call before this plugin reads it. Place after
  * `classExtractPlugin` in the plugins array.
  *
  * A usage site is inlined when:
- * - The component is defined in the same file with `precomputedClasses` injected
+ * - The component is defined in the same file or imported from a file already
+ *   transformed by this plugin, with `precomputedClasses` injected
  * - No `as`, `asChild`, `render`, or spread attributes at the site
  * - All variant props are static string literals
  * - `className` is absent or a static string literal
  * - The factory config has no `defaults` or `enforcement`
  *
- * Sites that do not meet all conditions fall through to the normal runtime path
- * unchanged.
+ * Cross-file inlining degrades gracefully when the definition file has not yet
+ * been transformed (dev mode ordering, barrel re-exports, aliased imports).
  *
  * @example
  * // vite.config.ts
@@ -392,4 +418,4 @@ declare function staticCompositionPlugin(options?: Pick<PluginOptions, 'calleeNa
  */
 declare function ssrOptimizePlugin(options?: Pick<PluginOptions, 'calleeNames'>): Plugin[];
 
-export { type ComponentConstraint, type ComponentTokens, type DesignTokenManifest, type DesignTokensOptions, type Diagnostic, type PluginOptions, type StaticBound, analyze, buildManifest, buildPrecomputedClasses, classExtractPlugin, collectFileTokens, composeStatically, compoundPrunePlugin, contractPlugin, designTokensPlugin, injectPrecomputedClasses, pruneDeadCompounds, slotTransformPlugin, ssrOptimizePlugin, staticCompositionPlugin, transformAsChild };
+export { type ComponentConstraint, type ComponentTokens, type DesignTokenManifest, type DesignTokensOptions, type Diagnostic, type ImportBinding, type PluginOptions, type StaticBound, type StaticComponent, analyze, buildManifest, buildPrecomputedClasses, classExtractPlugin, collectFileTokens, composeStatically, compoundPrunePlugin, contractPlugin, designTokensPlugin, extractStaticComponents, injectPrecomputedClasses, pruneDeadCompounds, slotTransformPlugin, ssrOptimizePlugin, staticCompositionPlugin, transformAsChild };