@shival99/z-ui 1.0.1 → 1.0.2

package/fesm2022/shival99-z-ui-services.mjs

@@ -0,0 +1,919 @@
+import * as i0 from '@angular/core';
+import { Injectable, inject, signal } from '@angular/core';
+import { BehaviorSubject, Subject, firstValueFrom } from 'rxjs';
+import { DOCUMENT } from '@angular/common';
+import { TranslateService } from '@ngx-translate/core';
+
+/**
+ * Z-Cache Service
+ * A localStorage-based cache service with optional encryption
+ */
+const Z_CACHE_DEFAULT_PREFIX = 'z_';
+class ZCacheService {
+    static _prefix = Z_CACHE_DEFAULT_PREFIX;
+    static _encrypt = true;
+    /**
+     * Configure the cache service
+     */
+    static configure(config) {
+        if (config.prefix) {
+            ZCacheService._prefix = config.prefix;
+        }
+        if (config.encrypt !== undefined) {
+            ZCacheService._encrypt = config.encrypt;
+        }
+    }
+    static _encode(data) {
+        const payload = { __z: true, __d: data };
+        return btoa(encodeURIComponent(JSON.stringify(payload)));
+    }
+    static _decode(data) {
+        try {
+            const decoded = JSON.parse(decodeURIComponent(atob(data)));
+            if (!decoded.__z) {
+                return null;
+            }
+            return decoded.__d;
+        }
+        catch {
+            return null;
+        }
+    }
+    static _getFullKey(key, encrypt) {
+        const prefixedKey = `${ZCacheService._prefix}${key}`;
+        return encrypt ? ZCacheService._encode(prefixedKey) : prefixedKey;
+    }
+    static _safeOperation(operation, fallback) {
+        try {
+            return operation();
+        }
+        catch (error) {
+            console.error('[ZCache] Operation error:', error);
+            return fallback;
+        }
+    }
+    /**
+     * Get a value from cache
+     * @param key - Cache key
+     * @param defaultValue - Default value if not found
+     * @param encrypt - Whether to use encryption (default: service config)
+     */
+    static get(key, defaultValue, encrypt = ZCacheService._encrypt) {
+        return ZCacheService._safeOperation(() => {
+            const _key = ZCacheService._getFullKey(key, encrypt);
+            const result = localStorage.getItem(_key);
+            if (!result) {
+                return defaultValue;
+            }
+            const data = encrypt ? ZCacheService._decode(result) : JSON.parse(result);
+            return data ?? defaultValue;
+        }, defaultValue);
+    }
+    /**
+     * Set a value in cache
+     * @param key - Cache key
+     * @param data - Data to store
+     * @param encrypt - Whether to use encryption
+     */
+    static set(key, data, encrypt = ZCacheService._encrypt) {
+        return ZCacheService._safeOperation(() => {
+            const _key = ZCacheService._getFullKey(key, encrypt);
+            const _value = encrypt ? ZCacheService._encode(data) : JSON.stringify(data);
+            localStorage.setItem(_key, _value);
+            return true;
+        }, false);
+    }
+    /**
+     * Delete a key from cache
+     * @param key - Cache key
+     * @param encrypt - Whether key is encrypted
+     */
+    static delete(key, encrypt = ZCacheService._encrypt) {
+        return ZCacheService._safeOperation(() => {
+            const _key = ZCacheService._getFullKey(key, encrypt);
+            localStorage.removeItem(_key);
+            return true;
+        }, false);
+    }
+    /**
+     * Delete multiple keys from cache
+     * @param keys - Array of cache keys
+     * @param encrypt - Whether keys are encrypted
+     */
+    static deleteMultiple(keys, encrypt = ZCacheService._encrypt) {
+        return ZCacheService._safeOperation(() => {
+            keys.forEach(key => {
+                const _key = ZCacheService._getFullKey(key, encrypt);
+                localStorage.removeItem(_key);
+            });
+            return true;
+        }, false);
+    }
+    /**
+     * Clear all cache with the configured prefix
+     */
+    static clear() {
+        return ZCacheService._safeOperation(() => {
+            const keysToRemove = [];
+            const prefixEncoded = ZCacheService._encode(ZCacheService._prefix);
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key?.startsWith(ZCacheService._prefix) || key?.startsWith(prefixEncoded)) {
+                    keysToRemove.push(key);
+                }
+            }
+            keysToRemove.forEach(key => localStorage.removeItem(key));
+            return true;
+        }, false);
+    }
+    /**
+     * Check if a key exists in cache
+     * @param key - Cache key
+     * @param encrypt - Whether key is encrypted
+     */
+    static has(key, encrypt = ZCacheService._encrypt) {
+        return ZCacheService._safeOperation(() => {
+            const _key = ZCacheService._getFullKey(key, encrypt);
+            return localStorage.getItem(_key) !== null;
+        }, false);
+    }
+    /**
+     * Get all keys with the configured prefix
+     */
+    static keys() {
+        return ZCacheService._safeOperation(() => {
+            const result = [];
+            const prefixEncoded = ZCacheService._encode(ZCacheService._prefix);
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key?.startsWith(ZCacheService._prefix)) {
+                    result.push(key.slice(ZCacheService._prefix.length));
+                }
+                else if (key?.startsWith(prefixEncoded)) {
+                    const decoded = ZCacheService._decode(key);
+                    if (decoded) {
+                        result.push(decoded.slice(ZCacheService._prefix.length));
+                    }
+                }
+            }
+            return result;
+        }, []);
+    }
+}
+
+/**
+ * Z-IndexDB Service
+ * A robust IndexedDB service with multi-store support, encryption, and retry logic
+ */
+/** Default configuration */
+const Z_INDEXDB_DEFAULT_CONFIG = {
+    dbName: 'ZDatabase',
+    version: 1,
+    mode: 'readwrite',
+    defaultStore: 'ZStore',
+};
+/** Batch size for bulk operations */
+const Z_INDEXDB_BATCH_SIZE = 100;
+class ZIndexDbService {
+    _db = null;
+    _dbName;
+    _version;
+    _mode;
+    _dbReady;
+    _stores = new Map();
+    _defaultStoreName;
+    _globalProtectedKeys;
+    constructor(config = {}) {
+        this._dbName = config.dbName ?? Z_INDEXDB_DEFAULT_CONFIG.dbName;
+        this._version = config.version ?? Z_INDEXDB_DEFAULT_CONFIG.version;
+        this._mode = config.mode ?? Z_INDEXDB_DEFAULT_CONFIG.mode;
+        this._defaultStoreName = config.defaultStore ?? Z_INDEXDB_DEFAULT_CONFIG.defaultStore;
+        this._globalProtectedKeys = config.protectedKeys ?? [];
+        if (config.stores?.length) {
+            config.stores.forEach(store => this._stores.set(store.name, store));
+        }
+        if (!this._stores.has(this._defaultStoreName)) {
+            this._stores.set(this._defaultStoreName, { name: this._defaultStoreName, encrypt: true });
+        }
+        this._dbReady = this._initDb();
+    }
+    _getStoreConfig(storeName) {
+        const name = storeName ?? this._defaultStoreName;
+        return this._stores.get(name) ?? { name, encrypt: true };
+    }
+    _encrypt(data) {
+        const payload = {
+            __z: true,
+            __t: typeof data,
+            __d: data,
+        };
+        return btoa(encodeURIComponent(JSON.stringify(payload)));
+    }
+    _decrypt(data) {
+        try {
+            const decoded = JSON.parse(decodeURIComponent(atob(data)));
+            if (!decoded.__z) {
+                return null;
+            }
+            return decoded.__d;
+        }
+        catch {
+            return null;
+        }
+    }
+    _closeConnection() {
+        if (this._db) {
+            this._db.close();
+            this._db = null;
+        }
+    }
+    async _reconnect() {
+        console.warn('[ZIndexDb] Reconnecting...');
+        this._closeConnection();
+        this._dbReady = this._initDb();
+        await this._dbReady;
+    }
+    async _withRetry(operation, retries = 3) {
+        let lastError;
+        for (let i = 0; i < retries; i++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                if (error instanceof Error && error.name === 'InvalidStateError') {
+                    await this._reconnect();
+                }
+                await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 100));
+            }
+        }
+        throw lastError;
+    }
+    async _initDb() {
+        if (this._db) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                const request = indexedDB.open(this._dbName, this._version);
+                request.onupgradeneeded = event => {
+                    const db = event.target.result;
+                    this._stores.forEach((_, storeName) => {
+                        if (!db.objectStoreNames.contains(storeName)) {
+                            db.createObjectStore(storeName);
+                        }
+                    });
+                };
+                request.onsuccess = event => {
+                    this._db = event.target.result;
+                    this._db.onerror = e => console.error('[ZIndexDb] Error:', e.target.error);
+                    this._db.onclose = () => {
+                        console.warn('[ZIndexDb] Connection closed unexpectedly');
+                        this._db = null;
+                    };
+                    resolve();
+                };
+                request.onerror = event => {
+                    console.error('[ZIndexDb] Open error:', event.target.error);
+                    reject(event.target.error);
+                };
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Get a value from the store
+     * @param key - The key to retrieve
+     * @param defaultValue - Default value if key not found
+     * @param storeName - Optional store name (uses default if not specified)
+     */
+    async get(key, defaultValue, storeName) {
+        const storeConfig = this._getStoreConfig(storeName);
+        return this._withRetry(async () => {
+            await this._dbReady;
+            if (!this._db) {
+                await this._reconnect();
+                if (!this._db) {
+                    return defaultValue;
+                }
+            }
+            const _key = storeConfig.encrypt !== false ? this._encrypt(key) : key;
+            return new Promise(resolve => {
+                try {
+                    const transaction = this._db.transaction([storeConfig.name], this._mode);
+                    const store = transaction.objectStore(storeConfig.name);
+                    const request = store.get(_key);
+                    request.onsuccess = () => {
+                        try {
+                            const { result } = request;
+                            if (!result) {
+                                resolve(defaultValue);
+                                return;
+                            }
+                            const decrypted = storeConfig.encrypt !== false ? this._decrypt(result) : result;
+                            resolve(decrypted ?? defaultValue);
+                        }
+                        catch {
+                            resolve(defaultValue);
+                        }
+                    };
+                    request.onerror = () => resolve(defaultValue);
+                    transaction.onerror = () => resolve(defaultValue);
+                }
+                catch {
+                    resolve(defaultValue);
+                }
+            });
+        });
+    }
+    /**
+     * Set a value in the store
+     * @param key - The key to set
+     * @param value - The value to store
+     * @param storeName - Optional store name
+     */
+    async set(key, value, storeName) {
+        const storeConfig = this._getStoreConfig(storeName);
+        return this._withRetry(async () => {
+            await this._dbReady;
+            if (!this._db) {
+                await this._reconnect();
+                if (!this._db) {
+                    throw new Error('Database not initialized');
+                }
+            }
+            const _key = storeConfig.encrypt !== false ? this._encrypt(key) : key;
+            const _value = storeConfig.encrypt !== false ? this._encrypt(value) : value;
+            return new Promise((resolve, reject) => {
+                try {
+                    const transaction = this._db.transaction([storeConfig.name], 'readwrite');
+                    const store = transaction.objectStore(storeConfig.name);
+                    const request = store.put(_value, _key);
+                    request.onerror = () => reject(request.error);
+                    transaction.oncomplete = () => resolve();
+                    transaction.onerror = () => reject(transaction.error);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    /**
+     * Delete a key from the store
+     * @param key - Key or array of keys to delete
+     * @param storeName - Optional store name
+     */
+    async delete(key, storeName) {
+        const storeConfig = this._getStoreConfig(storeName);
+        return this._withRetry(async () => {
+            await this._dbReady;
+            if (!this._db) {
+                await this._reconnect();
+                if (!this._db) {
+                    throw new Error('Database not initialized');
+                }
+            }
+            const keys = Array.isArray(key) ? key : [key];
+            return new Promise((resolve, reject) => {
+                try {
+                    const transaction = this._db.transaction([storeConfig.name], 'readwrite');
+                    const store = transaction.objectStore(storeConfig.name);
+                    keys.forEach(k => {
+                        const _key = storeConfig.encrypt !== false ? this._encrypt(k) : k;
+                        store.delete(_key);
+                    });
+                    transaction.oncomplete = () => resolve();
+                    transaction.onerror = () => reject(transaction.error);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    /**
+     * Clear all data from a store (respecting protected keys)
+     * @param storeName - Optional store name
+     */
+    async clear(storeName) {
+        const storeConfig = this._getStoreConfig(storeName);
+        const protectedKeys = [...this._globalProtectedKeys, ...(storeConfig.protectedKeys ?? [])];
+        return this._withRetry(async () => {
+            await this._dbReady;
+            if (!this._db) {
+                await this._reconnect();
+                if (!this._db) {
+                    throw new Error('Database not initialized');
+                }
+            }
+            if (protectedKeys.length === 0) {
+                return new Promise((resolve, reject) => {
+                    const transaction = this._db.transaction([storeConfig.name], 'readwrite');
+                    const store = transaction.objectStore(storeConfig.name);
+                    const request = store.clear();
+                    request.onsuccess = () => resolve();
+                    request.onerror = () => reject(request.error);
+                });
+            }
+            return new Promise((resolve, reject) => {
+                try {
+                    const transaction = this._db.transaction([storeConfig.name], 'readwrite');
+                    const store = transaction.objectStore(storeConfig.name);
+                    const keyRequest = store.getAllKeys();
+                    keyRequest.onsuccess = () => {
+                        const allKeys = keyRequest.result;
+                        const encryptedProtected = protectedKeys.map(k => this._encrypt(k));
+                        allKeys.forEach(k => {
+                            if (!encryptedProtected.includes(k) && !protectedKeys.includes(k)) {
+                                try {
+                                    const decrypted = this._decrypt(k);
+                                    if (!protectedKeys.includes(decrypted ?? '')) {
+                                        store.delete(k);
+                                    }
+                                }
+                                catch {
+                                    store.delete(k);
+                                }
+                            }
+                        });
+                    };
+                    keyRequest.onerror = () => reject(keyRequest.error);
+                    transaction.oncomplete = () => resolve();
+                    transaction.onerror = () => reject(transaction.error);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    /**
+     * Get all items from a store
+     * @param storeName - Optional store name
+     */
+    async getAll(storeName) {
+        const storeConfig = this._getStoreConfig(storeName);
+        return this._withRetry(async () => {
+            await this._dbReady;
+            if (!this._db) {
+                await this._reconnect();
+                if (!this._db) {
+                    return {};
+                }
+            }
+            return new Promise(resolve => {
+                try {
+                    const transaction = this._db.transaction([storeConfig.name], this._mode);
+                    const store = transaction.objectStore(storeConfig.name);
+                    const keysRequest = store.getAllKeys();
+                    const valuesRequest = store.getAll();
+                    const results = {};
+                    keysRequest.onsuccess = () => {
+                        const keys = keysRequest.result;
+                        const values = valuesRequest.result;
+                        keys.forEach((key, index) => {
+                            if (typeof key === 'string') {
+                                try {
+                                    const _key = storeConfig.encrypt !== false ? this._decrypt(key) : key;
+                                    const _value = storeConfig.encrypt !== false ? this._decrypt(values[index]) : values[index];
+                                    if (_key && _value !== null) {
+                                        results[_key] = _value;
+                                    }
+                                }
+                                catch {
+                                    // Skip invalid entries
+                                }
+                            }
+                        });
+                        resolve(results);
+                    };
+                    keysRequest.onerror = () => resolve({});
+                    transaction.onerror = () => resolve({});
+                }
+                catch {
+                    resolve({});
+                }
+            });
+        });
+    }
+    /**
+     * Set multiple items at once
+     * @param items - Object with key-value pairs
+     * @param storeName - Optional store name
+     */
+    async setMultiple(items, storeName) {
+        const storeConfig = this._getStoreConfig(storeName);
+        const entries = Object.entries(items);
+        for (let i = 0; i < entries.length; i += Z_INDEXDB_BATCH_SIZE) {
+            const batch = entries.slice(i, i + Z_INDEXDB_BATCH_SIZE);
+            await this._withRetry(async () => {
+                await this._dbReady;
+                if (!this._db) {
+                    await this._reconnect();
+                    if (!this._db) {
+                        throw new Error('Database not initialized');
+                    }
+                }
+                return new Promise((resolve, reject) => {
+                    const transaction = this._db.transaction([storeConfig.name], 'readwrite');
+                    const store = transaction.objectStore(storeConfig.name);
+                    batch.forEach(([key, value]) => {
+                        const _key = storeConfig.encrypt !== false ? this._encrypt(key) : key;
+                        const _value = storeConfig.encrypt !== false ? this._encrypt(value) : value;
+                        store.put(_value, _key);
+                    });
+                    transaction.oncomplete = () => resolve();
+                    transaction.onerror = () => reject(transaction.error);
+                });
+            });
+        }
+    }
+    /**
+     * Get the list of available store names
+     */
+    getStoreNames() {
+        return Array.from(this._stores.keys());
+    }
+    /**
+     * Check if a store exists
+     * @param storeName - Store name to check
+     */
+    hasStore(storeName) {
+        return this._stores.has(storeName);
+    }
+    /**
+     * Add a new store (requires database version upgrade)
+     * Note: This will cause database reconnection
+     * @param config - Store configuration
+     */
+    async addStore(config) {
+        if (this._stores.has(config.name)) {
+            return;
+        }
+        this._stores.set(config.name, config);
+        this._version += 1;
+        this._closeConnection();
+        this._dbReady = this._initDb();
+        await this._dbReady;
+    }
+}
+
+/**
+ * Z-Subject Service
+ * A service for managing reactive subjects (Subject and BehaviorSubject)
+ */
+class ZSubjectService {
+    _subjects = new Map();
+    _behaviorSubjects = new Map();
+    /**
+     * Emit a value to a subject
+     * @param key - Subject identifier
+     * @param type - 'subject' for Subject, 'behavior' for BehaviorSubject
+     * @param value - Value to emit
+     */
+    emit(key, type, value) {
+        if (type === 'behavior') {
+            const existingSubject = this._behaviorSubjects.get(key);
+            if (existingSubject) {
+                existingSubject.next(value);
+                return;
+            }
+            const newSubject = new BehaviorSubject(value);
+            this._behaviorSubjects.set(key, newSubject);
+            return;
+        }
+        const existingSubject = this._subjects.get(key);
+        if (existingSubject) {
+            existingSubject.next(value);
+            return;
+        }
+        const newSubject = new Subject();
+        this._subjects.set(key, newSubject);
+        newSubject.next(value);
+    }
+    /**
+     * Get an observable for a subject
+     * @param key - Subject identifier
+     * @param type - 'subject' for Subject, 'behavior' for BehaviorSubject
+     * @param initialValue - Initial value for BehaviorSubject (required for new behavior subjects)
+     */
+    on$(key, type, initialValue) {
+        if (type === 'behavior') {
+            const existingSubject = this._behaviorSubjects.get(key);
+            if (existingSubject) {
+                return existingSubject.asObservable();
+            }
+            const newSubject = new BehaviorSubject(initialValue);
+            this._behaviorSubjects.set(key, newSubject);
+            return newSubject.asObservable();
+        }
+        const existingSubject = this._subjects.get(key);
+        if (existingSubject) {
+            return existingSubject.asObservable();
+        }
+        const newSubject = new Subject();
+        this._subjects.set(key, newSubject);
+        return newSubject.asObservable();
+    }
+    /**
+     * Get the current value of a BehaviorSubject
+     * @param key - Subject identifier
+     */
+    getValue(key) {
+        const subject = this._behaviorSubjects.get(key);
+        if (!subject) {
+            return undefined;
+        }
+        return subject.getValue();
+    }
+    /**
+     * Complete and remove a subject
+     * @param key - Subject identifier
+     * @param type - 'subject' for Subject, 'behavior' for BehaviorSubject
+     */
+    complete(key, type) {
+        if (type === 'behavior') {
+            const subject = this._behaviorSubjects.get(key);
+            if (!subject) {
+                return;
+            }
+            subject.complete();
+            this._behaviorSubjects.delete(key);
+            return;
+        }
+        const subject = this._subjects.get(key);
+        if (!subject) {
+            return;
+        }
+        subject.complete();
+        this._subjects.delete(key);
+    }
+    /**
+     * Complete all subjects
+     */
+    completeAll() {
+        this._subjects.forEach(subject => subject.complete());
+        this._behaviorSubjects.forEach(subject => subject.complete());
+        this._subjects.clear();
+        this._behaviorSubjects.clear();
+    }
+    /**
+     * Check if a subject exists
+     * @param key - Subject identifier
+     * @param type - 'subject' for Subject, 'behavior' for BehaviorSubject
+     */
+    has(key, type) {
+        if (type === 'behavior') {
+            return this._behaviorSubjects.has(key);
+        }
+        return this._subjects.has(key);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZSubjectService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZSubjectService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZSubjectService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Z-Theme Types
+ */
+const Z_DEFAULT_THEME = 'neutral';
+const Z_THEME_CSS_MAP = {
+    neutral: '',
+    green: 'assets/css/themes/green.css',
+    orange: 'assets/css/themes/orange.css',
+    violet: 'assets/css/themes/violet.css',
+    stone: 'assets/css/themes/stone.css',
+    zinc: 'assets/css/themes/zinc.css',
+    gray: 'assets/css/themes/gray.css',
+    slate: 'assets/css/themes/slate.css',
+    hospital: 'assets/css/themes/hospital.css',
+};
+
+class ZThemeService {
+    _document = inject(DOCUMENT);
+    _isDark = signal(false, ...(ngDevMode ? [{ debugName: "_isDark" }] : []));
+    _currentTheme = signal(Z_DEFAULT_THEME, ...(ngDevMode ? [{ debugName: "_currentTheme" }] : []));
+    _loadedThemes = new Set(['neutral']);
+    isDark = this._isDark.asReadonly();
+    currentTheme = this._currentTheme.asReadonly();
+    setTheme(theme) {
+        this._currentTheme.set(theme);
+        if (this._loadedThemes.has(theme)) {
+            this._document.documentElement.setAttribute('z-theme', theme);
+            return;
+        }
+        if (!Z_THEME_CSS_MAP[theme]) {
+            this._document.documentElement.setAttribute('z-theme', theme);
+            return;
+        }
+        this._loadThemeCSS(theme, () => {
+            this._document.documentElement.setAttribute('z-theme', theme);
+        });
+    }
+    toggleDarkMode(isDark) {
+        this._isDark.set(isDark);
+        if (isDark) {
+            this._document.documentElement.classList.add('dark');
+            return;
+        }
+        this._document.documentElement.classList.remove('dark');
+    }
+    preloadTheme(theme) {
+        if (this._loadedThemes.has(theme) || !Z_THEME_CSS_MAP[theme]) {
+            return;
+        }
+        this._loadThemeCSS(theme);
+    }
+    _loadThemeCSS(theme, onLoad) {
+        const cssPath = Z_THEME_CSS_MAP[theme];
+        if (!cssPath) {
+            onLoad?.();
+            return;
+        }
+        const existingLink = this._document.querySelector(`link[data-theme="${theme}"]`);
+        if (existingLink) {
+            this._loadedThemes.add(theme);
+            onLoad?.();
+            return;
+        }
+        const link = this._document.createElement('link');
+        link.rel = 'stylesheet';
+        link.href = cssPath;
+        link.setAttribute('data-theme', theme);
+        link.onload = () => {
+            this._loadedThemes.add(theme);
+            onLoad?.();
+        };
+        link.onerror = () => {
+            console.error(`Failed to load theme "${theme}" from ${cssPath}`);
+            onLoad?.();
+        };
+        this._document.head.appendChild(link);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZThemeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Z-Translate Service
+ * A translation service with async support and caching
+ */
+const LANG_CACHE_KEY = 'Z_LANGUAGE';
+const DEFAULT_LANG = 'vi';
+class ZTranslateService {
+    _translate = inject(TranslateService);
+    /** Current language signal */
+    currentLang = signal(DEFAULT_LANG, ...(ngDevMode ? [{ debugName: "currentLang" }] : []));
+    /** Available languages */
+    availableLangs = signal(['vi', 'en'], ...(ngDevMode ? [{ debugName: "availableLangs" }] : []));
+    constructor() {
+        this._initialize();
+    }
+    _initialize() {
+        const savedLang = ZCacheService.get(LANG_CACHE_KEY) ?? DEFAULT_LANG;
+        this._translate.setFallbackLang(DEFAULT_LANG);
+        this._translate.use(savedLang);
+        this.currentLang.set(savedLang);
+    }
+    /**
+     * Change the current language
+     * @param lang - Language code
+     */
+    use(lang) {
+        this._translate.use(lang);
+        ZCacheService.set(LANG_CACHE_KEY, lang);
+        this.currentLang.set(lang);
+    }
+    /**
+     * Get the current language code
+     */
+    getLang() {
+        return this._translate.getCurrentLang() ?? DEFAULT_LANG;
+    }
+    /**
+     * Get translation synchronously (returns key if not found)
+     * @param key - Translation key
+     * @param params - Interpolation parameters
+     */
+    instant(key, params) {
+        if (!key) {
+            return '';
+        }
+        return this._translate.instant(key, params);
+    }
+    /**
+     * Get translation asynchronously
+     * @param key - Translation key
+     * @param params - Interpolation parameters
+     */
+    async get(key, params) {
+        if (!key) {
+            return '';
+        }
+        return firstValueFrom(this._translate.get(key, params));
+    }
+    /**
+     * Get translation as observable
+     * @param key - Translation key
+     * @param params - Interpolation parameters
+     */
+    get$(key, params) {
+        return this._translate.get(key, params);
+    }
+    /**
+     * Stream translations (re-emits on language change)
+     * @param key - Translation key
+     * @param params - Interpolation parameters
+     */
+    stream$(key, params) {
+        return this._translate.stream(key, params);
+    }
+    /**
+     * Get multiple translations at once
+     * @param keys - Array of translation keys
+     * @param params - Interpolation parameters (applied to all)
+     */
+    async getMany(keys, params) {
+        const results = {};
+        await Promise.all(keys.map(async (key) => {
+            results[key] = await this.get(key, params);
+        }));
+        return results;
+    }
+    /**
+     * Check if a translation key exists
+     * @param key - Translation key
+     */
+    has(key) {
+        const translation = this._translate.instant(key);
+        return translation !== key;
+    }
+    /**
+     * Add translations dynamically
+     * @param lang - Language code
+     * @param translations - Translation object
+     * @param shouldMerge - Whether to merge with existing translations
+     */
+    setTranslation(lang, translations, shouldMerge = true) {
+        this._translate.setTranslation(lang, translations, shouldMerge);
+    }
+    /**
+     * Get the underlying TranslateService for advanced usage
+     */
+    getNgxTranslate() {
+        return this._translate;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZTranslateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZTranslateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZTranslateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Z-Cache Types
+ */
+
+/**
+ * Z-Http Types
+ */
+
+/**
+ * Z-IndexDB Types
+ */
+
+/**
+ * Z-Translate Types
+ */
+
+/**
+ * Services types index
+ */
+
+/**
+ * Services index
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ZCacheService, ZIndexDbService, ZSubjectService, ZThemeService, ZTranslateService, Z_DEFAULT_THEME, Z_THEME_CSS_MAP };
+//# sourceMappingURL=shival99-z-ui-services.mjs.map