chaincss 2.0.6 → 2.1.0

package/dist/compiler/btt.d.ts

@@ -1,5 +1,7 @@
 import { DesignTokens } from './tokens.js';
 import type { AtomicOptimizer } from './atomic-optimizer.js';
+export { setBreakpoints } from './breakpoints.js';
+export { chain, enableDebug } from './Chain.js';
 interface StyleSnapshot {
     id: string;
     timestamp: number;
@@ -32,49 +34,21 @@ interface ComponentInfo {
 }
 export declare function generateComponentCode(info: ComponentInfo): string;
 export declare function setSourceComments(enabled: boolean): void;
-declare function calc(expression: string): string;
-declare function add(a: string | number, b: string | number): string;
-declare function subtract(a: string | number, b: string | number): string;
-declare function multiply(a: string | number, b: string | number): string;
-declare function divide(a: string | number, b: string | number): string;
-declare function percent(value: number): string;
-declare function vw(value: number): string;
-declare function vh(value: number): string;
-declare function rem(value: number): string;
-declare function em(value: number): string;
-declare function px(value: number): string;
-declare function min(...values: (string | number)[]): string;
-declare function max(...values: (string | number)[]): string;
-declare function clamp(min: string | number, preferred: string | number, max: string | number): string;
-declare const helpers: {
-    calc: typeof calc;
-    add: typeof add;
-    subtract: typeof subtract;
-    sub: typeof subtract;
-    multiply: typeof multiply;
-    mul: typeof multiply;
-    divide: typeof divide;
-    div: typeof divide;
-    percent: typeof percent;
-    vw: typeof vw;
-    vh: typeof vh;
-    rem: typeof rem;
-    em: typeof em;
-    px: typeof px;
-    min: typeof min;
-    max: typeof max;
-    clamp: typeof clamp;
-};
-declare function enableDebug(enable?: boolean): void;
-declare function setBreakpoints(breakpoints: Record<string, string>): void;
-export interface StyleDefinition {
-    selectors: string[];
-    hover?: Record<string, string | number>;
-    atRules?: AtRule[];
-    nestedRules?: NestedRule[];
-    themes?: ThemeBlock[];
-    [cssProperty: string]: any;
+export interface ChainObject {
+    cssOutput: string;
+    cachedValidProperties: string[];
+    classMap: Record<string, string>;
+    atomicStats: any;
+    componentMap?: Map<string, any>;
+    initializeProperties: () => Promise<void>;
+    getCachedProperties: () => string[] | null;
 }
+export declare const chains: ChainObject;
+declare let atomicOptimizer: AtomicOptimizer | null;
+export declare function setAtomicOptimizer(optimizer: AtomicOptimizer | null): void;
+export declare function configureAtomic(opts: Record<string, any>): void;
+export declare const tokens: DesignTokens;
+export declare function createTokens(tokenValues: Record<string, any>): DesignTokens;
 export interface AtRule {
     type: 'media' | 'keyframes' | 'font-face' | 'supports' | 'container' | 'layer' | 'counter-style' | 'property';
     query?: string;
@@ -95,23 +69,14 @@ export interface ThemeBlock {
     tokens: any;
     fallback: any;
 }
-export interface ChainObject {
-    cssOutput: string;
-    catcher: any;
-    cachedValidProperties: string[];
-    classMap: Record<string, string>;
-    atomicStats: any;
-    componentMap?: Map<string, any>;
-    initializeProperties: () => Promise<void>;
-    getCachedProperties: () => string[] | null;
+export interface StyleDefinition {
+    selectors: string[];
+    hover?: Record<string, string | number>;
+    atRules?: AtRule[];
+    nestedRules?: NestedRule[];
+    themes?: ThemeBlock[];
+    [cssProperty: string]: any;
 }
-export declare const chain: ChainObject;
-declare let atomicOptimizer: AtomicOptimizer | null;
-export declare function setAtomicOptimizer(optimizer: AtomicOptimizer | null): void;
-export declare function configureAtomic(opts: Record<string, any>): void;
-export declare const tokens: DesignTokens;
-export declare function createTokens(tokenValues: Record<string, any>): DesignTokens;
-export declare const $: any;
 export declare const run: (...args: any[]) => string;
 export declare const compile: (obj: Record<string, StyleDefinition>) => string;
 export interface RecipeOptions<TVariants extends Record<string, Record<string, any>>> {
@@ -140,7 +105,18 @@ export type Recipe<TVariants extends Record<string, Record<string, any>>> = {
         [K in keyof TVariants]: keyof TVariants[K];
     }>>;
     compileAll: () => string;
+    getVariantClassNames: () => Record<string, string>;
 };
 export declare function recipe<TVariants extends Record<string, Record<string, any>>>(options: RecipeOptions<TVariants>): Recipe<TVariants>;
-export { atomicOptimizer, chain as chainObject, setBreakpoints, enableDebug, helpers };
-//# sourceMappingURL=btt.d.ts.map
+/**
+ * The "Brain": Extracts ChainCSS calls from raw text
+ */
+export declare const scanContent: (text: string) => string[];
+/**
+ * The "Worker": Reads the file, uses the Brain, feeds the Optimizer
+ */
+export declare function scanFileForStyles(filePath: string, optimizer: any, source?: string | null): {
+    foundCount: number;
+    errors: Error[];
+};
+export { atomicOptimizer, chains as chainObject };

package/dist/compiler/cache-manager.d.ts

@@ -1,20 +1,74 @@
 export interface CacheData {
     version: string;
     created: string;
+    updated: string;
     atomic: Record<string, any>;
     usage: Record<string, any>;
+    componentMap: Record<string, any>;
+    stats: {
+        totalStyles: number;
+        atomicStyles: number;
+        cacheHits: number;
+        cacheMisses: number;
+    };
     [key: string]: any;
 }
+export interface CacheOptions {
+    maxAge?: number;
+    maxSize?: number;
+    compress?: boolean;
+    autoSave?: boolean;
+    saveInterval?: number;
+}
 export declare class CacheManager {
     cachePath: string;
     cacheDir: string;
     cache: CacheData | Record<string, any>;
-    constructor(cachePath?: string);
+    private dirty;
+    private saveTimer;
+    private stats;
+    private options;
+    constructor(cachePath?: string, options?: CacheOptions);
+    private startAutoSave;
+    private stopAutoSave;
     load(): void;
+    private getDefaultCache;
+    private isExpired;
+    private checkAndPrune;
+    private isCompressed;
+    private compress;
+    private decompress;
     get(key: string): any;
-    set(key: string, value: any): void;
-    save(): void;
+    set(key: string, value: any, ttl?: number): void;
+    has(key: string): boolean;
+    delete(key: string): boolean;
     clear(): void;
+    prune(): void;
+    save(): void;
+    getStats(): {
+        hits: number;
+        misses: number;
+        reads: number;
+        writes: number;
+        hitRate: number;
+        size: number;
+        entryCount: number;
+    };
+    getCacheSize(): number;
+    getCacheAge(): number;
+    getKeys(): string[];
+    getSize(): number;
+    isDirty(): boolean;
+    flush(): Promise<void>;
+    destroy(): void;
+    getEntry(key: string): {
+        value: any;
+        cachedAt: number;
+        expires?: number;
+    } | undefined;
+    setWithTTL(key: string, value: any, ttlSeconds: number): void;
+    setBulk(entries: Record<string, any>): void;
+    getBulk(keys: string[]): Record<string, any>;
+    getOrCompute<T>(key: string, compute: () => Promise<T>, ttl?: number): Promise<T>;
 }
 export { CacheManager as default };
-//# sourceMappingURL=cache-manager.d.ts.map

package/dist/compiler/commonProps.d.ts

@@ -1,2 +1 @@
 export declare const COMMON_CSS_PROPERTIES: string[];
-//# sourceMappingURL=commonProps.d.ts.map

package/dist/compiler/content-addressable-cache.d.ts

@@ -0,0 +1,78 @@
+export interface PersistentCacheEntry {
+    hash: string;
+    result: any;
+    dependencies: Record<string, string>;
+    timestamp: number;
+    version: string;
+    compilerVersion: string;
+    createdAt?: number;
+    lastAccessed?: number;
+    accessCount?: number;
+    size?: number;
+    value?: any;
+}
+export interface PersistentCacheOptions {
+    cacheDir?: string;
+    maxAgeDays?: number;
+    maxSizeMB?: number;
+    enabled?: boolean;
+    verbose?: boolean;
+}
+export declare class PersistentCache {
+    private cacheDir;
+    private options;
+    private memoryCache;
+    private metadataPath;
+    private metadata;
+    constructor(options?: PersistentCacheOptions);
+    private hash;
+    private hashFile;
+    getByContent(source: string): Promise<any | null>;
+    getByFile(filePath: string): Promise<any | null>;
+    getByHash(hash: string): Promise<any | null>;
+    setByContent(source: string, result: any, dependencies?: string[]): Promise<string>;
+    setByFile(filePath: string, result: any, dependencies?: string[]): Promise<string>;
+    setByHash(hash: string, result: any, dependencies?: string[]): Promise<string>;
+    getByHashSync(hash: string): any | null;
+    setByHashSync(hash: string, result: any, source: any, dependencies?: string[]): void;
+    invalidateByHash(hash: string): void;
+    clear(): Promise<void>;
+    getStats(): Promise<{
+        entryCount: number;
+        totalSizeMB: number;
+        totalSizeBytes: number;
+        oldestEntry: number;
+        newestEntry: number;
+        hitRate?: number;
+    }>;
+    prune(): Promise<void>;
+    private isExpired;
+    private loadMetadata;
+    private updateMetadata;
+    private updateMetadataSync;
+    enforceSizeLimit(): Promise<void>;
+    private enforceSizeLimitSync;
+    private ensureDir;
+    /**
+     * List all cache entries
+     */
+    listEntries(): Promise<Array<{
+        key: string;
+        size: number;
+        timestamp: number;
+        createdAt: number;
+        lastAccessed?: number;
+    }>>;
+    /**
+     * Get a cache entry by key
+     */
+    get(key: string): Promise<PersistentCacheEntry | null>;
+    /**
+     * Delete a cache entry by key
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Validate a cache entry
+     */
+    validate(key: string): Promise<boolean>;
+}

package/dist/compiler/helpers.d.ts

@@ -0,0 +1,54 @@
+export type Unit = 'px' | 'rem' | 'em' | '%' | 'vw' | 'vh' | 'vmin' | 'vmax' | 'ch' | 'ex';
+export type MathOperation = 'add' | 'subtract' | 'multiply' | 'divide';
+export interface CalcOptions {
+    precision?: number;
+    simplify?: boolean;
+}
+export declare const helpers: {
+    calc: (expr: string, options?: CalcOptions) => string;
+    add: (a: any, b: any, options?: CalcOptions) => string;
+    subtract: (a: any, b: any, options?: CalcOptions) => string;
+    sub: (a: any, b: any, options?: CalcOptions) => string;
+    multiply: (a: any, b: any, options?: CalcOptions) => string;
+    mul: (a: any, b: any, options?: CalcOptions) => string;
+    divide: (a: any, b: any, options?: CalcOptions) => string;
+    div: (a: any, b: any, options?: CalcOptions) => string;
+    sum: (...values: any[]) => string;
+    difference: (a: any, ...rest: any[]) => string;
+    product: (...values: any[]) => string;
+    quotient: (a: any, ...rest: any[]) => string;
+    mpx: (value: number | string) => string;
+    rem: (value: number | string, base?: number) => string;
+    em: (value: number | string, context?: number) => string;
+    percent: (value: number | string) => string;
+    vw: (value: number | string) => string;
+    vh: (value: number | string) => string;
+    vmin: (value: number | string) => string;
+    vmax: (value: number | string) => string;
+    ch: (value: number | string) => string;
+    ex: (value: number | string) => string;
+    convert: (value: string | number, fromUnit: Unit, toUnit: Unit, context?: number) => string;
+    min: (...values: any[]) => string;
+    max: (...values: any[]) => string;
+    clamp: (min: any, preferred: any, max: any, options?: CalcOptions) => string;
+    round: (value: number | string, precision?: number) => string;
+    ceil: (value: number | string) => string;
+    floor: (value: number | string) => string;
+    rgba: (r: number, g: number, b: number, a?: number) => string;
+    hsla: (h: number, s: number, l: number, a?: number) => string;
+    url: (path: string) => string;
+    format: (strings: TemplateStringsArray, ...values: any[]) => string;
+    if: (condition: boolean, trueValue: any, falseValue: any) => any;
+    camelToKebab: (str: string) => string;
+    kebabToCamel: (str: string) => string;
+    toPx: (value: number | string) => string;
+    toRem: (value: number | string, base?: number) => string;
+};
+export type MathHelpers = typeof helpers;
+export declare function withUnit(value: number | string, unit: Unit): string;
+export declare function extractNumeric(value: string): number;
+export declare function extractUnit(value: string): Unit | null;
+export declare function fluidType(minSize: number, maxSize: number, minWidth?: number, maxWidth?: number, unit?: 'px' | 'rem'): string;
+export default helpers;
+export declare const toPx: (v: number | string) => string;
+export declare const toRem: (v: number | string) => string;

package/dist/compiler/index.d.ts

@@ -1,12 +1,19 @@
-export { chain, $, run, compile, createTokens, configureAtomic, setAtomicOptimizer, recipe, tokens } from './btt.js';
+export { chain, chains, run, compile, createTokens, configureAtomic, setAtomicOptimizer, recipe, tokens, enableDebug, setBreakpoints, enableTimeline, getStyleHistory, getStyleChanges, getStyleDiff, exportTimeline, clearTimeline, setSourceComments } from './btt.js';
 export { AtomicOptimizer } from './atomic-optimizer.js';
+export type { AtomicClass, AtomicOptimizerOptions, AtomicOptimizerStats, ComponentClassMapEntry, OptimizeResult } from './atomic-optimizer.js';
 export { ChainCSSPrefixer } from './prefixer.js';
-export { DesignTokens, tokens as tokenInstance, createTokens as createTokensUtil, responsive } from './tokens.js';
-export { createThemeContract, validateTheme, createTheme } from './theme-contract.js';
+export type { PrefixerConfig, PrefixerResult } from './prefixer.js';
+export { DesignTokens, createTokens as createDesignTokens } from './tokens.js';
+export type { TokensStructure, FlattenedTokens } from './tokens.js';
+export { createThemeContract, validateTheme, createTheme, Theme } from './theme-contract.js';
+export type { ThemeContract, ThemeTokens } from './theme-contract.js';
 export { CacheManager } from './cache-manager.js';
-export type { StyleDefinition, AtRule, NestedRule, ThemeBlock } from './btt.js';
-export type { AtomicClass, AtomicOptimizerOptions, AtomicOptimizerStats } from './atomic-optimizer.js';
-export type { PrefixerConfig } from './prefixer.js';
-export type { TokensStructure, DesignTokens as DesignTokensType } from './tokens.js';
-export type { CacheData } from './cache-manager.js';
-//# sourceMappingURL=index.d.ts.map
+export { PersistentCache } from './content-addressable-cache.js';
+export type { CacheData, CacheOptions } from './cache-manager.js';
+export type { PersistentCacheOptions, PersistentCacheEntry } from './content-addressable-cache.js';
+export { shorthandMap, macros, handleShorthand, isShorthand, expandShorthand, getAvailableShorthands } from './shorthands.js';
+export { helpers } from './helpers.js';
+export { animationPresets, createAnimation, getAnimationPreset, hasAnimationPreset, getAnimationPresetNames } from './animations.js';
+export { setBreakpoints as setBreakpointsUtil, getBreakpoint, getAllBreakpoints, resetBreakpoints, addBreakpoint, removeBreakpoint } from './breakpoints.js';
+export { getSuggestion, getSuggestions, getPropertySuggestion, getShorthandSuggestion } from './suggestions.js';
+export { resolveToken, setTokenContext, getTokenContext, clearTokenContext, TokenResolver } from './token-resolver.js';