@codeleap/styles 6.2.3 → 6.8.0

package/dist/classes/Cacher.d.ts

@@ -0,0 +1,87 @@
+import { CacheType } from '../types/cache';
+import { StateStorage } from '../types/store';
+/**
+ * Generic cache implementation with persistence and stale time management
+ * @template T - The type of values stored in the cache
+ */
+export declare class Cache<T extends any = any> {
+    registryName: CacheType;
+    private storage;
+    persistCache: boolean;
+    /** In-memory cache storage */
+    cache: Record<string, T>;
+    /** Debounce timer for batch persistence */
+    private persistTimer;
+    /** Debounce delay in milliseconds */
+    private persistDelay;
+    /**
+     * Gets the persistence key for cache data
+     * @returns {string} The storage key for cache data
+     */
+    get persistKeyCache(): string;
+    /**
+     * Gets the persistence key for stale time
+     * @returns {string} The storage key for stale time
+     */
+    get persistKeyStaleTime(): string;
+    /**
+     * Creates a new Cache instance
+     * @param {CacheType} registryName - The name/type of the cache registry
+     * @param {StateStorage} [storage=null] - The storage implementation for persistence
+     * @param {boolean} [persistCache=!!storage] - Whether to persist cache to storage
+     */
+    constructor(registryName: CacheType, storage?: StateStorage | null | undefined, persistCache?: boolean);
+    /**
+     * Generates a cache key and retrieves the cached value
+     * @param {string} cacheBaseKey - The base key for cache generation
+     * @param {Array<any> | any} data - The data to use for key generation
+     * @returns {{ key: string, value: T | null }} Object containing the cache key and value
+     */
+    keyFor(cacheBaseKey: string, data: Array<any> | any): {
+        key: string;
+        value: NonNullable<T> | null;
+    };
+    /**
+     * Stores a value in the cache and optionally persists it
+     * @param {string} key - The cache key
+     * @param {T} cache - The value to cache
+     * @returns {T} The cached value
+     */
+    cacheFor(key: string, cache: T): T;
+    /**
+     * Replaces the entire cache with new data
+     * @param {Record<string, T>} cache - The new cache data
+     */
+    setCache(cache: Record<string, T>): void;
+    /**
+     * Clears both in-memory and persistent cache
+     */
+    clear(): void;
+    /**
+     * Schedules cache persistence with debounce
+     */
+    private schedulePersist;
+    /**
+     * Loads cache data and stale time from persistent storage
+     * @returns {{ persistedStaleTime: Date, persistedCache: any }} Loaded data from storage
+     */
+    loadStorage(): {
+        persistedStaleTime: Date;
+        persistedCache: any;
+    };
+    /**
+     * Clears cache data from persistent storage
+     */
+    clearStorage(): void;
+    /**
+     * Stores cache data to persistent storage
+     * @param {Record<string, T>} [cache=null] - Cache data to store (uses current cache if not provided)
+     */
+    storeCache(cache?: Record<string, T> | undefined): void;
+    /**
+     * Stores stale time to persistent storage
+     * @param {Date} staleTime - The stale time to store
+     */
+    storeStaleTime(staleTime: Date): void;
+}
+//# sourceMappingURL=Cacher.d.ts.map

package/dist/classes/Cacher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cacher.d.ts","sourceRoot":"","sources":["../../src/classes/Cacher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAkB7C;;;GAGG;AACH,qBAAa,KAAK,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG;IAiC3B,YAAY,EAAE,SAAS;IAC9B,OAAO,CAAC,OAAO;IACR,YAAY,EAAE,OAAO;IAlC9B,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAK;IAE7B,2CAA2C;IAC3C,OAAO,CAAC,YAAY,CAA6C;IAEjE,qCAAqC;IACrC,OAAO,CAAC,YAAY,CAAe;IAEnC;;;OAGG;IACH,IAAI,eAAe,WAElB;IAED;;;OAGG;IACH,IAAI,mBAAmB,WAEtB;IAED;;;;;OAKG;gBAEM,YAAY,EAAE,SAAS,EACtB,OAAO,GAAE,YAAY,GAAG,IAAI,GAAG,SAAqB,EACrD,YAAY,GAAE,OAAmB;IAuB1C;;;;;OAKG;IACH,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,GAAG;;;;IAYnD;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAU9B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IAIjC;;OAEG;IACH,KAAK;IAUL;;OAEG;IACF,OAAO,CAAC,eAAe;IAWxB;;;OAGG;IACH,WAAW;;;;IAYX;;OAEG;IACH,YAAY;IAOZ;;;OAGG;IACH,UAAU,CAAC,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,SAAqB;IAO3D;;;OAGG;IACH,cAAc,CAAC,SAAS,EAAE,IAAI;CAM/B"}

package/dist/classes/StaleControl.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @UNUSED_IMPLEMENTATION - Class available for future use
+ * Stale data controller with temporal expiration system
+ *
+ * @description This implementation is complete but not currently being used.
+ * Developed for potential future need of time-based cache invalidation.
+ */
+export declare class StaleControl {
+    private staleTime;
+    private staleTimeIdentifier;
+    private wiperInterval;
+    private wiperId;
+    /**
+     * @param staleTime - Expiration time in minutes (default: 60 minutes)
+     * @param staleTimeIdentifier - Separator to identify timestamp in value (default: '//:')
+     * @param wiperInterval - Expired data check interval in milliseconds (default: 30 minutes)
+     */
+    constructor(staleTime?: number, // minutes
+    staleTimeIdentifier?: string, wiperInterval?: number);
+    /**
+     * Checks if a value is expired based on embedded timestamp
+     * @param value - Value with embedded timestamp
+     * @returns boolean indicating if value is expired
+     */
+    isStaled(value: string): boolean;
+    /**
+     * Inserts expiration timestamp into a value
+     * @param value - Original value without timestamp
+     * @returns Value with expiration timestamp embedded
+     */
+    insertStaleTime(value: string): string;
+    /**
+     * Refreshes the expiration timestamp of a value
+     * @param value - Value with existing timestamp
+     * @returns Value with refreshed expiration timestamp
+     */
+    refreshStaleTime(value: string): string;
+    /**
+     * Extracts expiration timestamp and original value
+     * @param value - Value with embedded timestamp
+     * @returns Object containing expiration date and original value
+     */
+    extractStaleTime(value: string): {
+        staleTime: Date;
+        value: string;
+    };
+    /**
+     * Wipes expired cache; verifies isStaled values and removes them
+     * @throws Error indicating method is not implemented
+     */
+    cacheWiper(): void;
+    /**
+     * Registers periodic cache cleaning interval
+     */
+    registerCacheWiper(): void;
+    /**
+     * Unregisters periodic cache cleaning interval
+     */
+    unregisterCacheWiper(): void;
+    /**
+     * Cleanup method to clear intervals when instance is no longer needed
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=StaleControl.d.ts.map

package/dist/classes/StaleControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StaleControl.d.ts","sourceRoot":"","sources":["../../src/classes/StaleControl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACF,qBAAa,YAAY;IAStB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,aAAa;IAVvB,OAAO,CAAC,OAAO,CAA8C;IAE7D;;;;OAIG;gBAEO,SAAS,GAAE,MAAW,EAAE,UAAU;IAClC,mBAAmB,GAAE,MAAc,EACnC,aAAa,GAAE,MAAuB;IAGhD;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAUhC;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAUtC;;;;OAIG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAOvC;;;;OAIG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,SAAS,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;IAUnE;;;OAGG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAU1B;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAO5B;;OAEG;IACH,OAAO,IAAI,IAAI;CAGhB"}

package/dist/classes/StyleCache.d.ts

@@ -0,0 +1,63 @@
+import { Cache } from './Cacher';
+import { CacheType } from '../types/cache';
+import { StateStorage } from '../types/store';
+/**
+ * Aggregates the six typed `Cache` buckets used by the style registry.
+ * Three buckets (`styles`, `compositions`, `responsive`) are in-memory only.
+ * Three buckets (`variants`, `common`, `components`) are backed by the
+ * provided `StateStorage` and survive page reloads until the stale window expires.
+ *
+ * All keys are derived from a `baseKey` that encodes the active color scheme,
+ * theme snapshot, and common variants — so switching color scheme automatically
+ * invalidates all cached values without an explicit `wipeCache` call.
+ */
+export declare class StyleCache {
+    /** Base key used for cache key generation */
+    baseKey: string;
+    /** Cache for style data */
+    styles: Cache<any>;
+    /** Cache for style compositions */
+    compositions: Cache<any>;
+    /** Cache for responsive styles */
+    responsive: Cache<any>;
+    /** Cache for style variants with persistent storage */
+    variants: Cache;
+    /** Cache for common styles with persistent storage */
+    common: Cache;
+    /** Cache for component styles with persistent storage */
+    components: Cache;
+    /**
+     * Creates a new StyleCache instance
+     * @param storage - State storage instance for persistent caches
+     */
+    constructor(storage: StateStorage);
+    /**
+     * Registers and generates a base key for cache operations
+     * @param keys - Array of values to include in base key generation
+     * @returns The generated base key hash
+     */
+    registerBaseKey(keys: Array<any>): string;
+    /**
+     * Clears all cache instances
+     */
+    wipeCache(): void;
+    /**
+     * Generates a cache key and retrieves cached value if exists
+     * @param type - The cache type to use
+     * @param keyData - Data to use for key generation (array or object)
+     * @returns Object containing the generated key and cached value (if any)
+     */
+    keyFor(type: CacheType, keyData: Array<any> | any): {
+        key: string;
+        value: any;
+    };
+    /**
+     * Stores a value in the specified cache with compression
+     * @param type - The cache type to use
+     * @param key - Cache key
+     * @param value - Value to cache
+     * @returns The cached value (compressed if caching is enabled)
+     */
+    cacheFor(type: CacheType, key: string, value: any): any;
+}
+//# sourceMappingURL=StyleCache.d.ts.map

package/dist/classes/StyleCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StyleCache.d.ts","sourceRoot":"","sources":["../../src/classes/StyleCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAGhC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE7C;;;;;;;;;GASG;AACH,qBAAa,UAAU;IACrB,6CAA6C;IAC7C,OAAO,EAAG,MAAM,CAAA;IAEhB,2BAA2B;IAC3B,MAAM,aAAsB;IAE5B,mCAAmC;IACnC,YAAY,aAA4B;IAExC,kCAAkC;IAClC,UAAU,aAA0B;IAEpC,uDAAuD;IACvD,QAAQ,EAAE,KAAK,CAAA;IAEf,sDAAsD;IACtD,MAAM,EAAE,KAAK,CAAA;IAEb,yDAAyD;IACzD,UAAU,EAAE,KAAK,CAAA;IAEjB;;;OAGG;gBACS,OAAO,EAAE,YAAY;IAMjC;;;;OAIG;IACH,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,MAAM;IAUzC;;OAEG;IACH,SAAS,IAAI,IAAI;IASjB;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,GAAG,CAAA;KAAE;IAsB/E;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG;CAWxD"}

package/dist/classes/StylePersistor.d.ts

@@ -0,0 +1,52 @@
+import { StateStorage } from '../types/store';
+/**
+ * Platform-specific storage adapter required by `StylePersistor`.
+ * Implementations exist for MMKV (mobile) and localStorage (web).
+ * Note the method names (`set`/`get`/`del`) differ from the `StateStorage` interface
+ * (`setItem`/`getItem`/`removeItem`) — `StylePersistor` bridges the two.
+ */
+export type StoragePersistor = {
+    set: (key: string, value: any) => void;
+    get: (key: string) => any;
+    del: (key: string) => void;
+};
+/**
+ * Adapts a platform `StoragePersistor` to the `StateStorage` interface expected by
+ * `StyleCache`. All values are LZ-compressed on write and decompressed on read,
+ * substantially reducing storage footprint for large serialised style caches.
+ */
+export declare class StylePersistor implements StateStorage {
+    private storage;
+    /**
+     * Creates a new StylePersistor instance with compression capabilities
+     * @param {StoragePersistor} storage - The underlying storage implementation
+     */
+    constructor(storage: StoragePersistor);
+    /**
+     * Stores a value in the underlying storage with compression
+     *
+     * @param {string} name - Storage key identifier
+     * @param {string} value - Value to store (will be compressed)
+     * @returns {void}
+     * @throws {Error} If the underlying storage fails to set the value
+     */
+    setItem(name: string, value: string): void;
+    /**
+     * Retrieves and decompresses a value from storage
+     * Returns null if key doesn't exist, value is null/undefined, or decompression fails
+     *
+     * @param {string} name - Storage key identifier
+     * @returns {string | null} Decompressed value or null if not found/invalid
+     * @throws {Error} If the underlying storage fails to get the value
+     */
+    getItem(name: string): string | null;
+    /**
+     * Removes an item from storage
+     *
+     * @param {string} name - Storage key identifier
+     * @returns {void}
+     * @throws {Error} If the underlying storage fails to delete the value
+     */
+    removeItem(name: string): void;
+}
+//# sourceMappingURL=StylePersistor.d.ts.map

package/dist/classes/StylePersistor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StylePersistor.d.ts","sourceRoot":"","sources":["../../src/classes/StylePersistor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAI7C;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;IACtC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAA;IACzB,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3B,CAAA;AAED;;;;GAIG;AACH,qBAAa,cAAe,YAAW,YAAY;IAM/C,OAAO,CAAC,OAAO;IALjB;;;OAGG;gBAEO,OAAO,EAAE,gBAAgB;IAGnC;;;;;;;OAOG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAM1C;;;;;;;OAOG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAUpC;;;;;;OAMG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAG/B"}

package/dist/classes/StyleRegistry.d.ts

@@ -0,0 +1,108 @@
+import type { AnyStyledComponent, ComponentContext, ICSS, ITheme, StyleAggregator, StyleProp, VariantStyleSheet } from '../types';
+import type { StateStorage } from '../types/store';
+import type { MultiplierFunction } from '../variants';
+/**
+ * Central style resolution engine for the `@codeleap/styles` system.
+ *
+ * Responsibilities:
+ * - Stores compressed variant stylesheets per component (`stylesheets`).
+ * - Maintains the merged common-variant map (`defaultVariants + appVariants + dynamicVariants + spacing`).
+ * - Resolves `StyleProp` values into flat `ICSS` objects for each composition element.
+ * - Caches every resolution step in the six `StyleCache` buckets for performance.
+ * - Provides `createStyle` as an abstract hook for platform-specific style flattening
+ *   (web passes through; RN uses `StyleSheet.flatten`).
+ *
+ * Instantiated once per platform registry (not per component). Platform packages
+ * subclass or configure this to provide the appropriate `createStyle` implementation.
+ */
+export declare class CodeleapStyleRegistry {
+    stylesheets: Record<string, VariantStyleSheet>;
+    commonVariants: Record<string, ICSS | MultiplierFunction>;
+    aggregators: Record<string, StyleAggregator>;
+    components: Record<string, AnyStyledComponent>;
+    /** Per-component map of variant names to context-aware factory functions. Populated during `registerVariants`. */
+    variantFactories: Record<string, Record<string, (theme: ITheme, context: ComponentContext) => any>>;
+    private styleCache;
+    constructor(storage: StateStorage);
+    /**
+     * Resolves a single common-variant string (e.g., `"flex"`, `"padding:2"`, `"xl:flex"`)
+     * into a composition-keyed style object. Handles breakpoint-prefixed variants by wrapping
+     * the result in a `@media` key. Returns `null` if the variant is not found in `commonVariants`.
+     */
+    computeCommonVariantStyle(componentName: string, variant: string, component?: string | undefined): {
+        [x: string]: ICSS;
+    } | null;
+    /**
+     * Resolves an array of variant strings for a component into a single merged `ICSS`.
+     * Checks component-level variant stylesheet first, then falls back to common variants.
+     * Context-aware factories (registered via `CONTEXT_FACTORY_SYMBOL`) are called with
+     * the current theme and the provided `context` object.
+     */
+    computeVariantStyle(componentName: string, variants: string[], _component?: string | undefined, context?: ComponentContext): ICSS;
+    /**
+     * Determines whether a style object contains composition keys for a given component.
+     * A key is a composition key if it starts with one of the component's `elements` strings
+     * and is not in `ignoredStyleKeys`. Returns both a boolean flag and the extracted
+     * composition sub-record so callers can avoid a second pass.
+     */
+    isCompositionStyle(component: AnyStyledComponent, style: any): {
+        isComposition: boolean;
+        composition: Record<string, any>;
+    };
+    /**
+     * Checks whether a style object contains a `breakpoints` key, indicating it uses
+     * the responsive style API. Returns the key name alongside the boolean so the caller
+     * can use it to read and delete the breakpoints entry without a repeated `'breakpoints'`
+     * string literal.
+     */
+    isResponsiveStyle(style: any): {
+        responsiveStyleKey: string;
+        isResponsive: boolean;
+    };
+    getDefaultVariantStyle(componentName: string, defaultVariantStyleName?: string): any;
+    mergeStylesWithCache<T = unknown>(styles: ICSS[], key: string): T;
+    getRegisteredComponent(componentName: string): {
+        rootElement: string;
+        registeredComponent: AnyStyledComponent;
+    };
+    getResponsiveStyle(componentName: string, responsiveStyleKey: string, style: Record<string, any>): any;
+    getStyles(componentName: string, _style: any, component?: any, predicateObj?: (style: any) => any): {};
+    private getMediaQuery;
+    getStyleWithResponsive(componentName: string, style: any, component?: any): any;
+    getCompositionStyle(componentName: string, composition: Record<string, any>, style: any): any;
+    styleFor<T = unknown>(componentName: string, componentStyle: StyleProp<T & string>, mergeWithDefaultStyle?: boolean, context?: ComponentContext): T;
+    /**
+     * Rebuilds `commonVariants` by merging (in ascending priority order):
+     * `defaultVariants` → `appVariants` → `dynamicVariants` → `spacingVariants` → `insetVariants`.
+     * Called once in the constructor; must be re-called (via `update`) if app variants change.
+     */
+    registerCommonVariants(): void;
+    /**
+     * Registers a component's variant stylesheet. No-ops if the component is already
+     * registered (variants are immutable after first registration). Extracts any
+     * `CONTEXT_FACTORY_SYMBOL`-tagged entries into `variantFactories` for context-aware
+     * resolution, then compresses and stores the remaining variants.
+     */
+    registerVariants<Composition extends string = any>(componentName: string, variants: VariantStyleSheet, aggregator?: StyleAggregator<Composition>): void;
+    /**
+     * Records the minimal component metadata (`styleRegistryName`, `elements`,
+     * `rootElement`) needed for composition and style resolution. Only the metadata
+     * is stored — the component function itself is not retained.
+     */
+    registerComponent(component: AnyStyledComponent): void;
+    /**
+      * These should be overwritten by the end-user to support
+      * custom style merging logic, such as StyleSheet.flatten
+      */
+    createStyle(css: ICSS): ICSS;
+    /**
+     * Must be called after the active color scheme changes so that the `StyleCache`
+     * base key is regenerated. Without this call, cached values from the previous
+     * scheme would be returned for the new scheme.
+     */
+    update(): void;
+    private copyStyle;
+    createStyles<K extends string = string>(styles: Record<K, StyleProp<string, ''>> | ((theme: ITheme) => Record<K, StyleProp<string, ''>>)): Record<K, ICSS>;
+    prefixStyle(prefix: string, style: any): any;
+}
+//# sourceMappingURL=StyleRegistry.d.ts.map

package/dist/classes/StyleRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StyleRegistry.d.ts","sourceRoot":"","sources":["../../src/classes/StyleRegistry.ts"],"names":[],"mappings":"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"}

package/dist/classes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './StyleRegistry';
+export * from './StylePersistor';
+//# sourceMappingURL=index.d.ts.map

package/dist/classes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/classes/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA"}

package/dist/constants.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Package-wide feature flags and runtime constants. These are read once at module
+ * load time and are not reactive.
+ *
+ * - `STORES_PERSIST_VERSION` — bumping this value invalidates all persisted caches
+ *   on the next load (because it is included in every `hashKey` call via `registerBaseKey`).
+ * - `STORE_CACHE_ENABLED` — when `false`, the persistent `Cache` instances skip
+ *   loading from and writing to `StateStorage`.
+ * - `CACHE_ENABLED` — when `false`, `StyleCache.cacheFor` returns values without
+ *   writing to any cache bucket, effectively disabling all in-memory caching.
+ * - `IS_BROWSER` — sniffed at load time via `typeof document`; used as a fast guard
+ *   before any DOM access.
+ * - `LOG` — enables verbose `console.log` tracing inside `Cache` and `StylePersistor`.
+ */
+export declare const StyleConstants: {
+    STORES_PERSIST_VERSION: number;
+    STORE_CACHE_ENABLED: boolean;
+    CACHE_ENABLED: boolean;
+    IS_BROWSER: boolean;
+    LOG: boolean;
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc;;;;gBAIE,OAAO;;CAEnC,CAAA"}

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useCompositionStyles';
+export * from './useNestedStylesByKey';
+export * from './useStyleObserver';
+export * from './useTheme';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA"}

package/dist/hooks/useCompositionStyles.d.ts

@@ -0,0 +1,12 @@
+import { ICSS } from '../types';
+/**
+ * Slices a flat component-style record into per-element sub-records, memoised to
+ * avoid unnecessary re-renders. For each element name in `composition`, it calls
+ * `getNestedStylesByKey(element, componentStyles)` to collect all keys that start
+ * with that element name. Accepts either a single element string or an array.
+ *
+ * Useful when a parent component receives a merged `componentStyles` object and
+ * needs to distribute the correct slice to each child element.
+ */
+export declare function useCompositionStyles<T extends string, C extends string>(composition: (T | Array<T>), componentStyles: Partial<Record<C, ICSS>>): Partial<Record<T, ICSS>>;
+//# sourceMappingURL=useCompositionStyles.d.ts.map

package/dist/hooks/useCompositionStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCompositionStyles.d.ts","sourceRoot":"","sources":["../../src/hooks/useCompositionStyles.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAG/B;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EACrE,WAAW,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,EAC3B,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GACxC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAkB1B"}

package/dist/hooks/useNestedStylesByKey.d.ts

@@ -0,0 +1,11 @@
+import { ICSS } from '../types';
+/**
+ * Memoised wrapper around `getNestedStylesByKey`. Returns the sub-record of
+ * `componentStyles` whose keys start with `match`, with the prefix stripped and the
+ * remainder lowercased. Re-computes only when `componentStyles` changes by reference.
+ *
+ * Use instead of `useCompositionStyles` when you need the slice for a single element
+ * and don't want the overhead of iterating over an array.
+ */
+export declare function useNestedStylesByKey<T extends string>(match: string, componentStyles: Partial<Record<T, ICSS>>): Record<string, any>;
+//# sourceMappingURL=useNestedStylesByKey.d.ts.map

package/dist/hooks/useNestedStylesByKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNestedStylesByKey.d.ts","sourceRoot":"","sources":["../../src/hooks/useNestedStylesByKey.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAG/B;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,uBAQ9G"}

package/dist/hooks/useStyleObserver.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Produces a stable string that changes only when the style value changes, suitable
+ * for use as a `useEffect`/`useMemo` dependency when the style prop is an object or
+ * array (which would otherwise trigger on every render due to referential inequality).
+ * Falsy entries are stripped from arrays before serialisation, so `[null, style]` and
+ * `[style]` yield the same string.
+ */
+export declare const useStyleObserver: (style: any) => any;
+//# sourceMappingURL=useStyleObserver.d.ts.map

package/dist/hooks/useStyleObserver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStyleObserver.d.ts","sourceRoot":"","sources":["../../src/hooks/useStyleObserver.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,GAAG,QAU1C,CAAA"}

package/dist/hooks/useTheme.d.ts

@@ -0,0 +1,19 @@
+import { ThemeState } from '../theme';
+type ThemeSelector<T> = (state: ThemeState) => T;
+/**
+ * Subscribes to the global theme state and returns either the full `ThemeState`
+ * (when called without arguments) or a derived value (when called with a selector).
+ * Uses nanostores' `useStore` under the hood, so re-renders are triggered only when
+ * the selected slice changes by reference.
+ *
+ * @example
+ * // Full state
+ * const { theme, colorScheme } = useTheme()
+ *
+ * @example
+ * // Derived slice — component only re-renders when colorScheme changes
+ * const colorScheme = useTheme(s => s.colorScheme)
+ */
+export declare const useTheme: <T = ThemeState>(selector?: ThemeSelector<T>) => T;
+export {};
+//# sourceMappingURL=useTheme.d.ts.map

package/dist/hooks/useTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTheme.d.ts","sourceRoot":"","sources":["../../src/hooks/useTheme.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAsB,MAAM,UAAU,CAAA;AAGzD,KAAK,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,KAAK,CAAC,CAAA;AAEhD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,GAAG,UAAU,EACrC,WAAW,aAAa,CAAC,CAAC,CAAC,KAC1B,CAQF,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import './constants';
+import './utils';
+export * from './classes';
+export * from './hooks';
+export * from './lib';
+export * from './theme';
+export * from './tools';
+export * from './types';
+export * from './variants';
+export * from './constants';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,CAAA;AACpB,OAAO,SAAS,CAAA;AAEhB,cAAc,WAAW,CAAA;AACzB,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA;AACrB,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA;AACvB,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA"}

package/dist/lib/calc.d.ts

@@ -0,0 +1,27 @@
+type Unit = 'px' | 'vh' | 'dvh' | 'vw' | 'dvw' | '%' | 'lvh' | 'svh';
+/**
+ * Chainable builder for CSS `calc()` expressions. Each arithmetic method appends
+ * to the expression and returns `this`, so calls can be chained. Call `build()`
+ * at the end to get the final `calc(...)` string.
+ *
+ * @example
+ * calc(100, '%').sub(16).build() // → 'calc((100%) - (16px))'
+ */
+declare class CalcBuilder {
+    private expression;
+    constructor(initial: number, unit?: Unit);
+    private wrap;
+    sub(value: number, unit?: Unit): this;
+    add(value: number, unit?: Unit): this;
+    mult(value: number): this;
+    div(value: number): this;
+    build(): string;
+}
+/**
+ * Entry point for building CSS `calc()` expressions. Pass an initial numeric value
+ * and optional unit (default `'px'`), then chain `.add()`, `.sub()`, `.mult()`, `.div()`,
+ * and finally call `.build()` to get the complete string.
+ */
+export declare const calc: (base: number, unit?: Unit) => CalcBuilder;
+export {};
+//# sourceMappingURL=calc.d.ts.map

package/dist/lib/calc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calc.d.ts","sourceRoot":"","sources":["../../src/lib/calc.ts"],"names":[],"mappings":"AAAA,KAAK,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,GAAG,KAAK,CAAA;AAEpE;;;;;;;GAOG;AACH,cAAM,WAAW;IACf,OAAO,CAAC,UAAU,CAAQ;gBAEd,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,IAAW;IAI9C,OAAO,CAAC,IAAI;IAIZ,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,IAAW;IAMpC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,IAAW;IAMpC,IAAI,CAAC,KAAK,EAAE,MAAM;IAKlB,GAAG,CAAC,KAAK,EAAE,MAAM;IAKjB,KAAK;CAGN;AAED;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,EAAE,OAAM,IAAW,gBAAgC,CAAA"}

package/dist/lib/createStyles.d.ts

@@ -0,0 +1,30 @@
+import { AnyRecord, ComponentContext, ICSS, ITheme } from '../types';
+type Value = AnyRecord;
+type StylesShape<K extends string, V extends Value> = Partial<Record<K, ICSS & Partial<Omit<V, keyof ICSS>>>>;
+/**
+ * Symbol used to attach a context-aware factory function to a styles proxy.
+ * `CodeleapStyleRegistry.registerVariants` reads this symbol from each entry to
+ * identify which variants require a `ComponentContext` at resolution time.
+ * Not intended for direct use by consumers.
+ */
+export declare const CONTEXT_FACTORY_SYMBOL: unique symbol;
+/**
+ * Creates a reactive styles object that automatically updates when theme changes.
+ * Uses a proxy to re-compute styles on each access, ensuring theme changes are reflected.
+ *
+ * @template K - Style keys (extends string)
+ * @template V - Additional value type (extends AnyRecord)
+ * @param {StylesShape<K, V> | ((theme: ITheme) => StylesShape<K, V>)} styles - Static styles object or function that receives theme
+ * @returns {StylesShape<K, V>} Proxied styles object that recomputes on theme changes
+ */
+export declare function createStyles<K extends string, V extends Value = {}>(styles: StylesShape<K, V> | ((theme: ITheme) => StylesShape<K, V>)): Partial<Record<K, ICSS & Partial<Omit<V, never>>>>;
+/**
+ * Like `createStyles`, but the factory also receives a `ComponentContext` so that
+ * individual style values can vary based on runtime boolean/numeric state (e.g.,
+ * `isDisabled`, `isSelected`). The resulting proxy exposes a `CONTEXT_FACTORY_SYMBOL`
+ * getter so the registry can invoke the factory with the actual context at render time.
+ * Use this instead of `createStyles` when variant styles depend on component state.
+ */
+export declare function createStylesWithContext<K extends string, V extends Value = {}, C extends ComponentContext = {}>(styles: (theme: ITheme, context: C) => StylesShape<K, V>): Partial<Record<K, ICSS & Partial<Omit<V, never>>>>;
+export {};
+//# sourceMappingURL=createStyles.d.ts.map

package/dist/lib/createStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStyles.d.ts","sourceRoot":"","sources":["../../src/lib/createStyles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAGpE,KAAK,KAAK,GAAG,SAAS,CAAA;AAEtB,KAAK,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;AAE7G;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,eAA2B,CAAA;AAE9D;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,KAAK,GAAG,EAAE,EACjE,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,sDAqBnE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,KAAK,GAAG,EAAE,EAAE,CAAC,SAAS,gBAAgB,GAAG,EAAE,EAC7G,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,sDAazD"}

package/dist/lib/createTheme.d.ts

@@ -0,0 +1,28 @@
+import { AppTheme, Theme } from '../types';
+type ThemePersistor = {
+    get: (name: string) => any;
+    set: (name: string, value: any) => void;
+    getNoCompress?: (name: string) => any;
+    setNoCompress?: (name: string, value: any) => void;
+    getSystemColorScheme?: () => string | null;
+};
+/**
+ * Builds and registers the runtime `AppTheme<T>` object from a raw `Theme` definition.
+ *
+ * Key behaviours:
+ * - On web (`theme.isBrowser = true`), `theme.colors` is replaced with a CSS-var proxy
+ *   so all color references become `var(--cl-<token>)` strings. The active scheme's
+ *   real values are still accessible via `theme.currentSchemeColors`.
+ * - Persists the selected color scheme to storage and restores it on next load.
+ *   Falls back to `getSystemColorScheme()` if no persisted value exists.
+ * - `alternateColors` from storage are merged with those in the theme definition
+ *   (runtime-injected schemes take priority).
+ * - The constructed theme is immediately set on `themeStore` so hooks and the registry
+ *   can read it synchronously during the same render pass.
+ *
+ * @param theme - Raw theme object (output of `validateTheme` or a compliant literal).
+ * @param themePersistor - Storage adapter for persisting color-scheme selection and injected schemes.
+ */
+export declare const createTheme: <T extends Theme>(theme: T, themePersistor: ThemePersistor) => AppTheme<T>;
+export {};
+//# sourceMappingURL=createTheme.d.ts.map

package/dist/lib/createTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTheme.d.ts","sourceRoot":"","sources":["../../src/lib/createTheme.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAU,MAAM,UAAU,CAAA;AAMlD,KAAK,cAAc,GAAG;IACpB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,GAAG,CAAA;IAC1B,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;IACvC,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,GAAG,CAAA;IACrC,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;IAClD,oBAAoB,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;CAC3C,CAAA;AAKD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,KAAK,EAAE,OAAO,CAAC,EAAE,gBAAgB,cAAc,KAAG,QAAQ,CAAC,CAAC,CA6LjG,CAAA"}