@tenphi/tasty 0.0.0-snapshot.08a6610

package/dist/injector/index.d.ts

@@ -0,0 +1,165 @@
+import { CacheMetrics, DisposeFunction, GlobalInjectResult, InjectResult, KeyframesCacheEntry, KeyframesInfo, KeyframesResult, KeyframesSteps, PropertyDefinition, RawCSSResult, RootRegistry, RuleInfo, SheetInfo, StyleInjectorConfig, StyleRule } 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
+/**
+ * Allocate a className for a cacheKey without injecting styles yet
+ */
+declare function allocateClassName(cacheKey: string, options?: {
+  root?: Document | ShadowRoot;
+}): {
+  className: string;
+  isNewAllocation: boolean;
+};
+/**
+ * Track a reference to an already-injected cacheKey (refCount + dispose).
+ * Used on cache hits (SSR hydration or runtime reuse) where the pipeline
+ * was skipped. Returns null if the cacheKey is not in the cache.
+ */
+declare function trackRef(cacheKey: string, options?: {
+  root?: Document | ShadowRoot;
+}): InjectResult | null;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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, allocateClassName, cleanup, createInjector, destroy, getCssText, getCssTextForNode, getIsTestEnvironment, getRawCSSText, inject, injectGlobal, injectRawCSS, injector, isPropertyDefined, keyframes, property, trackRef };
+//# sourceMappingURL=index.d.ts.map

package/dist/injector/index.js

@@ -0,0 +1,162 @@
+import { SheetManager } from "./sheet-manager.js";
+import { StyleInjector } from "./injector.js";
+import { getConfig, getGlobalInjector, isTestEnvironment, markStylesGenerated } from "../config.js";
+
+//#region src/injector/index.ts
+/**
+* Allocate a className for a cacheKey without injecting styles yet
+*/
+function allocateClassName(cacheKey, options) {
+	return getGlobalInjector().allocateClassName(cacheKey, options);
+}
+/**
+* Track a reference to an already-injected cacheKey (refCount + dispose).
+* Used on cache hits (SSR hydration or runtime reuse) where the pipeline
+* was skipped. Returns null if the cacheKey is not in the cache.
+*/
+function trackRef(cacheKey, options) {
+	return getGlobalInjector().trackRef(cacheKey, options);
+}
+/**
+* Inject styles and return className with dispose function
+*/
+function inject(rules, options) {
+	markStylesGenerated();
+	return getGlobalInjector().inject(rules, options);
+}
+/**
+* Inject global rules that should not reserve tasty class names
+*/
+function injectGlobal(rules, options) {
+	return getGlobalInjector().injectGlobal(rules, options);
+}
+/**
+* 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();
+* ```
+*/
+function injectRawCSS(css, options) {
+	return getGlobalInjector().injectRawCSS(css, options);
+}
+/**
+* Get raw CSS text for SSR
+*/
+function getRawCSSText(options) {
+	return getGlobalInjector().getRawCSSText(options);
+}
+/**
+* Inject keyframes and return object with toString() and dispose()
+*/
+function keyframes(steps, nameOrOptions) {
+	return getGlobalInjector().keyframes(steps, nameOrOptions);
+}
+/**
+* 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',
+* });
+* ```
+*/
+function property(name, options) {
+	return getGlobalInjector().property(name, options);
+}
+/**
+* Check if a CSS @property has already been defined
+*
+* @param name - The custom property name to check
+* @param options - Options including root
+*/
+function isPropertyDefined(name, options) {
+	return getGlobalInjector().isPropertyDefined(name, options);
+}
+/**
+* Get CSS text from all sheets (for SSR)
+*/
+function getCssText(options) {
+	return getGlobalInjector().getCssText(options);
+}
+/**
+* Collect only CSS used by a rendered subtree (like jest-styled-components).
+* Pass the container returned by render(...).
+*/
+function getCssTextForNode(node, options) {
+	const classSet = /* @__PURE__ */ new Set();
+	const readClasses = (el) => {
+		const cls = el.getAttribute("class");
+		if (!cls) return;
+		for (const token of cls.split(/\s+/)) if (/^t\d+$/.test(token)) classSet.add(token);
+	};
+	if (node.getAttribute) readClasses(node);
+	const elements = node.querySelectorAll ? node.querySelectorAll("[class]") : [];
+	if (elements) elements.forEach(readClasses);
+	return getGlobalInjector().getCssTextForClasses(classSet, options);
+}
+/**
+* Force cleanup of unused rules
+*/
+function cleanup(root) {
+	return getGlobalInjector().cleanup(root);
+}
+/**
+* Check if we're currently running in a test environment
+*/
+function getIsTestEnvironment() {
+	return isTestEnvironment();
+}
+/**
+* Get the global injector instance for debugging
+*/
+const injector = { get instance() {
+	return getGlobalInjector();
+} };
+/**
+* Destroy all resources and clean up
+*/
+function destroy(root) {
+	return getGlobalInjector().destroy(root);
+}
+/**
+* Create a new isolated injector instance
+*/
+function createInjector(config = {}) {
+	return new StyleInjector({
+		...getConfig(),
+		forceTextInjection: config.forceTextInjection ?? isTestEnvironment(),
+		...config
+	});
+}
+
+//#endregion
+export { allocateClassName, cleanup, createInjector, destroy, getCssText, getCssTextForNode, getIsTestEnvironment, getRawCSSText, inject, injectGlobal, injectRawCSS, injector, isPropertyDefined, keyframes, property, trackRef };
+//# sourceMappingURL=index.js.map

package/dist/injector/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/injector/index.ts"],"sourcesContent":["import {\n  getConfig,\n  getGlobalInjector,\n  isTestEnvironment,\n  markStylesGenerated,\n} from '../config';\nimport type { StyleResult } from '../pipeline';\n\nimport { StyleInjector } from './injector';\nimport type {\n  GlobalInjectResult,\n  InjectResult,\n  KeyframesResult,\n  KeyframesSteps,\n  StyleInjectorConfig,\n} from './types';\n\n/**\n * Allocate a className for a cacheKey without injecting styles yet\n */\nexport function allocateClassName(\n  cacheKey: string,\n  options?: { root?: Document | ShadowRoot },\n): { className: string; isNewAllocation: boolean } {\n  return getGlobalInjector().allocateClassName(cacheKey, options);\n}\n\n/**\n * Track a reference to an already-injected cacheKey (refCount + dispose).\n * Used on cache hits (SSR hydration or runtime reuse) where the pipeline\n * was skipped. Returns null if the cacheKey is not in the cache.\n */\nexport function trackRef(\n  cacheKey: string,\n  options?: { root?: Document | ShadowRoot },\n): InjectResult | null {\n  return getGlobalInjector().trackRef(cacheKey, options);\n}\n\n/**\n * Inject styles and return className with dispose function\n */\nexport function inject(\n  rules: StyleResult[],\n  options?: { root?: Document | ShadowRoot; cacheKey?: string },\n): InjectResult {\n  // Mark that styles have been generated (prevents configuration changes)\n  markStylesGenerated();\n\n  return getGlobalInjector().inject(rules, options);\n}\n\n/**\n * Inject global rules that should not reserve tasty class names\n */\nexport function injectGlobal(\n  rules: StyleResult[],\n  options?: { root?: Document | ShadowRoot },\n): GlobalInjectResult {\n  return getGlobalInjector().injectGlobal(rules, options);\n}\n\n/**\n * Inject raw CSS text directly without parsing\n * This is a low-overhead method for injecting raw CSS that doesn't need tasty processing.\n * The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking.\n *\n * @example\n * ```tsx\n * // Inject raw CSS\n * const { dispose } = injectRawCSS(`\n *   body { margin: 0; padding: 0; }\n *   .my-class { color: red; }\n * `);\n *\n * // Later, remove the injected CSS\n * dispose();\n * ```\n */\nexport function injectRawCSS(\n  css: string,\n  options?: { root?: Document | ShadowRoot },\n): { dispose: () => void } {\n  return getGlobalInjector().injectRawCSS(css, options);\n}\n\n/**\n * Get raw CSS text for SSR\n */\nexport function getRawCSSText(options?: {\n  root?: Document | ShadowRoot;\n}): string {\n  return getGlobalInjector().getRawCSSText(options);\n}\n\n/**\n * Inject keyframes and return object with toString() and dispose()\n */\nexport function keyframes(\n  steps: KeyframesSteps,\n  nameOrOptions?: string | { root?: Document | ShadowRoot; name?: string },\n): KeyframesResult {\n  return getGlobalInjector().keyframes(steps, nameOrOptions);\n}\n\nexport interface PropertyOptions {\n  /**\n   * CSS syntax string for the property (e.g., '<color>', '<length>', '<angle>')\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   */\n  initialValue?: string | number;\n  /**\n   * Shadow root or document to inject into\n   */\n  root?: Document | ShadowRoot;\n}\n\n/**\n * Define 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 * Re-registering the same property name is a no-op.\n *\n * @param name - The custom property name (must start with --)\n * @param options - Property configuration\n *\n * @example\n * ```ts\n * // Define a color property that can be animated\n * property('--my-color', {\n *   syntax: '<color>',\n *   initialValue: 'red',\n * });\n *\n * // Define an angle property\n * property('--rotation', {\n *   syntax: '<angle>',\n *   inherits: false,\n *   initialValue: '0deg',\n * });\n * ```\n */\nexport function property(name: string, options?: PropertyOptions): void {\n  return getGlobalInjector().property(name, options);\n}\n\n/**\n * Check if a CSS @property has already been defined\n *\n * @param name - The custom property name to check\n * @param options - Options including root\n */\nexport function isPropertyDefined(\n  name: string,\n  options?: { root?: Document | ShadowRoot },\n): boolean {\n  return getGlobalInjector().isPropertyDefined(name, options);\n}\n\n/**\n * Get CSS text from all sheets (for SSR)\n */\nexport function getCssText(options?: { root?: Document | ShadowRoot }): string {\n  return getGlobalInjector().getCssText(options);\n}\n\n/**\n * Collect only CSS used by a rendered subtree (like jest-styled-components).\n * Pass the container returned by render(...).\n */\nexport function getCssTextForNode(\n  node: ParentNode | Element | DocumentFragment,\n  options?: { root?: Document | ShadowRoot },\n): string {\n  // Collect tasty-generated class names (t<number>) from the subtree\n  const classSet = new Set<string>();\n\n  const readClasses = (el: Element) => {\n    const cls = el.getAttribute('class');\n    if (!cls) return;\n    for (const token of cls.split(/\\s+/)) {\n      if (/^t\\d+$/.test(token)) classSet.add(token);\n    }\n  };\n\n  // Include node itself if it's an Element\n  if ((node as Element).getAttribute) {\n    readClasses(node as Element);\n  }\n  // Walk descendants\n  const elements = (node as ParentNode).querySelectorAll\n    ? (node as ParentNode).querySelectorAll('[class]')\n    : ([] as unknown as NodeListOf<Element>);\n  if (elements) elements.forEach(readClasses);\n\n  return getGlobalInjector().getCssTextForClasses(classSet, options);\n}\n\n/**\n * Force cleanup of unused rules\n */\nexport function cleanup(root?: Document | ShadowRoot): void {\n  return getGlobalInjector().cleanup(root);\n}\n\n/**\n * Check if we're currently running in a test environment\n */\nexport function getIsTestEnvironment(): boolean {\n  return isTestEnvironment();\n}\n\n/**\n * Get the global injector instance for debugging\n */\nexport const injector = {\n  get instance() {\n    return getGlobalInjector();\n  },\n};\n\n/**\n * Destroy all resources and clean up\n */\nexport function destroy(root?: Document | ShadowRoot): void {\n  return getGlobalInjector().destroy(root);\n}\n\n/**\n * Create a new isolated injector instance\n */\nexport function createInjector(\n  config: Partial<StyleInjectorConfig> = {},\n): StyleInjector {\n  const defaultConfig = getConfig();\n\n  const fullConfig: StyleInjectorConfig = {\n    ...defaultConfig,\n    // Auto-enable forceTextInjection in test environments\n    forceTextInjection: config.forceTextInjection ?? isTestEnvironment(),\n    ...config,\n  };\n\n  return new StyleInjector(fullConfig);\n}\n\n// Re-export types\nexport type {\n  StyleInjectorConfig,\n  InjectResult,\n  DisposeFunction,\n  RuleInfo,\n  SheetInfo,\n  RootRegistry,\n  StyleRule,\n  KeyframesInfo,\n  KeyframesResult,\n  KeyframesSteps,\n  KeyframesCacheEntry,\n  CacheMetrics,\n  RawCSSResult,\n  PropertyDefinition,\n} from './types';\n\nexport { StyleInjector } from './injector';\nexport { SheetManager } from './sheet-manager';\n"],"mappings":";;;;;;;;AAoBA,SAAgB,kBACd,UACA,SACiD;AACjD,QAAO,mBAAmB,CAAC,kBAAkB,UAAU,QAAQ;;;;;;;AAQjE,SAAgB,SACd,UACA,SACqB;AACrB,QAAO,mBAAmB,CAAC,SAAS,UAAU,QAAQ;;;;;AAMxD,SAAgB,OACd,OACA,SACc;AAEd,sBAAqB;AAErB,QAAO,mBAAmB,CAAC,OAAO,OAAO,QAAQ;;;;;AAMnD,SAAgB,aACd,OACA,SACoB;AACpB,QAAO,mBAAmB,CAAC,aAAa,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;AAoBzD,SAAgB,aACd,KACA,SACyB;AACzB,QAAO,mBAAmB,CAAC,aAAa,KAAK,QAAQ;;;;;AAMvD,SAAgB,cAAc,SAEnB;AACT,QAAO,mBAAmB,CAAC,cAAc,QAAQ;;;;;AAMnD,SAAgB,UACd,OACA,eACiB;AACjB,QAAO,mBAAmB,CAAC,UAAU,OAAO,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkD5D,SAAgB,SAAS,MAAc,SAAiC;AACtE,QAAO,mBAAmB,CAAC,SAAS,MAAM,QAAQ;;;;;;;;AASpD,SAAgB,kBACd,MACA,SACS;AACT,QAAO,mBAAmB,CAAC,kBAAkB,MAAM,QAAQ;;;;;AAM7D,SAAgB,WAAW,SAAoD;AAC7E,QAAO,mBAAmB,CAAC,WAAW,QAAQ;;;;;;AAOhD,SAAgB,kBACd,MACA,SACQ;CAER,MAAM,2BAAW,IAAI,KAAa;CAElC,MAAM,eAAe,OAAgB;EACnC,MAAM,MAAM,GAAG,aAAa,QAAQ;AACpC,MAAI,CAAC,IAAK;AACV,OAAK,MAAM,SAAS,IAAI,MAAM,MAAM,CAClC,KAAI,SAAS,KAAK,MAAM,CAAE,UAAS,IAAI,MAAM;;AAKjD,KAAK,KAAiB,aACpB,aAAY,KAAgB;CAG9B,MAAM,WAAY,KAAoB,mBACjC,KAAoB,iBAAiB,UAAU,GAC/C,EAAE;AACP,KAAI,SAAU,UAAS,QAAQ,YAAY;AAE3C,QAAO,mBAAmB,CAAC,qBAAqB,UAAU,QAAQ;;;;;AAMpE,SAAgB,QAAQ,MAAoC;AAC1D,QAAO,mBAAmB,CAAC,QAAQ,KAAK;;;;;AAM1C,SAAgB,uBAAgC;AAC9C,QAAO,mBAAmB;;;;;AAM5B,MAAa,WAAW,EACtB,IAAI,WAAW;AACb,QAAO,mBAAmB;GAE7B;;;;AAKD,SAAgB,QAAQ,MAAoC;AAC1D,QAAO,mBAAmB,CAAC,QAAQ,KAAK;;;;;AAM1C,SAAgB,eACd,SAAuC,EAAE,EAC1B;AAUf,QAAO,IAAI,cAP6B;EACtC,GAHoB,WAAW;EAK/B,oBAAoB,OAAO,sBAAsB,mBAAmB;EACpE,GAAG;EACJ,CAEmC"}

package/dist/injector/injector.d.ts

@@ -0,0 +1,148 @@
+import { CacheMetrics, GlobalInjectResult, InjectResult, KeyframesResult, KeyframesSteps, PropertyDefinition, RawCSSResult, StyleInjectorConfig } from "./types.js";
+import { StyleResult } from "../pipeline/index.js";
+import { SheetManager } from "./sheet-manager.js";
+
+//#region src/injector/injector.d.ts
+declare class StyleInjector {
+  private sheetManager;
+  private config;
+  private cleanupScheduled;
+  private globalRuleCounter;
+  /** @internal — exposed for debug utilities only */
+  get _sheetManager(): SheetManager;
+  constructor(config?: StyleInjectorConfig);
+  /**
+   * Allocate a className for a cacheKey without injecting styles yet.
+   * This allows separating className allocation (render phase) from style injection (insertion phase).
+   */
+  allocateClassName(cacheKey: string, options?: {
+    root?: Document | ShadowRoot;
+  }): {
+    className: string;
+    isNewAllocation: boolean;
+  };
+  /**
+   * Inject styles from StyleResult objects
+   */
+  inject(rules: StyleResult[], options?: {
+    root?: Document | ShadowRoot;
+    cacheKey?: string;
+  }): InjectResult;
+  /**
+   * Inject global styles (rules without a generated tasty class selector)
+   * This ensures we don't reserve a tasty class name (t{number}) for global rules,
+   * which could otherwise collide with element-level styles and break lookups.
+   */
+  injectGlobal(rules: StyleResult[], options?: {
+    root?: Document | ShadowRoot;
+  }): GlobalInjectResult;
+  /**
+   * Inject raw CSS text directly without parsing
+   * This is a low-overhead alternative to createGlobalStyle for raw CSS
+   * The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking
+   */
+  injectRawCSS(css: string, options?: {
+    root?: Document | ShadowRoot;
+  }): RawCSSResult;
+  /**
+   * Get raw CSS text for SSR
+   */
+  getRawCSSText(options?: {
+    root?: Document | ShadowRoot;
+  }): string;
+  /**
+   * Increment refCount for an already-injected cacheKey and return a dispose.
+   * Used by useStyles on cache hits (hydration or runtime reuse) where
+   * the pipeline was skipped but refCount tracking is still needed.
+   * Returns null if the cacheKey is not found.
+   */
+  trackRef(cacheKey: string, options?: {
+    root?: Document | ShadowRoot;
+  }): InjectResult | null;
+  /**
+   * Dispose of a className
+   */
+  private dispose;
+  /**
+   * Force bulk cleanup of unused styles
+   */
+  cleanup(root?: Document | ShadowRoot): void;
+  /**
+   * Get CSS text from all sheets (for SSR)
+   */
+  getCssText(options?: {
+    root?: Document | ShadowRoot;
+  }): string;
+  /**
+   * Get CSS only for the provided tasty classNames (e.g., ["t0","t3"])
+   */
+  getCssTextForClasses(classNames: Iterable<string>, options?: {
+    root?: Document | ShadowRoot;
+  }): string;
+  /**
+   * Get cache performance metrics
+   */
+  getMetrics(options?: {
+    root?: Document | ShadowRoot;
+  }): CacheMetrics | null;
+  /**
+   * Reset cache performance metrics
+   */
+  resetMetrics(options?: {
+    root?: Document | ShadowRoot;
+  }): void;
+  /**
+   * Define a CSS @property custom property.
+   *
+   * 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)
+   *
+   * Example:
+   * @property --rotation { syntax: "<angle>"; inherits: false; initial-value: 45deg; }
+   *
+   * Note: No caching or dispose — this defines a global property.
+   *
+   * If the same property is registered with different options, a warning is emitted
+   * but the original definition is preserved (CSS @property cannot be redefined).
+   */
+  property(name: string, options?: PropertyDefinition & {
+    root?: Document | ShadowRoot;
+  }): void;
+  /**
+   * Check whether a given @property name was already injected by this injector.
+   *
+   * Accepts tasty token syntax:
+   * - `$name` → checks `--name`
+   * - `#name` → checks `--name-color`
+   * - `--name` → checks `--name` (legacy format)
+   */
+  isPropertyDefined(name: string, options?: {
+    root?: Document | ShadowRoot;
+  }): boolean;
+  /**
+   * Inject keyframes and return object with toString() and dispose()
+   *
+   * Keyframes are cached by content (steps). If the same content is injected
+   * multiple times with different provided names, the first injected name is reused.
+   *
+   * If the same name is provided with different content (collision), a unique
+   * name is generated to avoid overwriting the existing keyframes.
+   */
+  keyframes(steps: KeyframesSteps, nameOrOptions?: string | {
+    root?: Document | ShadowRoot;
+    name?: string;
+  }): KeyframesResult;
+  /**
+   * Dispose keyframes
+   */
+  private disposeKeyframes;
+  /**
+   * Destroy all resources for a root
+   */
+  destroy(root?: Document | ShadowRoot): void;
+}
+//#endregion
+export { StyleInjector };
+//# sourceMappingURL=injector.d.ts.map