@tenphi/tasty 0.0.0-snapshot.056b911

package/dist/hooks/useRawCSS.d.ts

@@ -0,0 +1,22 @@
+//#region src/hooks/useRawCSS.d.ts
+interface UseRawCSSOptions {
+  /**
+   * Shadow root or document to inject into.
+   * Note: `root` is not part of the update-tracking comparison — changing
+   * only the root for the same id/content will not re-inject.
+   */
+  root?: Document | ShadowRoot;
+  /**
+   * Stable identifier for update tracking (client-only). When provided,
+   * changing the CSS content will dispose the previous injection and inject
+   * the new one. Without an id, deduplication is purely content-based (same
+   * CSS is injected only once). In RSC mode, renders are single-pass so
+   * update tracking does not apply.
+   */
+  id?: string;
+}
+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

@@ -0,0 +1,103 @@
+import { injectRawCSS } from "../injector/index.js";
+import { getStyleTarget, pushRSCCSS } from "../rsc-cache.js";
+import { hashString } from "../utils/hash.js";
+import { depsEqual } from "../utils/deps-equal.js";
+//#region src/hooks/useRawCSS.ts
+const clientEntries = /* @__PURE__ */ new Map();
+const clientContentDedup = /* @__PURE__ */ new Set();
+const factoryDepsCache = /* @__PURE__ */ new Map();
+/**
+* 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.
+*
+* Works in all environments: client, SSR with collector, and React Server Components.
+*
+* Injected styles are permanent — they are not cleaned up on component unmount.
+* Use the `id` option for update tracking when styles change over the
+* component lifecycle.
+*
+* @example Static CSS string
+* ```tsx
+* function GlobalStyles() {
+*   useRawCSS(`
+*     body {
+*       margin: 0;
+*       padding: 0;
+*       font-family: sans-serif;
+*     }
+*   `);
+*
+*   return null;
+* }
+* ```
+*
+* @example Factory function with dependencies
+* ```tsx
+* function ThemeStyles({ theme }: { theme: 'light' | 'dark' }) {
+*   useRawCSS(() => `
+*     :root {
+*       --bg-color: ${theme === 'dark' ? '#1a1a1a' : '#ffffff'};
+*       --text-color: ${theme === 'dark' ? '#ffffff' : '#1a1a1a'};
+*     }
+*   `, [theme], { id: 'theme-vars' });
+*
+*   return null;
+* }
+* ```
+*
+* @example With options
+* ```tsx
+* function ShadowStyles({ shadowRoot }) {
+*   useRawCSS(() => `.scoped { color: red; }`, [], { root: shadowRoot });
+*   return null;
+* }
+* ```
+*/
+function useRawCSS(cssOrFactory, depsOrOptions, options) {
+	const isFactory = typeof cssOrFactory === "function";
+	const deps = isFactory && Array.isArray(depsOrOptions) ? depsOrOptions : void 0;
+	const opts = isFactory ? options : depsOrOptions;
+	const target = getStyleTarget();
+	if (isFactory && deps && opts?.id && target.mode === "client") {
+		const cachedDeps = factoryDepsCache.get(opts.id);
+		if (cachedDeps && depsEqual(cachedDeps, deps)) return;
+	}
+	const css = isFactory ? cssOrFactory() : cssOrFactory;
+	if (!css.trim()) return;
+	if (target.mode === "ssr") {
+		const key = opts?.id ? `raw:${opts.id}` : `raw:${hashString(css)}`;
+		target.collector.collectRawCSS(key, css);
+		return;
+	}
+	if (target.mode === "rsc") {
+		const key = opts?.id ? `__raw:${opts.id}` : `__raw:${hashString(css)}`;
+		pushRSCCSS(target.cache, key, css);
+		return;
+	}
+	const id = opts?.id;
+	if (id) {
+		const existing = clientEntries.get(id);
+		if (existing) {
+			if (existing.contentKey === css) return;
+			existing.dispose();
+		}
+		const { dispose } = injectRawCSS(css, opts);
+		clientEntries.set(id, {
+			contentKey: css,
+			dispose
+		});
+		if (deps) factoryDepsCache.set(id, deps);
+	} else {
+		const contentKey = hashString(css);
+		if (clientContentDedup.has(contentKey)) return;
+		clientContentDedup.add(contentKey);
+		injectRawCSS(css, opts);
+	}
+}
+//#endregion
+export { useRawCSS };
+
+//# sourceMappingURL=useRawCSS.js.map

package/dist/hooks/useRawCSS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRawCSS.js","names":[],"sources":["../../src/hooks/useRawCSS.ts"],"sourcesContent":["import { injectRawCSS } from '../injector';\nimport { getStyleTarget, pushRSCCSS } from '../rsc-cache';\nimport { depsEqual } from '../utils/deps-equal';\nimport { hashString } from '../utils/hash';\n\ninterface UseRawCSSOptions {\n  /**\n   * Shadow root or document to inject into.\n   * Note: `root` is not part of the update-tracking comparison — changing\n   * only the root for the same id/content will not re-inject.\n   */\n  root?: Document | ShadowRoot;\n  /**\n   * Stable identifier for update tracking (client-only). When provided,\n   * changing the CSS content will dispose the previous injection and inject\n   * the new one. Without an id, deduplication is purely content-based (same\n   * CSS is injected only once). In RSC mode, renders are single-pass so\n   * update tracking does not apply.\n   */\n  id?: string;\n}\n\ninterface ClientEntry {\n  contentKey: string;\n  dispose: () => void;\n}\n\nconst clientEntries = new Map<string, ClientEntry>();\nconst clientContentDedup = new Set<string>();\nconst factoryDepsCache = new Map<string, readonly unknown[]>();\n\n/* @internal — used only for tests */\nexport function _resetRawCSSCache(): void {\n  clientEntries.clear();\n  clientContentDedup.clear();\n  factoryDepsCache.clear();\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/**\n * 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 * Works in all environments: client, SSR with collector, and React Server Components.\n *\n * Injected styles are permanent — they are not cleaned up on component unmount.\n * Use the `id` option for update tracking when styles change over the\n * component lifecycle.\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\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], { id: 'theme-vars' });\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 */\nexport function useRawCSS(\n  cssOrFactory: string | (() => string),\n  depsOrOptions?: readonly unknown[] | UseRawCSSOptions,\n  options?: UseRawCSSOptions,\n): void {\n  const isFactory = typeof cssOrFactory === 'function';\n\n  const deps =\n    isFactory && Array.isArray(depsOrOptions) ? depsOrOptions : undefined;\n  const opts = isFactory\n    ? options\n    : (depsOrOptions as UseRawCSSOptions | undefined);\n\n  const target = getStyleTarget();\n\n  // Client deps cache: skip factory re-evaluation when deps haven't changed\n  if (isFactory && deps && opts?.id && target.mode === 'client') {\n    const cachedDeps = factoryDepsCache.get(opts.id);\n    if (cachedDeps && depsEqual(cachedDeps, deps)) {\n      return;\n    }\n  }\n\n  const css = isFactory\n    ? (cssOrFactory as () => string)()\n    : (cssOrFactory as string);\n\n  if (!css.trim()) return;\n\n  if (target.mode === 'ssr') {\n    const key = opts?.id ? `raw:${opts.id}` : `raw:${hashString(css)}`;\n    target.collector.collectRawCSS(key, css);\n    return;\n  }\n\n  if (target.mode === 'rsc') {\n    const key = opts?.id ? `__raw:${opts.id}` : `__raw:${hashString(css)}`;\n    pushRSCCSS(target.cache, key, css);\n    return;\n  }\n\n  // Client path\n  const id = opts?.id;\n\n  if (id) {\n    const existing = clientEntries.get(id);\n    if (existing) {\n      if (existing.contentKey === css) return;\n      existing.dispose();\n    }\n\n    const { dispose } = injectRawCSS(css, opts);\n    clientEntries.set(id, { contentKey: css, dispose });\n    if (deps) factoryDepsCache.set(id, deps);\n  } else {\n    const contentKey = hashString(css);\n    if (clientContentDedup.has(contentKey)) return;\n    clientContentDedup.add(contentKey);\n    injectRawCSS(css, opts);\n  }\n}\n"],"mappings":";;;;;AA2BA,MAAM,gCAAgB,IAAI,KAA0B;AACpD,MAAM,qCAAqB,IAAI,KAAa;AAC5C,MAAM,mCAAmB,IAAI,KAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqE9D,SAAgB,UACd,cACA,eACA,SACM;CACN,MAAM,YAAY,OAAO,iBAAiB;CAE1C,MAAM,OACJ,aAAa,MAAM,QAAQ,cAAc,GAAG,gBAAgB,KAAA;CAC9D,MAAM,OAAO,YACT,UACC;CAEL,MAAM,SAAS,gBAAgB;AAG/B,KAAI,aAAa,QAAQ,MAAM,MAAM,OAAO,SAAS,UAAU;EAC7D,MAAM,aAAa,iBAAiB,IAAI,KAAK,GAAG;AAChD,MAAI,cAAc,UAAU,YAAY,KAAK,CAC3C;;CAIJ,MAAM,MAAM,YACP,cAA+B,GAC/B;AAEL,KAAI,CAAC,IAAI,MAAM,CAAE;AAEjB,KAAI,OAAO,SAAS,OAAO;EACzB,MAAM,MAAM,MAAM,KAAK,OAAO,KAAK,OAAO,OAAO,WAAW,IAAI;AAChE,SAAO,UAAU,cAAc,KAAK,IAAI;AACxC;;AAGF,KAAI,OAAO,SAAS,OAAO;EACzB,MAAM,MAAM,MAAM,KAAK,SAAS,KAAK,OAAO,SAAS,WAAW,IAAI;AACpE,aAAW,OAAO,OAAO,KAAK,IAAI;AAClC;;CAIF,MAAM,KAAK,MAAM;AAEjB,KAAI,IAAI;EACN,MAAM,WAAW,cAAc,IAAI,GAAG;AACtC,MAAI,UAAU;AACZ,OAAI,SAAS,eAAe,IAAK;AACjC,YAAS,SAAS;;EAGpB,MAAM,EAAE,YAAY,aAAa,KAAK,KAAK;AAC3C,gBAAc,IAAI,IAAI;GAAE,YAAY;GAAK;GAAS,CAAC;AACnD,MAAI,KAAM,kBAAiB,IAAI,IAAI,KAAK;QACnC;EACL,MAAM,aAAa,WAAW,IAAI;AAClC,MAAI,mBAAmB,IAAI,WAAW,CAAE;AACxC,qBAAmB,IAAI,WAAW;AAClC,eAAa,KAAK,KAAK"}

package/dist/hooks/useStyles.d.ts

@@ -0,0 +1,40 @@
+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.
+ * Thin wrapper around `computeStyles()` that adds React context-based
+ * SSR collector discovery for backward compatibility with TastyRegistry.
+ *
+ * For hook-free usage (e.g. in server components), use `computeStyles()` directly.
+ *
+ * @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

@@ -0,0 +1,31 @@
+import { computeStyles } from "../compute-styles.js";
+import { TastySSRContext } from "../ssr/context.js";
+import { useContext } from "react";
+//#region src/hooks/useStyles.ts
+/**
+* Hook to generate CSS classes from Tasty styles.
+* Thin wrapper around `computeStyles()` that adds React context-based
+* SSR collector discovery for backward compatibility with TastyRegistry.
+*
+* For hook-free usage (e.g. in server components), use `computeStyles()` directly.
+*
+* @example
+* ```tsx
+* function MyComponent() {
+*   const { className } = useStyles({
+*     padding: '2x',
+*     fill: '#purple',
+*     radius: '1r',
+*   });
+*
+*   return <div className={className}>Styled content</div>;
+* }
+* ```
+*/
+function useStyles(styles) {
+	return computeStyles(styles, { ssrCollector: useContext(TastySSRContext) });
+}
+//#endregion
+export { useStyles };
+
+//# sourceMappingURL=useStyles.js.map

package/dist/hooks/useStyles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStyles.js","names":[],"sources":["../../src/hooks/useStyles.ts"],"sourcesContent":["import { useContext } from 'react';\n\nimport { computeStyles } from '../compute-styles';\nimport { TastySSRContext } from '../ssr/context';\nimport type { Styles } from '../styles/types';\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 * Hook to generate CSS classes from Tasty styles.\n * Thin wrapper around `computeStyles()` that adds React context-based\n * SSR collector discovery for backward compatibility with TastyRegistry.\n *\n * For hook-free usage (e.g. in server components), use `computeStyles()` directly.\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  return computeStyles(styles, { ssrCollector: useContext(TastySSRContext) });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,UAAU,QAA2C;AACnE,QAAO,cAAc,QAAQ,EAAE,cAAc,WAAW,gBAAgB,EAAE,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+import { CacheMetrics, CounterStyleDescriptors, DisposeFunction, FontFaceDescriptors, FontFaceInput, GCConfig, GCOptions, InjectResult, KeyframesCacheEntry, KeyframesInfo, KeyframesResult, KeyframesSteps, PropertyDefinition, RawCSSResult, RootRegistry, RuleInfo, SheetInfo, StyleInjectorConfig, StyleRule, StyleUsage } from "./injector/types.js";
+import { CSSProperties } from "./utils/css-types.js";
+import { Bucket, ParserOptions, ProcessedStyle, StyleDetails, StyleDetailsPart, UnitHandler } from "./parser/types.js";
+import { StyleParser } from "./parser/parser.js";
+import { getNamedColorHex, getRgbValuesFromRgbaString, hexToRgb, hslToRgbValues, strToRgb } from "./utils/color-math.js";
+import { CSSMap, CUSTOM_UNITS, DIRECTIONS, ParsedColor, RawStyleHandler, StyleHandler, StyleHandlerDefinition, StyleHandlerResult, StyleMap, StylePropValue, StyleValue, StyleValueStateMap, customFunc, filterMods, getGlobalFuncs, getGlobalParser, getGlobalPredefinedTokens, normalizeColorTokenValue, parseColor, parseStyle, resetGlobalPredefinedTokens, setGlobalPredefinedTokens, stringifyStyles } from "./utils/styles.js";
+import { ConfigTokenValue, ConfigTokens, NoType, NotSelector, RecipeStyles, Selector, Styles, StylesInterface, StylesWithoutSelectors, SuffixForSelector, TastyNamedColors, TastyPresetNames } from "./styles/types.js";
+import { ConditionNode } from "./pipeline/conditions.js";
+import { AtRuleContext, ParsedAdvancedState, StateParserContext, createStateParserContext, getGlobalPredefinedStates, setGlobalPredefinedStates } from "./states/index.js";
+import { ParseStateKeyOptions, parseStateKey } from "./pipeline/parseStateKey.js";
+import { RenderResult, StyleResult, isSelector, renderStyles } from "./pipeline/index.js";
+import { SheetManager } from "./injector/sheet-manager.js";
+import { StyleInjector } from "./injector/injector.js";
+import { ColorSpace } from "./utils/color-space.js";
+import { TypographyPreset, TypographyTokenValue, generateTypographyTokens } from "./utils/typography.js";
+import { TastyPlugin, TastyPluginFactory } from "./plugins/types.js";
+import { TastyConfig, configure, getConfig, getGlobalCounterStyle, getGlobalFontFace, getGlobalKeyframes, getGlobalRecipes, hasGlobalKeyframes, hasGlobalRecipes, hasStylesGenerated, isConfigLocked, isTestEnvironment, resetConfig } from "./config.js";
+import { okhslFunc, okhslPlugin } from "./plugins/okhsl-plugin.js";
+import { CHUNK_NAMES, ChunkInfo, ChunkName, STYLE_TO_CHUNK, categorizeStyleKeys } from "./chunks/definitions.js";
+import { BASE_STYLES, BLOCK_INNER_STYLES, BLOCK_OUTER_STYLES, BLOCK_STYLES, COLOR_STYLES, CONTAINER_STYLES, DIMENSION_STYLES, FLOW_STYLES, INNER_STYLES, OUTER_STYLES, POSITION_STYLES, TEXT_STYLES } from "./styles/list.js";
+import { AllBaseProps, BaseProps, BasePropsWithoutChildren, BaseStyleProps, BlockInnerStyleProps, BlockOuterStyleProps, BlockStyleProps, ColorStyleProps, ContainerStyleProps, DimensionStyleProps, FlowStyleProps, GlobalStyledProps, InnerStyleProps, ModValue, Mods, OuterStyleProps, PositionStyleProps, Props, ShortGridStyles, TagName, TastyExtensionConfig, TastyThemeNames, TextStyleProps, TokenValue, Tokens } from "./types.js";
+import { AllBasePropsWithMods, Element, ElementsDefinition, ModPropDef, ModPropsInput, ResolveModPropDef, ResolveModProps, ResolveTokenProps, SubElementDefinition, SubElementProps, TastyElementOptions, TastyElementProps, TastyProps, TokenPropsInput, VariantMap, WithVariant, tasty } from "./tasty.js";
+import { UseStylesOptions, UseStylesResult, useStyles } from "./hooks/useStyles.js";
+import { useGlobalStyles } from "./hooks/useGlobalStyles.js";
+import { useRawCSS } from "./hooks/useRawCSS.js";
+import { useKeyframes } from "./hooks/useKeyframes.js";
+import { UsePropertyOptions, useProperty } from "./hooks/useProperty.js";
+import { useFontFace } from "./hooks/useFontFace.js";
+import { useCounterStyle } from "./hooks/useCounterStyle.js";
+import { getDisplayName } from "./utils/get-display-name.js";
+import { styleHandlers } from "./styles/predefined.js";
+import { ComputeStylesOptions, ComputeStylesResult, computeStyles } from "./compute-styles.js";
+import { PropertyOptions, cleanup, counterStyle, createInjector, destroy, fontFace, gc, getCssText, getCssTextForNode, getIsTestEnvironment, getRawCSSText, inject, injectGlobal, injectRawCSS, injector, isPropertyDefined, keyframes, property, touch } from "./injector/index.js";
+import { filterBaseProps } from "./utils/filter-base-props.js";
+import { color } from "./utils/colors.js";
+import { _modAttrs } from "./utils/mod-attrs.js";
+import { dotize } from "./utils/dotize.js";
+import { mergeStyles } from "./utils/merge-styles.js";
+import { resolveRecipes } from "./utils/resolve-recipes.js";
+import { deprecationWarning, warn } from "./utils/warnings.js";
+import { processTokens } from "./utils/process-tokens.js";
+import { tastyDebug } from "./debug.js";
+import { CSSProperties as CSSProperties$1 } from "react";
+
+//#region src/index.d.ts
+declare module './utils/css-types' {
+  interface CSSProperties extends CSSProperties$1 {}
+}
+//#endregion
+export { type AllBaseProps, type AllBasePropsWithMods, AtRuleContext, BASE_STYLES, BLOCK_INNER_STYLES, BLOCK_OUTER_STYLES, BLOCK_STYLES, type BaseProps, type BasePropsWithoutChildren, BaseStyleProps, BlockInnerStyleProps, BlockOuterStyleProps, BlockStyleProps, Bucket, CHUNK_NAMES, COLOR_STYLES, CONTAINER_STYLES, CSSMap, CSSProperties, CUSTOM_UNITS, CacheMetrics, ChunkInfo, ChunkName, ColorSpace, ColorStyleProps, ComputeStylesOptions, ComputeStylesResult, ConditionNode, ConfigTokenValue, ConfigTokens, ContainerStyleProps, CounterStyleDescriptors, DIMENSION_STYLES, DIRECTIONS, DimensionStyleProps, DisposeFunction, Element, type ElementsDefinition, FLOW_STYLES, FlowStyleProps, FontFaceDescriptors, FontFaceInput, GCConfig, GCOptions, GlobalStyledProps, INNER_STYLES, InjectResult, InnerStyleProps, KeyframesCacheEntry, KeyframesInfo, KeyframesResult, KeyframesSteps, type ModPropDef, type ModPropsInput, ModValue, Mods, NoType, NotSelector, OUTER_STYLES, OuterStyleProps, POSITION_STYLES, ParseStateKeyOptions, ParsedAdvancedState, ParsedColor, ParserOptions, PositionStyleProps, ProcessedStyle, PropertyDefinition, PropertyOptions, Props, RawCSSResult, RawStyleHandler, RecipeStyles, RenderResult, type ResolveModPropDef, type ResolveModProps, type ResolveTokenProps, RootRegistry, RuleInfo, STYLE_TO_CHUNK, Selector, SheetInfo, SheetManager, ShortGridStyles, StateParserContext, StyleDetails, StyleDetailsPart, StyleHandler, StyleHandlerDefinition, StyleHandlerResult, StyleInjector, StyleInjectorConfig, StyleMap, StyleParser, StylePropValue, StyleResult, StyleRule, StyleUsage, StyleValue, StyleValueStateMap, Styles, StylesInterface, StylesWithoutSelectors, type SubElementDefinition, type SubElementProps, SuffixForSelector, TEXT_STYLES, TagName, TastyConfig, type TastyElementOptions, type TastyElementProps, TastyExtensionConfig, TastyNamedColors, TastyPlugin, TastyPluginFactory, TastyPresetNames, type TastyProps, TastyThemeNames, TextStyleProps, type TokenPropsInput, TokenValue, Tokens, TypographyPreset, TypographyTokenValue, UnitHandler, type UsePropertyOptions, type UseStylesOptions, type UseStylesResult, type VariantMap, type WithVariant, categorizeStyleKeys, cleanup, color, computeStyles, configure, counterStyle, createInjector, createStateParserContext, customFunc, deprecationWarning, destroy, dotize, filterBaseProps, filterMods, fontFace, gc, generateTypographyTokens, getConfig, getCssText, getCssTextForNode, getDisplayName, getGlobalCounterStyle, getGlobalFontFace, getGlobalFuncs, getGlobalKeyframes, getGlobalParser, getGlobalPredefinedStates, getGlobalPredefinedTokens, getGlobalRecipes, getIsTestEnvironment, getNamedColorHex, getRawCSSText, getRgbValuesFromRgbaString, hasGlobalKeyframes, hasGlobalRecipes, hasStylesGenerated, hexToRgb, hslToRgbValues, inject, injectGlobal, injectRawCSS, injector, isConfigLocked, isPropertyDefined, isSelector, isTestEnvironment, keyframes, mergeStyles, _modAttrs as modAttrs, normalizeColorTokenValue, okhslFunc, okhslPlugin, parseColor, parseStateKey, parseStyle, processTokens, property, renderStyles, resetConfig, resetGlobalPredefinedTokens, resolveRecipes, setGlobalPredefinedStates, setGlobalPredefinedTokens, strToRgb, stringifyStyles, styleHandlers, tasty, tastyDebug, touch, useCounterStyle, useFontFace, useGlobalStyles, useKeyframes, useProperty, useRawCSS, useStyles, warn };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,36 @@
+import { getNamedColorHex, getRgbValuesFromRgbaString, hexToRgb, hslToRgbValues, strToRgb } from "./utils/color-math.js";
+import { Bucket } from "./parser/types.js";
+import { StyleParser } from "./parser/parser.js";
+import { okhslFunc, okhslPlugin } from "./plugins/okhsl-plugin.js";
+import { CUSTOM_UNITS, DIRECTIONS, customFunc, filterMods, getGlobalFuncs, getGlobalParser, getGlobalPredefinedTokens, normalizeColorTokenValue, parseColor, parseStyle, resetGlobalPredefinedTokens, setGlobalPredefinedTokens, stringifyStyles } from "./utils/styles.js";
+import { deprecationWarning, warn } from "./utils/warnings.js";
+import { styleHandlers } from "./styles/predefined.js";
+import { SheetManager } from "./injector/sheet-manager.js";
+import { StyleInjector } from "./injector/injector.js";
+import { createStateParserContext, getGlobalPredefinedStates, setGlobalPredefinedStates } from "./states/index.js";
+import { parseStateKey } from "./pipeline/parseStateKey.js";
+import { isSelector, renderStyles } from "./pipeline/index.js";
+import { generateTypographyTokens } from "./utils/typography.js";
+import { configure, getConfig, getGlobalCounterStyle, getGlobalFontFace, getGlobalKeyframes, getGlobalRecipes, hasGlobalKeyframes, hasGlobalRecipes, hasStylesGenerated, isConfigLocked, isTestEnvironment, resetConfig } from "./config.js";
+import { CHUNK_NAMES, STYLE_TO_CHUNK, categorizeStyleKeys } from "./chunks/definitions.js";
+import { BASE_STYLES, BLOCK_INNER_STYLES, BLOCK_OUTER_STYLES, BLOCK_STYLES, COLOR_STYLES, CONTAINER_STYLES, DIMENSION_STYLES, FLOW_STYLES, INNER_STYLES, OUTER_STYLES, POSITION_STYLES, TEXT_STYLES } from "./styles/list.js";
+import { cleanup, counterStyle, createInjector, destroy, fontFace, gc, getCssText, getCssTextForNode, getIsTestEnvironment, getRawCSSText, inject, injectGlobal, injectRawCSS, injector, isPropertyDefined, keyframes, property, touch } from "./injector/index.js";
+import { mergeStyles } from "./utils/merge-styles.js";
+import { resolveRecipes } from "./utils/resolve-recipes.js";
+import { computeStyles } from "./compute-styles.js";
+import { filterBaseProps } from "./utils/filter-base-props.js";
+import { color } from "./utils/colors.js";
+import { _modAttrs } from "./utils/mod-attrs.js";
+import { dotize } from "./utils/dotize.js";
+import { processTokens } from "./utils/process-tokens.js";
+import { tastyDebug } from "./debug.js";
+import { getDisplayName } from "./utils/get-display-name.js";
+import { Element, tasty } from "./tasty.js";
+import { useStyles } from "./hooks/useStyles.js";
+import { useGlobalStyles } from "./hooks/useGlobalStyles.js";
+import { useRawCSS } from "./hooks/useRawCSS.js";
+import { useKeyframes } from "./hooks/useKeyframes.js";
+import { useProperty } from "./hooks/useProperty.js";
+import { useFontFace } from "./hooks/useFontFace.js";
+import { useCounterStyle } from "./hooks/useCounterStyle.js";
+export { BASE_STYLES, BLOCK_INNER_STYLES, BLOCK_OUTER_STYLES, BLOCK_STYLES, Bucket, CHUNK_NAMES, COLOR_STYLES, CONTAINER_STYLES, CUSTOM_UNITS, DIMENSION_STYLES, DIRECTIONS, Element, FLOW_STYLES, INNER_STYLES, OUTER_STYLES, POSITION_STYLES, STYLE_TO_CHUNK, SheetManager, StyleInjector, StyleParser, TEXT_STYLES, categorizeStyleKeys, cleanup, color, computeStyles, configure, counterStyle, createInjector, createStateParserContext, customFunc, deprecationWarning, destroy, dotize, filterBaseProps, filterMods, fontFace, gc, generateTypographyTokens, getConfig, getCssText, getCssTextForNode, getDisplayName, getGlobalCounterStyle, getGlobalFontFace, getGlobalFuncs, getGlobalKeyframes, getGlobalParser, getGlobalPredefinedStates, getGlobalPredefinedTokens, getGlobalRecipes, getIsTestEnvironment, getNamedColorHex, getRawCSSText, getRgbValuesFromRgbaString, hasGlobalKeyframes, hasGlobalRecipes, hasStylesGenerated, hexToRgb, hslToRgbValues, inject, injectGlobal, injectRawCSS, injector, isConfigLocked, isPropertyDefined, isSelector, isTestEnvironment, keyframes, mergeStyles, _modAttrs as modAttrs, normalizeColorTokenValue, okhslFunc, okhslPlugin, parseColor, parseStateKey, parseStyle, processTokens, property, renderStyles, resetConfig, resetGlobalPredefinedTokens, resolveRecipes, setGlobalPredefinedStates, setGlobalPredefinedTokens, strToRgb, stringifyStyles, styleHandlers, tasty, tastyDebug, touch, useCounterStyle, useFontFace, useGlobalStyles, useKeyframes, useProperty, useRawCSS, useStyles, warn };

package/dist/injector/index.d.ts

@@ -0,0 +1,182 @@
+import { CacheMetrics, CounterStyleDescriptors, DisposeFunction, FontFaceDescriptors, FontFaceInput, GCConfig, GCOptions, GlobalInjectResult, InjectResult, KeyframesCacheEntry, KeyframesInfo, KeyframesResult, KeyframesSteps, PropertyDefinition, RawCSSResult, RootRegistry, RuleInfo, SheetInfo, StyleInjectorConfig, StyleRule, StyleUsage } from "./types.js";
+import { StyleResult } from "../pipeline/index.js";
+import { SheetManager } from "./sheet-manager.js";
+import { StyleInjector } from "./injector.js";
+
+//#region src/injector/index.d.ts
+/**
+ * Inject styles and return className with dispose function
+ */
+declare function inject(rules: StyleResult[], options?: {
+  root?: Document | ShadowRoot;
+  cacheKey?: string;
+}): InjectResult;
+/**
+ * Inject global rules that should not reserve tasty class names
+ */
+declare function injectGlobal(rules: StyleResult[], options?: {
+  root?: Document | ShadowRoot;
+}): GlobalInjectResult;
+/**
+ * Inject raw CSS text directly without parsing
+ * This is a low-overhead method for injecting raw CSS that doesn't need tasty processing.
+ * The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking.
+ *
+ * @example
+ * ```tsx
+ * // Inject raw CSS
+ * const { dispose } = injectRawCSS(`
+ *   body { margin: 0; padding: 0; }
+ *   .my-class { color: red; }
+ * `);
+ *
+ * // Later, remove the injected CSS
+ * dispose();
+ * ```
+ */
+declare function injectRawCSS(css: string, options?: {
+  root?: Document | ShadowRoot;
+}): {
+  dispose: () => void;
+};
+/**
+ * Get raw CSS text for SSR
+ */
+declare function getRawCSSText(options?: {
+  root?: Document | ShadowRoot;
+}): string;
+/**
+ * Inject keyframes and return object with toString() and dispose()
+ */
+declare function keyframes(steps: KeyframesSteps, nameOrOptions?: string | {
+  root?: Document | ShadowRoot;
+  name?: string;
+}): KeyframesResult;
+interface PropertyOptions {
+  /**
+   * CSS syntax string for the property (e.g., '<color>', '<length>', '<angle>')
+   * @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
+   */
+  initialValue?: string | number;
+  /**
+   * Shadow root or document to inject into
+   */
+  root?: Document | ShadowRoot;
+}
+/**
+ * Define a CSS @property custom property.
+ * This enables advanced features like animating custom properties.
+ *
+ * Note: @property rules are global and persistent once defined.
+ * Re-registering the same property name is a no-op.
+ *
+ * @param name - The custom property name (must start with --)
+ * @param options - Property configuration
+ *
+ * @example
+ * ```ts
+ * // Define a color property that can be animated
+ * property('--my-color', {
+ *   syntax: '<color>',
+ *   initialValue: 'red',
+ * });
+ *
+ * // Define an angle property
+ * property('--rotation', {
+ *   syntax: '<angle>',
+ *   inherits: false,
+ *   initialValue: '0deg',
+ * });
+ * ```
+ */
+declare function property(name: string, options?: PropertyOptions): void;
+/**
+ * Check if a CSS @property has already been defined
+ *
+ * @param name - The custom property name to check
+ * @param options - Options including root
+ */
+declare function isPropertyDefined(name: string, options?: {
+  root?: Document | ShadowRoot;
+}): boolean;
+/**
+ * Inject a CSS @font-face rule.
+ *
+ * Permanent and global — no dispose or ref-counting.
+ * Deduplicates by content hash (family + descriptors).
+ */
+declare function fontFace(family: string, descriptors: FontFaceDescriptors, options?: {
+  root?: Document | ShadowRoot;
+}): void;
+/**
+ * Inject a CSS @counter-style rule.
+ *
+ * Permanent and global — no dispose or ref-counting.
+ * Deduplicates by name (first definition wins).
+ */
+declare function counterStyle(name: string, descriptors: CounterStyleDescriptors, options?: {
+  root?: Document | ShadowRoot;
+}): void;
+/**
+ * Get CSS text from all sheets (for SSR)
+ */
+declare function getCssText(options?: {
+  root?: Document | ShadowRoot;
+}): string;
+/**
+ * Collect only CSS used by a rendered subtree (like jest-styled-components).
+ * Pass the container returned by render(...).
+ */
+declare function getCssTextForNode(node: ParentNode | Element | DocumentFragment, options?: {
+  root?: Document | ShadowRoot;
+}): string;
+/**
+ * Force cleanup of unused rules
+ */
+declare function cleanup(root?: Document | ShadowRoot): void;
+/**
+ * Record a render-time usage hit for one or more classNames.
+ * Used internally by computeStyles and tasty() to track usage for GC.
+ * When the global touch counter reaches `touchInterval`, schedules GC.
+ */
+declare function touch(className: string, options?: {
+  root?: Document | ShadowRoot;
+}): void;
+/**
+ * Synchronous garbage collection of unused styles.
+ * Evicts the oldest unused styles when usageMap exceeds capacity.
+ * With `{ force: true }`, removes ALL unused styles regardless of capacity.
+ *
+ * @returns Number of styles evicted.
+ */
+declare function gc(options?: GCOptions): number;
+/**
+ * Check if we're currently running in a test environment
+ */
+declare function getIsTestEnvironment(): boolean;
+/**
+ * Get the global injector instance for debugging
+ */
+declare const injector: {
+  readonly instance: StyleInjector;
+};
+/**
+ * Destroy all resources and clean up
+ */
+declare function destroy(root?: Document | ShadowRoot): void;
+/**
+ * Create a new isolated injector instance
+ */
+declare function createInjector(config?: Partial<StyleInjectorConfig>): StyleInjector;
+//#endregion
+export { PropertyOptions, cleanup, counterStyle, createInjector, destroy, fontFace, gc, getCssText, getCssTextForNode, getIsTestEnvironment, getRawCSSText, inject, injectGlobal, injectRawCSS, injector, isPropertyDefined, keyframes, property, touch };
+//# sourceMappingURL=index.d.ts.map