@qrvey/utils 1.13.0-7 → 1.13.0-7.performance.0

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

@@ -0,0 +1,34 @@
+import { OnChangeType, QrveyCacheManager } from "./cache-manager";
+export interface IGetChartConfig {
+    qv_token?: string;
+    api_key?: string;
+    app_id?: string;
+    user_id?: string;
+    domain?: string;
+    timezone?: any;
+    qrvey_id?: string;
+    i18n?: any;
+    chart_id?: string;
+    lang?: string;
+    translated?: boolean;
+    headers?: {
+        "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;
+    protected buildStoreId({ chart_id, translated }: IGetChartConfig): string;
+    protected createStore(): {
+        state: IChartStoreState;
+        onChange: OnChangeType;
+    };
+    protected fetchDataAndUpdateStore(state: IChartStoreState, config: IGetChartConfig): void;
+}
+export {};

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

@@ -0,0 +1,43 @@
+import { createStore } from "@stencil/store";
+import { QrveyCacheManager } from "./cache-manager";
+import ChartsApi from "../services/api/Charts.api";
+import { isEmpty } from "../general/mix/isEmpty";
+export class ChartCacheManager extends QrveyCacheManager {
+    static getInstance() {
+        if (!window.chartCacheManager) {
+            window.chartCacheManager = new ChartCacheManager();
+        }
+        return window.chartCacheManager;
+    }
+    getConfigPropertyName() {
+        return "chart_id";
+    }
+    getStorePropertyName() {
+        return "chart";
+    }
+    buildStoreId({ chart_id, translated }) {
+        const translate = isEmpty(translated) ? true : translated;
+        return `${chart_id}-${translate ? "translated" : ""}`;
+    }
+    createStore() {
+        return createStore({
+            chart: null,
+            loading: true,
+            error: null,
+        });
+    }
+    fetchDataAndUpdateStore(state, config) {
+        const api = new ChartsApi(config);
+        api
+            .getChart(config)
+            .then((chart) => {
+            state.chart = chart;
+            state.error = null;
+            state.loading = false;
+        })
+            .catch((e) => {
+            state.error = e;
+            state.loading = false;
+        });
+    }
+}

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

@@ -0,0 +1,27 @@
+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;
+    }>;
+    protected abstract getConfigPropertyName(): keyof TConfig;
+    protected abstract getStorePropertyName(): keyof TStoreState;
+    protected abstract buildStoreId(config: TConfig): string;
+    protected abstract fetchDataAndUpdateStore(state: TStoreState, config: TConfig): void;
+    protected abstract createStore(): {
+        state: TStoreState;
+        onChange: OnChangeType;
+    };
+    protected getStoreFromPromise(config: TConfig, id: string): Promise<{
+        state: TStoreState;
+        onChange: OnChangeType;
+    }>;
+    getStore(config: TConfig): {
+        state: TStoreState;
+        onChange: OnChangeType;
+    };
+    getMultipleStores(config: TConfig, ids: string[]): Promise<{
+        state: TStoreState;
+        onChange: OnChangeType;
+    }[]>;
+}

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

@@ -0,0 +1,39 @@
+export class QrveyCacheManager {
+    constructor() {
+        this.stores = new Map();
+    }
+    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();
+                        resolve(store);
+                    }
+                });
+            }
+        });
+    }
+    getStore(config) {
+        const storeId = this.buildStoreId(config);
+        const store = this.stores.get(storeId);
+        if (store) {
+            return store;
+        }
+        const { state, onChange } = store !== null && store !== void 0 ? store : this.createStore();
+        this.stores.set(storeId, { state, onChange });
+        this.fetchDataAndUpdateStore(state, config);
+        return { state, onChange };
+    }
+    getMultipleStores(config, ids) {
+        const promises = ids.map((id) => this.getStoreFromPromise(config, id));
+        return Promise.all(promises);
+    }
+}

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

@@ -0,0 +1,34 @@
+import { OnChangeType, QrveyCacheManager } from "./cache-manager";
+export interface IGetMetricConfig {
+    qv_token?: string;
+    api_key?: string;
+    app_id?: string;
+    user_id?: string;
+    domain?: string;
+    timezone?: any;
+    qrvey_id?: string;
+    i18n?: any;
+    metric_id?: string;
+    lang?: string;
+    translated?: boolean;
+    headers?: {
+        "temporal-tokens"?: boolean;
+    };
+}
+interface IMetricStoreState {
+    metric: any;
+    loading: boolean;
+    error: any;
+}
+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;
+    };
+    protected fetchDataAndUpdateStore(state: IMetricStoreState, config: IGetMetricConfig): void;
+}
+export {};

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

@@ -0,0 +1,43 @@
+import { createStore } from "@stencil/store";
+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();
+        }
+        return window.metricCacheManager;
+    }
+    getConfigPropertyName() {
+        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,
+        });
+    }
+    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;
+        });
+    }
+}

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

@@ -0,0 +1,29 @@
+import { OnChangeType, QrveyCacheManager } from "./cache-manager";
+import { IModel } from "../qrvey";
+interface IGetModelConfig {
+    qv_token?: string;
+    api_key?: string;
+    app_id?: string;
+    user_id?: string;
+    domain?: string;
+    timezone?: any;
+    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;
+    protected buildStoreId({ qrvey_id }: IGetModelConfig): string;
+    protected createStore(): {
+        state: IModelStoreState;
+        onChange: OnChangeType;
+    };
+    protected fetchDataAndUpdateStore(state: IModelStoreState, config: IGetModelConfig): void;
+}
+export {};

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

@@ -0,0 +1,40 @@
+import { createStore } from "@stencil/store";
+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();
+        }
+        return window.modelCacheManager;
+    }
+    getConfigPropertyName() {
+        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;
+        });
+    }
+}

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

@@ -0,0 +1,26 @@
+import { AdminPermissions } from "../interfaces/AdminPermissions.interface";
+import { OnChangeType, QrveyCacheManager } from "./cache-manager";
+export interface IGetPermissionsConfig {
+    qv_token?: string;
+    api_key?: string;
+    app_id?: string;
+    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;
+    protected buildStoreId({ user_id }: IGetPermissionsConfig): string;
+    protected createStore(): {
+        state: IPermissionsStoreState;
+        onChange: OnChangeType;
+    };
+    protected fetchDataAndUpdateStore(state: IPermissionsStoreState, config: IGetPermissionsConfig): void;
+}
+export {};

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

@@ -0,0 +1,39 @@
+import { createStore } from "@stencil/store";
+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();
+        }
+        return window.permissionsCacheManager;
+    }
+    getConfigPropertyName() {
+        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;
+        });
+    }
+}

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

@@ -0,0 +1,27 @@
+import { OnChangeType, QrveyCacheManager } from "./cache-manager";
+import { AnTheme } from "../interfaces/themes/an-theme";
+export interface IGetThemeConfig {
+    qv_token?: string;
+    api_key?: string;
+    app_id?: string;
+    user_id?: string;
+    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;
+    protected buildStoreId({ theme_id, app_id }: IGetThemeConfig): string;
+    protected createStore(): {
+        state: IThemeStoreState;
+        onChange: OnChangeType;
+    };
+    protected fetchDataAndUpdateStore(state: IThemeStoreState, config: IGetThemeConfig): void;
+}
+export {};

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

@@ -0,0 +1,39 @@
+import { createStore } from "@stencil/store";
+import { QrveyCacheManager } from "./cache-manager";
+import { getCurrentTheme, getThemeById } from "../services/api/Themes.api";
+export class ThemeCacheManager extends QrveyCacheManager {
+    static getInstance() {
+        if (!window.themeCacheManager) {
+            window.themeCacheManager = new ThemeCacheManager();
+        }
+        return window.themeCacheManager;
+    }
+    getConfigPropertyName() {
+        return "theme_id";
+    }
+    getStorePropertyName() {
+        return "theme";
+    }
+    buildStoreId({ theme_id, app_id }) {
+        return `${app_id}-${theme_id !== null && theme_id !== void 0 ? theme_id : "current"}`;
+    }
+    createStore() {
+        return createStore({
+            theme: null,
+            loading: true,
+            error: null,
+        });
+    }
+    fetchDataAndUpdateStore(state, config) {
+        (config.theme_id ? getThemeById(config) : getCurrentTheme(config))
+            .then((theme) => {
+            state.theme = theme;
+            state.error = null;
+            state.loading = false;
+        })
+            .catch((e) => {
+            state.error = e;
+            state.loading = false;
+        });
+    }
+}

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

@@ -0,0 +1,34 @@
+import { OnChangeType, QrveyCacheManager } from "./cache-manager";
+export interface IGetChartConfig {
+    qv_token?: string;
+    api_key?: string;
+    app_id?: string;
+    user_id?: string;
+    domain?: string;
+    timezone?: any;
+    qrvey_id?: string;
+    i18n?: any;
+    chart_id?: string;
+    lang?: string;
+    translated?: boolean;
+    headers?: {
+        "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;
+    protected buildStoreId({ chart_id, translated }: IGetChartConfig): string;
+    protected createStore(): {
+        state: IChartStoreState;
+        onChange: OnChangeType;
+    };
+    protected fetchDataAndUpdateStore(state: IChartStoreState, config: IGetChartConfig): void;
+}
+export {};

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

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChartCacheManager = void 0;
+const store_1 = require("@stencil/store");
+const cache_manager_1 = require("./cache-manager");
+const Charts_api_1 = __importDefault(require("../services/api/Charts.api"));
+const isEmpty_1 = require("../general/mix/isEmpty");
+class ChartCacheManager extends cache_manager_1.QrveyCacheManager {
+    static getInstance() {
+        if (!window.chartCacheManager) {
+            window.chartCacheManager = new ChartCacheManager();
+        }
+        return window.chartCacheManager;
+    }
+    getConfigPropertyName() {
+        return "chart_id";
+    }
+    getStorePropertyName() {
+        return "chart";
+    }
+    buildStoreId({ chart_id, translated }) {
+        const translate = (0, isEmpty_1.isEmpty)(translated) ? true : translated;
+        return `${chart_id}-${translate ? "translated" : ""}`;
+    }
+    createStore() {
+        return (0, store_1.createStore)({
+            chart: null,
+            loading: true,
+            error: null,
+        });
+    }
+    fetchDataAndUpdateStore(state, config) {
+        const api = new Charts_api_1.default(config);
+        api
+            .getChart(config)
+            .then((chart) => {
+            state.chart = chart;
+            state.error = null;
+            state.loading = false;
+        })
+            .catch((e) => {
+            state.error = e;
+            state.loading = false;
+        });
+    }
+}
+exports.ChartCacheManager = ChartCacheManager;

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

@@ -0,0 +1,27 @@
+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;
+    }>;
+    protected abstract getConfigPropertyName(): keyof TConfig;
+    protected abstract getStorePropertyName(): keyof TStoreState;
+    protected abstract buildStoreId(config: TConfig): string;
+    protected abstract fetchDataAndUpdateStore(state: TStoreState, config: TConfig): void;
+    protected abstract createStore(): {
+        state: TStoreState;
+        onChange: OnChangeType;
+    };
+    protected getStoreFromPromise(config: TConfig, id: string): Promise<{
+        state: TStoreState;
+        onChange: OnChangeType;
+    }>;
+    getStore(config: TConfig): {
+        state: TStoreState;
+        onChange: OnChangeType;
+    };
+    getMultipleStores(config: TConfig, ids: string[]): Promise<{
+        state: TStoreState;
+        onChange: OnChangeType;
+    }[]>;
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QrveyCacheManager = void 0;
+class QrveyCacheManager {
+    constructor() {
+        this.stores = new Map();
+    }
+    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();
+                        resolve(store);
+                    }
+                });
+            }
+        });
+    }
+    getStore(config) {
+        const storeId = this.buildStoreId(config);
+        const store = this.stores.get(storeId);
+        if (store) {
+            return store;
+        }
+        const { state, onChange } = store !== null && store !== void 0 ? store : this.createStore();
+        this.stores.set(storeId, { state, onChange });
+        this.fetchDataAndUpdateStore(state, config);
+        return { state, onChange };
+    }
+    getMultipleStores(config, ids) {
+        const promises = ids.map((id) => this.getStoreFromPromise(config, id));
+        return Promise.all(promises);
+    }
+}
+exports.QrveyCacheManager = QrveyCacheManager;

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

@@ -0,0 +1,34 @@
+import { OnChangeType, QrveyCacheManager } from "./cache-manager";
+export interface IGetMetricConfig {
+    qv_token?: string;
+    api_key?: string;
+    app_id?: string;
+    user_id?: string;
+    domain?: string;
+    timezone?: any;
+    qrvey_id?: string;
+    i18n?: any;
+    metric_id?: string;
+    lang?: string;
+    translated?: boolean;
+    headers?: {
+        "temporal-tokens"?: boolean;
+    };
+}
+interface IMetricStoreState {
+    metric: any;
+    loading: boolean;
+    error: any;
+}
+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;
+    };
+    protected fetchDataAndUpdateStore(state: IMetricStoreState, config: IGetMetricConfig): void;
+}
+export {};

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

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricCacheManager = void 0;
+const store_1 = require("@stencil/store");
+const cache_manager_1 = require("./cache-manager");
+const isEmpty_1 = require("../general/mix/isEmpty");
+const metrics_api_1 = __importDefault(require("../services/api/metrics.api"));
+class MetricCacheManager extends cache_manager_1.QrveyCacheManager {
+    static getInstance() {
+        if (!window.metricCacheManager) {
+            window.metricCacheManager = new MetricCacheManager();
+        }
+        return window.metricCacheManager;
+    }
+    getConfigPropertyName() {
+        return "metric_id";
+    }
+    getStorePropertyName() {
+        return "metric";
+    }
+    buildStoreId({ metric_id, translated }) {
+        const translate = (0, isEmpty_1.isEmpty)(translated) ? true : translated;
+        return `${metric_id}-${translate ? "translated" : ""}`;
+    }
+    createStore() {
+        return (0, store_1.createStore)({
+            metric: null,
+            loading: true,
+            error: null,
+        });
+    }
+    fetchDataAndUpdateStore(state, config) {
+        const api = new metrics_api_1.default();
+        api
+            .getMetricConfig(config)
+            .then((metric) => {
+            state.metric = metric;
+            state.error = null;
+            state.loading = false;
+        })
+            .catch((e) => {
+            state.error = e;
+            state.loading = false;
+        });
+    }
+}
+exports.MetricCacheManager = MetricCacheManager;