@codeleap/styles 4.0.1

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import './lib/constants';
+import './lib/utils';
+export * from './lib';
+export * from './types';
+export { default as deepmerge } from '@fastify/deepmerge';

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepmerge = void 0;
+require("./lib/constants");
+require("./lib/utils");
+__exportStar(require("./lib"), exports);
+__exportStar(require("./types"), exports);
+var deepmerge_1 = require("@fastify/deepmerge");
+Object.defineProperty(exports, "deepmerge", { enumerable: true, get: function () { return __importDefault(deepmerge_1).default; } });

package/dist/lib/Cacher.d.ts

@@ -0,0 +1,37 @@
+import { StateStorage } from 'zustand/middleware';
+import { AnyRecord } from '../types';
+import { CacheType } from '../types/cache';
+type StorePersistor = {
+    cached: AnyRecord;
+    cacheFor: (key: string, value: any) => void;
+    staleTime: Date;
+    reset: () => void;
+};
+export declare class Cache<T extends any = any> {
+    registryName: CacheType;
+    private storage;
+    persistCache: boolean;
+    cache: Record<string, T>;
+    persistor: any;
+    store: StorePersistor;
+    constructor(registryName: CacheType, storage?: StateStorage, persistCache?: boolean);
+    keyFor(cacheBaseKey: string, data: Array<any> | any): {
+        key: string;
+        value: T;
+    };
+    cacheFor(key: string, cache: T): T;
+    setCache(cache: Record<string, T>): void;
+    clear(): void;
+    createPersistor(registryName: string): import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<StorePersistor>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<import("zustand/middleware").PersistOptions<StorePersistor, StorePersistor>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => void | Promise<void>;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: StorePersistor) => void) => () => void;
+            onFinishHydration: (fn: (state: StorePersistor) => void) => () => void;
+            getOptions: () => Partial<import("zustand/middleware").PersistOptions<StorePersistor, StorePersistor>>;
+        };
+    }>;
+}
+export {};

package/dist/lib/Cacher.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+var zustand_1 = require("zustand");
+var middleware_1 = require("zustand/middleware");
+var constants_1 = require("./constants");
+var hashKey_1 = require("./hashKey");
+function getStaleTime() {
+    var time = 7;
+    var currentTime = new Date();
+    currentTime.setDate(currentTime.getDate() + time);
+    return currentTime;
+}
+var Cache = /** @class */ (function () {
+    function Cache(registryName, storage, persistCache) {
+        if (storage === void 0) { storage = null; }
+        if (persistCache === void 0) { persistCache = !!storage; }
+        this.registryName = registryName;
+        this.storage = storage;
+        this.persistCache = persistCache;
+        this.cache = {};
+        this.persistor = null;
+        this.store = {
+            cached: {},
+            cacheFor: function () { return null; },
+            reset: function () { return null; },
+            staleTime: null
+        };
+        if (!persistCache)
+            return;
+        this.createPersistor(registryName);
+        if (!constants_1.StyleConstants.STORE_CACHE_ENABLED || !this.persistor)
+            return;
+        var currentTime = new Date();
+        var staleTime = new Date(this.store.staleTime);
+        var isStaled = currentTime > staleTime;
+        if (isStaled) {
+            this.store.reset();
+            return;
+        }
+        this.setCache(this.store.cached);
+    }
+    Cache.prototype.keyFor = function (cacheBaseKey, data) {
+        var _a;
+        var values = [cacheBaseKey, data];
+        var cacheKey = (0, hashKey_1.hashKey)(values);
+        var cachedValue = (_a = this.cache[cacheKey]) !== null && _a !== void 0 ? _a : null;
+        return {
+            key: cacheKey,
+            value: cachedValue,
+        };
+    };
+    Cache.prototype.cacheFor = function (key, cache) {
+        this.cache[key] = cache;
+        if (this.persistCache)
+            this.store.cacheFor(key, cache);
+        return cache;
+    };
+    Cache.prototype.setCache = function (cache) {
+        this.cache = cache;
+    };
+    Cache.prototype.clear = function () {
+        this.cache = {};
+        if (this.persistCache)
+            this.persistor.persist.clearStorage();
+    };
+    Cache.prototype.createPersistor = function (registryName) {
+        var _this = this;
+        if (!this.persistCache)
+            return null;
+        var persistor = (0, zustand_1.create)((0, middleware_1.persist)(function (set, get) { return ({
+            staleTime: getStaleTime(),
+            cached: {},
+            cacheFor: function (key, value) { return set(function (store) {
+                var cached = store.cached;
+                cached[key] = value;
+                return {
+                    cached: cached
+                };
+            }); },
+            reset: function () { return set({
+                cached: {},
+                staleTime: getStaleTime()
+            }); }
+        }); }, {
+            name: "@styles.caches.".concat(registryName),
+            version: constants_1.StyleConstants.STORES_PERSIST_VERSION,
+            migrate: function (persistedState, version) {
+                if (version != constants_1.StyleConstants.STORES_PERSIST_VERSION) {
+                    persistedState.staleTime = getStaleTime();
+                    persistedState.cached = {};
+                    return persistedState;
+                }
+                return persistedState;
+            },
+            storage: (0, middleware_1.createJSONStorage)(function () { return _this.storage; }),
+        }));
+        this.persistor = persistor;
+        this.store = persistor.getState();
+        return persistor;
+    };
+    return Cache;
+}());
+exports.Cache = Cache;

package/dist/lib/StaleControl.d.ts

@@ -0,0 +1,21 @@
+export declare class StaleControl {
+    private staleTime;
+    private staleTimeIdentifier;
+    private wiperInterval;
+    private wiperId;
+    constructor(staleTime?: number, // minutes
+    staleTimeIdentifier?: string, wiperInterval?: number);
+    isStaled(value: string): boolean;
+    insertStaleTime(value: string): string;
+    refreshStaleTime(value: string): string;
+    extractStaleTime(value: string): {
+        staleTime: Date;
+        value: string;
+    };
+    /**
+     * wipe staled cache; verify isStaled values and remove
+     */
+    cacheWiper(): void;
+    registerCacheWiper(): void;
+    unregisterCacheWiper(): void;
+}

package/dist/lib/StaleControl.js

@@ -0,0 +1,78 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaleControl = void 0;
+var StaleControl = /** @class */ (function () {
+    function StaleControl(staleTime, // minutes
+    staleTimeIdentifier, wiperInterval) {
+        if (staleTime === void 0) { staleTime = 60; }
+        if (staleTimeIdentifier === void 0) { staleTimeIdentifier = '//:'; }
+        if (wiperInterval === void 0) { wiperInterval = 30 * 60 * 1000; }
+        this.staleTime = staleTime;
+        this.staleTimeIdentifier = staleTimeIdentifier;
+        this.wiperInterval = wiperInterval;
+        this.wiperId = null;
+    }
+    StaleControl.prototype.isStaled = function (value) {
+        var staleTime = this.extractStaleTime(value).staleTime;
+        var currentTime = new Date();
+        var isStaled = currentTime > staleTime;
+        return isStaled;
+    };
+    StaleControl.prototype.insertStaleTime = function (value) {
+        var currentTime = new Date();
+        currentTime.setMinutes(currentTime.getMinutes() + this.staleTime);
+        var staleTime = currentTime.toISOString();
+        var valueWithStaleTime = "".concat(value).concat(this.staleTimeIdentifier).concat(staleTime);
+        return valueWithStaleTime;
+    };
+    StaleControl.prototype.refreshStaleTime = function (value) {
+        var extractedValue = this.extractStaleTime(value).value;
+        var refreshedValue = this.insertStaleTime(extractedValue);
+        return refreshedValue;
+    };
+    StaleControl.prototype.extractStaleTime = function (value) {
+        var _a = __read(value === null || value === void 0 ? void 0 : value.split(this.staleTimeIdentifier), 2), extractedValue = _a[0], _staleTime = _a[1];
+        var staleTime = new Date(_staleTime);
+        return {
+            staleTime: staleTime,
+            value: extractedValue,
+        };
+    };
+    /**
+     * wipe staled cache; verify isStaled values and remove
+     */
+    StaleControl.prototype.cacheWiper = function () {
+        throw new Error('Cache Wiper not implement');
+    };
+    StaleControl.prototype.registerCacheWiper = function () {
+        var _this = this;
+        if (this.wiperId !== null) {
+            this.unregisterCacheWiper();
+        }
+        this.wiperId = setInterval(function () {
+            _this.cacheWiper();
+        }, this.wiperInterval);
+    };
+    StaleControl.prototype.unregisterCacheWiper = function () {
+        clearInterval(this.wiperId);
+        this.wiperId = null;
+    };
+    return StaleControl;
+}());
+exports.StaleControl = StaleControl;

package/dist/lib/StyleCache.d.ts

@@ -0,0 +1,20 @@
+import { Cache } from './Cacher';
+import { CacheType } from '../types/cache';
+import { StateStorage } from 'zustand/middleware';
+export declare class StyleCache {
+    baseKey: string;
+    styles: Cache<any>;
+    compositions: Cache<any>;
+    responsive: Cache<any>;
+    variants: Cache;
+    common: Cache;
+    components: Cache;
+    constructor(storage: StateStorage);
+    registerBaseKey(keys: Array<any>): string;
+    wipeCache(): void;
+    keyFor(type: CacheType, keyData: Array<any> | any): {
+        key: string;
+        value: any;
+    };
+    cacheFor(type: CacheType, key: string, value: any): any;
+}

package/dist/lib/StyleCache.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StyleCache = void 0;
+var Cacher_1 = require("./Cacher");
+var hashKey_1 = require("./hashKey");
+var constants_1 = require("./constants");
+var minifier_1 = require("./minifier");
+var StyleCache = /** @class */ (function () {
+    function StyleCache(storage) {
+        this.styles = new Cacher_1.Cache('styles');
+        this.compositions = new Cacher_1.Cache('compositions');
+        this.responsive = new Cacher_1.Cache('responsive');
+        this.variants = new Cacher_1.Cache('variants', storage);
+        this.common = new Cacher_1.Cache('common', storage);
+        this.components = new Cacher_1.Cache('components', storage);
+    }
+    StyleCache.prototype.registerBaseKey = function (keys) {
+        keys.push(constants_1.StyleConstants.STORES_PERSIST_VERSION);
+        var baseKey = (0, hashKey_1.hashKey)(keys);
+        this.baseKey = baseKey;
+        return baseKey;
+    };
+    StyleCache.prototype.wipeCache = function () {
+        this.components.clear();
+        this.responsive.clear();
+        this.compositions.clear();
+        this.variants.clear();
+        this.common.clear();
+        this.styles.clear();
+    };
+    StyleCache.prototype.keyFor = function (type, keyData) {
+        var _a;
+        var cache = this[type];
+        var values = [this.baseKey, keyData];
+        var cacheKey = (0, hashKey_1.hashKey)(values);
+        var cachedValue = minifier_1.minifier.decompress((_a = cache.cache[cacheKey]) !== null && _a !== void 0 ? _a : null);
+        return {
+            key: cacheKey,
+            value: cachedValue,
+        };
+    };
+    StyleCache.prototype.cacheFor = function (type, key, value) {
+        if (!constants_1.StyleConstants.CACHE_ENABLED) {
+            return value;
+        }
+        var cache = this[type];
+        var minifiedValue = minifier_1.minifier.compress(value);
+        return cache.cacheFor(key, minifiedValue);
+    };
+    return StyleCache;
+}());
+exports.StyleCache = StyleCache;

package/dist/lib/StylePersistor.d.ts

@@ -0,0 +1,13 @@
+import { StateStorage } from 'zustand/middleware';
+export type StoragePersistor = {
+    set: (key: string, value: any) => void;
+    get: (key: string) => any;
+    del: (key: string) => void;
+};
+export declare class StylePersistor implements StateStorage {
+    private storage;
+    constructor(storage: StoragePersistor);
+    setItem(name: string, value: string): void;
+    getItem(name: string): string | null;
+    removeItem(name: string): void;
+}

package/dist/lib/StylePersistor.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylePersistor = void 0;
+var minifier_1 = require("./minifier");
+var StylePersistor = /** @class */ (function () {
+    function StylePersistor(storage) {
+        this.storage = storage;
+    }
+    StylePersistor.prototype.setItem = function (name, value) {
+        return this.storage.set(name, value);
+    };
+    StylePersistor.prototype.getItem = function (name) {
+        var _a;
+        var persistedValue = (_a = this.storage) === null || _a === void 0 ? void 0 : _a.get(name);
+        return minifier_1.minifier.decompress(persistedValue !== null && persistedValue !== void 0 ? persistedValue : null);
+    };
+    StylePersistor.prototype.removeItem = function (name) {
+        return this.storage.del(name);
+    };
+    return StylePersistor;
+}());
+exports.StylePersistor = StylePersistor;

package/dist/lib/StyleRegistry.d.ts

@@ -0,0 +1,46 @@
+import { AnyRecord, AnyStyledComponent, ICSS, ITheme, StyleProp, VariantStyleSheet } from '../types';
+import { MultiplierFunction } from './spacing';
+import { StateStorage } from 'zustand/middleware';
+export declare class CodeleapStyleRegistry {
+    stylesheets: Record<string, VariantStyleSheet>;
+    commonVariants: Record<string, ICSS | MultiplierFunction>;
+    components: Record<string, AnyStyledComponent>;
+    private theme;
+    private styleCache;
+    constructor(storage: StateStorage);
+    computeCommonVariantStyle(componentName: string, variant: string, component?: any): {
+        [x: number]: ICSS;
+    };
+    computeVariantStyle(componentName: string, variants: string[], _component?: any): ICSS;
+    isCompositionStyle(component: AnyStyledComponent, style: any): {
+        isComposition: boolean;
+        composition: {};
+    };
+    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: object): 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>, mergeWithDefaultStyle?: boolean): T;
+    registerCommonVariants(): void;
+    registerVariants(componentName: string, variants: VariantStyleSheet): void;
+    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;
+    update(): void;
+    private copyStyle;
+    createStyles<K extends string = string>(styles: Record<K, StyleProp<AnyRecord, ''>> | ((theme: ITheme) => Record<K, StyleProp<AnyRecord, ''>>)): Record<K, ICSS>;
+}