@provoly/dashboard 0.11.0

package/esm2022/lib/dashboard/store/dashboard.selectors.mjs

@@ -0,0 +1,118 @@
+import { createFeatureSelector, createSelector } from '@ngrx/store';
+import equal from 'fast-deep-equal/es6';
+import { DashboardGridLayout } from '../../core/model/manifest.interface';
+import { ViewMode } from './dashboard.actions';
+const NEW_WINDOW_TARGET = -1;
+const feature = createFeatureSelector('@pry/dashboard');
+const manifests = createSelector(feature, (state) => state?.manifests);
+const rank = createSelector(manifests, (manifests) => manifests?.tenants.indexOf(manifests.sender));
+const currentManifestId = createSelector(manifests, (manifests) => manifests.currentId);
+const globalManifest = createSelector(manifests, 
+// @ts-ignore
+(manifests) => ({ windows: [], ...manifests?.manifest }) ?? { windows: [] });
+const staticManifest = createSelector(manifests, 
+// @ts-ignore
+(manifests) => ({ windows: [], ...manifests?.staticManifest }) ?? { windows: [] });
+const refreshRates = createSelector(globalManifest, (manifests) => manifests.refreshRates ?? {});
+const windowManifest = createSelector(globalManifest, rank, (manifest, rank) => manifest.windows[rank] ?? { widgets: [] });
+const gridLayout = createSelector(windowManifest, (manifest) => (manifest.grid ?? {}).layout ?? DashboardGridLayout.MANUAL);
+const memoizeWidgetManifest = {};
+const widgetManifest = (index) => {
+    if (!memoizeWidgetManifest[index]) {
+        memoizeWidgetManifest[index] = createSelector(windowManifest, (windowManifest) => windowManifest.widgets[index] ??
+            {
+                type: 'placeholder',
+                layout: { x: 1, y: 1, width: 1, height: 1 }
+            });
+    }
+    return memoizeWidgetManifest[index];
+};
+const manifestsList = createSelector(manifests, (manifests) => manifests.list);
+const tenants = createSelector(manifests, (manifests) => manifests.tenants ?? []);
+const targetTenantsIndexes = createSelector(manifests, rank, (manifests, rank) => [
+    NEW_WINDOW_TARGET,
+    ...(manifests.tenants ?? []).map((ten, idx) => idx).filter((idx) => idx !== rank)
+]);
+const results = createSelector(feature, (state) => state?.results);
+const resultSets = createSelector(results, (results) => results.resultSets ?? {});
+const resultSetsParams = createSelector(results, (results) => results.resultSetsParams ?? {});
+const namedQueriesNames = createSelector(resultSets, (state) => Object.keys(state) ?? []);
+const availableNamedQueries = createSelector(results, (results) => {
+    return [...new Set([...results.availableDatasourceNames, ...Object.keys(results.resultSets)])] ?? [];
+});
+const defaultDatasourceNames = createSelector(results, (results) => results.defaultDatasource ?? 'current');
+const selectedItemIds = createSelector(results, (results) => results.selectedItems ?? []);
+const objectDetails = createSelector(results, (results) => results.objectDetails ?? {});
+const quickOrder = createSelector(results, (results) => results.quickOrder ?? {});
+const address = createSelector(results, (results) => (results.address ?? {}));
+const allItems = createSelector(results, (results) => Object.keys(results.resultSets)
+    .map((rsKey) => Object.keys(results.resultSets[rsKey].items)
+    .map((classKey) => results.resultSets[rsKey].items[classKey])
+    .reduce((p, c) => [...p, ...c], []))
+    .reduce((p, c) => [...p, ...c], []));
+const getItemsByIds = (ids) => createSelector(allItems, (items) => items.filter((item) => ids.includes(item.id)));
+const selectedItems = createSelector(selectedItemIds, allItems, (itemNames, allItems) => itemNames.map((name) => allItems.find((it) => it.id === name)) ?? []);
+const dashboard = createSelector(feature, (state) => state?.dashboard ?? {});
+const dashboardCellParams = createSelector(dashboard, (dashboard) => dashboard.params ?? {});
+const dashboardEditionMode = createSelector(dashboard, (dashboard) => dashboard.editionMode ?? false);
+const namedQueriesUses = createSelector(globalManifest, (manifest) => manifest.windows
+    .map((window, idx) => ({ windowIndex: idx, widgets: window.widgets }))
+    .map(({ windowIndex, widgets }) => widgets.map((widget) => (Array.isArray(widget.datasource) ? widget.datasource : [widget.datasource])
+    .filter((rsName) => rsName !== undefined)
+    .map((rsName) => ({
+    rsName,
+    windowIndex,
+    type: widget.type,
+    layout: widget.layout
+}))))
+    .reduce((p, c) => [...p, ...c], [])
+    .reduce((p, c) => [...p, ...c], [])
+    .reduce((p, c) => ({ ...p, [c.rsName ?? '']: [...(p[c.rsName ?? ''] || []), { ...c }] }), {}));
+const presentation = createSelector(feature, (state) => state?.presentation);
+const savePresentationActive = createSelector(presentation, globalManifest, (state, global) => !!state.current && (state.viewMode === ViewMode.CREATION || !equal(global, state.initial)));
+const filters = createSelector(feature, (state) => state?.manifests.manifest.filters ?? {});
+const datasourceFilters = createSelector(feature, (state) => state?.manifests.manifest.filters
+    ? state?.manifests.manifest.filters.reduce((obj, filter) => (filter.attributes.forEach((attribute) => (obj[attribute.datasource] || (obj[attribute.datasource] = [])).push({
+        attribute: attribute.id,
+        operator: filter.operator ?? '',
+        value: filter.value ?? ''
+    })),
+        obj), {})
+    : {});
+const wmsFeatures = createSelector(feature, (state) => state?.wmsFeatures);
+export const DashboardSelectors = {
+    feature,
+    rank,
+    currentManifestId,
+    globalManifest,
+    refreshRates,
+    windowManifest,
+    widgetManifest,
+    manifestsList,
+    gridLayout,
+    tenants,
+    resultSets,
+    resultSetsParams,
+    address,
+    namedQueriesNames,
+    namedQueriesUses,
+    availableNamedQueries,
+    defaultDatasourceNames,
+    selectedItemIds,
+    allItems,
+    getItemsByIds,
+    selectedItems,
+    objectDetails,
+    targetTenantsIndexes,
+    dashboard,
+    dashboardCellParams,
+    dashboardEditionMode,
+    staticManifest,
+    quickOrder,
+    presentation,
+    savePresentationActive,
+    filters,
+    datasourceFilters,
+    wmsFeatures
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.selectors.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/lib/dashboard/store/dashboard.selectors.ts"],"names":[],"mappings":"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","sourcesContent":["import { createFeatureSelector, createSelector, MemoizedSelector } from '@ngrx/store';\nimport equal from 'fast-deep-equal/es6';\nimport { Filter, FilterContext } from '../../core/model/filter.interface';\nimport { Item } from '../../core/model/item.interface';\nimport {\n  DashboardGridLayout,\n  DashboardManifest,\n  GlobalManifest,\n  WidgetLayout,\n  WidgetManifest\n} from '../../core/model/manifest.interface';\nimport { ResultOrder } from '../../core/model/result-order.interface';\nimport { ResultSet, ResultSets } from '../../core/model/result-set.interface';\nimport { DashboardCellParams, ViewMode } from './dashboard.actions';\nimport { DashboardState } from './dashboard.reducers';\n\nconst NEW_WINDOW_TARGET = -1;\n\nconst feature = createFeatureSelector<DashboardState>('@pry/dashboard');\nconst manifests = createSelector(feature, (state: DashboardState) => state?.manifests);\nconst rank = createSelector(manifests, (manifests) => manifests?.tenants.indexOf(manifests.sender));\nconst currentManifestId = createSelector(manifests, (manifests) => manifests.currentId);\nconst globalManifest = createSelector(\n  manifests,\n  // @ts-ignore\n  (manifests) => ({ windows: [], ...manifests?.manifest }) ?? ({ windows: [] } as GlobalManifest)\n);\nconst staticManifest = createSelector(\n  manifests,\n  // @ts-ignore\n  (manifests) => ({ windows: [], ...manifests?.staticManifest }) ?? ({ windows: [] } as GlobalManifest)\n);\nconst refreshRates = createSelector(globalManifest, (manifests) => manifests.refreshRates ?? {});\nconst windowManifest = createSelector(\n  globalManifest,\n  rank,\n  (manifest, rank) => manifest.windows[rank] ?? <DashboardManifest>{ widgets: [] }\n);\nconst gridLayout = createSelector(\n  windowManifest,\n  (manifest) => (manifest.grid ?? {}).layout ?? DashboardGridLayout.MANUAL\n);\nconst memoizeWidgetManifest = {} as any;\nconst widgetManifest = (index: number) => {\n  if (!memoizeWidgetManifest[index]) {\n    memoizeWidgetManifest[index] = createSelector(\n      windowManifest,\n      (windowManifest: DashboardManifest) =>\n        windowManifest.widgets[index] ??\n        ({\n          type: 'placeholder',\n          layout: { x: 1, y: 1, width: 1, height: 1 }\n        } as WidgetManifest)\n    );\n  }\n  return memoizeWidgetManifest[index] as MemoizedSelector<DashboardManifest, WidgetManifest>;\n};\nconst manifestsList = createSelector(manifests, (manifests) => manifests.list);\nconst tenants = createSelector(manifests, (manifests) => manifests.tenants ?? <string[]>[]);\nconst targetTenantsIndexes = createSelector(manifests, rank, (manifests, rank) => [\n  NEW_WINDOW_TARGET,\n  ...(manifests.tenants ?? ([] as string[])).map((ten, idx) => idx).filter((idx) => idx !== rank)\n]);\nconst results = createSelector(feature, (state: DashboardState) => state?.results);\nconst resultSets = createSelector(results, (results) => results.resultSets ?? ({} as ResultSets));\nconst resultSetsParams = createSelector(\n  results,\n  (results) => results.resultSetsParams ?? ({} as { [id: string]: string | undefined })\n);\nconst namedQueriesNames = createSelector(resultSets, (state: ResultSets) => Object.keys(state) ?? <string[]>[]);\nconst availableNamedQueries = createSelector(results, (results) => {\n  return [...new Set([...results.availableDatasourceNames, ...Object.keys(results.resultSets)])] ?? <string[]>[];\n});\nconst defaultDatasourceNames = createSelector(results, (results) => results.defaultDatasource ?? 'current');\nconst selectedItemIds = createSelector(results, (results) => results.selectedItems ?? ([] as string[]));\nconst objectDetails = createSelector(results, (results) => results.objectDetails ?? ({} as { [id: string]: Item }));\nconst quickOrder = createSelector(results, (results) => results.quickOrder ?? ({} as { [id: string]: ResultOrder }));\nconst address = createSelector(\n  results,\n  (results) => (results.address ?? {}) as { latLon: number[]; pointAddress: string }\n);\nconst allItems = createSelector(results, (results) =>\n  Object.keys(results.resultSets)\n    .map((rsKey) =>\n      Object.keys(results.resultSets[rsKey].items)\n        .map((classKey) => (results.resultSets[rsKey] as ResultSet).items[classKey])\n        .reduce((p, c) => [...p, ...c], [])\n    )\n    .reduce((p, c) => [...p, ...c], [])\n);\nconst getItemsByIds = (ids: string[]) =>\n  createSelector(allItems, (items) => items.filter((item) => ids.includes(item.id)));\nconst selectedItems = createSelector(\n  selectedItemIds,\n  allItems,\n  (itemNames, allItems) => itemNames.map((name) => allItems.find((it) => it.id === name)) ?? ([] as Item[])\n);\nconst dashboard = createSelector(feature, (state: DashboardState) => state?.dashboard ?? {});\nconst dashboardCellParams = createSelector(dashboard, (dashboard) => dashboard.params ?? <DashboardCellParams>{});\nconst dashboardEditionMode = createSelector(dashboard, (dashboard) => dashboard.editionMode ?? false);\nconst namedQueriesUses = createSelector(globalManifest, (manifest) =>\n  manifest.windows\n    .map((window, idx) => ({ windowIndex: idx, widgets: window.widgets }))\n    .map(({ windowIndex, widgets }) =>\n      widgets.map((widget) =>\n        (Array.isArray(widget.datasource) ? widget.datasource : [widget.datasource])\n          .filter((rsName) => rsName !== undefined)\n          .map((rsName) => ({\n            rsName,\n            windowIndex,\n            type: widget.type,\n            layout: widget.layout\n          }))\n      )\n    )\n    .reduce((p, c) => [...p, ...c], [])\n    .reduce((p, c) => [...p, ...c], [])\n    .reduce(\n      (p, c) => ({ ...p, [c.rsName ?? '']: [...(p[c.rsName ?? ''] || []), { ...c }] }),\n      {} as { [key: string]: { windowIndex: number; type: string; layout: WidgetLayout; rsName?: string }[] }\n    )\n);\nconst presentation = createSelector(feature, (state: DashboardState) => state?.presentation);\nconst savePresentationActive = createSelector(\n  presentation,\n  globalManifest,\n  (state, global) => !!state.current && (state.viewMode === ViewMode.CREATION || !equal(global, state.initial))\n);\n\nconst filters = createSelector(feature, (state: DashboardState) => state?.manifests.manifest.filters ?? {});\nconst datasourceFilters = createSelector(feature, (state: DashboardState) =>\n  state?.manifests.manifest.filters\n    ? state?.manifests.manifest.filters.reduce(\n        (obj: { [datasourceId: string]: FilterContext[] }, filter: Filter) => (\n          filter.attributes.forEach((attribute) =>\n            (obj[attribute.datasource] || (obj[attribute.datasource] = [])).push({\n              attribute: attribute.id,\n              operator: filter.operator ?? '',\n              value: filter.value ?? ''\n            })\n          ),\n          obj\n        ),\n        {}\n      )\n    : {}\n);\nconst wmsFeatures = createSelector(feature, (state: DashboardState) => state?.wmsFeatures);\n\nexport const DashboardSelectors = {\n  feature,\n  rank,\n  currentManifestId,\n  globalManifest,\n  refreshRates,\n  windowManifest,\n  widgetManifest,\n  manifestsList,\n  gridLayout,\n  tenants,\n  resultSets,\n  resultSetsParams,\n  address,\n  namedQueriesNames,\n  namedQueriesUses,\n  availableNamedQueries,\n  defaultDatasourceNames,\n  selectedItemIds,\n  allItems,\n  getItemsByIds,\n  selectedItems,\n  objectDetails,\n  targetTenantsIndexes,\n  dashboard,\n  dashboardCellParams,\n  dashboardEditionMode,\n  staticManifest,\n  quickOrder,\n  presentation,\n  savePresentationActive,\n  filters,\n  datasourceFilters,\n  wmsFeatures\n};\n"]}

package/esm2022/lib/dashboard/store/geocoding.service.mjs

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import { map, mergeMap } from 'rxjs';
+import { ConfigSelectors } from '../../core/store/config/config.selectors';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@ngrx/store";
+export class GeocodingService {
+    constructor(httpClient, store) {
+        this.httpClient = httpClient;
+        this.store = store;
+    }
+    fromAddress(address) {
+        const preparedAddress = address.replace(/\s/g, '+');
+        return this.store.select(ConfigSelectors.geocodingUrl).pipe(mergeMap((url) => this.httpClient.get(`${url}/search/?text=${preparedAddress}`).pipe(map((result) => ({
+            latLon: result.features[0].geometry.coordinates.reverse(),
+            pointAddress: result.features[0].properties.label
+        })))));
+    }
+    fromLatLong(latLng) {
+        return this.store.select(ConfigSelectors.geocodingUrl).pipe(mergeMap((url) => this.httpClient
+            .get(`${url}/reverse/`, {
+            params: {
+                lat: latLng[0],
+                lon: latLng[1]
+            }
+        })
+            .pipe(map((result) => ({
+            latLon: result.features[0].geometry.coordinates.reverse(),
+            pointAddress: result.features[0].properties.label
+        })))));
+    }
+    getWmsFeatures(url) {
+        return this.httpClient.get(url).pipe(map((json) => json));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: GeocodingService, deps: [{ token: i1.HttpClient }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: GeocodingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: GeocodingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/dashboard/store/manifest.service.mjs

@@ -0,0 +1,95 @@
+import { Injectable } from '@angular/core';
+import { mergeMap, of } from 'rxjs';
+import { catchError, map, withLatestFrom } from 'rxjs/operators';
+import { v4 as uuidv4 } from 'uuid';
+import { ConfigSelectors } from '../../core/store/config/config.selectors';
+import { DashboardSelectors } from './dashboard.selectors';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@ngrx/store";
+import * as i3 from "../../core/components/snackbar/snackbar.service";
+import * as i4 from "../../core/i18n/i18n.service";
+export class ManifestService {
+    constructor(httpClient, store, snackBar, translateService) {
+        this.httpClient = httpClient;
+        this.store = store;
+        this.snackBar = snackBar;
+        this.translateService = translateService;
+    }
+    list() {
+        return this.store.select(ConfigSelectors.refUrl).pipe(mergeMap((url) => this.httpClient.get(encodeURI(`${url}/users/me/dashboards`))), catchError((error) => {
+            if (error.error instanceof Error) {
+                // A client-side or network error occurred
+                console.error('A frontend error occurred:', error.error.message);
+                this.snackBar.open({
+                    type: 'error',
+                    message: this.translateService.instant('@pry.manifest.get.errorFront', { msg: error.error.message })
+                });
+            }
+            else {
+                // The backend returned an unsuccessful response code.
+                console.error(`Backend returned code ${error.status}, body was: ${JSON.stringify(error.error)}`);
+                if (error.code !== 204) {
+                    this.snackBar.open({
+                        type: 'error',
+                        message: this.translateService.instant('@pry.manifest.get.errorBack', {
+                            code: error.status
+                        })
+                    });
+                }
+            }
+            return of([]);
+        }));
+    }
+    get(id) {
+        return this.store
+            .select(ConfigSelectors.refUrl)
+            .pipe(mergeMap((url) => this.httpClient.get(encodeURI(`${url}/users/me/dashboards/id/${id}/manifest`))));
+    }
+    save(name, manifest, visibility, id, description, image, cover) {
+        return this.store.select(ConfigSelectors.refUrl).pipe(mergeMap((url) => this.httpClient.post(encodeURI(`${url}/users/me/dashboards`), {
+            id: id === undefined || id.length === 0 ? uuidv4() : id,
+            name,
+            description,
+            manifest,
+            image,
+            visibility,
+            cover,
+            datasets: [
+                ...new Set(manifest.windows
+                    .map((window) => window.widgets.map((widget) => widget.datasource))
+                    .flat(3)
+                    .filter((dataset) => !!dataset))
+            ]
+        })));
+    }
+    delete(id) {
+        return this.store
+            .select(ConfigSelectors.refUrl)
+            .pipe(mergeMap((url) => this.httpClient.delete(encodeURI(`${url}/users/me/dashboards/id/${id}`))));
+    }
+    default(id) {
+        return this.store.select(ConfigSelectors.refUrl).pipe(withLatestFrom(this.store.select(DashboardSelectors.manifestsList)), mergeMap(([url, manifests]) => {
+            const actual = manifests.find((manifest) => manifest.id === id);
+            if (!!actual && !actual.default) {
+                return this.httpClient
+                    .put(encodeURI(`${url}/users/me/dashboards/id/${id}/default`), {})
+                    .pipe(map(() => true));
+            }
+            else {
+                return this.httpClient
+                    .delete(encodeURI(`${url}/users/me/dashboards/default`), {})
+                    .pipe(map(() => false));
+            }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: ManifestService, deps: [{ token: i1.HttpClient }, { token: i2.Store }, { token: i3.PrySnackbarService }, { token: i4.PryI18nService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: ManifestService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: ManifestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.Store }, { type: i3.PrySnackbarService }, { type: i4.PryI18nService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifest.service.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/lib/dashboard/store/manifest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { mergeMap, Observable, of } from 'rxjs';\nimport { catchError, map, withLatestFrom } from 'rxjs/operators';\nimport { v4 as uuidv4 } from 'uuid';\nimport { PryVisibility } from '../../core/components/share/share.model';\nimport { PrySnackbarService } from '../../core/components/snackbar/snackbar.service';\nimport { PryI18nService } from '../../core/i18n/i18n.service';\nimport { GlobalManifest, ManifestDescription } from '../../core/model/manifest.interface';\nimport { ConfigSelectors } from '../../core/store/config/config.selectors';\nimport { DashboardSelectors } from './dashboard.selectors';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ManifestService {\n  constructor(\n    private httpClient: HttpClient,\n    private store: Store<any>,\n    private snackBar: PrySnackbarService,\n    private translateService: PryI18nService\n  ) {}\n\n  list(): Observable<ManifestDescription[]> {\n    return this.store.select(ConfigSelectors.refUrl).pipe(\n      mergeMap((url) => this.httpClient.get<ManifestDescription[]>(encodeURI(`${url}/users/me/dashboards`))),\n      catchError((error) => {\n        if (error.error instanceof Error) {\n          // A client-side or network error occurred\n          console.error('A frontend error occurred:', error.error.message);\n          this.snackBar.open({\n            type: 'error',\n            message: this.translateService.instant('@pry.manifest.get.errorFront', { msg: error.error.message })\n          });\n        } else {\n          // The backend returned an unsuccessful response code.\n          console.error(`Backend returned code ${error.status}, body was: ${JSON.stringify(error.error)}`);\n          if (error.code !== 204) {\n            this.snackBar.open({\n              type: 'error',\n              message: this.translateService.instant('@pry.manifest.get.errorBack', {\n                code: error.status\n              })\n            });\n          }\n        }\n        return of([]);\n      })\n    );\n  }\n\n  get(id: string): Observable<GlobalManifest> {\n    return this.store\n      .select(ConfigSelectors.refUrl)\n      .pipe(\n        mergeMap((url) =>\n          this.httpClient.get<GlobalManifest>(encodeURI(`${url}/users/me/dashboards/id/${id}/manifest`))\n        )\n      );\n  }\n\n  save(\n    name: string,\n    manifest: GlobalManifest,\n    visibility: PryVisibility,\n    id?: string,\n    description?: string,\n    image?: string,\n    cover?: boolean\n  ): Observable<{ id: string; name: string; manifest: GlobalManifest }> {\n    return this.store.select(ConfigSelectors.refUrl).pipe(\n      mergeMap((url) =>\n        this.httpClient.post<{ id: string; description: string; name: string; manifest: GlobalManifest }>(\n          encodeURI(`${url}/users/me/dashboards`),\n          {\n            id: id === undefined || id.length === 0 ? uuidv4() : id,\n            name,\n            description,\n            manifest,\n            image,\n            visibility,\n            cover,\n            datasets: [\n              ...new Set(\n                manifest.windows\n                  .map((window) => window.widgets.map((widget) => widget.datasource))\n                  .flat(3)\n                  .filter((dataset) => !!dataset)\n              )\n            ]\n          }\n        )\n      )\n    );\n  }\n\n  delete(id: string): Observable<void> {\n    return this.store\n      .select(ConfigSelectors.refUrl)\n      .pipe(mergeMap((url) => this.httpClient.delete<void>(encodeURI(`${url}/users/me/dashboards/id/${id}`))));\n  }\n\n  default(id: string): Observable<boolean> {\n    return this.store.select(ConfigSelectors.refUrl).pipe(\n      withLatestFrom(this.store.select(DashboardSelectors.manifestsList)),\n      mergeMap(([url, manifests]) => {\n        const actual = manifests.find((manifest) => manifest.id === id);\n        if (!!actual && !actual.default) {\n          return this.httpClient\n            .put<ArrayBuffer>(encodeURI(`${url}/users/me/dashboards/id/${id}/default`), {})\n            .pipe(map(() => true));\n        } else {\n          return this.httpClient\n            .delete<ArrayBuffer>(encodeURI(`${url}/users/me/dashboards/default`), {})\n            .pipe(map(() => false));\n        }\n      })\n    );\n  }\n}\n"]}

package/esm2022/lib/dashboard/store/refresh.service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { filter, interval } from 'rxjs';
+import { map, withLatestFrom } from 'rxjs/operators';
+import { SearchActions } from '../../core/store/search/search.actions';
+import { DashboardSelectors } from './dashboard.selectors';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+export class RefreshService {
+    constructor(store) {
+        this.store = store;
+    }
+    stop() {
+        this.subscription?.unsubscribe();
+    }
+    start() {
+        if (!this.subscription) {
+            this.subscription = interval(1000)
+                .pipe(withLatestFrom(this.store.select(DashboardSelectors.refreshRates)), map(([interval, refreshRates]) => Object.keys(refreshRates)
+                .filter((key) => refreshRates[key] !== undefined && refreshRates[key] !== 0)
+                .filter((key) => interval % refreshRates[key] === 0)), filter((rs) => rs.length > 0))
+                .subscribe((resultSetsToUpdate) => {
+                resultSetsToUpdate.forEach((rs) => {
+                    this.store.dispatch(SearchActions.getDatasourceItems({ id: rs }));
+                });
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: RefreshService, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: RefreshService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: RefreshService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/dashboard/store/title.service.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { DashboardSelectors } from './dashboard.selectors';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+import * as i2 from "../../core/i18n/i18n.service";
+import * as i3 from "@ngrx/store";
+export class PryTitleService {
+    constructor(title, translateService, store) {
+        this.title = title;
+        this.translateService = translateService;
+        this.store = store;
+        this.rank = 0;
+        this.displayPageNumber = true;
+        this.pageCount = 0;
+        this.store.select(DashboardSelectors.rank).subscribe((rank) => (this.rank = rank));
+        this.store.select(DashboardSelectors.tenants).subscribe((tenants) => (this.pageCount = tenants.length));
+    }
+    setDisplayPageNumber(display) {
+        this.displayPageNumber = display;
+    }
+    changeTitle(key) {
+        const nextTitle = !!key ? this.translateService.instant(key) : this.title.getTitle().split('[')[0];
+        const pageNumber = this.displayPageNumber && this.pageCount > 1
+            ? `[${this.translateService.instant('@pry.view.name', {
+                rank: this.rank + 1
+            })}]`
+            : '';
+        this.title.setTitle(`${nextTitle} ${pageNumber}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: PryTitleService, deps: [{ token: i1.Title }, { token: i2.PryI18nService }, { token: i3.Store }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: PryTitleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: PryTitleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Title }, { type: i2.PryI18nService }, { type: i3.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/dashboard/tooltip/base-tooltip.component.mjs

@@ -0,0 +1,20 @@
+import { Component, HostBinding } from '@angular/core';
+import { SubscriptionnerDirective } from '../components/subscriptionner.directive';
+import * as i0 from "@angular/core";
+export class BaseTooltipComponent extends SubscriptionnerDirective {
+    constructor() {
+        super(...arguments);
+        this.class = 'm-tooltip__item';
+        this.data = {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: BaseTooltipComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.6", type: BaseTooltipComponent, selector: "pry-tooltip-widget", host: { properties: { "class": "this.class" } }, usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: BaseTooltipComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pry-tooltip-widget', template: '' }]
+        }], propDecorators: { class: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS10b29sdGlwLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3Byb3ZvbHkvZGFzaGJvYXJkL2xpYi9kYXNoYm9hcmQvdG9vbHRpcC9iYXNlLXRvb2x0aXAuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWMsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRW5FLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLHlDQUF5QyxDQUFDOztBQUduRixNQUFNLE9BQU8sb0JBQXFCLFNBQVEsd0JBQXdCO0lBRGxFOztRQUV3QixVQUFLLEdBQUcsaUJBQWlCLENBQUM7UUFFaEQsU0FBSSxHQUdBLEVBQUUsQ0FBQztLQUdSOzhHQVRZLG9CQUFvQjtrR0FBcEIsb0JBQW9CLGtJQURzQixFQUFFOzsyRkFDNUMsb0JBQW9CO2tCQURoQyxTQUFTO21CQUFDLEVBQUUsUUFBUSxFQUFFLG9CQUFvQixFQUFFLFFBQVEsRUFBRSxFQUFFLEVBQUU7OEJBRW5DLEtBQUs7c0JBQTFCLFdBQVc7dUJBQUMsT0FBTyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgRWxlbWVudFJlZiwgSG9zdEJpbmRpbmcgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJlc3VsdFNldCB9IGZyb20gJy4uLy4uL2NvcmUvbW9kZWwvcmVzdWx0LXNldC5pbnRlcmZhY2UnO1xuaW1wb3J0IHsgU3Vic2NyaXB0aW9ubmVyRGlyZWN0aXZlIH0gZnJvbSAnLi4vY29tcG9uZW50cy9zdWJzY3JpcHRpb25uZXIuZGlyZWN0aXZlJztcblxuQENvbXBvbmVudCh7IHNlbGVjdG9yOiAncHJ5LXRvb2x0aXAtd2lkZ2V0JywgdGVtcGxhdGU6ICcnIH0pXG5leHBvcnQgY2xhc3MgQmFzZVRvb2x0aXBDb21wb25lbnQgZXh0ZW5kcyBTdWJzY3JpcHRpb25uZXJEaXJlY3RpdmUge1xuICBASG9zdEJpbmRpbmcoJ2NsYXNzJykgY2xhc3MgPSAnbS10b29sdGlwX19pdGVtJztcblxuICBkYXRhOiB7XG4gICAgaXRlbT86IGFueTtcbiAgICByZXN1bHRTZXQ/OiBSZXN1bHRTZXQ7XG4gIH0gPSB7fTtcbiAgY29udGV4dDogYW55O1xuICBwb3B1cD86IEVsZW1lbnRSZWY7XG59XG4iXX0=

package/esm2022/lib/dashboard/tooltip/base-tooltip.module.mjs

@@ -0,0 +1,16 @@
+import { NgModule } from '@angular/core';
+import { DefaultTooltipComponent } from './components/default/default.tooltip.component';
+import * as i0 from "@angular/core";
+export class BaseTooltipModule {
+    getComponent() {
+        return DefaultTooltipComponent;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: BaseTooltipModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.6", ngImport: i0, type: BaseTooltipModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: BaseTooltipModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: BaseTooltipModule, decorators: [{
+            type: NgModule,
+            args: [{}]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS10b29sdGlwLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3Byb3ZvbHkvZGFzaGJvYXJkL2xpYi9kYXNoYm9hcmQvdG9vbHRpcC9iYXNlLXRvb2x0aXAubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQVEsTUFBTSxlQUFlLENBQUM7QUFFL0MsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sZ0RBQWdELENBQUM7O0FBR3pGLE1BQU0sT0FBTyxpQkFBaUI7SUFDNUIsWUFBWTtRQUNWLE9BQU8sdUJBQXVCLENBQUM7SUFDakMsQ0FBQzs4R0FIVSxpQkFBaUI7K0dBQWpCLGlCQUFpQjsrR0FBakIsaUJBQWlCOzsyRkFBakIsaUJBQWlCO2tCQUQ3QixRQUFRO21CQUFDLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSwgVHlwZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmFzZVRvb2x0aXBDb21wb25lbnQgfSBmcm9tICcuL2Jhc2UtdG9vbHRpcC5jb21wb25lbnQnO1xuaW1wb3J0IHsgRGVmYXVsdFRvb2x0aXBDb21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvZGVmYXVsdC9kZWZhdWx0LnRvb2x0aXAuY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHt9KVxuZXhwb3J0IGNsYXNzIEJhc2VUb29sdGlwTW9kdWxlIHtcbiAgZ2V0Q29tcG9uZW50KCk6IFR5cGU8QmFzZVRvb2x0aXBDb21wb25lbnQ+IHtcbiAgICByZXR1cm4gRGVmYXVsdFRvb2x0aXBDb21wb25lbnQ7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/dashboard/tooltip/components/default/default.tooltip.component.mjs

@@ -0,0 +1,15 @@
+import { Component } from '@angular/core';
+import { BaseTooltipComponent } from '../../base-tooltip.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../../core/components/translate-id/translate-id.pipe";
+import * as i3 from "../../../../core/i18n/i18n.pipe";
+export class DefaultTooltipComponent extends BaseTooltipComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: DefaultTooltipComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.6", type: DefaultTooltipComponent, selector: "pry-default-tooltip", usesInheritance: true, ngImport: i0, template: "<div class=\"m-tooltip__item__content\" *ngIf=\"data.item.properties; else defaultTooltip\">\n  <p *ngFor=\"let property of data.item.properties\">\n    <span>{{ property.key | titlecase }} :</span> {{ property.value }}\n  </p>\n</div>\n<ng-template #defaultTooltip>\n  <p>\n    <span>{{ '@pry.widget.itemId' | i18n }} :</span> {{ data.item?.id }}\n  </p>\n  <p>\n    <span>{{ '@pry.widget.class' | i18n }} :</span>\n    {{\n      data.item?.oClass\n        | translateId\n          : {\n              type: 'class',\n              output: 'name'\n            }\n        | async\n    }}\n  </p>\n</ng-template>\n", dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i1.TitleCasePipe, name: "titlecase" }, { kind: "pipe", type: i2.TranslateIdPipe, name: "translateId" }, { kind: "pipe", type: i3.I18nPipe, name: "i18n" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: DefaultTooltipComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pry-default-tooltip', template: "<div class=\"m-tooltip__item__content\" *ngIf=\"data.item.properties; else defaultTooltip\">\n  <p *ngFor=\"let property of data.item.properties\">\n    <span>{{ property.key | titlecase }} :</span> {{ property.value }}\n  </p>\n</div>\n<ng-template #defaultTooltip>\n  <p>\n    <span>{{ '@pry.widget.itemId' | i18n }} :</span> {{ data.item?.id }}\n  </p>\n  <p>\n    <span>{{ '@pry.widget.class' | i18n }} :</span>\n    {{\n      data.item?.oClass\n        | translateId\n          : {\n              type: 'class',\n              output: 'name'\n            }\n        | async\n    }}\n  </p>\n</ng-template>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC50b29sdGlwLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3Byb3ZvbHkvZGFzaGJvYXJkL2xpYi9kYXNoYm9hcmQvdG9vbHRpcC9jb21wb25lbnRzL2RlZmF1bHQvZGVmYXVsdC50b29sdGlwLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3Byb3ZvbHkvZGFzaGJvYXJkL2xpYi9kYXNoYm9hcmQvdG9vbHRpcC9jb21wb25lbnRzL2RlZmF1bHQvZGVmYXVsdC50b29sdGlwLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDMUMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sOEJBQThCLENBQUM7Ozs7O0FBTXBFLE1BQU0sT0FBTyx1QkFBd0IsU0FBUSxvQkFBb0I7OEdBQXBELHVCQUF1QjtrR0FBdkIsdUJBQXVCLGtGQ1BwQyxzbUJBc0JBOzsyRkRmYSx1QkFBdUI7a0JBSm5DLFNBQVM7K0JBQ0UscUJBQXFCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCYXNlVG9vbHRpcENvbXBvbmVudCB9IGZyb20gJy4uLy4uL2Jhc2UtdG9vbHRpcC5jb21wb25lbnQnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdwcnktZGVmYXVsdC10b29sdGlwJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2RlZmF1bHQudG9vbHRpcC5jb21wb25lbnQuaHRtbCdcbn0pXG5leHBvcnQgY2xhc3MgRGVmYXVsdFRvb2x0aXBDb21wb25lbnQgZXh0ZW5kcyBCYXNlVG9vbHRpcENvbXBvbmVudCB7fVxuIiwiPGRpdiBjbGFzcz1cIm0tdG9vbHRpcF9faXRlbV9fY29udGVudFwiICpuZ0lmPVwiZGF0YS5pdGVtLnByb3BlcnRpZXM7IGVsc2UgZGVmYXVsdFRvb2x0aXBcIj5cbiAgPHAgKm5nRm9yPVwibGV0IHByb3BlcnR5IG9mIGRhdGEuaXRlbS5wcm9wZXJ0aWVzXCI+XG4gICAgPHNwYW4+e3sgcHJvcGVydHkua2V5IHwgdGl0bGVjYXNlIH19IDo8L3NwYW4+IHt7IHByb3BlcnR5LnZhbHVlIH19XG4gIDwvcD5cbjwvZGl2PlxuPG5nLXRlbXBsYXRlICNkZWZhdWx0VG9vbHRpcD5cbiAgPHA+XG4gICAgPHNwYW4+e3sgJ0Bwcnkud2lkZ2V0Lml0ZW1JZCcgfCBpMThuIH19IDo8L3NwYW4+IHt7IGRhdGEuaXRlbT8uaWQgfX1cbiAgPC9wPlxuICA8cD5cbiAgICA8c3Bhbj57eyAnQHByeS53aWRnZXQuY2xhc3MnIHwgaTE4biB9fSA6PC9zcGFuPlxuICAgIHt7XG4gICAgICBkYXRhLml0ZW0/Lm9DbGFzc1xuICAgICAgICB8IHRyYW5zbGF0ZUlkXG4gICAgICAgICAgOiB7XG4gICAgICAgICAgICAgIHR5cGU6ICdjbGFzcycsXG4gICAgICAgICAgICAgIG91dHB1dDogJ25hbWUnXG4gICAgICAgICAgICB9XG4gICAgICAgIHwgYXN5bmNcbiAgICB9fVxuICA8L3A+XG48L25nLXRlbXBsYXRlPlxuIl19

package/esm2022/lib/dashboard/tooltip/public-api.mjs

@@ -0,0 +1,6 @@
+export * from './base-tooltip.component';
+export * from './base-tooltip.module';
+export * from './components/default/default.tooltip.component';
+export * from './tooltip-factory.service';
+export * from './tooltip-loader.function';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3Byb3ZvbHkvZGFzaGJvYXJkL2xpYi9kYXNoYm9hcmQvdG9vbHRpcC9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGdEQUFnRCxDQUFDO0FBQy9ELGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmFzZS10b29sdGlwLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Jhc2UtdG9vbHRpcC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL2RlZmF1bHQvZGVmYXVsdC50b29sdGlwLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3Rvb2x0aXAtZmFjdG9yeS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vdG9vbHRpcC1sb2FkZXIuZnVuY3Rpb24nO1xuIl19

package/esm2022/lib/dashboard/tooltip/tooltip-factory.service.mjs

@@ -0,0 +1,77 @@
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { BehaviorSubject, from, map, of } from 'rxjs';
+import { ConfigSelectors } from '../../core/store/config/config.selectors';
+import { DefaultTooltipComponent } from './components/default/default.tooltip.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+export const TOOLTIP_DEFINITION = new InjectionToken('Tooltip definition');
+export class TooltipFactoryService {
+    constructor(injector, reference, store) {
+        this.injector = injector;
+        this.store = store;
+        this.reference$ = new BehaviorSubject({
+            default: { name: 'default', component: DefaultTooltipComponent },
+            none: { name: 'none', component: null }
+        });
+        this.defs = {};
+        this.moduleRefCache = {};
+        this.putDefinitions(reference);
+        this.types$ = this.reference$.pipe(map((defs) => Object.keys(defs)));
+        this.store.select(ConfigSelectors.tooltipDefinitions).subscribe((defs) => (this.defs = defs));
+    }
+    resolveComponent(_type) {
+        let type = _type;
+        if (this.moduleRefCache[type]) {
+            return of(this.moduleRefCache[type]);
+        }
+        if (!this.reference$.getValue()[type]) {
+            type = 'default';
+        }
+        // @ts-ignore
+        if (this.reference$.getValue()[type].load === undefined) {
+            this.moduleRefCache[type] = this.reference$.getValue()[type].component;
+            return of(this.moduleRefCache[type]);
+        }
+        else {
+            return from(this.reference$.getValue()[type].load().then((fn) => {
+                this.moduleRefCache[type] = fn(this.injector);
+                return this.moduleRefCache[type];
+            }));
+        }
+    }
+    putDefinitions(definitions) {
+        this.reference$.next({
+            ...this.reference$.getValue(),
+            ...definitions
+        });
+    }
+    isModuleLoaded(type) {
+        return this.reference$.pipe(map((componentDefs) => !!componentDefs[type]));
+    }
+    generateTooltip(type, parentInjector, container) {
+        const definition = this.defs[type] ?? { type };
+        return this.resolveComponent(definition.type).pipe(map((component) => {
+            if (component) {
+                const tmpComponent = container.createComponent(component);
+                tmpComponent.instance.context = definition.options;
+                return tmpComponent;
+            }
+            return null;
+        }));
+    }
+    addTooltipDefinitions(defs) {
+        this.reference$.next({ ...this.reference$.getValue(), ...defs });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: TooltipFactoryService, deps: [{ token: i0.Injector }, { token: TOOLTIP_DEFINITION }, { token: i1.Store }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: TooltipFactoryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: TooltipFactoryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TOOLTIP_DEFINITION]
+                }] }, { type: i1.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip-factory.service.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/lib/dashboard/tooltip/tooltip-factory.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef, Inject, Injectable, InjectionToken, Injector, Type, ViewContainerRef } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { BehaviorSubject, from, map, Observable, of } from 'rxjs';\nimport { TooltipOfClass } from '../../core/model/tooltip-of-class.interface';\nimport { ConfigSelectors } from '../../core/store/config/config.selectors';\nimport { BaseTooltipComponent } from './base-tooltip.component';\nimport { DefaultTooltipComponent } from './components/default/default.tooltip.component';\n\nexport const TOOLTIP_DEFINITION = new InjectionToken<string>('Tooltip definition');\n\nexport type TooltipStaticDefinition = {\n  name: string;\n  component: Type<BaseTooltipComponent>;\n};\nexport type TooltipLazyDefinition = {\n  name: string;\n  load: () => Promise<(injector: Injector) => Type<BaseTooltipComponent>>;\n};\nexport type TooltipDefinition = TooltipStaticDefinition | TooltipLazyDefinition;\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class TooltipFactoryService {\n  reference$ = new BehaviorSubject<{ [key: string]: TooltipDefinition }>({\n    default: { name: 'default', component: DefaultTooltipComponent },\n    none: { name: 'none', component: null as unknown as Type<BaseTooltipComponent> }\n  });\n  types$: Observable<string[]>;\n  defs: { [p: string]: TooltipOfClass } = {};\n  moduleRefCache = {} as { [manifestType: string]: Type<BaseTooltipComponent> };\n\n  constructor(\n    private injector: Injector,\n    @Inject(TOOLTIP_DEFINITION) reference: { [key: string]: TooltipDefinition },\n    private store: Store\n  ) {\n    this.putDefinitions(reference);\n    this.types$ = this.reference$.pipe(map((defs) => Object.keys(defs)));\n    this.store.select(ConfigSelectors.tooltipDefinitions).subscribe((defs) => (this.defs = defs));\n  }\n\n  resolveComponent(_type: string) {\n    let type = _type;\n    if (this.moduleRefCache[type]) {\n      return of(this.moduleRefCache[type]);\n    }\n    if (!this.reference$.getValue()[type]) {\n      type = 'default';\n    }\n    // @ts-ignore\n    if (this.reference$.getValue()[type].load === undefined) {\n      this.moduleRefCache[type] = (this.reference$.getValue()[type] as TooltipStaticDefinition).component;\n      return of(this.moduleRefCache[type]);\n    } else {\n      return from(\n        (this.reference$.getValue()[type] as TooltipLazyDefinition).load().then((fn) => {\n          this.moduleRefCache[type] = fn(this.injector);\n          return this.moduleRefCache[type];\n        })\n      );\n    }\n  }\n\n  private putDefinitions(definitions: { [key: string]: TooltipDefinition }) {\n    this.reference$.next({\n      ...this.reference$.getValue(),\n      ...definitions\n    });\n  }\n\n  isModuleLoaded(type: string): Observable<boolean> {\n    return this.reference$.pipe(map((componentDefs) => !!componentDefs[type]));\n  }\n\n  generateTooltip(\n    type: string,\n    parentInjector: Injector,\n    container: ViewContainerRef\n  ): Observable<ComponentRef<BaseTooltipComponent> | null> {\n    const definition = this.defs[type] ?? { type };\n    return this.resolveComponent(definition.type).pipe(\n      map((component) => {\n        if (component) {\n          const tmpComponent = container.createComponent<BaseTooltipComponent>(component);\n          tmpComponent.instance.context = definition.options;\n          return tmpComponent;\n        }\n        return null;\n      })\n    );\n  }\n\n  addTooltipDefinitions(defs: { [key: string]: TooltipDefinition }) {\n    this.reference$.next({ ...this.reference$.getValue(), ...defs });\n  }\n}\n"]}