@barocss/browser 0.0.1 → 0.4.0

package/dist/browser-runtime.d.ts

@@ -1,119 +0,0 @@
-import { GenerateCssRulesResult, Config } from '@barocss/kit';
-export interface BrowserRuntimeOptions {
-    config?: Config;
-    styleId?: string;
-    insertionPoint?: 'head' | 'body' | HTMLElement;
-    maxRulesPerPartition?: number;
-}
-export declare class BrowserRuntime {
-    private cache;
-    private rootCache;
-    private context;
-    private options;
-    private isDestroyed;
-    private incrementalParser;
-    private changeDetector;
-    private stylePartitionManager;
-    constructor(options?: BrowserRuntimeOptions);
-    /**
-     * Add debug logs (by level)
-     */
-    private debugLog;
-    private init;
-    private injectPreflightCSS;
-    private ensureCssVars;
-    private getInsertionPoint;
-    /**
-     * Dynamically add one or more class names and generate/insert CSS
-     */
-    addClass(classes: string | string[]): void;
-    /**
-     * Process classes
-     */
-    private processClasses;
-    /**
-     * Process classes using incremental parsing
-     */
-    private processClassesIncremental;
-    /**
-     * Public method to apply parser results, update internal caches, and inject CSS
-     */
-    applyParseResults(results: Array<GenerateCssRulesResult>, _opts?: {
-        isBrowser?: boolean;
-    }): void;
-    /**
-     * MutationObserver instance method to automatically call addClass when class attributes change in DOM
-     */
-    observe(root?: HTMLElement, options?: {
-        scan?: boolean;
-        onReady?: () => void;
-    }): MutationObserver;
-    private normalizeClasses;
-    has(cls: string): boolean;
-    getCss(cls: string): string | undefined;
-    getAllCss(): string;
-    getClasses(): string[];
-    /**
-     * Get comprehensive cache statistics
-     */
-    getCacheStats(): {
-        runtime: {
-            cachedClasses: number;
-            rootCacheSize: number;
-        };
-        ast: {
-            size: number;
-            maxSize: number;
-            hitRate: number;
-        };
-        incremental: {
-            processedClasses: number;
-            pendingClasses: number;
-            cacheStats: {
-                ast: {
-                    size: number;
-                    maxSize: number;
-                    hitRate: number;
-                };
-                css: {};
-            };
-        };
-    };
-    /**
-     * Clear all caches (useful for debugging or memory management)
-     */
-    clearCaches(): void;
-    reset(): void;
-    updateConfig(newConfig: Config): void;
-    removeClass(classes: string | string[]): void;
-    destroy(): void;
-    getStats(): {
-        cachedClasses: number;
-        styleElementId: string;
-        isDestroyed: boolean;
-        config: Config;
-        cacheStats: {
-            runtime: {
-                cachedClasses: number;
-                rootCacheSize: number;
-            };
-            ast: {
-                size: number;
-                maxSize: number;
-                hitRate: number;
-            };
-            incremental: {
-                processedClasses: number;
-                pendingClasses: number;
-                cacheStats: {
-                    ast: {
-                        size: number;
-                        maxSize: number;
-                        hitRate: number;
-                    };
-                    css: {};
-                };
-            };
-        };
-    };
-}

package/dist/change-detector.d.ts

@@ -1,80 +0,0 @@
-import { IncrementalParser } from '@barocss/kit';
-import { BrowserRuntime } from './browser-runtime';
-/**
- * Change detection system for DOM mutations
- *
- * ⚠️ BROWSER-ONLY: This class is designed for browser environments only.
- * It uses MutationObserver and DOM APIs that are not available in Node.js.
- *
- * This class monitors DOM changes and automatically processes new CSS classes
- * that are added to elements. It uses MutationObserver to detect:
- * - Class attribute changes on existing elements
- * - New elements being added to the DOM
- * - Changes in child elements
- *
- * For server-side usage, use IncrementalParser directly with processClassesSync()
- * or processClasses() methods.
- */
-export declare class ChangeDetector {
-    /** MutationObserver instance for DOM change detection */
-    private observer;
-    /** Reference to IncrementalParser for class processing */
-    private incrementalParser;
-    /** Reference to BrowserRuntime for CSS injection (optional) */
-    private BrowserRuntime?;
-    /** Set of elements that have already been processed to avoid duplicates */
-    private processedElements;
-    /**
-     * Create a new ChangeDetector instance
-     *
-     * @param incrementalParser - IncrementalParser instance for class processing
-     * @param BrowserRuntime - Optional BrowserRuntime instance for CSS injection
-     */
-    constructor(incrementalParser: IncrementalParser, BrowserRuntime?: BrowserRuntime);
-    /**
-     * Starts observing DOM changes for new CSS classes
-     *
-     * This method sets up a MutationObserver that monitors:
-     * - Attribute changes (specifically class attribute modifications)
-     * - Child list changes (new elements being added)
-     * - Subtree changes (changes in descendant elements)
-     *
-     * The observer automatically processes any new classes it discovers
-     * by adding them to the IncrementalParser's pending queue.
-     *
-     * @param root - The root element to observe (defaults to document.body)
-     * @param options - Configuration options including initial scan and onReady callback
-     * @returns The MutationObserver instance for external control
-     */
-    observe(root?: HTMLElement, options?: {
-        scan?: boolean;
-        onReady?: () => void;
-    }): MutationObserver;
-    /**
-     * Scan existing classes in the DOM and process them
-     */
-    private scanExistingClasses;
-    /**
-     * Processes an individual element and extracts new classes
-     *
-     * This method is called for each element discovered during DOM mutations.
-     * It:
-     * - Checks if the element has already been processed
-     * - Extracts all class names from the element's className
-     * - Filters out already processed classes
-     * - Adds new classes to the collection for batch processing
-     * - Marks the element as processed to avoid duplicates
-     *
-     * @param element - The HTML element to process
-     * @param newClasses - Set to collect newly discovered class names
-     */
-    private processElement;
-    /**
-     * Stops observing DOM changes and cleans up resources
-     *
-     * This method disconnects the MutationObserver and clears the
-     * observer reference to prevent memory leaks and allow the
-     * ChangeDetector to be properly garbage collected.
-     */
-    disconnect(): void;
-}

package/dist/style-partition-manager.d.ts

@@ -1,51 +0,0 @@
-import { GenerateCssRulesResult } from '@barocss/kit';
-export interface StylePartition {
-    id: string;
-    styles: string[];
-    styleElement: HTMLStyleElement;
-}
-export declare class StylePartitionManager {
-    private partitions;
-    private categoryPartitions;
-    private partitionCounter;
-    private maxRulesPerPartition;
-    private insertionPoint;
-    private classToPartitionMap;
-    private classToCategoryPartitionMap;
-    private styleIdPrefix;
-    constructor(insertionPoint: HTMLElement, maxRulesPerPartition?: number, styleIdPrefix?: string);
-    private initializeDefaultPartition;
-    private createNewCategoryPartition;
-    private createNewPartition;
-    hasRule(rule: string): boolean;
-    hasCategoryRule(rule: string, category: string): boolean;
-    setRuleCache(rule: string, partitionIndex: number): void;
-    setCategoryRuleCache(rule: string, category: string): void;
-    get currentPartition(): StylePartition;
-    getCategoryPartition(category: string): StylePartition | undefined;
-    /**
-     * Escape CSS rule text
-     * - Properly escape special characters
-     * - Prevent CSS syntax errors
-     */
-    private escapeCssRule;
-    addRule(rule: string): boolean;
-    addCategoryRule(rule: string, category: string): boolean;
-    addRootRules(rules: string[]): {
-        success: number;
-        failed: number;
-    };
-    addRules(rules: GenerateCssRulesResult[]): {
-        success: number;
-        failed: number;
-    };
-    /**
-     * 특정 규칙이 어느 파티션에 있는지 찾기
-     */
-    findRulePartition(rule: string): StylePartition | null;
-    updateRuleContent(category: string, ruleContent: string): void;
-    /**
-     * 모든 파티션 정리
-     */
-    cleanup(): void;
-}

package/dist/utils.d.ts

@@ -1,2 +0,0 @@
-export declare function normalizeClassName(className: any): string;
-export declare function normalizeClassNameList(className: any): string[];