@tenphi/tasty 0.0.0-snapshot.c8bdaeb → 0.0.0-snapshot.c8c7b2a

package/dist/compute-styles.js

@@ -0,0 +1,322 @@
+import { extractLocalProperties, hasLocalProperties } from "./properties/index.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 { counterStyle, fontFace, inject, keyframes, property, touch } from "./injector/index.js";
+import { extractAnimationNamesFromStyles, extractLocalKeyframes, filterUsedKeyframes, hasLocalKeyframes, mergeKeyframes, replaceAnimationNames } from "./keyframes/index.js";
+import { getRegisteredSSRCollector } from "./ssr/ssr-collector-ref.js";
+import { flushPendingCSS, getRSCCache, rscAllocateClassName } from "./rsc-cache.js";
+import { formatPropertyCSS } from "./ssr/format-property.js";
+import { collectAutoInferredProperties } from "./ssr/collect-auto-properties.js";
+import { formatKeyframesCSS } from "./ssr/format-keyframes.js";
+import { formatRules } from "./ssr/format-rules.js";
+import { hasKeys } from "./utils/has-keys.js";
+import { resolveRecipes } from "./utils/resolve-recipes.js";
+//#region src/compute-styles.ts
+/**
+* Hook-free, synchronous style computation.
+*
+* Extracts the core logic from useStyles() into a plain function that can
+* be called during React render without any hooks. Three code paths:
+*
+* 1. SSR collector — styles collected via ServerStyleCollector
+* 2. Client inject — styles injected synchronously into the DOM
+* 3. RSC inline — styles returned as CSS strings for inline <style> emission
+*
+* This enables tasty() components to work as React Server Components.
+*/
+const EMPTY_RESULT = { className: "" };
+/**
+* Mark internals as emitted for this RSC request.
+*
+* Internals (tokens, @property, @font-face, @counter-style) are emitted
+* exclusively by the SSR collector via ServerStyleCollector.collectInternals().
+* The SSR path is reliable because TastyRegistry is always present as a
+* client component in the root layout, guaranteeing SSR runs for every page.
+*
+* Previously this function also emitted internals and coordinated with SSR
+* via a globalThis flag, but that flag leaked across requests in the same
+* Node.js process, causing pages without RSC-rendered tasty components
+* (e.g. the playground route) to lose all token CSS.
+*/
+function collectInternalsRSC(rscCache) {
+	if (rscCache.internalsEmitted) return "";
+	rscCache.internalsEmitted = true;
+	return "";
+}
+/**
+* Collect per-component ancillary CSS (keyframes, @property, font-face,
+* counter-style) for RSC mode.
+*/
+function collectAncillaryRSC(rscCache, styles) {
+	const parts = [];
+	const usedKf = getUsedKeyframes(styles);
+	if (usedKf) for (const [name, steps] of Object.entries(usedKf)) {
+		const key = `__kf:${name}:${JSON.stringify(steps)}`;
+		if (!rscCache.emittedKeys.has(key)) {
+			rscCache.emittedKeys.add(key);
+			parts.push(formatKeyframesCSS(name, steps));
+		}
+	}
+	if (hasLocalProperties(styles)) {
+		const localProperties = extractLocalProperties(styles);
+		if (localProperties) for (const [token, definition] of Object.entries(localProperties)) {
+			const key = `__prop:${token}`;
+			if (!rscCache.emittedKeys.has(key)) {
+				rscCache.emittedKeys.add(key);
+				const css = formatPropertyCSS(token, definition);
+				if (css) parts.push(css);
+			}
+		}
+	}
+	if (hasLocalFontFace(styles)) {
+		const localFontFace = extractLocalFontFace(styles);
+		if (localFontFace) for (const [family, input] of Object.entries(localFontFace)) {
+			const descriptors = Array.isArray(input) ? input : [input];
+			for (const desc of descriptors) {
+				const key = `__ff:${fontFaceContentHash(family, desc)}`;
+				if (!rscCache.emittedKeys.has(key)) {
+					rscCache.emittedKeys.add(key);
+					parts.push(formatFontFaceRule(family, desc));
+				}
+			}
+		}
+	}
+	if (hasLocalCounterStyle(styles)) {
+		const localCounterStyle = extractLocalCounterStyle(styles);
+		if (localCounterStyle) for (const [name, descriptors] of Object.entries(localCounterStyle)) {
+			const key = `__cs:${name}:${JSON.stringify(descriptors)}`;
+			if (!rscCache.emittedKeys.has(key)) {
+				rscCache.emittedKeys.add(key);
+				parts.push(formatCounterStyleRule(name, descriptors));
+			}
+		}
+	}
+	return parts.join("\n");
+}
+/**
+* Process all chunks in RSC mode: render CSS to strings, allocate classNames,
+* and return combined { className, css }.
+*/
+function computeStylesRSC(styles, chunkMap) {
+	const rscCache = getRSCCache();
+	const cssParts = [];
+	const classNames = [];
+	const pendingCSS = flushPendingCSS(rscCache);
+	if (pendingCSS) cssParts.push(pendingCSS);
+	const internalsCSS = collectInternalsRSC(rscCache);
+	if (internalsCSS) cssParts.push(internalsCSS);
+	for (const [chunkName, chunkStyleKeys] of chunkMap) {
+		if (chunkStyleKeys.length === 0) continue;
+		const { className, isNew } = rscAllocateClassName(rscCache, generateChunkCacheKey(styles, chunkName, chunkStyleKeys));
+		classNames.push(className);
+		if (isNew) {
+			const renderResult = renderStylesForChunk(styles, chunkName, chunkStyleKeys);
+			if (renderResult.rules.length > 0) {
+				const css = formatRules(renderResult.rules, className);
+				if (css) cssParts.push(css);
+			}
+		}
+	}
+	const ancillaryCSS = collectAncillaryRSC(rscCache, styles);
+	if (ancillaryCSS) cssParts.push(ancillaryCSS);
+	if (classNames.length === 0) return EMPTY_RESULT;
+	const css = cssParts.join("\n");
+	return {
+		className: classNames.join(" "),
+		css: css || void 0
+	};
+}
+/**
+* Get keyframes that are actually used in styles.
+* Returns null if no keyframes are used (fast path for zero overhead).
+*/
+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.
+*/
+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
+	};
+}
+/**
+* Process a chunk on the client: render, allocate className, and inject
+* CSS synchronously. The injector's cache makes this idempotent.
+*/
+function processChunkSync(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 } = inject(renderResult.rules, { cacheKey });
+	return {
+		name: chunkName,
+		styleKeys,
+		cacheKey,
+		renderResult,
+		className
+	};
+}
+/**
+* Inject keyframes synchronously and return a name replacement map.
+* On the client, keyframes are injected into the DOM.
+*/
+function injectKeyframesSync(usedKeyframes) {
+	let nameMap = null;
+	for (const [name, steps] of Object.entries(usedKeyframes)) {
+		const injectedName = keyframes(steps, { name }).toString();
+		if (injectedName !== name) {
+			if (!nameMap) nameMap = /* @__PURE__ */ new Map();
+			nameMap.set(name, injectedName);
+		}
+	}
+	return nameMap;
+}
+/**
+* Inject chunk rules synchronously, replacing animation names if needed.
+*/
+function injectChunkRulesSync(chunks, nameMap) {
+	for (const chunk of chunks) if (chunk.renderResult.rules.length > 0) inject(nameMap ? chunk.renderResult.rules.map((rule) => ({
+		...rule,
+		declarations: replaceAnimationNames(rule.declarations, nameMap)
+	})) : chunk.renderResult.rules, { cacheKey: chunk.cacheKey });
+}
+/**
+* Inject all ancillary rules (properties, font-faces, counter-styles) synchronously.
+*/
+function injectAncillarySync(styles) {
+	if (hasLocalProperties(styles)) {
+		const localProperties = extractLocalProperties(styles);
+		if (localProperties) for (const [token, definition] of Object.entries(localProperties)) property(token, definition);
+	}
+	if (hasLocalFontFace(styles)) {
+		const localFontFace = extractLocalFontFace(styles);
+		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 (hasLocalCounterStyle(styles)) {
+		const localCounterStyle = extractLocalCounterStyle(styles);
+		if (localCounterStyle) for (const [name, descriptors] of Object.entries(localCounterStyle)) counterStyle(name, descriptors);
+	}
+}
+/**
+* Collect all ancillary rules into the SSR collector.
+*/
+function collectAncillarySSR(collector, styles, chunks) {
+	const usedKf = getUsedKeyframes(styles);
+	if (usedKf) for (const [name, steps] of Object.entries(usedKf)) {
+		const css = formatKeyframesCSS(name, steps);
+		collector.collectKeyframes(name, css);
+	}
+	if (hasLocalProperties(styles)) {
+		const localProperties = extractLocalProperties(styles);
+		if (localProperties) for (const [token, definition] of Object.entries(localProperties)) {
+			const css = formatPropertyCSS(token, definition);
+			if (css) collector.collectProperty(token, css);
+		}
+	}
+	if (hasLocalFontFace(styles)) {
+		const localFontFace = extractLocalFontFace(styles);
+		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);
+				collector.collectFontFace(hash, css);
+			}
+		}
+	}
+	if (hasLocalCounterStyle(styles)) {
+		const localCounterStyle = extractLocalCounterStyle(styles);
+		if (localCounterStyle) for (const [name, descriptors] of Object.entries(localCounterStyle)) {
+			const css = formatCounterStyleRule(name, descriptors);
+			collector.collectCounterStyle(name, css);
+		}
+	}
+	if (getConfig().autoPropertyTypes !== false) {
+		const allRules = chunks.flatMap((c) => c.renderResult.rules);
+		if (allRules.length > 0) collectAutoInferredProperties(allRules, collector, styles);
+	}
+}
+/**
+* Synchronous, hook-free style computation.
+*
+* Resolves recipes, categorizes style keys into chunks, renders CSS rules,
+* allocates class names, and injects / collects / returns the CSS.
+*
+* Three code paths:
+* 1. SSR collector — discovered via ALS or passed explicitly; CSS collected
+* 2. RSC inline — no collector and no `document`; CSS returned as `result.css`
+*    for the caller to emit as an inline `<style>` tag
+* 3. Client inject — CSS injected synchronously into the DOM (idempotent)
+*
+* @param styles - Tasty styles object (or undefined for no styles)
+* @param options - Optional SSR collector override
+*/
+function computeStyles(styles, options) {
+	if (!styles || !hasKeys(styles)) return EMPTY_RESULT;
+	const resolved = resolveRecipes(styles);
+	const chunkMap = categorizeStyleKeys(resolved);
+	const collector = options?.ssrCollector !== void 0 ? options.ssrCollector : getRegisteredSSRCollector();
+	const chunks = [];
+	if (collector) {
+		collector.collectInternals();
+		for (const [chunkName, chunkStyleKeys] of chunkMap) {
+			const chunk = processChunkSSR(collector, resolved, chunkName, chunkStyleKeys);
+			if (chunk) chunks.push(chunk);
+		}
+		collectAncillarySSR(collector, resolved, chunks);
+	} else if (typeof document === "undefined") return computeStylesRSC(resolved, chunkMap);
+	else {
+		injectAncillarySync(resolved);
+		const usedKf = getUsedKeyframes(resolved);
+		const nameMap = usedKf ? injectKeyframesSync(usedKf) : null;
+		for (const [chunkName, chunkStyleKeys] of chunkMap) {
+			const chunk = processChunkSync(resolved, chunkName, chunkStyleKeys);
+			if (chunk) chunks.push(chunk);
+		}
+		if (nameMap) injectChunkRulesSync(chunks, nameMap);
+		for (const chunk of chunks) touch(chunk.className);
+	}
+	if (chunks.length === 0) return EMPTY_RESULT;
+	if (chunks.length === 1) return { className: chunks[0].className };
+	return { className: chunks.map((c) => c.className).join(" ") };
+}
+//#endregion
+export { computeStyles };
+
+//# sourceMappingURL=compute-styles.js.map

package/dist/compute-styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-styles.js","names":[],"sources":["../src/compute-styles.ts"],"sourcesContent":["/**\n * Hook-free, synchronous style computation.\n *\n * Extracts the core logic from useStyles() into a plain function that can\n * be called during React render without any hooks. Three code paths:\n *\n * 1. SSR collector — styles collected via ServerStyleCollector\n * 2. Client inject — styles injected synchronously into the DOM\n * 3. RSC inline — styles returned as CSS strings for inline <style> emission\n *\n * This enables tasty() components to work as React Server Components.\n */\n\nimport {\n  categorizeStyleKeys,\n  generateChunkCacheKey,\n  renderStylesForChunk,\n} from './chunks';\nimport { getConfig, getGlobalKeyframes, hasGlobalKeyframes } from './config';\nimport {\n  counterStyle,\n  fontFace,\n  inject,\n  keyframes,\n  property,\n  touch,\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, StyleResult } from './pipeline';\nimport {\n  flushPendingCSS,\n  getRSCCache,\n  rscAllocateClassName,\n} from './rsc-cache';\nimport type { RSCStyleCache } from './rsc-cache';\nimport { extractLocalProperties, hasLocalProperties } from './properties';\nimport { collectAutoInferredProperties } from './ssr/collect-auto-properties';\nimport type { ServerStyleCollector } from './ssr/collector';\nimport { formatKeyframesCSS } from './ssr/format-keyframes';\nimport { formatPropertyCSS } from './ssr/format-property';\nimport { formatRules } from './ssr/format-rules';\nimport { getRegisteredSSRCollector } from './ssr/ssr-collector-ref';\nimport type { Styles } from './styles/types';\nimport { hasKeys } from './utils/has-keys';\nimport { resolveRecipes } from './utils/resolve-recipes';\n\nexport interface ComputeStylesResult {\n  className: string;\n  /** CSS text to emit as an inline <style> tag (RSC mode only). */\n  css?: string;\n}\n\nexport interface ComputeStylesOptions {\n  ssrCollector?: ServerStyleCollector | null;\n}\n\ninterface ProcessedChunk {\n  name: string;\n  styleKeys: string[];\n  cacheKey: string;\n  renderResult: RenderResult;\n  className: string;\n}\n\nconst EMPTY_RESULT: ComputeStylesResult = { className: '' };\n\n// ---------------------------------------------------------------------------\n// RSC (React Server Components) inline style support\n// ---------------------------------------------------------------------------\n\n/**\n * Mark internals as emitted for this RSC request.\n *\n * Internals (tokens, @property, @font-face, @counter-style) are emitted\n * exclusively by the SSR collector via ServerStyleCollector.collectInternals().\n * The SSR path is reliable because TastyRegistry is always present as a\n * client component in the root layout, guaranteeing SSR runs for every page.\n *\n * Previously this function also emitted internals and coordinated with SSR\n * via a globalThis flag, but that flag leaked across requests in the same\n * Node.js process, causing pages without RSC-rendered tasty components\n * (e.g. the playground route) to lose all token CSS.\n */\nfunction collectInternalsRSC(rscCache: RSCStyleCache): string {\n  if (rscCache.internalsEmitted) return '';\n  rscCache.internalsEmitted = true;\n\n  return '';\n}\n\n/**\n * Collect per-component ancillary CSS (keyframes, @property, font-face,\n * counter-style) for RSC mode.\n */\nfunction collectAncillaryRSC(rscCache: RSCStyleCache, styles: Styles): string {\n  const parts: string[] = [];\n\n  const usedKf = getUsedKeyframes(styles);\n  if (usedKf) {\n    for (const [name, steps] of Object.entries(usedKf)) {\n      const key = `__kf:${name}:${JSON.stringify(steps)}`;\n      if (!rscCache.emittedKeys.has(key)) {\n        rscCache.emittedKeys.add(key);\n        parts.push(formatKeyframesCSS(name, steps));\n      }\n    }\n  }\n\n  if (hasLocalProperties(styles)) {\n    const localProperties = extractLocalProperties(styles);\n    if (localProperties) {\n      for (const [token, definition] of Object.entries(localProperties)) {\n        const key = `__prop:${token}`;\n        if (!rscCache.emittedKeys.has(key)) {\n          rscCache.emittedKeys.add(key);\n          const css = formatPropertyCSS(token, definition);\n          if (css) parts.push(css);\n        }\n      }\n    }\n  }\n\n  if (hasLocalFontFace(styles)) {\n    const localFontFace = extractLocalFontFace(styles);\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 key = `__ff:${hash}`;\n          if (!rscCache.emittedKeys.has(key)) {\n            rscCache.emittedKeys.add(key);\n            parts.push(formatFontFaceRule(family, desc));\n          }\n        }\n      }\n    }\n  }\n\n  if (hasLocalCounterStyle(styles)) {\n    const localCounterStyle = extractLocalCounterStyle(styles);\n    if (localCounterStyle) {\n      for (const [name, descriptors] of Object.entries(localCounterStyle)) {\n        const key = `__cs:${name}:${JSON.stringify(descriptors)}`;\n        if (!rscCache.emittedKeys.has(key)) {\n          rscCache.emittedKeys.add(key);\n          parts.push(formatCounterStyleRule(name, descriptors));\n        }\n      }\n    }\n  }\n\n  return parts.join('\\n');\n}\n\n/**\n * Process all chunks in RSC mode: render CSS to strings, allocate classNames,\n * and return combined { className, css }.\n */\nfunction computeStylesRSC(\n  styles: Styles,\n  chunkMap: Map<string, string[]>,\n): ComputeStylesResult {\n  const rscCache = getRSCCache();\n  const cssParts: string[] = [];\n  const classNames: string[] = [];\n\n  // Flush CSS accumulated by standalone style functions\n  const pendingCSS = flushPendingCSS(rscCache);\n  if (pendingCSS) cssParts.push(pendingCSS);\n\n  const internalsCSS = collectInternalsRSC(rscCache);\n  if (internalsCSS) cssParts.push(internalsCSS);\n\n  for (const [chunkName, chunkStyleKeys] of chunkMap) {\n    if (chunkStyleKeys.length === 0) continue;\n\n    const cacheKey = generateChunkCacheKey(styles, chunkName, chunkStyleKeys);\n    const { className, isNew } = rscAllocateClassName(rscCache, cacheKey);\n    classNames.push(className);\n\n    if (isNew) {\n      const renderResult = renderStylesForChunk(\n        styles,\n        chunkName,\n        chunkStyleKeys,\n      );\n      if (renderResult.rules.length > 0) {\n        const css = formatRules(renderResult.rules, className);\n        if (css) cssParts.push(css);\n      }\n    }\n  }\n\n  const ancillaryCSS = collectAncillaryRSC(rscCache, styles);\n  if (ancillaryCSS) cssParts.push(ancillaryCSS);\n\n  if (classNames.length === 0) return EMPTY_RESULT;\n\n  const css = cssParts.join('\\n');\n\n  return {\n    className: classNames.join(' '),\n    css: css || undefined,\n  };\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 */\nfunction getUsedKeyframes(\n  styles: Styles,\n): Record<string, KeyframesSteps> | null {\n  const hasLocal = hasLocalKeyframes(styles);\n  const hasGlobal = hasGlobalKeyframes();\n  if (!hasLocal && !hasGlobal) return null;\n\n  const usedNames = extractAnimationNamesFromStyles(styles);\n  if (usedNames.size === 0) return null;\n\n  const local = hasLocal ? extractLocalKeyframes(styles) : null;\n  const global = hasGlobal ? getGlobalKeyframes() : null;\n  const allKeyframes = mergeKeyframes(local, global);\n\n  return filterUsedKeyframes(allKeyframes, usedNames);\n}\n\n/**\n * Process a chunk on the SSR path: allocate via collector, render, collect CSS.\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 { name: chunkName, styleKeys, cacheKey, renderResult, className };\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 * Process a chunk on the client: render, allocate className, and inject\n * CSS synchronously. The injector's cache makes this idempotent.\n */\nfunction processChunkSync(\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 } = inject(renderResult.rules, { cacheKey });\n\n  return { name: chunkName, styleKeys, cacheKey, renderResult, className };\n}\n\n/**\n * Inject keyframes synchronously and return a name replacement map.\n * On the client, keyframes are injected into the DOM.\n */\nfunction injectKeyframesSync(\n  usedKeyframes: Record<string, KeyframesSteps>,\n): Map<string, string> | null {\n  let nameMap: Map<string, string> | null = null;\n\n  for (const [name, steps] of Object.entries(usedKeyframes)) {\n    const result = keyframes(steps, { name });\n    const injectedName = result.toString();\n    if (injectedName !== name) {\n      if (!nameMap) nameMap = new Map();\n      nameMap.set(name, injectedName);\n    }\n  }\n\n  return nameMap;\n}\n\n/**\n * Inject chunk rules synchronously, replacing animation names if needed.\n */\nfunction injectChunkRulesSync(\n  chunks: ProcessedChunk[],\n  nameMap: Map<string, string> | null,\n): void {\n  for (const chunk of chunks) {\n    if (chunk.renderResult.rules.length > 0) {\n      const rulesToInject: StyleResult[] = nameMap\n        ? chunk.renderResult.rules.map((rule) => ({\n            ...rule,\n            declarations: replaceAnimationNames(rule.declarations, nameMap!),\n          }))\n        : chunk.renderResult.rules;\n\n      inject(rulesToInject, { cacheKey: chunk.cacheKey });\n    }\n  }\n}\n\n/**\n * Inject all ancillary rules (properties, font-faces, counter-styles) synchronously.\n */\nfunction injectAncillarySync(styles: Styles): void {\n  if (hasLocalProperties(styles)) {\n    const localProperties = extractLocalProperties(styles);\n    if (localProperties) {\n      for (const [token, definition] of Object.entries(localProperties)) {\n        property(token, definition);\n      }\n    }\n  }\n\n  if (hasLocalFontFace(styles)) {\n    const localFontFace = extractLocalFontFace(styles);\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  if (hasLocalCounterStyle(styles)) {\n    const localCounterStyle = extractLocalCounterStyle(styles);\n    if (localCounterStyle) {\n      for (const [name, descriptors] of Object.entries(localCounterStyle)) {\n        counterStyle(name, descriptors);\n      }\n    }\n  }\n}\n\n/**\n * Collect all ancillary rules into the SSR collector.\n */\nfunction collectAncillarySSR(\n  collector: ServerStyleCollector,\n  styles: Styles,\n  chunks: ProcessedChunk[],\n): void {\n  const usedKf = getUsedKeyframes(styles);\n  if (usedKf) {\n    for (const [name, steps] of Object.entries(usedKf)) {\n      const css = formatKeyframesCSS(name, steps);\n      collector.collectKeyframes(name, css);\n    }\n  }\n\n  if (hasLocalProperties(styles)) {\n    const localProperties = extractLocalProperties(styles);\n    if (localProperties) {\n      for (const [token, definition] of Object.entries(localProperties)) {\n        const css = formatPropertyCSS(token, definition);\n        if (css) {\n          collector.collectProperty(token, css);\n        }\n      }\n    }\n  }\n\n  if (hasLocalFontFace(styles)) {\n    const localFontFace = extractLocalFontFace(styles);\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          collector.collectFontFace(hash, css);\n        }\n      }\n    }\n  }\n\n  if (hasLocalCounterStyle(styles)) {\n    const localCounterStyle = extractLocalCounterStyle(styles);\n    if (localCounterStyle) {\n      for (const [name, descriptors] of Object.entries(localCounterStyle)) {\n        const css = formatCounterStyleRule(name, descriptors);\n        collector.collectCounterStyle(name, css);\n      }\n    }\n  }\n\n  if (getConfig().autoPropertyTypes !== false) {\n    const allRules = chunks.flatMap((c) => c.renderResult.rules);\n    if (allRules.length > 0) {\n      collectAutoInferredProperties(allRules, collector, styles);\n    }\n  }\n}\n\n/**\n * Synchronous, hook-free style computation.\n *\n * Resolves recipes, categorizes style keys into chunks, renders CSS rules,\n * allocates class names, and injects / collects / returns the CSS.\n *\n * Three code paths:\n * 1. SSR collector — discovered via ALS or passed explicitly; CSS collected\n * 2. RSC inline — no collector and no `document`; CSS returned as `result.css`\n *    for the caller to emit as an inline `<style>` tag\n * 3. Client inject — CSS injected synchronously into the DOM (idempotent)\n *\n * @param styles - Tasty styles object (or undefined for no styles)\n * @param options - Optional SSR collector override\n */\nexport function computeStyles(\n  styles: Styles | undefined,\n  options?: ComputeStylesOptions,\n): ComputeStylesResult {\n  if (!styles || !hasKeys(styles as Record<string, unknown>)) {\n    return EMPTY_RESULT;\n  }\n\n  const resolved = resolveRecipes(styles);\n  const chunkMap = categorizeStyleKeys(resolved as Record<string, unknown>);\n\n  const collector =\n    options?.ssrCollector !== undefined\n      ? options.ssrCollector\n      : getRegisteredSSRCollector();\n\n  const chunks: ProcessedChunk[] = [];\n\n  if (collector) {\n    collector.collectInternals();\n\n    for (const [chunkName, chunkStyleKeys] of chunkMap) {\n      const chunk = processChunkSSR(\n        collector,\n        resolved,\n        chunkName,\n        chunkStyleKeys,\n      );\n      if (chunk) chunks.push(chunk);\n    }\n\n    collectAncillarySSR(collector, resolved, chunks);\n  } else if (typeof document === 'undefined') {\n    // RSC path: render CSS to strings for inline <style> emission\n    return computeStylesRSC(resolved, chunkMap);\n  } else {\n    injectAncillarySync(resolved);\n\n    const usedKf = getUsedKeyframes(resolved);\n    const nameMap = usedKf ? injectKeyframesSync(usedKf) : null;\n\n    for (const [chunkName, chunkStyleKeys] of chunkMap) {\n      const chunk = processChunkSync(resolved, chunkName, chunkStyleKeys);\n      if (chunk) chunks.push(chunk);\n    }\n\n    if (nameMap) {\n      injectChunkRulesSync(chunks, nameMap);\n    }\n\n    for (const chunk of chunks) {\n      touch(chunk.className);\n    }\n  }\n\n  if (chunks.length === 0) return EMPTY_RESULT;\n  if (chunks.length === 1) return { className: chunks[0].className };\n\n  return { className: chunks.map((c) => c.className).join(' ') };\n}\n"],"mappings":"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"}

package/dist/config.d.ts

@@ -1,8 +1,10 @@
-import { KeyframesSteps, PropertyDefinition } from "./injector/types.js";
+import { CounterStyleDescriptors, FontFaceInput, GCConfig, KeyframesSteps, PropertyDefinition } from "./injector/types.js";
 import { StyleDetails, UnitHandler } from "./parser/types.js";
 import { StyleHandlerDefinition } from "./utils/styles.js";
-import { RecipeStyles } from "./styles/types.js";
+import { ConfigTokens, RecipeStyles, Styles } from "./styles/types.js";
 import { StyleInjector } from "./injector/injector.js";
+import { ColorSpace } from "./utils/color-space.js";
+import { TypographyPreset } from "./utils/typography.js";
 import { TastyPlugin } from "./plugins/types.js";
 
 //#region src/config.d.ts
@@ -14,27 +16,10 @@ interface TastyConfig {
   nonce?: string;
   /** Maximum rules per stylesheet (default: 8192) */
   maxRulesPerSheet?: number;
-  /** Threshold for bulk cleanup of unused styles (default: 500) */
-  unusedStylesThreshold?: number;
-  /** Delay before bulk cleanup in ms, ignored if idleCleanup is true (default: 5000) */
-  bulkCleanupDelay?: number;
-  /** Use requestIdleCallback for cleanup when available (default: true) */
-  idleCleanup?: boolean;
   /** Force text injection mode, auto-detected in test environments (default: auto) */
   forceTextInjection?: boolean;
   /** Enable development mode features: performance metrics and debug info (default: auto) */
   devMode?: boolean;
-  /**
-   * Ratio of unused styles to delete per bulk cleanup run (0..1).
-   * Defaults to 0.5 (oldest half) to reduce risk of removing styles
-   * that may be restored shortly after being marked unused.
-   */
-  bulkCleanupBatchRatio?: number;
-  /**
-   * Minimum age (in ms) a style must remain unused before eligible for deletion.
-   * Helps avoid races during rapid mount/unmount cycles. Default: 10000ms.
-   */
-  unusedStylesMinAgeMs?: number;
   /**
    * Global predefined states for advanced state mapping.
    * These are state aliases that can be used in any component.
@@ -58,6 +43,37 @@ interface TastyConfig {
    * @example { myFunc: (groups) => groups.map(g => g.output).join(' ') }
    */
   funcs?: Record<string, (groups: StyleDetails[]) => string>;
+  /**
+   * Color space used for decomposed color token companion variables.
+   * Controls the CSS function and suffix for alpha composition.
+   *
+   * - `'rgb'`   — suffix `-rgb`, e.g. `rgb(var(--name-color-rgb) / .5)`
+   * - `'hsl'`   — suffix `-hsl`, e.g. `hsl(var(--name-color-hsl) / .5)`
+   * - `'oklch'` — suffix `-oklch`, e.g. `oklch(var(--name-color-oklch) / .5)`
+   *
+   * @default 'oklch'
+   */
+  colorSpace?: ColorSpace;
+  /**
+   * Automatically infer and register CSS @property declarations
+   * from custom property values found in styles, keyframes, and global config.
+   * Covers all types: \<color\>, \<number\>, \<length\>, \<angle\>, \<percentage\>, \<time\>.
+   * When false, only explicitly declared @properties are registered.
+   * @default true
+   */
+  autoPropertyTypes?: boolean;
+  /**
+   * Garbage collection configuration for unused styles.
+   * GC is triggered by touch count: every `touchInterval` touches, the
+   * oldest unused styles are evicted when their count exceeds `capacity`.
+   * @example
+   * ```ts
+   * configure({
+   *   gc: { touchInterval: 1000, capacity: 1000 },
+   * });
+   * ```
+   */
+  gc?: GCConfig;
   /**
    * Plugins that extend tasty with custom functions, units, or states.
    * Plugins are processed in order, with later plugins overriding earlier ones.
@@ -89,7 +105,11 @@ interface TastyConfig {
   /**
    * Global CSS @property definitions for custom properties.
    * Keys use tasty token syntax ($name for properties, #name for colors).
-   * Properties are only injected when the component using them is rendered.
+   *
+   * Tasty ships with `DEFAULT_PROPERTIES` (e.g. `$gap`, `$radius`, `#white`,
+   * `#black`, `#clear`, `#border`, etc.) that are always included.
+   * Properties you specify here are merged on top, so you can override any
+   * default by using the same key.
    *
    * For color tokens (#name), `syntax: '<color>'` is auto-set and
    * `initialValue` defaults to `'transparent'` if not specified.
@@ -101,6 +121,8 @@ interface TastyConfig {
    *     '$rotation': { syntax: '<angle>', initialValue: '0deg' },
    *     '$scale': { syntax: '<number>', inherits: false, initialValue: 1 },
    *     '#accent': { initialValue: 'purple' }, // syntax: '<color>' auto-set
+   *     // Override a default property:
+   *     '$gap': { syntax: '<length>', inherits: true, initialValue: '8px' },
    *   },
    * });
    *
@@ -114,6 +136,39 @@ interface TastyConfig {
    * ```
    */
   properties?: Record<string, PropertyDefinition>;
+  /**
+   * Global @font-face definitions.
+   * Keys are font-family names, values are descriptors or arrays of descriptors
+   * (for multiple weights/styles of the same family).
+   * Injected eagerly when styles are first generated.
+   * @example
+   * ```ts
+   * configure({
+   *   fontFace: {
+   *     'Brand Sans': [
+   *       { src: 'url("/fonts/brand-regular.woff2") format("woff2")', fontWeight: 400, fontDisplay: 'swap' },
+   *       { src: 'url("/fonts/brand-bold.woff2") format("woff2")', fontWeight: 700, fontDisplay: 'swap' },
+   *     ],
+   *     Icons: { src: 'url("/fonts/icons.woff2") format("woff2")', fontDisplay: 'block' },
+   *   },
+   * });
+   * ```
+   */
+  fontFace?: Record<string, FontFaceInput>;
+  /**
+   * Global @counter-style definitions.
+   * Keys are counter-style names, values are descriptor objects.
+   * Injected eagerly when styles are first generated.
+   * @example
+   * ```ts
+   * configure({
+   *   counterStyle: {
+   *     thumbs: { system: 'cyclic', symbols: '"👍"', suffix: '" "' },
+   *   },
+   * });
+   * ```
+   */
+  counterStyle?: Record<string, CounterStyleDescriptors>;
   /**
    * Custom style handlers that transform style properties into CSS declarations.
    * Handlers replace built-in handlers for the same style name.
@@ -144,20 +199,43 @@ interface TastyConfig {
    */
   handlers?: Record<string, StyleHandlerDefinition>;
   /**
-   * Predefined tokens that are replaced during style parsing.
-   * Token values are processed through the parser (like component tokens).
+   * Design tokens injected as CSS custom properties on `:root`.
+   * Values are parsed through the Tasty DSL. Supports state maps
+   * for responsive/theme-aware tokens.
+   *
+   * - `$name` keys become `--name` CSS custom properties
+   * - `#name` keys become `--name-color` and `--name-color-{colorSpace}` properties
+   *
+   * Tokens are injected once when the first style is rendered.
+   *
+   * @example
+   * ```ts
+   * configure({
+   *   tokens: {
+   *     '$gap': '4px',
+   *     '#primary': {
+   *       '': '#purple',
+   *       '@dark': '#light-purple',
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  tokens?: ConfigTokens;
+  /**
+   * Predefined tokens that are replaced during style parsing (parse-time substitution).
    * Use `$name` for custom properties and `#name` for color tokens.
+   * Values are substituted inline before CSS generation, unlike `tokens` which
+   * inject CSS custom properties on `:root`.
    *
    * For color tokens (#name), boolean `true` is converted to `transparent`.
    *
    * @example
    * ```ts
    * configure({
-   *   tokens: {
+   *   replaceTokens: {
    *     $spacing: '2x',
-   *     '$card-padding': '4x',
    *     '#accent': '#purple',
-   *     '#surface': '#white',
    *     '#overlay': true, // → transparent
    *   },
    * });
@@ -165,13 +243,13 @@ interface TastyConfig {
    * // Now use in styles - tokens are replaced at parse time:
    * const Card = tasty({
    *   styles: {
-   *     padding: '$card-padding',  // → calc(4 * var(--gap))
-   *     fill: '#surface',          // → var(--white-color)
+   *     padding: '$spacing',  // → calc(2 * var(--gap))
+   *     fill: '#accent',      // → var(--purple-color)
    *   },
    * });
    * ```
    */
-  tokens?: Record<`$${string}`, string | number | boolean> & Record<`#${string}`, string | number | boolean>;
+  replaceTokens?: Record<`$${string}`, string | number | boolean> & Record<`#${string}`, string | number | boolean>;
   /**
    * Predefined style recipes -- named style bundles that can be applied via `recipe` style property.
    * Recipe values are flat tasty styles (no sub-element keys). They may contain base styles,
@@ -203,6 +281,43 @@ interface TastyConfig {
    * ```
    */
   recipes?: Record<string, RecipeStyles>;
+  /**
+   * Typography presets — shorthand for `generateTypographyTokens()`.
+   * Accepts the same input and internally generates typography tokens
+   * that are merged into `tokens`. Explicit `tokens` override preset-generated ones.
+   *
+   * @example
+   * ```ts
+   * configure({
+   *   presets: {
+   *     h1: { fontSize: '32px', lineHeight: '1.2', fontWeight: '700' },
+   *     t2: { fontSize: '16px', lineHeight: '1.5', fontWeight: '400' },
+   *   },
+   *   tokens: {
+   *     // Overrides the preset-generated $t2-font-weight
+   *     '$t2-font-weight': { '': '400', '@dark': '300' },
+   *   },
+   * });
+   * ```
+   */
+  presets?: Record<string, TypographyPreset>;
+  /**
+   * Global Tasty styles keyed by CSS selector.
+   * Each entry applies the full Tasty style syntax (style properties,
+   * tokens, state maps, selector-based sub-styling) to the given selector.
+   * Injected alongside `:root` tokens when the first style is rendered.
+   *
+   * @example
+   * ```ts
+   * configure({
+   *   globalStyles: {
+   *     body: { fill: '#surface', color: '#text', preset: 't2', margin: 0 },
+   *     html: { overflow: 'hidden' },
+   *   },
+   * });
+   * ```
+   */
+  globalStyles?: Record<string, Styles>;
 }
 declare const GLOBAL_INJECTOR_KEY = "__TASTY_GLOBAL_INJECTOR__";
 declare global {
@@ -221,7 +336,7 @@ declare function isTestEnvironment(): boolean;
 declare function hasStylesGenerated(): boolean;
 /**
  * Check if any global keyframes are configured.
- * Fast path: returns false if no keyframes were ever set.
+ * Uses a pre-computed flag to avoid Object.keys() allocation on every call.
  */
 declare function hasGlobalKeyframes(): boolean;
 /**
@@ -229,6 +344,18 @@ declare function hasGlobalKeyframes(): boolean;
  * Returns null if no keyframes configured (fast path for zero-overhead).
  */
 declare function getGlobalKeyframes(): Record<string, KeyframesSteps> | null;
+/**
+ * Get global font-face configuration.
+ * Returns null if no font faces configured.
+ * Reads from globalThis first for cross-module SSR support.
+ */
+declare function getGlobalFontFace(): Record<string, FontFaceInput> | null;
+/**
+ * Get global counter-style configuration.
+ * Returns null if no counter styles configured.
+ * Reads from globalThis first for cross-module SSR support.
+ */
+declare function getGlobalCounterStyle(): Record<string, CounterStyleDescriptors> | null;
 /**
  * Check if any global recipes are configured.
  * Fast path: returns false if no recipes were ever set.
@@ -276,5 +403,5 @@ declare function getConfig(): TastyConfig;
  */
 declare function resetConfig(): void;
 //#endregion
-export { TastyConfig, configure, getConfig, getGlobalKeyframes, getGlobalRecipes, hasGlobalKeyframes, hasGlobalRecipes, hasStylesGenerated, isConfigLocked, isTestEnvironment, resetConfig };
+export { TastyConfig, configure, getConfig, getGlobalCounterStyle, getGlobalFontFace, getGlobalKeyframes, getGlobalRecipes, hasGlobalKeyframes, hasGlobalRecipes, hasStylesGenerated, isConfigLocked, isTestEnvironment, resetConfig };
 //# sourceMappingURL=config.d.ts.map