@qrvey/utils 1.13.0-9 → 1.13.1

package/dist/cache-managers/cache-chart-manager.d.ts

@@ -1,4 +1,4 @@
-import { OnChangeType, QrveyCacheManager } from "./cache-manager";
+import { QrveyCacheManager, QvCacheStoreProperties } from "./cache-manager";
 export interface IGetChartConfig {
     qv_token?: string;
     api_key?: string;
@@ -14,21 +14,9 @@ export interface IGetChartConfig {
         "temporal-tokens"?: boolean;
     };
 }
-interface IChartStoreState {
-    chart: any;
-    loading: boolean;
-    error: any;
-}
-export declare class ChartCacheManager extends QrveyCacheManager<IChartStoreState, IGetChartConfig> {
-    static getInstance(): ChartCacheManager;
-    protected getConfigPropertyName(): keyof IGetChartConfig;
-    protected getStorePropertyName(): keyof IChartStoreState;
+export declare class ChartCacheManager extends QrveyCacheManager<QvCacheStoreProperties, IGetChartConfig> {
+    static getInstance(): any;
+    protected getConfigEntityId(): keyof IGetChartConfig;
     protected buildStoreId({ chart_id }: IGetChartConfig): string;
-    protected createStore(_initialState?: Partial<IChartStoreState>): {
-        state: IChartStoreState;
-        onChange: OnChangeType;
-        set: (property: keyof IChartStoreState, value: unknown) => void;
-    };
-    protected fetchDataAndUpdateStore(state: IChartStoreState, config: IGetChartConfig): void;
+    protected fetchDataAndUpdateStore(state: QvCacheStoreProperties, config: IGetChartConfig): Promise<void>;
 }
-export {};

package/dist/cache-managers/cache-chart-manager.js

@@ -1,38 +1,40 @@
-import { createStore } from "@stencil/store";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { QrveyCacheManager } from "./cache-manager";
 import ChartsApi from "../services/api/Charts.api";
 export class ChartCacheManager extends QrveyCacheManager {
     static getInstance() {
-        if (!window.chartCacheManager) {
-            window.chartCacheManager = new ChartCacheManager();
+        if (!window.qvChartCacheManager) {
+            window.qvChartCacheManager = new ChartCacheManager();
         }
-        return window.chartCacheManager;
+        return window.qvChartCacheManager;
     }
-    getConfigPropertyName() {
+    getConfigEntityId() {
         return "chart_id";
     }
-    getStorePropertyName() {
-        return "chart";
-    }
     buildStoreId({ chart_id }) {
         return `${chart_id}`;
     }
-    createStore(_initialState) {
-        return createStore(Object.assign({ chart: null, loading: true, error: null }, _initialState));
-    }
     fetchDataAndUpdateStore(state, config) {
-        const chartConfig = Object.assign(Object.assign({}, config), { translated: true });
-        const api = new ChartsApi(chartConfig);
-        api
-            .getChart(chartConfig)
-            .then((chart) => {
-            state.chart = chart;
-            state.error = null;
-            state.loading = false;
-        })
-            .catch((e) => {
-            state.error = e;
-            state.loading = false;
+        return __awaiter(this, void 0, void 0, function* () {
+            const chartConfig = Object.assign(Object.assign({}, config), { translated: true });
+            const api = new ChartsApi(chartConfig);
+            return api
+                .getChart(chartConfig)
+                .then((chart) => {
+                state.entity = chart;
+                state.error = null;
+            })
+                .catch((e) => {
+                state.error = e;
+            });
         });
     }
 }

package/dist/cache-managers/cache-manager.d.ts

@@ -1,36 +1,32 @@
 export type OnChangeType = (property: string | number | symbol, callback: (entity: unknown) => void) => () => void;
-export declare abstract class QrveyCacheManager<TStoreState, TConfig> {
-    protected stores: Map<string, {
-        state: TStoreState;
-        onChange: OnChangeType;
-        set: (property: keyof TStoreState, value: unknown) => void;
-    }>;
-    protected abstract getConfigPropertyName(): keyof TConfig;
-    protected abstract getStorePropertyName(): keyof TStoreState;
+export interface QvCacheStoreProperties {
+    entity: unknown;
+    error: boolean;
+}
+interface QrveyCacheStore<T> {
+    state: T;
+    onChange: OnChangeType;
+    set: (property: keyof T, value: unknown) => void;
+    dispose: () => void;
+}
+export declare abstract class QrveyCacheManager<TStoreState extends QvCacheStoreProperties, TConfig> {
+    protected stores: Map<string, QrveyCacheStore<TStoreState> | Promise<QrveyCacheStore<TStoreState>>>;
+    operationLocks: Map<any, any>;
+    protected abstract getConfigEntityId(): keyof TConfig;
     protected abstract buildStoreId(config: TConfig): string;
-    protected abstract fetchDataAndUpdateStore(state: TStoreState, config: TConfig): void;
-    protected abstract createStore(_initialState?: Partial<TStoreState>): {
-        state: TStoreState;
-        onChange: OnChangeType;
-        set: (property: keyof TStoreState, value: unknown) => void;
-    };
-    protected getStoreFromPromise(config: TConfig, id: string): Promise<{
-        state: TStoreState;
-        onChange: OnChangeType;
-        set: (property: keyof TStoreState, value: unknown) => void;
-    }>;
+    protected abstract fetchDataAndUpdateStore(state: TStoreState, config: TConfig): Promise<void>;
+    protected createStore(_initialState?: Partial<TStoreState>): Promise<QrveyCacheStore<TStoreState>>;
+    getStoreFromPromise(config: TConfig, id: string): Promise<QrveyCacheStore<TStoreState>>;
     private getCreatedStore;
-    getStore(config: TConfig): {
-        state: TStoreState;
-        onChange: OnChangeType;
-        set: (property: keyof TStoreState, value: unknown) => void;
-    };
-    getMultipleStores(config: TConfig, ids: string[]): Promise<{
-        state: TStoreState;
-        onChange: OnChangeType;
-    }[]>;
+    private initializeStore;
+    getStore(config: TConfig): Promise<QrveyCacheStore<TStoreState>>;
+    getMultipleStores(config: TConfig, ids: string[]): Promise<QrveyCacheStore<TStoreState>[]>;
     setStoresFromData(stores: {
         storeId: string;
         state: Partial<TStoreState>;
-    }[]): void;
+    }[]): Promise<void[]>;
+    private deleteStoreRegister;
+    cleanStore(storeId: string): Promise<void>;
+    cleanAllStores(): Promise<void>;
 }
+export {};

package/dist/cache-managers/cache-manager.js

@@ -1,54 +1,114 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createStore } from "@stencil/store";
 export class QrveyCacheManager {
     constructor() {
         this.stores = new Map();
+        this.operationLocks = new Map();
+    }
+    createStore(_initialState) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const initialState = Object.assign({ entity: null, error: null }, _initialState);
+            return createStore(initialState);
+        });
     }
     getStoreFromPromise(config, id) {
-        return new Promise((resolve) => {
-            const configProperty = this.getConfigPropertyName();
-            const storeProperty = this.getStorePropertyName();
-            const extendedConfig = Object.assign(Object.assign({}, config), { [configProperty]: id });
-            const store = this.getStore(extendedConfig);
-            if (store.state[storeProperty] !== null) {
-                resolve(store);
-            }
-            else {
-                const unsubscribe = store.onChange(storeProperty, (entity) => {
-                    if (entity !== null) {
-                        unsubscribe();
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                (() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const configEntityId = this.getConfigEntityId();
+                        const extendedConfig = Object.assign(Object.assign({}, config), { [configEntityId]: id });
+                        const store = yield this.getStore(extendedConfig);
                         resolve(store);
                     }
-                });
-            }
+                    catch (error) {
+                        reject(error);
+                    }
+                }))();
+            });
         });
     }
     getCreatedStore(storeId) {
-        return this.stores.get(storeId);
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.stores.get(storeId);
+        });
+    }
+    initializeStore(config, storeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newStore = yield this.createStore();
+            yield this.fetchDataAndUpdateStore(newStore.state, config);
+            this.stores.set(storeId, newStore);
+            return newStore;
+        });
     }
     getStore(config) {
-        const storeId = this.buildStoreId(config);
-        const store = this.getCreatedStore(storeId);
-        if (store) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storeId = this.buildStoreId(config);
+            while (this.operationLocks.has(storeId)) {
+                yield this.operationLocks.get(storeId);
+            }
+            let store = this.stores.get(storeId);
+            if (!store) {
+                let resolveLock;
+                const lockPromise = new Promise((resolve) => (resolveLock = resolve));
+                this.operationLocks.set(storeId, lockPromise);
+                try {
+                    store = yield this.initializeStore(config, storeId);
+                    this.stores.set(storeId, store);
+                }
+                finally {
+                    resolveLock();
+                    this.operationLocks.delete(storeId);
+                }
+            }
             return store;
-        }
-        const { state, onChange, set } = store !== null && store !== void 0 ? store : this.createStore();
-        this.stores.set(storeId, { state, onChange, set });
-        this.fetchDataAndUpdateStore(state, config);
-        return { state, onChange, set };
+        });
     }
     getMultipleStores(config, ids) {
-        const promises = ids.map((id) => this.getStoreFromPromise(config, id));
+        const promises = ids.map((id) => __awaiter(this, void 0, void 0, function* () { return yield this.getStoreFromPromise(config, id); }));
         return Promise.all(promises);
     }
     setStoresFromData(stores) {
-        stores.forEach((store) => {
-            const createdStore = this.getCreatedStore(store.storeId);
-            if (!createdStore) {
-                const newStore = this.createStore(store.state);
-                this.stores.set(store.storeId, newStore);
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(stores.map((store) => __awaiter(this, void 0, void 0, function* () {
+                let createdStore = yield this.getCreatedStore(store.storeId);
+                if (!createdStore) {
+                    createdStore = yield this.createStore();
+                    this.stores.set(store.storeId, createdStore);
+                }
+                Object.entries(store.state).forEach(([key, value]) => {
+                    createdStore.set(key, value);
+                });
+            })));
+        });
+    }
+    deleteStoreRegister(storeId) {
+        this.stores.delete(storeId);
+    }
+    cleanStore(storeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingStore = yield this.getCreatedStore(storeId);
+            if (existingStore) {
+                const store = existingStore instanceof Promise ? yield existingStore : existingStore;
+                store.dispose();
+                this.deleteStoreRegister(storeId);
+            }
+        });
+    }
+    cleanAllStores() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storeIds = Array.from(this.stores.keys());
+            for (const storeId of storeIds) {
+                yield this.cleanStore(storeId);
             }
-            Object.entries(store.state).forEach(([key, value]) => {
-                createdStore.set(key, value);
-            });
         });
     }
 }

package/dist/cache-managers/cache-metric-manager.d.ts

@@ -1,4 +1,4 @@
-import { OnChangeType, QrveyCacheManager } from "./cache-manager";
+import { QrveyCacheManager, QvCacheStoreProperties } from "./cache-manager";
 export interface IGetMetricConfig {
     qv_token?: string;
     api_key?: string;
@@ -15,21 +15,9 @@ export interface IGetMetricConfig {
         "temporal-tokens"?: boolean;
     };
 }
-interface IMetricStoreState {
-    metric: any;
-    loading: boolean;
-    error: any;
+export declare class MetricCacheManager extends QrveyCacheManager<QvCacheStoreProperties, IGetMetricConfig> {
+    static getInstance(): any;
+    protected getConfigEntityId(): keyof IGetMetricConfig;
+    protected buildStoreId({ metric_id }: IGetMetricConfig): string;
+    protected fetchDataAndUpdateStore(state: QvCacheStoreProperties, config: IGetMetricConfig): Promise<void>;
 }
-export declare class MetricCacheManager extends QrveyCacheManager<IMetricStoreState, IGetMetricConfig> {
-    static getInstance(): MetricCacheManager;
-    protected getConfigPropertyName(): keyof IGetMetricConfig;
-    protected getStorePropertyName(): keyof IMetricStoreState;
-    protected buildStoreId({ metric_id, translated }: IGetMetricConfig): string;
-    protected createStore(): {
-        state: IMetricStoreState;
-        onChange: OnChangeType;
-        set: (property: keyof IMetricStoreState, value: unknown) => void;
-    };
-    protected fetchDataAndUpdateStore(state: IMetricStoreState, config: IGetMetricConfig): void;
-}
-export {};

package/dist/cache-managers/cache-metric-manager.js

@@ -1,43 +1,39 @@
-import { createStore } from "@stencil/store";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { QrveyCacheManager } from "./cache-manager";
-import { isEmpty } from "../general/mix/isEmpty";
 import MetricPanelApi from "../services/api/metrics.api";
 export class MetricCacheManager extends QrveyCacheManager {
     static getInstance() {
-        if (!window.metricCacheManager) {
-            window.metricCacheManager = new MetricCacheManager();
+        if (!window.qvMetricCacheManager) {
+            window.qvMetricCacheManager = new MetricCacheManager();
         }
-        return window.metricCacheManager;
+        return window.qvMetricCacheManager;
     }
-    getConfigPropertyName() {
+    getConfigEntityId() {
         return "metric_id";
     }
-    getStorePropertyName() {
-        return "metric";
-    }
-    buildStoreId({ metric_id, translated }) {
-        const translate = isEmpty(translated) ? true : translated;
-        return `${metric_id}-${translate ? "translated" : ""}`;
-    }
-    createStore() {
-        return createStore({
-            metric: null,
-            loading: true,
-            error: null,
-        });
+    buildStoreId({ metric_id }) {
+        return `${metric_id}`;
     }
     fetchDataAndUpdateStore(state, config) {
-        const api = new MetricPanelApi();
-        api
-            .getMetricConfig(config)
-            .then((metric) => {
-            state.metric = metric;
-            state.error = null;
-            state.loading = false;
-        })
-            .catch((e) => {
-            state.error = e;
-            state.loading = false;
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = new MetricPanelApi();
+            return api
+                .getMetricConfig(config)
+                .then((metric) => {
+                state.entity = metric;
+                state.error = null;
+            })
+                .catch((e) => {
+                state.error = e;
+            });
         });
     }
 }

package/dist/cache-managers/cache-model-manager.d.ts

@@ -1,5 +1,4 @@
-import { OnChangeType, QrveyCacheManager } from "./cache-manager";
-import { IModel } from "../qrvey";
+import { QrveyCacheManager, QvCacheStoreProperties } from "./cache-manager";
 interface IGetModelConfig {
     qv_token?: string;
     api_key?: string;
@@ -10,21 +9,10 @@ interface IGetModelConfig {
     qrvey_id: string;
     i18n?: any;
 }
-interface IModelStoreState {
-    model: IModel;
-    loading: boolean;
-    error: any;
-}
-export declare class ModelCacheManager extends QrveyCacheManager<IModelStoreState, IGetModelConfig> {
-    static getInstance(): ModelCacheManager;
-    protected getConfigPropertyName(): keyof IGetModelConfig;
-    protected getStorePropertyName(): keyof IModelStoreState;
+export declare class ModelCacheManager extends QrveyCacheManager<QvCacheStoreProperties, IGetModelConfig> {
+    static getInstance(): any;
+    protected getConfigEntityId(): keyof IGetModelConfig;
     protected buildStoreId({ qrvey_id }: IGetModelConfig): string;
-    protected createStore(): {
-        state: IModelStoreState;
-        onChange: OnChangeType;
-        set: (property: keyof IModelStoreState, value: unknown) => void;
-    };
-    protected fetchDataAndUpdateStore(state: IModelStoreState, config: IGetModelConfig): void;
+    protected fetchDataAndUpdateStore(state: QvCacheStoreProperties, config: IGetModelConfig): Promise<void>;
 }
 export {};

package/dist/cache-managers/cache-model-manager.js

@@ -1,40 +1,38 @@
-import { createStore } from "@stencil/store";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { QrveyCacheManager } from "./cache-manager";
 import { getModel } from "../services/api/getModel.api";
 export class ModelCacheManager extends QrveyCacheManager {
     static getInstance() {
-        if (!window.modelCacheManager) {
-            window.modelCacheManager = new ModelCacheManager();
+        if (!window.qvModelCacheManager) {
+            window.qvModelCacheManager = new ModelCacheManager();
         }
-        return window.modelCacheManager;
+        return window.qvModelCacheManager;
     }
-    getConfigPropertyName() {
+    getConfigEntityId() {
         return "qrvey_id";
     }
-    getStorePropertyName() {
-        return "model";
-    }
     buildStoreId({ qrvey_id }) {
         return `${qrvey_id}`;
     }
-    createStore() {
-        return createStore({
-            model: null,
-            loading: true,
-            error: null,
-        });
-    }
     fetchDataAndUpdateStore(state, config) {
-        const includeInfo = ["bucketsInfo", "formulaInfo", "colorByValueInfo"];
-        getModel(config, { includeInfo })
-            .then((model) => {
-            state.model = model;
-            state.error = null;
-            state.loading = false;
-        })
-            .catch((e) => {
-            state.error = e;
-            state.loading = false;
+        return __awaiter(this, void 0, void 0, function* () {
+            const includeInfo = ["bucketsInfo", "formulaInfo", "colorByValueInfo"];
+            return getModel(config, { includeInfo })
+                .then((model) => {
+                state.entity = model;
+                state.error = null;
+            })
+                .catch((e) => {
+                state.error = e;
+            });
         });
     }
 }

package/dist/cache-managers/cache-permissions-manager.d.ts

@@ -1,5 +1,4 @@
-import { AdminPermissions } from "../interfaces/AdminPermissions.interface";
-import { OnChangeType, QrveyCacheManager } from "./cache-manager";
+import { QrveyCacheManager, QvCacheStoreProperties } from "./cache-manager";
 export interface IGetPermissionsConfig {
     qv_token?: string;
     api_key?: string;
@@ -7,21 +6,9 @@ export interface IGetPermissionsConfig {
     user_id?: string;
     domain?: string;
 }
-interface IPermissionsStoreState {
-    permissions: AdminPermissions;
-    loading: boolean;
-    error: any;
-}
-export declare class PermissionsCacheManager extends QrveyCacheManager<IPermissionsStoreState, IGetPermissionsConfig> {
-    static getInstance(): PermissionsCacheManager;
-    protected getConfigPropertyName(): keyof IGetPermissionsConfig;
-    protected getStorePropertyName(): keyof IPermissionsStoreState;
+export declare class PermissionsCacheManager extends QrveyCacheManager<QvCacheStoreProperties, IGetPermissionsConfig> {
+    static getInstance(): any;
+    protected getConfigEntityId(): keyof IGetPermissionsConfig;
     protected buildStoreId({ user_id }: IGetPermissionsConfig): string;
-    protected createStore(): {
-        state: IPermissionsStoreState;
-        onChange: OnChangeType;
-        set: (property: keyof IPermissionsStoreState, value: unknown) => void;
-    };
-    protected fetchDataAndUpdateStore(state: IPermissionsStoreState, config: IGetPermissionsConfig): void;
+    protected fetchDataAndUpdateStore(state: QvCacheStoreProperties, config: IGetPermissionsConfig): Promise<void>;
 }
-export {};

package/dist/cache-managers/cache-permissions-manager.js

@@ -1,39 +1,37 @@
-import { createStore } from "@stencil/store";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { QrveyCacheManager } from "./cache-manager";
 import { getAdminPermissions } from "../services/api/adminPermissions.api";
 export class PermissionsCacheManager extends QrveyCacheManager {
     static getInstance() {
-        if (!window.permissionsCacheManager) {
-            window.permissionsCacheManager = new PermissionsCacheManager();
+        if (!window.qvPermissionsCacheManager) {
+            window.qvPermissionsCacheManager = new PermissionsCacheManager();
         }
-        return window.permissionsCacheManager;
+        return window.qvPermissionsCacheManager;
     }
-    getConfigPropertyName() {
+    getConfigEntityId() {
         return "user_id";
     }
-    getStorePropertyName() {
-        return "permissions";
-    }
     buildStoreId({ user_id }) {
         return `${user_id}`;
     }
-    createStore() {
-        return createStore({
-            permissions: null,
-            loading: true,
-            error: null,
-        });
-    }
     fetchDataAndUpdateStore(state, config) {
-        getAdminPermissions(config)
-            .then((permissions) => {
-            state.permissions = permissions;
-            state.error = null;
-            state.loading = false;
-        })
-            .catch((e) => {
-            state.error = e;
-            state.loading = false;
+        return __awaiter(this, void 0, void 0, function* () {
+            return getAdminPermissions(config)
+                .then((permissions) => {
+                state.entity = permissions;
+                state.error = null;
+            })
+                .catch((e) => {
+                state.error = e;
+            });
         });
     }
 }

package/dist/cache-managers/cache-theme-manager.d.ts

@@ -1,5 +1,4 @@
-import { OnChangeType, QrveyCacheManager } from "./cache-manager";
-import { AnTheme } from "../interfaces/themes/an-theme";
+import { QrveyCacheManager, QvCacheStoreProperties } from "./cache-manager";
 export interface IGetThemeConfig {
     qv_token?: string;
     api_key?: string;
@@ -8,21 +7,9 @@ export interface IGetThemeConfig {
     domain?: string;
     theme_id?: string;
 }
-interface IThemeStoreState {
-    theme: AnTheme;
-    loading: boolean;
-    error: any;
-}
-export declare class ThemeCacheManager extends QrveyCacheManager<IThemeStoreState, IGetThemeConfig> {
-    static getInstance(): ThemeCacheManager;
-    protected getConfigPropertyName(): keyof IGetThemeConfig;
-    protected getStorePropertyName(): keyof IThemeStoreState;
+export declare class ThemeCacheManager extends QrveyCacheManager<QvCacheStoreProperties, IGetThemeConfig> {
+    static getInstance(): any;
+    protected getConfigEntityId(): keyof IGetThemeConfig;
     protected buildStoreId({ theme_id, app_id }: IGetThemeConfig): string;
-    protected createStore(): {
-        state: IThemeStoreState;
-        onChange: OnChangeType;
-        set: (property: keyof IThemeStoreState, value: unknown) => void;
-    };
-    protected fetchDataAndUpdateStore(state: IThemeStoreState, config: IGetThemeConfig): void;
+    protected fetchDataAndUpdateStore(state: QvCacheStoreProperties, config: IGetThemeConfig): Promise<void>;
 }
-export {};