@ogxjs/core 0.1.1 → 0.2.0-alpha.1

package/dist/tailwind/class-cache.js

@@ -0,0 +1,212 @@
+/**
+ * @ogxjs/core - Tailwind Class Cache
+ * Per-class caching for maximum performance
+ *
+ * @description
+ * Caches individual parsed classes instead of full class strings.
+ * This allows reuse across different elements with overlapping classes.
+ *
+ * @example
+ * Element A: "flex bg-blue-500 p-4"
+ * Element B: "flex bg-red-500 p-4"
+ * → "flex" and "p-4" are parsed once, reused for both
+ *
+ * @performance
+ * - Eliminates redundant parsing for common classes
+ * - Reduces memory by sharing parsed results
+ * - O(1) lookup per class
+ *
+ * @version 0.2.0 "Turbo"
+ */
+// CONFIGURATION
+/**
+ * Maximum cache size to prevent memory leaks
+ * ~5000 classes × ~200 bytes avg = ~1MB max
+ */
+const MAX_CACHE_SIZE = 5000;
+/**
+ * Classes to never cache (dynamic/theme-dependent)
+ */
+const UNCACHEABLE_PATTERNS = [
+    /^dark:/, // Dark mode variants (theme-dependent)
+];
+// CLASS CACHE
+/**
+ * Cache for individual parsed Tailwind classes
+ * Key: class name (e.g., "bg-blue-500")
+ * Value: parsed CSS properties
+ *
+ * @performance v0.2.0 Turbo optimizations:
+ * - Direct reference return (no spread copy) - trust consumers
+ * - No Object.freeze - avoid expensive operation
+ * - Lazy eviction check
+ */
+class TailwindClassCache {
+    cache = new Map();
+    hits = 0;
+    misses = 0;
+    /**
+     * Get cached CSS properties for a class
+     * @returns Cached properties or undefined if not cached
+     *
+     * @performance Returns direct reference - DO NOT MUTATE
+     */
+    get(cls) {
+        const cached = this.cache.get(cls);
+        if (cached !== undefined) {
+            this.hits++;
+            return cached; // Direct reference - no copy overhead
+        }
+        this.misses++;
+        return undefined;
+    }
+    /**
+     * Cache CSS properties for a class
+     * @param cls - Tailwind class name
+     * @param props - Parsed CSS properties (will be stored directly)
+     */
+    set(cls, props) {
+        // Don't cache theme-dependent classes
+        if (this.isUncacheable(cls))
+            return;
+        // Evict oldest entries if cache is full (lazy check)
+        if (this.cache.size >= MAX_CACHE_SIZE) {
+            this.evictOldest();
+        }
+        // Store directly - no copy, no freeze
+        this.cache.set(cls, props);
+    }
+    /**
+     * Check if a class has cached properties
+     */
+    has(cls) {
+        return this.cache.has(cls);
+    }
+    /**
+     * Clear the entire cache
+     */
+    clear() {
+        this.cache.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        const total = this.hits + this.misses;
+        return {
+            size: this.cache.size,
+            maxSize: MAX_CACHE_SIZE,
+            hits: this.hits,
+            misses: this.misses,
+            hitRate: total > 0 ? this.hits / total : 0,
+        };
+    }
+    /**
+     * Check if a class should not be cached
+     */
+    isUncacheable(cls) {
+        return UNCACHEABLE_PATTERNS.some((pattern) => pattern.test(cls));
+    }
+    /**
+     * Evict oldest entries (FIFO strategy)
+     * Removes 10% of cache to avoid frequent evictions
+     */
+    evictOldest() {
+        const toRemove = Math.ceil(MAX_CACHE_SIZE * 0.1);
+        const iterator = this.cache.keys();
+        for (let i = 0; i < toRemove; i++) {
+            const { value, done } = iterator.next();
+            if (done)
+                break;
+            this.cache.delete(value);
+        }
+    }
+}
+// FULL STRING CACHE
+/**
+ * Cache for full class strings (entire tw prop)
+ * Useful when the same exact class string is used multiple times
+ *
+ * Key: "flex bg-blue-500 p-4"
+ * Value: merged CSS properties
+ *
+ * @performance v0.2.0 Turbo optimizations:
+ * - Direct reference return (no spread copy)
+ * - No Object.freeze
+ * - Efficient LRU-like eviction
+ */
+class TailwindStringCache {
+    cache = new Map();
+    maxSize = 1000;
+    /**
+     * Get cached properties for a full class string
+     * @performance Returns direct reference - DO NOT MUTATE
+     */
+    get(key) {
+        return this.cache.get(key);
+    }
+    /**
+     * Cache properties for a full class string
+     */
+    set(key, props) {
+        if (this.cache.size >= this.maxSize) {
+            // Simple eviction: delete oldest entries (first 20%)
+            const toRemove = Math.ceil(this.maxSize * 0.2);
+            const iterator = this.cache.keys();
+            for (let i = 0; i < toRemove; i++) {
+                const { value, done } = iterator.next();
+                if (done)
+                    break;
+                this.cache.delete(value);
+            }
+        }
+        // Store directly - no copy, no freeze
+        this.cache.set(key, props);
+    }
+    /**
+     * Check if a string has cached properties
+     */
+    has(key) {
+        return this.cache.has(key);
+    }
+    /**
+     * Clear the cache
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache size
+     */
+    get size() {
+        return this.cache.size;
+    }
+}
+// EXPORTS
+/**
+ * Singleton instance for class-level caching
+ */
+export const classCache = new TailwindClassCache();
+/**
+ * Singleton instance for full string caching
+ */
+export const stringCache = new TailwindStringCache();
+/**
+ * Clear all Tailwind caches
+ * Useful for testing or when theme changes
+ */
+export function clearAllCaches() {
+    classCache.clear();
+    stringCache.clear();
+}
+/**
+ * Get combined cache statistics
+ */
+export function getCacheStats() {
+    return {
+        classCache: classCache.getStats(),
+        stringCacheSize: stringCache.size,
+    };
+}

package/dist/tailwind/index.d.ts

@@ -1,2 +1,15 @@
-export { borderRadius, colors, fontSize, fontWeight, opacity, parseTailwind, spacing, } from "./parser";
+/**
+ * @ogxjs/core - Tailwind Module
+ * High-performance Tailwind CSS parser
+ *
+ * @version 0.2.0 "Turbo"
+ */
+export type { CacheStats } from "./class-cache";
+export { classCache, stringCache } from "./class-cache";
+export { colors } from "./colors";
+export { getStaticClass, isStaticClass, STATIC_CLASSES } from "./lookup-tables";
+export { clearAllCaches, getCacheStats, parseTailwind, parseTailwindBatch, } from "./parser-v2";
+export type { GradientState, ParseContext } from "./prefix-handlers";
+export { ORDERED_PREFIXES, PREFIX_HANDLERS, parseSpacingValue, resolveColorValue, } from "./prefix-handlers";
+export { borderRadius, fontSize, fontWeight, opacity, spacing } from "./scales";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tailwind/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,YAAY,EACZ,MAAM,EACN,QAAQ,EACR,UAAU,EACV,OAAO,EACP,aAAa,EACb,OAAO,GACP,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tailwind/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEhF,OAAO,EACN,cAAc,EACd,aAAa,EACb,aAAa,EACb,kBAAkB,GAClB,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,EACN,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,iBAAiB,GACjB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC"}

package/dist/tailwind/index.js

@@ -1 +1,15 @@
-export { borderRadius, colors, fontSize, fontWeight, opacity, parseTailwind, spacing, } from "./parser";
+/**
+ * @ogxjs/core - Tailwind Module
+ * High-performance Tailwind CSS parser
+ *
+ * @version 0.2.0 "Turbo"
+ */
+export { classCache, stringCache } from "./class-cache";
+export { colors } from "./colors";
+// Advanced exports for customization
+export { getStaticClass, isStaticClass, STATIC_CLASSES } from "./lookup-tables";
+// Main parser (v2 with O(1) lookups)
+export { clearAllCaches, getCacheStats, parseTailwind, parseTailwindBatch, } from "./parser-v2";
+export { ORDERED_PREFIXES, PREFIX_HANDLERS, parseSpacingValue, resolveColorValue, } from "./prefix-handlers";
+// Scales and values
+export { borderRadius, fontSize, fontWeight, opacity, spacing } from "./scales";

package/dist/tailwind/lookup-tables.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @ogxjs/core - Tailwind Lookup Tables
+ * O(1) lookup for static classes (no dynamic values)
+ *
+ * @description
+ * This module provides instant lookup for ~200+ static Tailwind classes.
+ * Instead of iterating through if/else chains, we use Map for O(1) access.
+ *
+ * @performance
+ * - Before: O(n) where n = number of if/else conditions (~100)
+ * - After: O(1) constant time lookup
+ *
+ * @version 0.2.0 "Turbo"
+ */
+import type { CSSProperties } from "../css";
+/**
+ * Static classes that map directly to CSS properties
+ * No parsing needed - just lookup and return
+ */
+export declare const STATIC_CLASSES: Map<string, CSSProperties>;
+/**
+ * Check if a class is static (can be looked up directly)
+ */
+export declare function isStaticClass(cls: string): boolean;
+/**
+ * Get CSS properties for a static class
+ * Returns undefined if not a static class
+ */
+export declare function getStaticClass(cls: string): CSSProperties | undefined;
+//# sourceMappingURL=lookup-tables.d.ts.map

package/dist/tailwind/lookup-tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup-tables.d.ts","sourceRoot":"","sources":["../../src/tailwind/lookup-tables.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C;;;GAGG;AACH,eAAO,MAAM,cAAc,4BAsdzB,CAAC;AAEH;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAErE"}