@shival99/z-ui 1.0.11 → 1.0.13

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

@@ -1,20 +1,15 @@
+import { HttpClient, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
 import * as i0 from '@angular/core';
-import { Injectable, InjectionToken, inject, PLATFORM_ID, signal, effect } from '@angular/core';
-import { BehaviorSubject, Subject, firstValueFrom } from 'rxjs';
-import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { inject, signal, Injectable, InjectionToken, PLATFORM_ID, effect } from '@angular/core';
+import { Router } from '@angular/router';
+import { firstValueFrom, from, switchMap, of, catchError, throwError, tap, map, defer, BehaviorSubject, Subject } from 'rxjs';
 import { TranslateService } from '@ngx-translate/core';
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
 
-/**
- * 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;
@@ -161,18 +156,12 @@ class ZCacheService {
     }
 }
 
-/**
- * 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;
@@ -561,10 +550,444 @@ class ZIndexDbService {
     }
 }
 
-/**
- * Z-Subject Service
- * A service for managing reactive subjects (Subject and BehaviorSubject)
- */
+const LANG_CACHE_KEY = 'Z_LANGUAGE';
+const DEFAULT_LANG = 'vi';
+class ZTranslateService {
+    _translate = inject(TranslateService);
+    currentLang = signal(DEFAULT_LANG, ...(ngDevMode ? [{ debugName: "currentLang" }] : []));
+    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: () => [] });
+
+const Z_HTTP_DEFAULT_CONFIG = {
+    defaultCacheTime: 3 * 60 * 1000,
+    networkCheckCacheTime: 10000,
+    tokenKey: 'Z_TOKEN',
+    userInfoKey: 'Z_USER_INFO',
+    lastUrlKey: 'Z_LAST_URL',
+    loginRoute: '/login',
+    homeRoute: '/',
+};
+class ZHttpAbstractService {
+    http = inject(HttpClient);
+    router = inject(Router);
+    cacheService = ZCacheService;
+    translateService = inject(ZTranslateService);
+    indexDbService;
+    config = Z_HTTP_DEFAULT_CONFIG;
+    _networkCache = null;
+    constructor() {
+        this.indexDbService = new ZIndexDbService({
+            dbName: 'ZHttpCache',
+            defaultStore: 'HttpCache',
+            stores: [{ name: 'HttpCache', encrypt: false }],
+        });
+    }
+    get(endpoint, options) {
+        const httpCall = () => {
+            const { headers, params } = this._buildRequest(options);
+            const httpOptions = this._buildHttpOptions({ ...options, headers, params });
+            const url = `${this.resolveBaseUrl(options?.api)}${endpoint}`;
+            return this.http.get(url, httpOptions);
+        };
+        return this._handleCacheAndRequest('GET', endpoint, httpCall, options);
+    }
+    post(endpoint, body, options) {
+        const httpCall = () => {
+            const { headers, body: transformedBody } = this._buildRequest(options, body);
+            const httpOptions = this._buildHttpOptions({ ...options, headers });
+            const url = `${this.resolveBaseUrl(options?.api)}${endpoint}`;
+            return this.http.post(url, transformedBody, httpOptions);
+        };
+        return this._handleCacheAndRequest('POST', endpoint, httpCall, options, body);
+    }
+    put(endpoint, body, options) {
+        const httpCall = () => {
+            const { headers, body: transformedBody } = this._buildRequest(options, body);
+            const httpOptions = this._buildHttpOptions({ ...options, headers });
+            const url = `${this.resolveBaseUrl(options?.api)}${endpoint}`;
+            return this.http.put(url, transformedBody, httpOptions);
+        };
+        return this._handleCacheAndRequest('PUT', endpoint, httpCall, options, body);
+    }
+    patch(endpoint, body, options) {
+        const httpCall = () => {
+            const { headers, body: transformedBody } = this._buildRequest(options, body);
+            const httpOptions = this._buildHttpOptions({ ...options, headers });
+            const url = `${this.resolveBaseUrl(options?.api)}${endpoint}`;
+            return this.http.patch(url, transformedBody, httpOptions);
+        };
+        return this._handleCacheAndRequest('PATCH', endpoint, httpCall, options, body);
+    }
+    delete(endpoint, body, options) {
+        const httpCall = () => {
+            const { headers, body: transformedBody } = this._buildRequest(options, body);
+            const httpOptions = this._buildHttpOptions({
+                ...options,
+                headers,
+                body: transformedBody,
+            });
+            if ('transferCache' in httpOptions) {
+                delete httpOptions['transferCache'];
+            }
+            const url = `${this.resolveBaseUrl(options?.api)}${endpoint}`;
+            return this.http.delete(url, httpOptions);
+        };
+        return this._handleCacheAndRequest('DELETE', endpoint, httpCall, options, body);
+    }
+    _buildRequest(options, body) {
+        let headers = new HttpHeaders().set('Accept', 'application/json');
+        const contentType = options?.contentType ?? 'json';
+        let finalBody = body;
+        let params;
+        if (contentType === 'json') {
+            headers = headers.set('Content-Type', 'application/json');
+            if (body !== undefined && body !== null) {
+                finalBody = JSON.stringify(body);
+            }
+        }
+        if (contentType === 'urlencoded') {
+            headers = headers.set('Content-Type', 'application/x-www-form-urlencoded');
+            if (body && typeof body === 'object') {
+                const urlParams = new URLSearchParams();
+                Object.entries(body).forEach(([key, value]) => {
+                    urlParams.set(key, String(value));
+                });
+                finalBody = urlParams.toString();
+            }
+        }
+        if (contentType === 'form-data') {
+            if (body instanceof FormData) {
+                finalBody = body;
+            }
+            if (!(body instanceof FormData) && body && typeof body === 'object') {
+                const formData = new FormData();
+                Object.entries(body).forEach(([key, value]) => {
+                    formData.append(key, value);
+                });
+                finalBody = formData;
+            }
+        }
+        if (options?.headers && !(options.headers instanceof HttpHeaders)) {
+            const headersObj = options.headers;
+            Object.keys(headersObj).forEach(key => {
+                const value = headersObj[key];
+                headers = headers.set(key, Array.isArray(value) ? value.join(',') : value);
+            });
+        }
+        const token = this.cacheService.get(this.config.tokenKey);
+        if (token && !options?.skipToken) {
+            headers = headers.set('Authorization', `Bearer ${token}`);
+        }
+        if (options?.params && !(options.params instanceof Object.getPrototypeOf(URLSearchParams).constructor)) {
+            const paramsObj = options.params;
+            params = {};
+            Object.keys(paramsObj).forEach(key => {
+                const value = paramsObj[key];
+                if (value !== undefined && value !== null) {
+                    params[key] = String(value);
+                }
+            });
+        }
+        return { headers, body: finalBody, params };
+    }
+    _buildHttpOptions(options) {
+        const httpOptions = { ...options };
+        delete httpOptions['enableCache'];
+        delete httpOptions['timeCache'];
+        delete httpOptions['contentType'];
+        delete httpOptions['api'];
+        delete httpOptions['skipToken'];
+        delete httpOptions['skipErrorToast'];
+        return httpOptions;
+    }
+    _handleCacheAndRequest(method, endpoint, httpCall, options, body) {
+        if (!options?.enableCache) {
+            return this._executeHttpCall(httpCall, options, method, endpoint, body);
+        }
+        const cacheKey = this._generateCacheKey(method, endpoint, options, body);
+        return from(this._getCachedData(cacheKey)).pipe(switchMap(cachedData => {
+            if (cachedData !== null) {
+                return of(cachedData);
+            }
+            return this._executeHttpCall(httpCall, options, method, endpoint, body);
+        }), catchError(() => this._executeHttpCall(httpCall, options, method, endpoint, body)));
+    }
+    _executeHttpCall(httpCall, options, method, endpoint, body) {
+        return this._detectNetworkStatus().pipe(switchMap(isOnline => {
+            if (!isOnline) {
+                const error = {
+                    message: this.translateService.instant('i18n_z_ui_http_network_offline'),
+                    status: 0,
+                };
+                return throwError(() => error);
+            }
+            return httpCall().pipe(catchError(err => this._handleError(err, options, method, endpoint, body)), tap(data => {
+                if (options?.enableCache && method && endpoint) {
+                    const cacheKey = this._generateCacheKey(method, endpoint, options, body);
+                    const ttl = options.timeCache ?? this.config.defaultCacheTime;
+                    this._cacheData(cacheKey, data, ttl).catch(console.warn);
+                }
+            }));
+        }));
+    }
+    _generateCacheKey(method, endpoint, options, body) {
+        const api = options?.api ?? 'default';
+        const params = options?.params ? JSON.stringify(options.params) : '';
+        const bodyStr = body ? JSON.stringify(body) : '';
+        return `${method}_${api}_${endpoint}_${params}_${bodyStr}`;
+    }
+    async _cacheData(key, data, ttl) {
+        const cacheEntry = { data, timestamp: Date.now(), ttl };
+        await this.indexDbService.set(key, cacheEntry, 'HttpCache');
+    }
+    async _getCachedData(key) {
+        try {
+            const cached = await this.indexDbService.get(key, undefined, 'HttpCache');
+            if (!cached) {
+                return null;
+            }
+            if (Date.now() - cached.timestamp > cached.ttl) {
+                await this.indexDbService.delete(key, 'HttpCache');
+                return null;
+            }
+            return cached.data;
+        }
+        catch {
+            return null;
+        }
+    }
+    _detectNetworkStatus() {
+        const now = Date.now();
+        if (this._networkCache && now - this._networkCache.time < this.config.networkCheckCacheTime) {
+            return of(this._networkCache.isOnline);
+        }
+        if (!navigator.onLine) {
+            this._networkCache = { time: now, isOnline: false };
+            return of(false);
+        }
+        return this._checkNetworkWithRetry().pipe(map(isOnline => {
+            this._networkCache = { time: Date.now(), isOnline };
+            return isOnline;
+        }), catchError(() => {
+            this._networkCache = { time: Date.now(), isOnline: false };
+            return of(false);
+        }));
+    }
+    _checkNetworkWithRetry(retries = 2) {
+        return defer(() => this._performNetworkCheck()).pipe(catchError(() => {
+            if (retries > 0) {
+                return this._checkNetworkWithRetry(retries - 1);
+            }
+            return of(false);
+        }));
+    }
+    _performNetworkCheck() {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3000);
+        return from(fetch('data:,', { method: 'HEAD', signal: controller.signal })).pipe(tap(() => clearTimeout(timeoutId)), map(() => true), catchError(() => {
+            clearTimeout(timeoutId);
+            throw new Error('Network check failed');
+        }));
+    }
+    _handleError(error, options, method, endpoint, body) {
+        const statusCode = error instanceof HttpErrorResponse ? error.status : 500;
+        const fullEndpoint = `${this.resolveBaseUrl(options?.api)}${endpoint}`;
+        const httpError = this._buildErrorObject(error, statusCode, fullEndpoint, method, body, options);
+        const localizedError = this._localizeError(httpError, statusCode);
+        console.error('[ZHttp] Request failed:', {
+            method,
+            endpoint: fullEndpoint,
+            status: statusCode,
+            error: localizedError,
+        });
+        this._handleStatusCode(statusCode);
+        return throwError(() => localizedError);
+    }
+    _buildErrorObject(error, statusCode, endpoint, method, body, options) {
+        const baseError = { message: '', status: statusCode, endpoint, method, body, options };
+        if (!(error instanceof HttpErrorResponse)) {
+            return {
+                ...baseError,
+                error: error.message,
+                message: error.message || this.translateService.instant('i18n_z_ui_http_error_default'),
+            };
+        }
+        const errorBody = error.error;
+        if (typeof errorBody?.message === 'string') {
+            const message = errorBody.message === 'Failed to fetch'
+                ? this.translateService.instant('i18n_z_ui_http_error_failed_to_fetch', { url: endpoint })
+                : errorBody.message;
+            return { ...baseError, error: errorBody, message };
+        }
+        if (Array.isArray(errorBody?.errors) && errorBody.errors.length > 0) {
+            const message = errorBody.errors
+                .map((err) => (typeof err === 'string' ? err : JSON.stringify(err)))
+                .join(', ');
+            return { ...baseError, error: errorBody, message };
+        }
+        if (typeof errorBody === 'object' &&
+            errorBody !== null &&
+            !Array.isArray(errorBody) &&
+            Object.keys(errorBody).length > 0) {
+            return { ...baseError, error: errorBody, message: JSON.stringify(errorBody) };
+        }
+        if (typeof errorBody === 'string') {
+            return { ...baseError, error: errorBody, message: errorBody };
+        }
+        return {
+            ...baseError,
+            error: error.message,
+            message: error.message || this.translateService.instant('i18n_z_ui_http_error_default'),
+        };
+    }
+    _localizeError(error, statusCode) {
+        const localizedError = { ...error };
+        const errorMessages = {
+            400: error.message || this.translateService.instant('i18n_z_ui_http_error_400'),
+            401: this._get401Message(),
+            403: this.translateService.instant('i18n_z_ui_http_error_403'),
+            404: this.translateService.instant('i18n_z_ui_http_error_404'),
+            500: this.translateService.instant('i18n_z_ui_http_error_500'),
+        };
+        if (errorMessages[statusCode]) {
+            localizedError.message = errorMessages[statusCode];
+        }
+        return localizedError;
+    }
+    _get401Message() {
+        const userInfo = this.cacheService.get(this.config.userInfoKey);
+        const isExpired = userInfo?.timeExpired ? Date.now() >= userInfo.timeExpired : false;
+        if (isExpired) {
+            return this.translateService.instant('i18n_z_ui_http_error_401_expired');
+        }
+        return this.translateService.instant('i18n_z_ui_http_error_401_permission');
+    }
+    _handleStatusCode(statusCode) {
+        if (statusCode !== 401) {
+            return;
+        }
+        const userInfo = this.cacheService.get(this.config.userInfoKey);
+        const isExpired = userInfo?.timeExpired ? Date.now() >= userInfo.timeExpired : false;
+        if (isExpired) {
+            this.indexDbService.clear('HttpCache').catch(console.error);
+            this.cacheService.deleteMultiple([this.config.tokenKey, this.config.userInfoKey]);
+            this.router.navigate([this.config.loginRoute]).catch(console.error);
+            return;
+        }
+        this.router.navigate([this.config.homeRoute]).catch(console.error);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZHttpAbstractService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZHttpAbstractService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZHttpAbstractService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
 class ZSubjectService {
     _subjects = new Map();
     _behaviorSubjects = new Map();
@@ -681,9 +1104,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
                 }]
         }] });
 
-/**
- * Z-Theme Types
- */
 const Z_THEME_CONFIG = new InjectionToken('Z_THEME_CONFIG');
 const Z_DEFAULT_THEME = 'neutral';
 const Z_THEME_CACHE_KEY = 'z-theme';
@@ -813,145 +1233,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
                 }]
         }], ctorParameters: () => [] });
 
-/**
- * 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
  */
@@ -960,5 +1241,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ZCacheService, ZIndexDbService, ZSubjectService, ZThemeService, ZTranslateService, Z_DARK_MODE_CACHE_KEY, Z_DEFAULT_THEME, Z_THEME_CACHE_KEY, Z_THEME_CONFIG, Z_THEME_CSS_MAP };
+export { ZCacheService, ZHttpAbstractService, ZIndexDbService, ZSubjectService, ZThemeService, ZTranslateService, Z_DARK_MODE_CACHE_KEY, Z_DEFAULT_THEME, Z_THEME_CACHE_KEY, Z_THEME_CONFIG, Z_THEME_CSS_MAP };
 //# sourceMappingURL=shival99-z-ui-services.mjs.map