@pandacss/transformer 2.0.0-beta.19 → 2.0.0-beta.20

package/dist/runtime/cx.d.ts

@@ -9,8 +9,8 @@ declare function splitClassName(className: string): string[];
 /** Merge key for one Panda atomic class token (conditions + property). */
 declare function getMergeKey(className: string, separator: string): string | null;
 /** Build a transform-time `cx` helper bound to the project separator. */
-declare function createCx(options?: CxOptions): (...parts: PandaClassPart[]) => string;
+declare function createCx(options?: CxOptions): (...args: PandaClassPart[]) => string;
 /** Default transform-time `cx` — mirrors styled-system naming with Panda merge semantics. */
-declare const cx: (...parts: PandaClassPart[]) => string;
+declare const cx: (...args: PandaClassPart[]) => string;
 
 export { type CxOptions, type CxSeparator, type PandaClassPart, createCx, cx, getMergeKey, splitClassName };

package/dist/runtime/cx.js

@@ -42,70 +42,199 @@ function getMergeKey(className, separator) {
   const propStart = lastColon + 1;
   const sepIdx = className.indexOf(separator, propStart);
   if (sepIdx < propStart + 1 || sepIdx >= end) return null;
-  const property = className.slice(propStart, sepIdx);
-  if (lastColon === -1) return property;
-  return `${className.slice(0, lastColon)}:${property}`;
+  return className.slice(0, sepIdx);
 }
-function flattenParts(parts, out) {
-  for (const part of parts) {
-    if (!part) continue;
-    if (Array.isArray(part)) {
-      flattenParts(part, out);
+var CACHE_LIMIT = 2048;
+var CHAR_SPACE = 32;
+var CHAR_BANG = 33;
+var FIELDS = 4;
+function createCache(limit = CACHE_LIMIT) {
+  let size = 0;
+  let current = /* @__PURE__ */ new Map();
+  let previous = /* @__PURE__ */ new Map();
+  const set = (key, value) => {
+    current.set(key, value);
+    if (++size > limit) {
+      size = 0;
+      previous = current;
+      current = /* @__PURE__ */ new Map();
+    }
+  };
+  return {
+    get(key) {
+      let value = current.get(key);
+      if (value === void 0 && (value = previous.get(key)) !== void 0) set(key, value);
+      return value;
+    },
+    set
+  };
+}
+function scanPart(part, separator, out, offset) {
+  let count = 0;
+  let clean = part.length > 0;
+  let start = 0;
+  for (let i = 0; i <= part.length; i++) {
+    const code = i === part.length ? CHAR_SPACE : part.charCodeAt(i);
+    if (code !== CHAR_SPACE && (code < 9 || code > 13)) continue;
+    if (code !== CHAR_SPACE || i === start) clean = false;
+    if (i === start) {
+      start = i + 1;
       continue;
     }
-    if (part === "") continue;
-    out.push(part);
+    const at = offset + count * FIELDS;
+    count++;
+    out[at] = start;
+    out[at + 1] = i;
+    out[at + 2] = -1;
+    let end = i;
+    if (part.charCodeAt(end - 1) === CHAR_BANG) end--;
+    let depth = 0;
+    let propStart = start;
+    for (let c = start; c < end; c++) {
+      const code2 = part.charCodeAt(c);
+      if (code2 === CHAR_OPEN_BRACKET) depth++;
+      else if (code2 === CHAR_CLOSE_BRACKET) depth--;
+      else if (code2 === CHAR_COLON && depth === 0) propStart = c + 1;
+    }
+    const sep = part.indexOf(separator, propStart);
+    if (sep > propStart && sep < end) {
+      let hash = 2166136261;
+      for (let c = start; c < sep; c++) hash = Math.imul(hash ^ part.charCodeAt(c), 16777619);
+      out[at + 2] = sep;
+      out[at + 3] = hash;
+    }
+    start = i + 1;
   }
+  return clean ? count : -count;
 }
-function mergeClassStrings(separator, classes) {
-  const seen = /* @__PURE__ */ new Map();
-  const order = [];
-  let id = 0;
-  for (const cls of classes) {
-    let tokenStart = 0;
-    for (let i = 0; i <= cls.length; i++) {
-      if (i !== cls.length && cls.charCodeAt(i) !== 32) continue;
-      if (i === tokenStart) {
-        tokenStart = i + 1;
-        continue;
+function createCx(options = {}) {
+  const separator = options.separator ?? bakedSeparator;
+  const scanned = createCache();
+  const seenOnce = createCache(512);
+  const parts = [];
+  let tokens = new Int32Array(64 * FIELDS);
+  let tokenPart = new Int32Array(64);
+  let winner = new Int32Array(64);
+  let tableSize = 128;
+  let table = new Int32Array(tableSize);
+  let stamps = new Int32Array(tableSize);
+  let stamp = 0;
+  function collect(value) {
+    if (!value) return;
+    if (typeof value === "string") parts.push(value);
+    else for (let i = 0; i < value.length; i++) collect(value[i]);
+  }
+  function reserve(tokenCount) {
+    if (tokenCount <= tokenPart.length) return;
+    let size = tokenPart.length;
+    while (size < tokenCount) size *= 2;
+    const grow = (from, length) => {
+      const next = new Int32Array(length);
+      next.set(from);
+      return next;
+    };
+    tokens = grow(tokens, size * FIELDS);
+    tokenPart = grow(tokenPart, size);
+    winner = grow(winner, size);
+  }
+  function sameKey(a, b) {
+    const aStart = tokens[a * FIELDS];
+    const bStart = tokens[b * FIELDS];
+    const length = tokens[a * FIELDS + 2] - aStart;
+    if (tokens[b * FIELDS + 2] - bStart !== length) return false;
+    const left = parts[tokenPart[a]];
+    const right = parts[tokenPart[b]];
+    for (let i = 0; i < length; i++) {
+      if (left.charCodeAt(aStart + i) !== right.charCodeAt(bStart + i)) return false;
+    }
+    return true;
+  }
+  function merge() {
+    let count = 0;
+    let clean = true;
+    for (let p = 0; p < parts.length; p++) {
+      const part = parts[p];
+      const cached = scanned.get(part);
+      let partCount;
+      if (cached !== void 0) {
+        partCount = cached[0];
+        reserve(count + Math.abs(partCount));
+        const base = count * FIELDS;
+        for (let i = 1; i < cached.length; i++) tokens[base + i - 1] = cached[i];
+      } else {
+        reserve(count + part.length);
+        partCount = scanPart(part, separator, tokens, count * FIELDS);
+        if (seenOnce.get(part) === void 0) seenOnce.set(part, true);
+        else {
+          const record = new Int32Array(1 + Math.abs(partCount) * FIELDS);
+          record[0] = partCount;
+          record.set(tokens.subarray(count * FIELDS, (count + Math.abs(partCount)) * FIELDS), 1);
+          scanned.set(part, record);
+        }
       }
-      const token = cls.slice(tokenStart, i);
-      tokenStart = i + 1;
-      const key = getMergeKey(token, separator);
-      if (key !== null) {
-        if (!seen.has(key)) order.push(key);
-        seen.set(key, token);
+      if (partCount <= 0) clean = false;
+      const end = count + Math.abs(partCount);
+      for (; count < end; count++) tokenPart[count] = p;
+    }
+    if (count * 2 > tableSize) {
+      while (count * 2 > tableSize) tableSize *= 2;
+      table = new Int32Array(tableSize);
+      stamps = new Int32Array(tableSize);
+      stamp = 0;
+    }
+    if (++stamp === 2147483647) {
+      stamp = 1;
+      stamps.fill(0);
+    }
+    const mask = tableSize - 1;
+    let replaced = false;
+    for (let t = 0; t < count; t++) {
+      winner[t] = t;
+      if (tokens[t * FIELDS + 2] < 0) continue;
+      const hash = tokens[t * FIELDS + 3];
+      let slot = hash & mask;
+      let owner = -1;
+      while (stamps[slot] === stamp) {
+        const candidate = table[slot];
+        if (tokens[candidate * FIELDS + 3] === hash && sameKey(candidate, t)) {
+          owner = candidate;
+          break;
+        }
+        slot = slot + 1 & mask;
+      }
+      if (owner === -1) {
+        stamps[slot] = stamp;
+        table[slot] = t;
       } else {
-        const uniqueKey = `__${id++}`;
-        order.push(uniqueKey);
-        seen.set(uniqueKey, token);
+        winner[owner] = t;
+        winner[t] = -1;
+        replaced = true;
       }
     }
-  }
-  if (order.length === 0) return "";
-  if (order.length === 1) return seen.get(order[0]);
-  let str = seen.get(order[0]);
-  for (let i = 1; i < order.length; i++) {
-    str += ` ${seen.get(order[i])}`;
-  }
-  return str;
-}
-function createCx(options = {}) {
-  const separator = options.separator ?? bakedSeparator;
-  return function cx2(...parts) {
-    if (parts.length === 1) {
-      const only = parts[0];
-      if (typeof only === "string") return only;
-      if (!only) return "";
+    if (!replaced && clean) {
+      let joined = parts[0];
+      for (let p = 1; p < parts.length; p++) joined += " " + parts[p];
+      return joined;
+    }
+    let result = "";
+    for (let t = 0; t < count; t++) {
+      const w = winner[t];
+      if (w === -1) continue;
+      const piece = parts[tokenPart[w]].slice(tokens[w * FIELDS], tokens[w * FIELDS + 1]);
+      result = result ? result + " " + piece : piece;
     }
-    const flat = [];
-    flattenParts(parts, flat);
-    if (flat.length === 0) return "";
-    if (flat.length === 1) return flat[0];
-    return mergeClassStrings(separator, flat);
+    return result;
+  }
+  return function cx2(...args) {
+    parts.length = 0;
+    for (let i = 0; i < args.length; i++) collect(args[i]);
+    const count = parts.length;
+    if (count === 0) return "";
+    if (count === 1) return parts[0];
+    return merge();
   };
 }
-var cx = createCx();
+var cx = /* @__PURE__ */ createCx();
 export {
   createCx,
   cx,

package/dist/runtime/internal.d.ts

@@ -1,65 +1,54 @@
 export { CxOptions, CxSeparator, PandaClassPart, createCx, cx, getMergeKey, splitClassName } from './cx.js';
+export { c as css } from '../css-BPeL3U6s.js';
 
-/** Transformed `css()` sites receive pre-encoded class strings only. */
-declare function css(...styles: string[]): string;
-
-type VariantMap = Record<string, Record<string, string>>;
 type VariantValue = string | number | boolean;
 type CompoundVariant = Record<string, unknown> & {
     css?: string;
     className?: string;
 };
 
-interface StringCvaConfig {
-    base?: string;
-    variants?: VariantMap;
+type Style = Record<string, unknown>;
+type Props$1 = Record<string, unknown>;
+interface RecipeConfig {
+    slots?: string[];
+    base?: Style;
+    variants?: Record<string, Record<string, Style>>;
     defaultVariants?: Record<string, VariantValue>;
     compoundVariants?: CompoundVariant[];
 }
-/** The shape `merge` needs from the other recipe — `cva()`'s own return satisfies it. */
-interface MergeableCva {
-    config: StringCvaConfig;
-    variantKeys: string[];
+/** The public surface of a styled-system `cva` that `merge` reads from its operand. */
+interface RecipeLike {
+    (props?: Props$1): string;
+    raw(props?: Props$1): Style;
+    variantKeys?: string[];
+    variantMap?: Record<string, string[]>;
+    config?: RecipeConfig;
 }
-/** String-branch recipe factory for transformed source (TW-style cva). */
-declare function cva(config: StringCvaConfig): ((props?: Record<string, unknown>) => string) & {
-    __cva__: true;
+/**
+ * Attach the observable recipe surface to a compiler-specialized `cva`/`sva` function.
+ * A `classNameMap` marks the function as a slot recipe.
+ */
+declare function attachRecipe<F extends (props?: Props$1) => any, C extends object>(fn: F, config: C, variantKeys: string[], variantMap: Record<string, string[]>, classNameMap?: Record<string, string>): F & {
+    config: C;
+    raw: (props?: Props$1) => any;
+    merge: (other: RecipeLike, cva?: (config: C) => {
+        merge(other: RecipeLike): unknown;
+    }) => unknown;
+    getVariantProps: (props?: Props$1) => Record<string, unknown>;
+    splitVariantProps: (props: Props$1) => readonly [Props$1, Props$1];
+    classNameMap?: Record<string, string> | undefined;
+    __cva__: boolean;
     variantKeys: string[];
     variantMap: Record<string, string[]>;
-    raw: (props?: Record<string, unknown>) => string;
-    merge: (other: MergeableCva) => ((props?: Record<string, unknown>) => string) & /*elided*/ any;
-    config: StringCvaConfig;
-    getVariantProps: (props: Record<string, unknown>) => Record<string, unknown>;
-    splitVariantProps: (props: Record<string, unknown>) => [Record<string, unknown>, Record<string, unknown>];
 };
 
-type SvaCompound = Record<string, unknown> & {
-    css?: Record<string, string> | string;
-    className?: string;
-    classNames?: Record<string, string>;
-};
-/** An option is one string for every slot, or a map of the slots it styles. */
-type SlotVariantMap = Record<string, Record<string, string | Record<string, string>>>;
-type SvaConfig = {
-    slots?: string[];
-    base?: Record<string, string>;
-    variants?: SlotVariantMap;
-    defaultVariants?: Record<string, VariantValue>;
-    compoundVariants?: SvaCompound[];
-    className?: Record<string, string>;
-};
-/** String-branch slot recipe factory for transformed source. */
-declare function sva(config: SvaConfig): ((props?: Record<string, unknown>) => Record<string, string>) & {
-    __cva__: false;
-    raw: (props?: Record<string, unknown>) => Record<string, string>;
-    config: SvaConfig;
-    variantMap: {
-        [k: string]: string[];
-    };
-    variantKeys: string[];
-    classNameMap: Record<string, string>;
-    getVariantProps: (props: Record<string, unknown>) => Record<string, unknown>;
-    splitVariantProps: (props: Record<string, unknown>) => [Record<string, unknown>, Record<string, unknown>];
-};
+type Props = Record<string, unknown>;
+type Resolve<T> = (props?: Props) => T;
+type Memoized<T> = (props?: Props | null) => T;
+/**
+ * Memoize a compiler-specialized recipe. `variantMap` lists every prop the function reads; the
+ * compiler only specializes recipes whose compounds select on declared variants.
+ */
+declare function memoRecipe<T>(resolve: Resolve<T>, variantMap: Record<string, string[]>, hasCompounds?: unknown): Memoized<T>;
 
-export { type StringCvaConfig, css, cva, sva };
+export { attachRecipe, memoRecipe };