chaincss 2.0.7 → 2.1.0

package/dist/compiler/prefixer.d.ts

@@ -4,17 +4,28 @@ export interface PrefixerConfig {
     mode?: 'auto' | 'full' | 'lightweight';
     sourceMap?: boolean;
     sourceMapInline?: boolean;
+    remove?: boolean;
+    add?: boolean;
+    verbose?: boolean;
+    flexbox?: boolean | 'no-2009';
+    grid?: boolean | 'autoplace' | 'no-autoplace';
 }
 export interface PrefixerResult {
     css: string;
     map: string | null;
+    warnings?: string[];
 }
 export interface ProcessOptionsWithPaths {
     from?: string;
     to?: string;
+    map?: boolean | object;
 }
 export interface CaniuseFeature {
+    title: string;
+    description: string;
     stats: Record<string, Record<string, string>>;
+    spec?: string;
+    status?: string;
 }
 export declare class ChainCSSPrefixer {
     config: Required<PrefixerConfig>;
@@ -26,17 +37,22 @@ export declare class ChainCSSPrefixer {
     specialValues: Record<string, string[]>;
     browserPrefixMap: Record<string, string>;
     targetBrowsers: string[] | null;
+    private warnings;
     constructor(config?: PrefixerConfig);
     determineMode(): Promise<'auto' | 'full' | 'lightweight'>;
     process(cssString: string, options?: ProcessOptionsWithPaths): Promise<PrefixerResult>;
     private processWithAutoprefixer;
     private processWithBuiltIn;
+    private lightweightPrefix;
     private createBuiltInPlugin;
     private processBuiltInDeclaration;
+    private shouldKeepPrefix;
     private addPrefixesFromCaniuse;
     private addSpecialValuePrefixes;
     private findFeature;
     private getCommonProperties;
+    needsPrefix(property: string, browser: string, version: number): boolean;
+    getAvailablePrefixes(property: string): string[];
+    reset(): void;
 }
 export { ChainCSSPrefixer as default };
-//# sourceMappingURL=prefixer.d.ts.map

package/dist/compiler/shorthands.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 1. THE DICTIONARY (Simple 1-to-1 Swaps)
+ * Handled by the ChainClass for performance.
+ */
+export declare const shorthandMap: Record<string, string>;
+type MacroHandler = (value: any, catcher: Record<string, any>, useTokens: boolean) => void;
+/**
+ * 2. THE MACRO REGISTRY (Complex Logic)
+ */
+export declare const macros: Record<string, MacroHandler>;
+/**
+ * Main handler for shorthand processing
+ * Returns true if the shorthand was handled, false otherwise
+ */
+export declare function handleShorthand(prop: string, value: any, catcher: Record<string, any>, useTokens?: boolean): boolean;
+/**
+ * Utility to check if a property is a registered shorthand
+ */
+export declare function isShorthand(prop: string): boolean;
+/**
+ * Get the expanded property name for a shorthand
+ */
+export declare function expandShorthand(prop: string): string | null;
+/**
+ * Get all available shorthands
+ */
+export declare function getAvailableShorthands(): string[];
+export {};

package/dist/compiler/suggestions.d.ts

@@ -0,0 +1,43 @@
+export interface SuggestionMatch {
+    name: string;
+    distance: number;
+    type: 'shorthand' | 'css-property' | 'macro' | 'animation' | 'breakpoint';
+}
+export declare const KNOWN_SHORTHANDS: string[];
+export declare const COMMON_CSS_PROPERTIES: string[];
+export declare const ANIMATION_PRESETS: string[];
+export declare const BREAKPOINTS: string[];
+export declare function getSuggestion(prop: string, validProperties?: string[], type?: 'shorthand' | 'css-property' | 'all'): string | SuggestionMatch | null;
+export declare function getSuggestions(prop: string, validProperties?: string[], maxResults?: number): SuggestionMatch[];
+export declare function getPropertySuggestion(prop: string, context?: 'spacing' | 'color' | 'typography' | 'layout' | 'animation'): string | null;
+export declare function getShorthandSuggestion(shorthand: string): {
+    suggestion: string;
+    explanation: string;
+} | null;
+export declare function getValueSuggestion(property: string, value: string): {
+    suggested: string;
+    confidence: number;
+} | null;
+export declare function getAutocompleteSuggestions(prefix?: string, limit?: number): SuggestionMatch[];
+export declare function formatSuggestion(suggestion: SuggestionMatch): string;
+export declare function getDetailedSuggestion(prop: string, validProperties?: string[]): {
+    suggestion: string | null;
+    alternatives: SuggestionMatch[];
+    type: string;
+    confidence: number;
+} | null;
+declare const _default: {
+    getSuggestion: typeof getSuggestion;
+    getSuggestions: typeof getSuggestions;
+    getPropertySuggestion: typeof getPropertySuggestion;
+    getShorthandSuggestion: typeof getShorthandSuggestion;
+    getValueSuggestion: typeof getValueSuggestion;
+    getAutocompleteSuggestions: typeof getAutocompleteSuggestions;
+    formatSuggestion: typeof formatSuggestion;
+    getDetailedSuggestion: typeof getDetailedSuggestion;
+    KNOWN_SHORTHANDS: string[];
+    COMMON_CSS_PROPERTIES: string[];
+    ANIMATION_PRESETS: string[];
+    BREAKPOINTS: string[];
+};
+export default _default;

package/dist/compiler/theme-contract.d.ts

@@ -8,20 +8,6 @@ export interface ThemeContract {
 export interface ThemeTokens {
     [key: string]: string | ThemeTokens;
 }
-export interface TokensStructure {
-    colors: Record<string, string | Record<string, string>>;
-    spacing: Record<string, string>;
-    typography: {
-        fontFamily: Record<string, string>;
-        fontSize: Record<string, string>;
-        fontWeight: Record<string, string>;
-        lineHeight: Record<string, string>;
-    };
-    breakpoints: Record<string, string>;
-    zIndex: Record<string, string>;
-    shadows: Record<string, string>;
-    borderRadius: Record<string, string>;
-}
 /**
  * Theme class with getter method
  */
@@ -29,33 +15,36 @@ export declare class Theme {
     private tokens;
     constructor(tokens: ThemeTokens);
     get(path: string): string | undefined;
+    set(path: string, value: string): void;
     toObject(): ThemeTokens;
+    toCSSVariables(prefix?: string): string;
 }
 /**
  * Create a theme contract that defines the expected shape of themes
- * @param contractShape - The contract object defining required token paths
- * @returns Proxy contract with validation methods
  */
-export declare function createThemeContract(contractShape: ThemeContract): ThemeContract & {
-    __isContract: boolean;
+export declare function createThemeContract<T extends ThemeContract>(contractShape: T): T & {
+    __isContract: true;
     __validate: (theme: ThemeTokens) => boolean;
 };
 /**
  * Validate that a theme matches the contract
- * @param contract - The contract to validate against
- * @param theme - The theme to validate
- * @param path - Current path for error messages
  * @returns true if valid, throws error otherwise
  */
 export declare function validateTheme(contract: ThemeContract, theme?: ThemeTokens, path?: string): boolean;
 /**
  * Create an actual theme from a contract and values
- * @param contract - The contract defining the shape
- * @param themeValues - The actual theme values
- * @returns Theme object with getter method
  */
-export declare function createTheme(contract: ThemeContract | (ThemeContract & {
+export declare function createTheme<T extends ThemeContract>(contract: T | (T & {
     __isContract: boolean;
-    __validate: (theme: ThemeTokens) => boolean;
 }), themeValues: ThemeTokens): Theme;
-//# sourceMappingURL=theme-contract.d.ts.map
+export declare function isThemeContract(obj: any): obj is ThemeContract & {
+    __isContract: true;
+};
+declare const _default: {
+    Theme: typeof Theme;
+    createThemeContract: typeof createThemeContract;
+    validateTheme: typeof validateTheme;
+    createTheme: typeof createTheme;
+    isThemeContract: typeof isThemeContract;
+};
+export default _default;

package/dist/compiler/token-resolver.d.ts

@@ -0,0 +1,69 @@
+import type { DesignTokens } from './tokens.js';
+/**
+ * Set the current token context for resolution
+ */
+export declare function setTokenContext(context: DesignTokens | null): void;
+/**
+ * Get the current token context
+ */
+export declare function getTokenContext(): DesignTokens | null;
+/**
+ * Clear the current token context
+ */
+export declare function clearTokenContext(): void;
+/**
+ * Resolve token references in a value
+ * Supports formats:
+ * - $token.path (e.g., $colors.primary)
+ * - token('path') function style
+ * - Nested references within strings
+ */
+export declare function resolveToken(value: any, useTokens?: boolean, tokenContext?: DesignTokens | null): any;
+/**
+ * Resolve multiple token references in an object
+ */
+export declare function resolveTokens(obj: Record<string, any>, useTokens?: boolean, tokenContext?: DesignTokens | null): Record<string, any>;
+/**
+ * Check if a value contains token references
+ */
+export declare function hasTokenReferences(value: any): boolean;
+/**
+ * Extract all token paths from a string
+ */
+export declare function extractTokenPaths(value: string): string[];
+/**
+ * Create a token resolver function for a specific context
+ */
+export declare function createTokenResolver(tokenContext?: DesignTokens | null): (value: any) => any;
+/**
+ * Batch resolve multiple values
+ */
+export declare function resolveBatch(values: string[], useTokens?: boolean, tokenContext?: DesignTokens | null): string[];
+/**
+ * Token resolver class for caching and batch operations
+ */
+export declare class TokenResolver {
+    private cache;
+    private context;
+    constructor(context?: DesignTokens | null);
+    resolve(value: any): any;
+    resolveObject(obj: Record<string, any>): Record<string, any>;
+    clearCache(): void;
+    updateContext(context: DesignTokens | null): void;
+    getStats(): {
+        cacheSize: number;
+    };
+}
+declare const _default: {
+    resolveToken: typeof resolveToken;
+    setTokenContext: typeof setTokenContext;
+    getTokenContext: typeof getTokenContext;
+    clearTokenContext: typeof clearTokenContext;
+    resolveTokens: typeof resolveTokens;
+    hasTokenReferences: typeof hasTokenReferences;
+    extractTokenPaths: typeof extractTokenPaths;
+    createTokenResolver: typeof createTokenResolver;
+    resolveBatch: typeof resolveBatch;
+    TokenResolver: typeof TokenResolver;
+};
+export default _default;

package/dist/compiler/tokens.d.ts

@@ -9,6 +9,7 @@ export interface TokenTypography {
     fontSize: Record<string, string>;
     fontWeight: Record<string, string>;
     lineHeight: Record<string, string>;
+    letterSpacing?: Record<string, string>;
 }
 export interface TokenBreakpoints {
     [key: string]: string;
@@ -32,21 +33,45 @@ export interface TokensStructure {
     borderRadius: TokenBorderRadius;
     [key: string]: any;
 }
+export interface TokenValue {
+    value: any;
+    description?: string;
+    deprecated?: boolean;
+    aliases?: string[];
+}
 export type FlattenedTokens = Record<string, string>;
+export declare const defaultTokens: TokensStructure;
 export declare class DesignTokens {
-    tokens: TokensStructure;
-    flattened: FlattenedTokens;
-    constructor(tokens?: Partial<TokensStructure>);
-    deepFreeze<T extends object>(obj: T): T;
+    private customTokens;
+    private customFlattened;
+    private defaultFlattened;
+    private tokenCache;
+    constructor(customTokens?: Partial<TokensStructure>);
+    private deepClone;
+    private deepFreeze;
     flattenTokens(obj: Record<string, any>, prefix?: string): FlattenedTokens;
     get(path: string, defaultValue?: string): string;
+    getColor(path: string, defaultValue?: string): string;
+    getSpacing(path: string, defaultValue?: string): string;
+    getFontSize(path: string, defaultValue?: string): string;
+    getFontWeight(path: string, defaultValue?: string): string;
+    getLineHeight(path: string, defaultValue?: string): string;
+    getBreakpoint(path: string, defaultValue?: string): string;
+    getZIndex(path: string, defaultValue?: string): string;
+    getShadow(path: string, defaultValue?: string): string;
+    getBorderRadius(path: string, defaultValue?: string): string;
+    getCustomTokens(): FlattenedTokens;
+    getDefaultTokens(): FlattenedTokens;
+    has(path: string): boolean;
     toCSSVariables(prefix?: string): string;
+    toMediaQueries(): Record<string, string>;
     createTheme(name: string, overrides: Record<string, string>): DesignTokens;
-    expandTokens(flattened: FlattenedTokens): TokensStructure;
+    merge(tokens: Partial<TokensStructure>): DesignTokens;
+    clearCache(): void;
+    getSuggestions(partialPath: string): string[];
 }
-export declare const defaultTokens: TokensStructure;
 export declare const tokens: DesignTokens;
 export declare function createTokens(customTokens: Partial<TokensStructure>): DesignTokens;
-export declare function responsive(values: Record<string, string> | string): string;
+export declare function resolveTokenReferences(value: string, tokens: DesignTokens, prefix?: string): string;
+export declare function isTokenReference(value: any, prefix?: string): boolean;
 export { DesignTokens as default };
-//# sourceMappingURL=tokens.d.ts.map

package/dist/core/auto-detector.d.ts

@@ -0,0 +1,34 @@
+export type ValueType = 'static' | 'dynamic' | 'runtime-only';
+export type Mode = 'build' | 'runtime' | 'hybrid' | 'auto';
+export interface DetectedPart {
+    type: ValueType;
+    prop: string;
+    value: any;
+    originalValue: any;
+    index: number;
+}
+export interface AnalysisResult {
+    staticParts: DetectedPart[];
+    dynamicParts: DetectedPart[];
+    runtimeOnlyParts: DetectedPart[];
+    isHybrid: boolean;
+    mode: Mode;
+}
+export declare class AutoDetector {
+    private static instance;
+    private dynamicPatterns;
+    private staticPatterns;
+    private debug;
+    static getInstance(): AutoDetector;
+    enableDebug(enabled: boolean): void;
+    detectValueType(value: any, prop?: string): ValueType;
+    analyzeChain(calls: Array<{
+        prop: string;
+        value: any;
+        index: number;
+    }>): AnalysisResult;
+    addDynamicPattern(pattern: RegExp): void;
+    addStaticPattern(pattern: RegExp): void;
+    reset(): void;
+}
+export declare const autoDetector: AutoDetector;

package/dist/core/common-utils.d.ts

@@ -0,0 +1,97 @@
+import type { DesignTokens } from '../compiler/tokens.js';
+/**
+ * Convert camelCase to kebab-case
+ */
+export declare function kebabCase(str: string): string;
+/**
+ * Convert kebab-case to camelCase
+ */
+export declare function camelCase(str: string): string;
+/**
+ * Resolve token references in a value
+ * Supports $token.path format
+ */
+export declare function resolveToken(value: any, tokenStore?: Record<string, any> | DesignTokens, debug?: boolean): any;
+/**
+ * Process a style object, expanding shorthands and resolving tokens
+ */
+export declare function processStyleObject(obj: Record<string, any>, tokenStore?: Record<string, any> | DesignTokens, options?: {
+    useTokens?: boolean;
+    debug?: boolean;
+}): string;
+/**
+ * Extract CSS string from style definition
+ */
+export declare function extractCSS(styleDef: Record<string, any>): string;
+/**
+ * Extract hover CSS from style definition
+ */
+export declare function extractHoverCSS(styleDef: Record<string, any>): string;
+/**
+ * Merge multiple style objects
+ */
+export declare function mergeStyles(...styles: Record<string, any>[]): Record<string, any>;
+/**
+ * Check if a value is a valid CSS length
+ */
+export declare function isValidCSSLength(value: any): boolean;
+/**
+ * Check if a value is a valid CSS color
+ */
+export declare function isValidCSSColor(value: any): boolean;
+/**
+ * Escape CSS selector
+ */
+export declare function escapeSelector(selector: string): string;
+/**
+ * Clean class name for CSS
+ */
+export declare function cleanClassName(className: string): string;
+/**
+ * Extract numeric value from CSS value
+ */
+export declare function extractNumericValue(value: string): number;
+/**
+ * Extract unit from CSS value
+ */
+export declare function extractUnit(value: string): string;
+/**
+ * Add unit to numeric value if missing
+ */
+export declare function addUnit(value: number | string, unit?: string): string;
+/**
+ * Sort class names for consistent output
+ */
+export declare function sortClassNames(classNames: string[]): string[];
+/**
+ * Join class names safely
+ */
+export declare function cn(...classes: (string | undefined | null | false)[]): string;
+export declare function enableDebug(enable?: boolean): void;
+export declare function isDebugEnabled(): boolean;
+/**
+ * Debug log function
+ */
+export declare function debugLog(message: string, ...args: any[]): void;
+declare const _default: {
+    kebabCase: typeof kebabCase;
+    camelCase: typeof camelCase;
+    resolveToken: typeof resolveToken;
+    processStyleObject: typeof processStyleObject;
+    extractCSS: typeof extractCSS;
+    extractHoverCSS: typeof extractHoverCSS;
+    mergeStyles: typeof mergeStyles;
+    isValidCSSLength: typeof isValidCSSLength;
+    isValidCSSColor: typeof isValidCSSColor;
+    escapeSelector: typeof escapeSelector;
+    cleanClassName: typeof cleanClassName;
+    extractNumericValue: typeof extractNumericValue;
+    extractUnit: typeof extractUnit;
+    addUnit: typeof addUnit;
+    sortClassNames: typeof sortClassNames;
+    cn: typeof cn;
+    enableDebug: typeof enableDebug;
+    isDebugEnabled: typeof isDebugEnabled;
+    debugLog: typeof debugLog;
+};
+export default _default;

package/dist/core/compiler.d.ts

@@ -1,32 +1,72 @@
 import type { ChainCSSConfig, CompileResult, StyleDefinition } from './types.js';
+import { AtomicOptimizer } from '../compiler/atomic-optimizer.js';
 export declare class ChainCSSCompiler {
     private config;
-    private atomicOptimizer;
     private prefixer;
+    atomicOptimizer: AtomicOptimizer | null;
+    private sharedStyles;
     private styleCache;
     private classMap;
-    constructor(config?: ChainCSSConfig);
-    private initOptimizer;
-    private initPrefixer;
-    private generateCSS;
+    private runtimeCache;
+    private persistentCache;
+    private readonly MAX_STYLE_CACHE_SIZE;
+    private importedModules;
+    private dependencyGraph;
+    private generatedCSS;
+    private accumulatedCSS;
+    private compileInProgress;
+    private compileQueue;
+    private lruList;
+    constructor(config: ChainCSSConfig);
+    hasStyles(): boolean;
+    private processStyleObject;
+    private addToCache;
+    /**
+     * Scans a raw source string (from Vite) for useChainStyles patterns
+     * and registers them with the optimizer.
+     * Uses brace-counting parser instead of fragile regex.
+     */
+    compileSource(source: string, id: string): Promise<void>;
+    /**
+     * Safely parse a style object string without using eval.
+     * Supports JSON-like syntax and token references.
+     */
+    private safeParseStyleObject;
+    /**
+     * Parse a limited subset of JavaScript object literal syntax.
+     * Handles: strings, numbers, booleans, null, nested objects, arrays.
+     * Does NOT execute code.
+     */
+    private parseObjectLiteral;
+    private restoreTokens;
+    /**
+     * @deprecated Use safeParseStyleObject instead.
+     * Kept for backward compatibility during migration.
+     */
+    private looseParse;
+    private setupCompilerGlobals;
+    private hashStyleDef;
+    private importModule;
     compileStyle(styleId: string, styleDef: StyleDefinition): CompileResult;
-    compileRecipe(recipeId: string, recipeFn: any): CompileResult;
-    compileFile(filePath: string): Record<string, CompileResult>;
-    generateTypeScriptTypes(results: Record<string, CompileResult>, outputPath: string): void;
-    generateJavaScriptModule(results: Record<string, CompileResult>, outputPath: string): void;
-    generateCSSFile(results: Record<string, CompileResult>, outputPath: string): void;
-    compile(inputFile: string, outputDir: string): Promise<{
-        cssFile: string;
-        jsFile: string;
-        typesFile: string;
-        results: Record<string, CompileResult>;
-    }>;
+    compileRecipe(recipeId: string, recipeValue: any): CompileResult;
+    compile(inputFile: string, outputDir: string): Promise<any>;
+    compileFile(filePath: string): Promise<Record<string, CompileResult>>;
     compileComponents(components: string[]): Promise<void>;
-    private importModule;
-    private hash;
-    watch(inputFile: string, outputDir: string): Promise<void>;
-    getStats(): any;
-    clearCache(): void;
+    /**
+     * Drains the compile queue safely, handling items added during draining.
+     */
+    private drainCompileQueue;
+    getCombinedCSS(): string;
+    clearCSS(): void;
+    getStats(): {
+        totalStyles: number;
+        atomicStyles: any;
+        uniqueProperties: any;
+        savings: string;
+    };
+    private generateCSSFile;
+    getAtomicMap(): Record<string, string>;
+    private initOptimizer;
+    private initPrefixer;
 }
-export declare function compileChainCSS(inputFile: string, outputDir: string, config?: ChainCSSConfig): Promise<ReturnType<ChainCSSCompiler['compile']>>;
-//# sourceMappingURL=compiler.d.ts.map
+export declare function compileChainCSS(inputFile: string, outputDir: string, config?: ChainCSSConfig): Promise<any>;