@tenphi/tasty 0.0.0-snapshot.db103fd → 0.0.0-snapshot.dc62ea3

package/dist/hooks/useProperty.d.ts

@@ -1,79 +0,0 @@
-//#region src/hooks/useProperty.d.ts
-interface UsePropertyOptions {
-  /**
-   * CSS syntax string for the property (e.g., '<color>', '<length>', '<angle>').
-   * For color tokens (#name), this is auto-set to '<color>' and cannot be overridden.
-   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@property/syntax
-   */
-  syntax?: string;
-  /**
-   * Whether the property inherits from parent elements
-   * @default true
-   */
-  inherits?: boolean;
-  /**
-   * Initial value for the property.
-   * For color tokens (#name), this defaults to 'transparent' if not specified.
-   */
-  initialValue?: string | number;
-  /**
-   * Shadow root or document to inject into
-   */
-  root?: Document | ShadowRoot;
-}
-/**
- * Hook to register a CSS @property custom property.
- * This enables advanced features like animating custom properties.
- *
- * Note: @property rules are global and persistent once defined.
- * The hook ensures the property is only registered once per root.
- *
- * Accepts tasty token syntax for the property name:
- * - `$name` → defines `--name`
- * - `#name` → defines `--name-color` (auto-sets syntax: '<color>', defaults initialValue: 'transparent')
- * - `--name` → defines `--name` (legacy format)
- *
- * @param name - The property token ($name, #name) or CSS property name (--name)
- * @param options - Property configuration
- *
- * @example Basic property with token syntax
- * ```tsx
- * function Spinner() {
- *   useProperty('$rotation', {
- *     syntax: '<angle>',
- *     inherits: false,
- *     initialValue: '0deg',
- *   });
- *
- *   return <div className="spinner" />;
- * }
- * ```
- *
- * @example Color property with token syntax (auto-sets syntax)
- * ```tsx
- * function MyComponent() {
- *   useProperty('#theme', {
- *     initialValue: 'red', // syntax: '<color>' is auto-set
- *   });
- *
- *   // Now --theme-color can be animated with CSS transitions
- *   return <div style={{ '--theme-color': 'blue' } as React.CSSProperties}>Colored</div>;
- * }
- * ```
- *
- * @example Legacy format (still supported)
- * ```tsx
- * function ResizableBox() {
- *   useProperty('--box-size', {
- *     syntax: '<length>',
- *     initialValue: '100px',
- *   });
- *
- *   return <div style={{ width: 'var(--box-size)' }} />;
- * }
- * ```
- */
-declare function useProperty(name: string, options?: UsePropertyOptions): void;
-//#endregion
-export { UsePropertyOptions, useProperty };
-//# sourceMappingURL=useProperty.d.ts.map

package/dist/hooks/useProperty.js

@@ -1,109 +0,0 @@
-import { getGlobalInjector } from "../config.js";
-import { formatPropertyCSS } from "../ssr/format-property.js";
-import { resolveSSRCollector } from "./resolve-ssr-collector.js";
-import { TastySSRContext } from "../ssr/context.js";
-import { useContext, useInsertionEffect, useMemo } from "react";
-//#region src/hooks/useProperty.ts
-/**
-* Hook to register a CSS @property custom property.
-* This enables advanced features like animating custom properties.
-*
-* Note: @property rules are global and persistent once defined.
-* The hook ensures the property is only registered once per root.
-*
-* Accepts tasty token syntax for the property name:
-* - `$name` → defines `--name`
-* - `#name` → defines `--name-color` (auto-sets syntax: '<color>', defaults initialValue: 'transparent')
-* - `--name` → defines `--name` (legacy format)
-*
-* @param name - The property token ($name, #name) or CSS property name (--name)
-* @param options - Property configuration
-*
-* @example Basic property with token syntax
-* ```tsx
-* function Spinner() {
-*   useProperty('$rotation', {
-*     syntax: '<angle>',
-*     inherits: false,
-*     initialValue: '0deg',
-*   });
-*
-*   return <div className="spinner" />;
-* }
-* ```
-*
-* @example Color property with token syntax (auto-sets syntax)
-* ```tsx
-* function MyComponent() {
-*   useProperty('#theme', {
-*     initialValue: 'red', // syntax: '<color>' is auto-set
-*   });
-*
-*   // Now --theme-color can be animated with CSS transitions
-*   return <div style={{ '--theme-color': 'blue' } as React.CSSProperties}>Colored</div>;
-* }
-* ```
-*
-* @example Legacy format (still supported)
-* ```tsx
-* function ResizableBox() {
-*   useProperty('--box-size', {
-*     syntax: '<length>',
-*     initialValue: '100px',
-*   });
-*
-*   return <div style={{ width: 'var(--box-size)' }} />;
-* }
-* ```
-*/
-function useProperty(name, options) {
-	const ssrCollector = resolveSSRCollector(useContext(TastySSRContext));
-	const optionsKey = useMemo(() => {
-		if (!options) return "";
-		return JSON.stringify({
-			syntax: options.syntax,
-			inherits: options.inherits,
-			initialValue: options.initialValue
-		});
-	}, [
-		options?.syntax,
-		options?.inherits,
-		options?.initialValue
-	]);
-	useMemo(() => {
-		if (!ssrCollector || !name) return;
-		ssrCollector.collectInternals();
-		const css = formatPropertyCSS(name, {
-			syntax: options?.syntax,
-			inherits: options?.inherits,
-			initialValue: options?.initialValue
-		});
-		if (css) ssrCollector.collectProperty(name, css);
-	}, [
-		ssrCollector,
-		name,
-		optionsKey
-	]);
-	useInsertionEffect(() => {
-		if (!name) {
-			console.warn(`[Tasty] useProperty: property name is required`);
-			return;
-		}
-		const injector = getGlobalInjector();
-		if (injector.isPropertyDefined(name, { root: options?.root })) return;
-		injector.property(name, {
-			syntax: options?.syntax,
-			inherits: options?.inherits,
-			initialValue: options?.initialValue,
-			root: options?.root
-		});
-	}, [
-		name,
-		optionsKey,
-		options?.root
-	]);
-}
-//#endregion
-export { useProperty };
-
-//# sourceMappingURL=useProperty.js.map

package/dist/hooks/useProperty.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useProperty.js","names":[],"sources":["../../src/hooks/useProperty.ts"],"sourcesContent":["import { useContext, useInsertionEffect, useMemo } from 'react';\n\nimport { getGlobalInjector } from '../config';\nimport { resolveSSRCollector } from './resolve-ssr-collector';\nimport { TastySSRContext } from '../ssr/context';\nimport { formatPropertyCSS } from '../ssr/format-property';\n\nexport interface UsePropertyOptions {\n  /**\n   * CSS syntax string for the property (e.g., '<color>', '<length>', '<angle>').\n   * For color tokens (#name), this is auto-set to '<color>' and cannot be overridden.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@property/syntax\n   */\n  syntax?: string;\n  /**\n   * Whether the property inherits from parent elements\n   * @default true\n   */\n  inherits?: boolean;\n  /**\n   * Initial value for the property.\n   * For color tokens (#name), this defaults to 'transparent' if not specified.\n   */\n  initialValue?: string | number;\n  /**\n   * Shadow root or document to inject into\n   */\n  root?: Document | ShadowRoot;\n}\n\n/**\n * Hook to register a CSS @property custom property.\n * This enables advanced features like animating custom properties.\n *\n * Note: @property rules are global and persistent once defined.\n * The hook ensures the property is only registered once per root.\n *\n * Accepts tasty token syntax for the property name:\n * - `$name` → defines `--name`\n * - `#name` → defines `--name-color` (auto-sets syntax: '<color>', defaults initialValue: 'transparent')\n * - `--name` → defines `--name` (legacy format)\n *\n * @param name - The property token ($name, #name) or CSS property name (--name)\n * @param options - Property configuration\n *\n * @example Basic property with token syntax\n * ```tsx\n * function Spinner() {\n *   useProperty('$rotation', {\n *     syntax: '<angle>',\n *     inherits: false,\n *     initialValue: '0deg',\n *   });\n *\n *   return <div className=\"spinner\" />;\n * }\n * ```\n *\n * @example Color property with token syntax (auto-sets syntax)\n * ```tsx\n * function MyComponent() {\n *   useProperty('#theme', {\n *     initialValue: 'red', // syntax: '<color>' is auto-set\n *   });\n *\n *   // Now --theme-color can be animated with CSS transitions\n *   return <div style={{ '--theme-color': 'blue' } as React.CSSProperties}>Colored</div>;\n * }\n * ```\n *\n * @example Legacy format (still supported)\n * ```tsx\n * function ResizableBox() {\n *   useProperty('--box-size', {\n *     syntax: '<length>',\n *     initialValue: '100px',\n *   });\n *\n *   return <div style={{ width: 'var(--box-size)' }} />;\n * }\n * ```\n */\nexport function useProperty(name: string, options?: UsePropertyOptions): void {\n  const ssrContextValue = useContext(TastySSRContext);\n  const ssrCollector = resolveSSRCollector(ssrContextValue);\n\n  // Memoize the options to create a stable dependency\n  const optionsKey = useMemo(() => {\n    if (!options) return '';\n    return JSON.stringify({\n      syntax: options.syntax,\n      inherits: options.inherits,\n      initialValue: options.initialValue,\n    });\n  }, [options?.syntax, options?.inherits, options?.initialValue]);\n\n  // SSR path: collect @property CSS during render\n  useMemo(() => {\n    if (!ssrCollector || !name) return;\n\n    ssrCollector.collectInternals();\n\n    const css = formatPropertyCSS(name, {\n      syntax: options?.syntax,\n      inherits: options?.inherits,\n      initialValue: options?.initialValue,\n    });\n    if (css) {\n      ssrCollector.collectProperty(name, css);\n    }\n  }, [ssrCollector, name, optionsKey]);\n\n  // Client path: inject via DOM\n  useInsertionEffect(() => {\n    if (!name) {\n      if (process.env.NODE_ENV !== 'production') {\n        console.warn(`[Tasty] useProperty: property name is required`);\n      }\n      return;\n    }\n\n    const injector = getGlobalInjector();\n\n    if (injector.isPropertyDefined(name, { root: options?.root })) {\n      return;\n    }\n\n    injector.property(name, {\n      syntax: options?.syntax,\n      inherits: options?.inherits,\n      initialValue: options?.initialValue,\n      root: options?.root,\n    });\n  }, [name, optionsKey, options?.root]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,SAAgB,YAAY,MAAc,SAAoC;CAE5E,MAAM,eAAe,oBADG,WAAW,gBAAgB,CACM;CAGzD,MAAM,aAAa,cAAc;AAC/B,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,KAAK,UAAU;GACpB,QAAQ,QAAQ;GAChB,UAAU,QAAQ;GAClB,cAAc,QAAQ;GACvB,CAAC;IACD;EAAC,SAAS;EAAQ,SAAS;EAAU,SAAS;EAAa,CAAC;AAG/D,eAAc;AACZ,MAAI,CAAC,gBAAgB,CAAC,KAAM;AAE5B,eAAa,kBAAkB;EAE/B,MAAM,MAAM,kBAAkB,MAAM;GAClC,QAAQ,SAAS;GACjB,UAAU,SAAS;GACnB,cAAc,SAAS;GACxB,CAAC;AACF,MAAI,IACF,cAAa,gBAAgB,MAAM,IAAI;IAExC;EAAC;EAAc;EAAM;EAAW,CAAC;AAGpC,0BAAyB;AACvB,MAAI,CAAC,MAAM;AAEP,WAAQ,KAAK,iDAAiD;AAEhE;;EAGF,MAAM,WAAW,mBAAmB;AAEpC,MAAI,SAAS,kBAAkB,MAAM,EAAE,MAAM,SAAS,MAAM,CAAC,CAC3D;AAGF,WAAS,SAAS,MAAM;GACtB,QAAQ,SAAS;GACjB,UAAU,SAAS;GACnB,cAAc,SAAS;GACvB,MAAM,SAAS;GAChB,CAAC;IACD;EAAC;EAAM;EAAY,SAAS;EAAK,CAAC"}

package/dist/hooks/useRawCSS.d.ts

@@ -1,53 +0,0 @@
-//#region src/hooks/useRawCSS.d.ts
-interface UseRawCSSOptions {
-  root?: Document | ShadowRoot;
-}
-/**
- * Hook to inject raw CSS text directly without parsing.
- * This is a low-overhead alternative for injecting global CSS that doesn't need tasty processing.
- *
- * The CSS is inserted into a separate style element (data-tasty-raw) to avoid conflicts
- * with tasty's chunked style sheets.
- *
- * @example Static CSS string
- * ```tsx
- * function GlobalStyles() {
- *   useRawCSS(`
- *     body {
- *       margin: 0;
- *       padding: 0;
- *       font-family: sans-serif;
- *     }
- *   `);
- *
- *   return null;
- * }
- * ```
- *
- * @example Factory function with dependencies (like useMemo)
- * ```tsx
- * function ThemeStyles({ theme }: { theme: 'light' | 'dark' }) {
- *   useRawCSS(() => `
- *     :root {
- *       --bg-color: ${theme === 'dark' ? '#1a1a1a' : '#ffffff'};
- *       --text-color: ${theme === 'dark' ? '#ffffff' : '#1a1a1a'};
- *     }
- *   `, [theme]);
- *
- *   return null;
- * }
- * ```
- *
- * @example With options
- * ```tsx
- * function ShadowStyles({ shadowRoot }) {
- *   useRawCSS(() => `.scoped { color: red; }`, [], { root: shadowRoot });
- *   return null;
- * }
- * ```
- */
-declare function useRawCSS(css: string, options?: UseRawCSSOptions): void;
-declare function useRawCSS(factory: () => string, deps: readonly unknown[], options?: UseRawCSSOptions): void;
-//#endregion
-export { useRawCSS };
-//# sourceMappingURL=useRawCSS.d.ts.map

package/dist/hooks/useRawCSS.js

@@ -1,35 +0,0 @@
-import { injectRawCSS } from "../injector/index.js";
-import { resolveSSRCollector } from "./resolve-ssr-collector.js";
-import { TastySSRContext } from "../ssr/context.js";
-import { useContext, useInsertionEffect, useMemo, useRef } from "react";
-//#region src/hooks/useRawCSS.ts
-function useRawCSS(cssOrFactory, depsOrOptions, options) {
-	const ssrCollector = resolveSSRCollector(useContext(TastySSRContext));
-	const isFactory = typeof cssOrFactory === "function";
-	const deps = isFactory && Array.isArray(depsOrOptions) ? depsOrOptions : void 0;
-	const opts = isFactory ? options : depsOrOptions;
-	const css = useMemo(() => isFactory ? cssOrFactory() : cssOrFactory, isFactory ? deps ?? [] : [cssOrFactory]);
-	useMemo(() => {
-		if (!ssrCollector || !css.trim()) return;
-		const key = `raw:${css.length}:${css.slice(0, 64)}`;
-		ssrCollector.collectRawCSS(key, css);
-	}, [ssrCollector, css]);
-	const disposeRef = useRef(null);
-	useInsertionEffect(() => {
-		disposeRef.current?.();
-		if (!css.trim()) {
-			disposeRef.current = null;
-			return;
-		}
-		const { dispose } = injectRawCSS(css, opts);
-		disposeRef.current = dispose;
-		return () => {
-			disposeRef.current?.();
-			disposeRef.current = null;
-		};
-	}, [css, opts?.root]);
-}
-//#endregion
-export { useRawCSS };
-
-//# sourceMappingURL=useRawCSS.js.map

package/dist/hooks/useRawCSS.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useRawCSS.js","names":[],"sources":["../../src/hooks/useRawCSS.ts"],"sourcesContent":["import { useContext, useInsertionEffect, useMemo, useRef } from 'react';\n\nimport { injectRawCSS } from '../injector';\nimport { resolveSSRCollector } from './resolve-ssr-collector';\nimport { TastySSRContext } from '../ssr/context';\n\ninterface UseRawCSSOptions {\n  root?: Document | ShadowRoot;\n}\n\n/**\n * Hook to inject raw CSS text directly without parsing.\n * This is a low-overhead alternative for injecting global CSS that doesn't need tasty processing.\n *\n * The CSS is inserted into a separate style element (data-tasty-raw) to avoid conflicts\n * with tasty's chunked style sheets.\n *\n * @example Static CSS string\n * ```tsx\n * function GlobalStyles() {\n *   useRawCSS(`\n *     body {\n *       margin: 0;\n *       padding: 0;\n *       font-family: sans-serif;\n *     }\n *   `);\n *\n *   return null;\n * }\n * ```\n *\n * @example Factory function with dependencies (like useMemo)\n * ```tsx\n * function ThemeStyles({ theme }: { theme: 'light' | 'dark' }) {\n *   useRawCSS(() => `\n *     :root {\n *       --bg-color: ${theme === 'dark' ? '#1a1a1a' : '#ffffff'};\n *       --text-color: ${theme === 'dark' ? '#ffffff' : '#1a1a1a'};\n *     }\n *   `, [theme]);\n *\n *   return null;\n * }\n * ```\n *\n * @example With options\n * ```tsx\n * function ShadowStyles({ shadowRoot }) {\n *   useRawCSS(() => `.scoped { color: red; }`, [], { root: shadowRoot });\n *   return null;\n * }\n * ```\n */\n\n// Overload 1: Static CSS string\nexport function useRawCSS(css: string, options?: UseRawCSSOptions): void;\n\n// Overload 2: Factory function with dependencies\nexport function useRawCSS(\n  factory: () => string,\n  deps: readonly unknown[],\n  options?: UseRawCSSOptions,\n): void;\n\n// Implementation\nexport function useRawCSS(\n  cssOrFactory: string | (() => string),\n  depsOrOptions?: readonly unknown[] | UseRawCSSOptions,\n  options?: UseRawCSSOptions,\n): void {\n  const ssrContextValue = useContext(TastySSRContext);\n  const ssrCollector = resolveSSRCollector(ssrContextValue);\n\n  // Detect which overload is being used\n  const isFactory = typeof cssOrFactory === 'function';\n\n  // Parse arguments based on overload\n  const deps =\n    isFactory && Array.isArray(depsOrOptions) ? depsOrOptions : undefined;\n  const opts = isFactory\n    ? options\n    : (depsOrOptions as UseRawCSSOptions | undefined);\n\n  // Memoize CSS - for factory functions, use provided deps; for strings, use the string itself\n  const css = useMemo(\n    () =>\n      isFactory ? (cssOrFactory as () => string)() : (cssOrFactory as string),\n\n    isFactory ? (deps ?? []) : [cssOrFactory],\n  );\n\n  // SSR path: collect raw CSS during render\n  useMemo(() => {\n    if (!ssrCollector || !css.trim()) return;\n\n    const key = `raw:${css.length}:${css.slice(0, 64)}`;\n    ssrCollector.collectRawCSS(key, css);\n  }, [ssrCollector, css]);\n\n  const disposeRef = useRef<(() => void) | null>(null);\n\n  // Client path: inject via DOM\n  useInsertionEffect(() => {\n    disposeRef.current?.();\n\n    if (!css.trim()) {\n      disposeRef.current = null;\n      return;\n    }\n\n    const { dispose } = injectRawCSS(css, opts);\n    disposeRef.current = dispose;\n\n    return () => {\n      disposeRef.current?.();\n      disposeRef.current = null;\n    };\n  }, [css, opts?.root]);\n}\n"],"mappings":";;;;;AAkEA,SAAgB,UACd,cACA,eACA,SACM;CAEN,MAAM,eAAe,oBADG,WAAW,gBAAgB,CACM;CAGzD,MAAM,YAAY,OAAO,iBAAiB;CAG1C,MAAM,OACJ,aAAa,MAAM,QAAQ,cAAc,GAAG,gBAAgB,KAAA;CAC9D,MAAM,OAAO,YACT,UACC;CAGL,MAAM,MAAM,cAER,YAAa,cAA+B,GAAI,cAElD,YAAa,QAAQ,EAAE,GAAI,CAAC,aAAa,CAC1C;AAGD,eAAc;AACZ,MAAI,CAAC,gBAAgB,CAAC,IAAI,MAAM,CAAE;EAElC,MAAM,MAAM,OAAO,IAAI,OAAO,GAAG,IAAI,MAAM,GAAG,GAAG;AACjD,eAAa,cAAc,KAAK,IAAI;IACnC,CAAC,cAAc,IAAI,CAAC;CAEvB,MAAM,aAAa,OAA4B,KAAK;AAGpD,0BAAyB;AACvB,aAAW,WAAW;AAEtB,MAAI,CAAC,IAAI,MAAM,EAAE;AACf,cAAW,UAAU;AACrB;;EAGF,MAAM,EAAE,YAAY,aAAa,KAAK,KAAK;AAC3C,aAAW,UAAU;AAErB,eAAa;AACX,cAAW,WAAW;AACtB,cAAW,UAAU;;IAEtB,CAAC,KAAK,MAAM,KAAK,CAAC"}

package/dist/hooks/useStyles.d.ts

@@ -1,45 +0,0 @@
-import { Styles } from "../styles/types.js";
-
-//#region src/hooks/useStyles.d.ts
-/**
- * Tasty styles object to generate CSS classes for.
- * Can be undefined or empty object for no styles.
- */
-type UseStylesOptions = Styles | undefined;
-interface UseStylesResult {
-  /**
-   * Generated className(s) to apply to the element.
-   * Can be empty string if no styles are provided.
-   * With chunking enabled, may contain multiple space-separated class names.
-   */
-  className: string;
-}
-/**
- * Hook to generate CSS classes from Tasty styles.
- * Handles style rendering, className allocation, and CSS injection.
- *
- * SSR-aware: when a ServerStyleCollector is available (via React context
- * or AsyncLocalStorage), CSS is collected during the render phase instead
- * of being injected into the DOM. useInsertionEffect does not run on the
- * server, so the collector path is the only active path during SSR.
- *
- * Uses chunking to split styles into logical groups for better caching
- * and CSS reuse across components.
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { className } = useStyles({
- *     padding: '2x',
- *     fill: '#purple',
- *     radius: '1r',
- *   });
- *
- *   return <div className={className}>Styled content</div>;
- * }
- * ```
- */
-declare function useStyles(styles: UseStylesOptions): UseStylesResult;
-//#endregion
-export { UseStylesOptions, UseStylesResult, useStyles };
-//# sourceMappingURL=useStyles.d.ts.map

package/dist/hooks/useStyles.js

@@ -1,237 +0,0 @@
-import { extractLocalProperties, hasLocalProperties } from "../properties/index.js";
-import { stringifyStyles } from "../utils/styles.js";
-import { extractLocalFontFace, fontFaceContentHash, formatFontFaceRule, hasLocalFontFace } from "../font-face/index.js";
-import { extractLocalCounterStyle, formatCounterStyleRule, hasLocalCounterStyle } from "../counter-style/index.js";
-import { getConfig, getGlobalKeyframes, hasGlobalKeyframes } from "../config.js";
-import { categorizeStyleKeys } from "../chunks/definitions.js";
-import { generateChunkCacheKey } from "../chunks/cacheKey.js";
-import { renderStylesForChunk } from "../chunks/renderChunk.js";
-import { allocateClassName, counterStyle, fontFace, inject, keyframes, property } from "../injector/index.js";
-import { resolveRecipes } from "../utils/resolve-recipes.js";
-import { extractAnimationNamesFromStyles, extractLocalKeyframes, filterUsedKeyframes, hasLocalKeyframes, mergeKeyframes, replaceAnimationNames } from "../keyframes/index.js";
-import { formatPropertyCSS } from "../ssr/format-property.js";
-import { collectAutoInferredProperties } from "../ssr/collect-auto-properties.js";
-import { resolveSSRCollector } from "./resolve-ssr-collector.js";
-import { TastySSRContext } from "../ssr/context.js";
-import { formatKeyframesCSS } from "../ssr/format-keyframes.js";
-import { hasKeys } from "../utils/has-keys.js";
-import { useContext, useInsertionEffect, useMemo, useRef } from "react";
-//#region src/hooks/useStyles.ts
-/**
-* Render, cache-key, and allocate a className for a single chunk.
-* Returns a ProcessedChunk, or null if the chunk produces no CSS rules.
-*
-* Always runs the pipeline and calls allocateClassName. The inject()
-* call in useInsertionEffect handles all edge cases: placeholders from
-* abandoned concurrent renders, hydration hits (ruleIndex -2), and
-* runtime cache hits (already injected). The pipeline's own LRU cache
-* makes repeated calls for identical styles cheap.
-*/
-function processChunk(styles, chunkName, styleKeys) {
-	if (styleKeys.length === 0) return null;
-	const cacheKey = generateChunkCacheKey(styles, chunkName, styleKeys);
-	const renderResult = renderStylesForChunk(styles, chunkName, styleKeys, cacheKey);
-	if (renderResult.rules.length === 0) return null;
-	const { className } = allocateClassName(cacheKey);
-	return {
-		name: chunkName,
-		styleKeys,
-		cacheKey,
-		renderResult,
-		className
-	};
-}
-/**
-* Get keyframes that are actually used in styles.
-* Returns null if no keyframes are used (fast path for zero overhead).
-*
-* Optimization order:
-* 1. Check if any keyframes are defined (local or global) - if not, return null
-* 2. Extract animation names from styles - if none, return null
-* 3. Merge and filter keyframes to only used ones
-*/
-function getUsedKeyframes(styles) {
-	const hasLocal = hasLocalKeyframes(styles);
-	const hasGlobal = hasGlobalKeyframes();
-	if (!hasLocal && !hasGlobal) return null;
-	const usedNames = extractAnimationNamesFromStyles(styles);
-	if (usedNames.size === 0) return null;
-	return filterUsedKeyframes(mergeKeyframes(hasLocal ? extractLocalKeyframes(styles) : null, hasGlobal ? getGlobalKeyframes() : null), usedNames);
-}
-/**
-* Process a chunk on the SSR path: allocate via collector, render, collect CSS.
-* Returns null if the chunk produces no CSS rules.
-*/
-function processChunkSSR(collector, styles, chunkName, styleKeys) {
-	if (styleKeys.length === 0) return null;
-	const cacheKey = generateChunkCacheKey(styles, chunkName, styleKeys);
-	const { className, isNewAllocation } = collector.allocateClassName(cacheKey);
-	if (isNewAllocation) {
-		const renderResult = renderStylesForChunk(styles, chunkName, styleKeys);
-		if (renderResult.rules.length > 0) {
-			collector.collectChunk(cacheKey, className, renderResult.rules);
-			return {
-				name: chunkName,
-				styleKeys,
-				cacheKey,
-				renderResult,
-				className
-			};
-		}
-		return null;
-	}
-	return {
-		name: chunkName,
-		styleKeys,
-		cacheKey,
-		renderResult: { rules: [] },
-		className
-	};
-}
-/**
-* Hook to generate CSS classes from Tasty styles.
-* Handles style rendering, className allocation, and CSS injection.
-*
-* SSR-aware: when a ServerStyleCollector is available (via React context
-* or AsyncLocalStorage), CSS is collected during the render phase instead
-* of being injected into the DOM. useInsertionEffect does not run on the
-* server, so the collector path is the only active path during SSR.
-*
-* Uses chunking to split styles into logical groups for better caching
-* and CSS reuse across components.
-*
-* @example
-* ```tsx
-* function MyComponent() {
-*   const { className } = useStyles({
-*     padding: '2x',
-*     fill: '#purple',
-*     radius: '1r',
-*   });
-*
-*   return <div className={className}>Styled content</div>;
-* }
-* ```
-*/
-function useStyles(styles) {
-	const ssrCollector = resolveSSRCollector(useContext(TastySSRContext));
-	const disposeRef = useRef([]);
-	const stylesRef = useRef({
-		key: "",
-		styles: void 0
-	});
-	const resolvedStyles = useMemo(() => {
-		if (!styles) return styles;
-		return resolveRecipes(styles);
-	}, [styles]);
-	const styleKey = useMemo(() => {
-		if (!resolvedStyles || !hasKeys(resolvedStyles)) return "";
-		return stringifyStyles(resolvedStyles);
-	}, [resolvedStyles]);
-	if (stylesRef.current.key !== styleKey) stylesRef.current = {
-		key: styleKey,
-		styles: resolvedStyles
-	};
-	const processedChunks = useMemo(() => {
-		const currentStyles = stylesRef.current.styles;
-		if (!styleKey || !currentStyles) return [];
-		const chunkMap = categorizeStyleKeys(currentStyles);
-		const chunks = [];
-		if (ssrCollector) {
-			ssrCollector.collectInternals();
-			for (const [chunkName, chunkStyleKeys] of chunkMap) {
-				const chunk = processChunkSSR(ssrCollector, currentStyles, chunkName, chunkStyleKeys);
-				if (chunk) chunks.push(chunk);
-			}
-			const usedKeyframes = getUsedKeyframes(currentStyles);
-			if (usedKeyframes) for (const [name, steps] of Object.entries(usedKeyframes)) {
-				const css = formatKeyframesCSS(name, steps);
-				ssrCollector.collectKeyframes(name, css);
-			}
-			if (hasLocalProperties(currentStyles)) {
-				const localProperties = extractLocalProperties(currentStyles);
-				if (localProperties) for (const [token, definition] of Object.entries(localProperties)) {
-					const css = formatPropertyCSS(token, definition);
-					if (css) ssrCollector.collectProperty(token, css);
-				}
-			}
-			if (hasLocalFontFace(currentStyles)) {
-				const localFontFace = extractLocalFontFace(currentStyles);
-				if (localFontFace) for (const [family, input] of Object.entries(localFontFace)) {
-					const descriptors = Array.isArray(input) ? input : [input];
-					for (const desc of descriptors) {
-						const hash = fontFaceContentHash(family, desc);
-						const css = formatFontFaceRule(family, desc);
-						ssrCollector.collectFontFace(hash, css);
-					}
-				}
-			}
-			if (hasLocalCounterStyle(currentStyles)) {
-				const localCounterStyle = extractLocalCounterStyle(currentStyles);
-				if (localCounterStyle) for (const [name, descriptors] of Object.entries(localCounterStyle)) {
-					const css = formatCounterStyleRule(name, descriptors);
-					ssrCollector.collectCounterStyle(name, css);
-				}
-			}
-			if (getConfig().autoPropertyTypes !== false) {
-				const allRules = chunks.flatMap((c) => c.renderResult.rules);
-				if (allRules.length > 0) collectAutoInferredProperties(allRules, ssrCollector, currentStyles);
-			}
-		} else for (const [chunkName, chunkStyleKeys] of chunkMap) {
-			const chunk = processChunk(currentStyles, chunkName, chunkStyleKeys);
-			if (chunk) chunks.push(chunk);
-		}
-		return chunks;
-	}, [styleKey]);
-	useInsertionEffect(() => {
-		disposeRef.current.forEach((dispose) => dispose?.());
-		disposeRef.current = [];
-		if (processedChunks.length === 0) return;
-		const currentStyles = stylesRef.current.styles;
-		if (currentStyles && hasLocalProperties(currentStyles)) {
-			const localProperties = extractLocalProperties(currentStyles);
-			if (localProperties) for (const [token, definition] of Object.entries(localProperties)) property(token, definition);
-		}
-		if (currentStyles && hasLocalFontFace(currentStyles)) {
-			const localFontFace = extractLocalFontFace(currentStyles);
-			if (localFontFace) for (const [family, input] of Object.entries(localFontFace)) {
-				const descriptors = Array.isArray(input) ? input : [input];
-				for (const desc of descriptors) fontFace(family, desc);
-			}
-		}
-		if (currentStyles && hasLocalCounterStyle(currentStyles)) {
-			const localCounterStyle = extractLocalCounterStyle(currentStyles);
-			if (localCounterStyle) for (const [name, descriptors] of Object.entries(localCounterStyle)) counterStyle(name, descriptors);
-		}
-		const usedKeyframes = currentStyles ? getUsedKeyframes(currentStyles) : null;
-		let nameMap = null;
-		if (usedKeyframes) {
-			nameMap = /* @__PURE__ */ new Map();
-			for (const [name, steps] of Object.entries(usedKeyframes)) {
-				const result = keyframes(steps, { name });
-				const injectedName = result.toString();
-				if (injectedName !== name) nameMap.set(name, injectedName);
-				disposeRef.current.push(result.dispose);
-			}
-			if (nameMap.size === 0) nameMap = null;
-		}
-		for (const chunk of processedChunks) if (chunk.renderResult.rules.length > 0) {
-			const { dispose } = inject(nameMap ? chunk.renderResult.rules.map((rule) => ({
-				...rule,
-				declarations: replaceAnimationNames(rule.declarations, nameMap)
-			})) : chunk.renderResult.rules, { cacheKey: chunk.cacheKey });
-			disposeRef.current.push(dispose);
-		}
-		return () => {
-			disposeRef.current.forEach((dispose) => dispose?.());
-			disposeRef.current = [];
-		};
-	}, [processedChunks]);
-	return { className: useMemo(() => {
-		return processedChunks.map((chunk) => chunk.className).join(" ");
-	}, [processedChunks]) };
-}
-//#endregion
-export { useStyles };
-
-//# sourceMappingURL=useStyles.js.map

package/dist/hooks/useStyles.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useStyles.js","names":[],"sources":["../../src/hooks/useStyles.ts"],"sourcesContent":["import { useContext, useInsertionEffect, useMemo, useRef } from 'react';\n\nimport {\n  categorizeStyleKeys,\n  generateChunkCacheKey,\n  renderStylesForChunk,\n} from '../chunks';\nimport { getConfig, getGlobalKeyframes, hasGlobalKeyframes } from '../config';\nimport {\n  allocateClassName,\n  counterStyle,\n  fontFace,\n  inject,\n  keyframes,\n  property,\n} from '../injector';\nimport type { FontFaceDescriptors, KeyframesSteps } from '../injector/types';\nimport {\n  extractLocalCounterStyle,\n  formatCounterStyleRule,\n  hasLocalCounterStyle,\n} from '../counter-style';\nimport {\n  extractLocalFontFace,\n  fontFaceContentHash,\n  formatFontFaceRule,\n  hasLocalFontFace,\n} from '../font-face';\nimport {\n  extractAnimationNamesFromStyles,\n  extractLocalKeyframes,\n  filterUsedKeyframes,\n  hasLocalKeyframes,\n  mergeKeyframes,\n  replaceAnimationNames,\n} from '../keyframes';\nimport type { RenderResult } from '../pipeline';\nimport { extractLocalProperties, hasLocalProperties } from '../properties';\nimport { collectAutoInferredProperties } from '../ssr/collect-auto-properties';\nimport type { ServerStyleCollector } from '../ssr/collector';\nimport { resolveSSRCollector } from './resolve-ssr-collector';\nimport { TastySSRContext } from '../ssr/context';\nimport { formatKeyframesCSS } from '../ssr/format-keyframes';\nimport { formatPropertyCSS } from '../ssr/format-property';\nimport type { Styles } from '../styles/types';\nimport { hasKeys } from '../utils/has-keys';\nimport { resolveRecipes } from '../utils/resolve-recipes';\nimport { stringifyStyles } from '../utils/styles';\n\n/**\n * Tasty styles object to generate CSS classes for.\n * Can be undefined or empty object for no styles.\n */\nexport type UseStylesOptions = Styles | undefined;\n\nexport interface UseStylesResult {\n  /**\n   * Generated className(s) to apply to the element.\n   * Can be empty string if no styles are provided.\n   * With chunking enabled, may contain multiple space-separated class names.\n   */\n  className: string;\n}\n\n/**\n * Information about a processed chunk\n */\ninterface ProcessedChunk {\n  name: string;\n  styleKeys: string[];\n  cacheKey: string;\n  renderResult: RenderResult;\n  className: string;\n}\n\n/**\n * Render, cache-key, and allocate a className for a single chunk.\n * Returns a ProcessedChunk, or null if the chunk produces no CSS rules.\n *\n * Always runs the pipeline and calls allocateClassName. The inject()\n * call in useInsertionEffect handles all edge cases: placeholders from\n * abandoned concurrent renders, hydration hits (ruleIndex -2), and\n * runtime cache hits (already injected). The pipeline's own LRU cache\n * makes repeated calls for identical styles cheap.\n */\nfunction processChunk(\n  styles: Styles,\n  chunkName: string,\n  styleKeys: string[],\n): ProcessedChunk | null {\n  if (styleKeys.length === 0) return null;\n\n  const cacheKey = generateChunkCacheKey(styles, chunkName, styleKeys);\n  const renderResult = renderStylesForChunk(\n    styles,\n    chunkName,\n    styleKeys,\n    cacheKey,\n  );\n  if (renderResult.rules.length === 0) return null;\n\n  const { className } = allocateClassName(cacheKey);\n\n  return { name: chunkName, styleKeys, cacheKey, renderResult, className };\n}\n\n/**\n * Get keyframes that are actually used in styles.\n * Returns null if no keyframes are used (fast path for zero overhead).\n *\n * Optimization order:\n * 1. Check if any keyframes are defined (local or global) - if not, return null\n * 2. Extract animation names from styles - if none, return null\n * 3. Merge and filter keyframes to only used ones\n */\nfunction getUsedKeyframes(\n  styles: Styles,\n): Record<string, KeyframesSteps> | null {\n  // Fast path: no keyframes defined anywhere\n  const hasLocal = hasLocalKeyframes(styles);\n  const hasGlobal = hasGlobalKeyframes();\n  if (!hasLocal && !hasGlobal) return null;\n\n  // Extract animation names from styles (not from rendered CSS - faster)\n  const usedNames = extractAnimationNamesFromStyles(styles);\n  if (usedNames.size === 0) return null;\n\n  // Merge local and global keyframes\n  const local = hasLocal ? extractLocalKeyframes(styles) : null;\n  const global = hasGlobal ? getGlobalKeyframes() : null;\n  const allKeyframes = mergeKeyframes(local, global);\n\n  // Filter to only used keyframes\n  return filterUsedKeyframes(allKeyframes, usedNames);\n}\n\n/**\n * Process a chunk on the SSR path: allocate via collector, render, collect CSS.\n * Returns null if the chunk produces no CSS rules.\n */\nfunction processChunkSSR(\n  collector: ServerStyleCollector,\n  styles: Styles,\n  chunkName: string,\n  styleKeys: string[],\n): ProcessedChunk | null {\n  if (styleKeys.length === 0) return null;\n\n  const cacheKey = generateChunkCacheKey(styles, chunkName, styleKeys);\n  const { className, isNewAllocation } = collector.allocateClassName(cacheKey);\n\n  if (isNewAllocation) {\n    const renderResult = renderStylesForChunk(styles, chunkName, styleKeys);\n    if (renderResult.rules.length > 0) {\n      collector.collectChunk(cacheKey, className, renderResult.rules);\n      return {\n        name: chunkName,\n        styleKeys,\n        cacheKey,\n        renderResult,\n        className,\n      };\n    }\n    return null;\n  }\n\n  return {\n    name: chunkName,\n    styleKeys,\n    cacheKey,\n    renderResult: { rules: [] },\n    className,\n  };\n}\n\n/**\n * Hook to generate CSS classes from Tasty styles.\n * Handles style rendering, className allocation, and CSS injection.\n *\n * SSR-aware: when a ServerStyleCollector is available (via React context\n * or AsyncLocalStorage), CSS is collected during the render phase instead\n * of being injected into the DOM. useInsertionEffect does not run on the\n * server, so the collector path is the only active path during SSR.\n *\n * Uses chunking to split styles into logical groups for better caching\n * and CSS reuse across components.\n *\n * @example\n * ```tsx\n * function MyComponent() {\n *   const { className } = useStyles({\n *     padding: '2x',\n *     fill: '#purple',\n *     radius: '1r',\n *   });\n *\n *   return <div className={className}>Styled content</div>;\n * }\n * ```\n */\nexport function useStyles(styles: UseStylesOptions): UseStylesResult {\n  const ssrContextValue = useContext(TastySSRContext);\n  const ssrCollector = resolveSSRCollector(ssrContextValue);\n\n  // Array of dispose functions for each chunk\n  const disposeRef = useRef<(() => void)[]>([]);\n\n  // Store styles by their stringified key to avoid recomputing when only reference changes\n  const stylesRef = useRef<{ key: string; styles: Styles | undefined }>({\n    key: '',\n    styles: undefined,\n  });\n\n  // Resolve recipes before any processing (zero overhead if no recipes configured)\n  const resolvedStyles = useMemo(() => {\n    if (!styles) return styles;\n    return resolveRecipes(styles);\n  }, [styles]);\n\n  // Compute style key - this is a primitive string that captures style content\n  const styleKey = useMemo(() => {\n    if (!resolvedStyles || !hasKeys(resolvedStyles)) {\n      return '';\n    }\n    return stringifyStyles(resolvedStyles);\n  }, [resolvedStyles]);\n\n  // Update ref when styleKey changes (content actually changed)\n  if (stylesRef.current.key !== styleKey) {\n    stylesRef.current = { key: styleKey, styles: resolvedStyles };\n  }\n\n  // Process chunks: categorize, generate cache keys, render, and allocate classNames\n  // Only depends on styleKey (primitive), not styles object reference\n  const processedChunks: ProcessedChunk[] = useMemo(() => {\n    const currentStyles = stylesRef.current.styles;\n    if (!styleKey || !currentStyles) {\n      return [];\n    }\n\n    // Categorize style keys into chunks\n    const chunkMap = categorizeStyleKeys(\n      currentStyles as Record<string, unknown>,\n    );\n\n    const chunks: ProcessedChunk[] = [];\n\n    if (ssrCollector) {\n      // Ensure internal @property and :root token CSS is included\n      ssrCollector.collectInternals();\n\n      // SERVER PATH: allocate via collector, collect CSS\n      for (const [chunkName, chunkStyleKeys] of chunkMap) {\n        const chunk = processChunkSSR(\n          ssrCollector,\n          currentStyles,\n          chunkName,\n          chunkStyleKeys,\n        );\n        if (chunk) chunks.push(chunk);\n      }\n\n      // Collect keyframes on the server\n      const usedKeyframes = getUsedKeyframes(currentStyles);\n      if (usedKeyframes) {\n        for (const [name, steps] of Object.entries(usedKeyframes)) {\n          const css = formatKeyframesCSS(name, steps);\n          ssrCollector.collectKeyframes(name, css);\n        }\n      }\n\n      // Collect explicit @property rules on the server\n      if (hasLocalProperties(currentStyles)) {\n        const localProperties = extractLocalProperties(currentStyles);\n        if (localProperties) {\n          for (const [token, definition] of Object.entries(localProperties)) {\n            const css = formatPropertyCSS(token, definition);\n            if (css) {\n              ssrCollector.collectProperty(token, css);\n            }\n          }\n        }\n      }\n\n      // Collect @font-face rules on the server\n      if (hasLocalFontFace(currentStyles)) {\n        const localFontFace = extractLocalFontFace(currentStyles);\n        if (localFontFace) {\n          for (const [family, input] of Object.entries(localFontFace)) {\n            const descriptors: FontFaceDescriptors[] = Array.isArray(input)\n              ? input\n              : [input];\n            for (const desc of descriptors) {\n              const hash = fontFaceContentHash(family, desc);\n              const css = formatFontFaceRule(family, desc);\n              ssrCollector.collectFontFace(hash, css);\n            }\n          }\n        }\n      }\n\n      // Collect @counter-style rules on the server\n      if (hasLocalCounterStyle(currentStyles)) {\n        const localCounterStyle = extractLocalCounterStyle(currentStyles);\n        if (localCounterStyle) {\n          for (const [name, descriptors] of Object.entries(localCounterStyle)) {\n            const css = formatCounterStyleRule(name, descriptors);\n            ssrCollector.collectCounterStyle(name, css);\n          }\n        }\n      }\n\n      // Auto-infer @property types from rendered declarations (SSR).\n      // On the client this happens inside StyleInjector.inject(), which\n      // runs in useInsertionEffect and therefore never executes on the server.\n      if (getConfig().autoPropertyTypes !== false) {\n        const allRules = chunks.flatMap((c) => c.renderResult.rules);\n        if (allRules.length > 0) {\n          collectAutoInferredProperties(allRules, ssrCollector, currentStyles);\n        }\n      }\n    } else {\n      // CLIENT PATH: unchanged behavior\n      for (const [chunkName, chunkStyleKeys] of chunkMap) {\n        const chunk = processChunk(currentStyles, chunkName, chunkStyleKeys);\n        if (chunk) chunks.push(chunk);\n      }\n    }\n\n    return chunks;\n  }, [styleKey]);\n\n  // Inject styles in insertion effect (avoids render phase side effects).\n  // Does NOT run on the server — the SSR path above handles collection.\n  useInsertionEffect(() => {\n    // Cleanup all previous disposals\n    disposeRef.current.forEach((dispose) => dispose?.());\n    disposeRef.current = [];\n\n    // Fast path: no chunks to inject\n    if (processedChunks.length === 0) {\n      return;\n    }\n\n    const currentStyles = stylesRef.current.styles;\n\n    // Register explicit @properties first so they take precedence over auto-inference\n    // that happens during keyframe and style chunk injection.\n    // Token formats: $name → --name, #name → --name-color (with auto syntax: '<color>')\n    // Note: Global properties are injected once when styles are first generated (see markStylesGenerated)\n    if (currentStyles && hasLocalProperties(currentStyles)) {\n      const localProperties = extractLocalProperties(currentStyles);\n      if (localProperties) {\n        for (const [token, definition] of Object.entries(localProperties)) {\n          property(token, definition);\n        }\n      }\n    }\n\n    // Inject @font-face rules (permanent, no cleanup needed)\n    if (currentStyles && hasLocalFontFace(currentStyles)) {\n      const localFontFace = extractLocalFontFace(currentStyles);\n      if (localFontFace) {\n        for (const [family, input] of Object.entries(localFontFace)) {\n          const descriptors: FontFaceDescriptors[] = Array.isArray(input)\n            ? input\n            : [input];\n          for (const desc of descriptors) {\n            fontFace(family, desc);\n          }\n        }\n      }\n    }\n\n    // Inject @counter-style rules (permanent, no cleanup needed)\n    if (currentStyles && hasLocalCounterStyle(currentStyles)) {\n      const localCounterStyle = extractLocalCounterStyle(currentStyles);\n      if (localCounterStyle) {\n        for (const [name, descriptors] of Object.entries(localCounterStyle)) {\n          counterStyle(name, descriptors);\n        }\n      }\n    }\n\n    // Get keyframes that are actually used (returns null if none - zero overhead)\n    const usedKeyframes = currentStyles\n      ? getUsedKeyframes(currentStyles)\n      : null;\n\n    // Inject keyframes and build name map (only if we have keyframes)\n    let nameMap: Map<string, string> | null = null;\n\n    if (usedKeyframes) {\n      nameMap = new Map();\n      for (const [name, steps] of Object.entries(usedKeyframes)) {\n        const result = keyframes(steps, { name });\n        const injectedName = result.toString();\n        // Only add to map if name differs (optimization for replacement check)\n        if (injectedName !== name) {\n          nameMap.set(name, injectedName);\n        }\n        disposeRef.current.push(result.dispose);\n      }\n      // Clear map if no replacements needed\n      if (nameMap.size === 0) {\n        nameMap = null;\n      }\n    }\n\n    // Inject each chunk\n    for (const chunk of processedChunks) {\n      if (chunk.renderResult.rules.length > 0) {\n        // Replace animation names only if needed\n        const rulesToInject = nameMap\n          ? chunk.renderResult.rules.map((rule) => ({\n              ...rule,\n              declarations: replaceAnimationNames(rule.declarations, nameMap!),\n            }))\n          : chunk.renderResult.rules;\n\n        const { dispose } = inject(rulesToInject, {\n          cacheKey: chunk.cacheKey,\n        });\n        disposeRef.current.push(dispose);\n      }\n    }\n\n    return () => {\n      disposeRef.current.forEach((dispose) => dispose?.());\n      disposeRef.current = [];\n    };\n  }, [processedChunks]);\n\n  // Combine all chunk classNames\n  const className = useMemo(() => {\n    return processedChunks.map((chunk) => chunk.className).join(' ');\n  }, [processedChunks]);\n\n  return {\n    className,\n  };\n}\n"],"mappings":"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"}