@valtimo/dashboard 10.6.0 → 10.7.0

package/esm2020/lib/services/widget-layout.service.mjs

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, filter, map } from 'rxjs';
+import { WIDGET_1X_HEIGHT, WIDGET_1X_MIN_WIDTH } from '../constants';
+import pack from 'bin-pack-with-constraints';
+import * as i0 from "@angular/core";
+import * as i1 from "./widget.service";
+export class WidgetLayoutService {
+    constructor(widgetService) {
+        this.widgetService = widgetService;
+        this._widgetContainerWidth$ = new BehaviorSubject(null);
+        this._widgetConfigurations$ = new BehaviorSubject([]);
+        this._widgetPackResult$ = new BehaviorSubject(null);
+        this.openLayoutSubscription();
+    }
+    get widgetPackResult$() {
+        return this._widgetPackResult$.asObservable().pipe(filter(result => !!result));
+    }
+    get widgetContainerWidth$() {
+        return this._widgetContainerWidth$.asObservable().pipe(filter(width => !!width));
+    }
+    get widgetConfigurationBins$() {
+        return combineLatest([
+            this.widgetService.supportedDisplayTypes$,
+            this._widgetConfigurations$,
+        ]).pipe(map(([displayTypes, configurations]) => configurations.map(configuration => {
+            const specification = displayTypes.find(type => type.displayTypeKey === configuration.displayType);
+            return {
+                configurationKey: configuration.key,
+                width: specification.width,
+                height: specification.height,
+            };
+        })));
+    }
+    ngOnDestroy() {
+        this._layoutSubscription?.unsubscribe();
+    }
+    setWidgetContainerWidth(width) {
+        this._widgetContainerWidth$.next(width);
+    }
+    setWidgetConfigurations(configurations) {
+        this._widgetConfigurations$.next(configurations);
+    }
+    openLayoutSubscription() {
+        this._layoutSubscription = combineLatest([
+            this.widgetContainerWidth$,
+            this.widgetConfigurationBins$,
+        ]).subscribe(([widgetContainerWidth, configurationBins]) => {
+            const amountOfMinWidthColumns = this.getAmountOfMinWidthColumns(widgetContainerWidth);
+            const widget1xWidth = this.getWidget1xWidth(widgetContainerWidth, amountOfMinWidthColumns);
+            const binsToFit = configurationBins.map(configurationBin => ({
+                ...configurationBin,
+                width: configurationBin.width * widget1xWidth,
+                height: configurationBin.height * WIDGET_1X_HEIGHT,
+            }));
+            const heightConstraint = this.getHeightConstraint(configurationBins, amountOfMinWidthColumns);
+            const resultWithoutHeightConstraint = this.getPackResult(binsToFit, widgetContainerWidth);
+            const resultWithHeightConstraint = this.getPackResult(binsToFit, widgetContainerWidth, heightConstraint);
+            const resultWithHeightConstraintExceedsBoundary = this.checkIfPackResultExceedsBoundary(resultWithHeightConstraint, widgetContainerWidth);
+            const resultToUse = resultWithHeightConstraintExceedsBoundary
+                ? resultWithoutHeightConstraint
+                : resultWithHeightConstraint;
+            const resultWithMaxWidth = this.getResultWithMaxWidth(resultToUse, widgetContainerWidth);
+            this._widgetPackResult$.next(resultWithMaxWidth);
+        });
+    }
+    getPackResult(binsToFit, maxWidth, maxHeight) {
+        return pack(binsToFit, {
+            maxWidth,
+            ...(maxHeight && { maxHeight }),
+        });
+    }
+    checkIfPackResultExceedsBoundary(result, maxWidth) {
+        return !!result.items.find(item => item.width + item.x > maxWidth);
+    }
+    getAmountOfMinWidthColumns(containerWidth) {
+        return Math.floor(containerWidth / WIDGET_1X_MIN_WIDTH);
+    }
+    getWidget1xWidth(containerWidth, amountOfMinWidthColumns) {
+        const widget1xWidth = Math.floor(containerWidth / (amountOfMinWidthColumns || 1));
+        return widget1xWidth;
+    }
+    getResultWithMaxWidth(result, containerWidth) {
+        return {
+            ...result,
+            items: result.items.map(item => ({
+                ...item,
+                width: item.width > containerWidth ? containerWidth : item.width,
+            })),
+        };
+    }
+    getHeightConstraint(binsToFit, amountOfMinWidthColumns) {
+        const amountOfSpacesNeeded = binsToFit.reduce((acc, curr) => acc + curr.height * curr.width, 0);
+        const minAmountOfRowsNeeded = Math.ceil(amountOfSpacesNeeded / amountOfMinWidthColumns);
+        const tallestWidgetHeightSpace = binsToFit.reduce((acc, curr) => (curr.height > acc ? curr.height : acc), 0);
+        const amountOfRowsNeeded = minAmountOfRowsNeeded < tallestWidgetHeightSpace
+            ? tallestWidgetHeightSpace
+            : minAmountOfRowsNeeded;
+        return amountOfRowsNeeded * WIDGET_1X_HEIGHT;
+    }
+}
+WidgetLayoutService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WidgetLayoutService, deps: [{ token: i1.WidgetService }], target: i0.ɵɵFactoryTarget.Injectable });
+WidgetLayoutService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WidgetLayoutService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WidgetLayoutService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.WidgetService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-layout.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/dashboard/src/lib/services/widget-layout.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Injectable, OnDestroy} from '@angular/core';\nimport {BehaviorSubject, combineLatest, filter, map, Observable, Subscription} from 'rxjs';\nimport {WidgetService} from './widget.service';\nimport {DashboardWidgetConfiguration, PackResult, WidgetConfigurationBin} from '../models';\nimport {WIDGET_1X_HEIGHT, WIDGET_1X_MIN_WIDTH} from '../constants';\nimport pack from 'bin-pack-with-constraints';\n\n@Injectable()\nexport class WidgetLayoutService implements OnDestroy {\n  private readonly _widgetContainerWidth$ = new BehaviorSubject<number | null>(null);\n  private readonly _widgetConfigurations$ = new BehaviorSubject<\n    Array<DashboardWidgetConfiguration>\n  >([]);\n  private readonly _widgetPackResult$ = new BehaviorSubject<PackResult | null>(null);\n\n  private _layoutSubscription!: Subscription;\n\n  public get widgetPackResult$(): Observable<PackResult> {\n    return this._widgetPackResult$.asObservable().pipe(filter(result => !!result));\n  }\n\n  private get widgetContainerWidth$(): Observable<number> {\n    return this._widgetContainerWidth$.asObservable().pipe(filter(width => !!width));\n  }\n\n  private get widgetConfigurationBins$(): Observable<Array<WidgetConfigurationBin>> {\n    return combineLatest([\n      this.widgetService.supportedDisplayTypes$,\n      this._widgetConfigurations$,\n    ]).pipe(\n      map(([displayTypes, configurations]) =>\n        configurations.map(configuration => {\n          const specification = displayTypes.find(\n            type => type.displayTypeKey === configuration.displayType\n          );\n          return {\n            configurationKey: configuration.key,\n            width: specification.width,\n            height: specification.height,\n          };\n        })\n      )\n    );\n  }\n\n  constructor(private readonly widgetService: WidgetService) {\n    this.openLayoutSubscription();\n  }\n\n  ngOnDestroy(): void {\n    this._layoutSubscription?.unsubscribe();\n  }\n\n  setWidgetContainerWidth(width: number): void {\n    this._widgetContainerWidth$.next(width);\n  }\n\n  setWidgetConfigurations(configurations: Array<DashboardWidgetConfiguration>): void {\n    this._widgetConfigurations$.next(configurations);\n  }\n\n  private openLayoutSubscription(): void {\n    this._layoutSubscription = combineLatest([\n      this.widgetContainerWidth$,\n      this.widgetConfigurationBins$,\n    ]).subscribe(([widgetContainerWidth, configurationBins]) => {\n      const amountOfMinWidthColumns = this.getAmountOfMinWidthColumns(widgetContainerWidth);\n      const widget1xWidth = this.getWidget1xWidth(widgetContainerWidth, amountOfMinWidthColumns);\n      const binsToFit = configurationBins.map(configurationBin => ({\n        ...configurationBin,\n        width: configurationBin.width * widget1xWidth,\n        height: configurationBin.height * WIDGET_1X_HEIGHT,\n      }));\n      const heightConstraint = this.getHeightConstraint(configurationBins, amountOfMinWidthColumns);\n      const resultWithoutHeightConstraint = this.getPackResult(binsToFit, widgetContainerWidth);\n      const resultWithHeightConstraint = this.getPackResult(\n        binsToFit,\n        widgetContainerWidth,\n        heightConstraint\n      );\n      const resultWithHeightConstraintExceedsBoundary = this.checkIfPackResultExceedsBoundary(\n        resultWithHeightConstraint,\n        widgetContainerWidth\n      );\n      const resultToUse = resultWithHeightConstraintExceedsBoundary\n        ? resultWithoutHeightConstraint\n        : resultWithHeightConstraint;\n      const resultWithMaxWidth = this.getResultWithMaxWidth(resultToUse, widgetContainerWidth);\n\n      this._widgetPackResult$.next(resultWithMaxWidth);\n    });\n  }\n\n  private getPackResult(\n    binsToFit: Array<WidgetConfigurationBin>,\n    maxWidth: number,\n    maxHeight?: number\n  ): PackResult {\n    return pack(binsToFit, {\n      maxWidth,\n      ...(maxHeight && {maxHeight}),\n    });\n  }\n\n  private checkIfPackResultExceedsBoundary(result: PackResult, maxWidth: number): boolean {\n    return !!result.items.find(item => item.width + item.x > maxWidth);\n  }\n\n  private getAmountOfMinWidthColumns(containerWidth: number): number {\n    return Math.floor(containerWidth / WIDGET_1X_MIN_WIDTH);\n  }\n\n  private getWidget1xWidth(containerWidth: number, amountOfMinWidthColumns: number): number {\n    const widget1xWidth = Math.floor(containerWidth / (amountOfMinWidthColumns || 1));\n\n    return widget1xWidth;\n  }\n\n  private getResultWithMaxWidth(result: PackResult, containerWidth: number): PackResult {\n    return {\n      ...result,\n      items: result.items.map(item => ({\n        ...item,\n        width: item.width > containerWidth ? containerWidth : item.width,\n      })),\n    };\n  }\n\n  private getHeightConstraint(\n    binsToFit: Array<WidgetConfigurationBin>,\n    amountOfMinWidthColumns: number\n  ): number {\n    const amountOfSpacesNeeded = binsToFit.reduce((acc, curr) => acc + curr.height * curr.width, 0);\n    const minAmountOfRowsNeeded = Math.ceil(amountOfSpacesNeeded / amountOfMinWidthColumns);\n    const tallestWidgetHeightSpace = binsToFit.reduce(\n      (acc, curr) => (curr.height > acc ? curr.height : acc),\n      0\n    );\n    const amountOfRowsNeeded =\n      minAmountOfRowsNeeded < tallestWidgetHeightSpace\n        ? tallestWidgetHeightSpace\n        : minAmountOfRowsNeeded;\n\n    return amountOfRowsNeeded * WIDGET_1X_HEIGHT;\n  }\n}\n"]}

package/esm2020/lib/services/widget-translation.service.mjs

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "./widget.service";
+export class WidgetTranslationService {
+    constructor(translateService, widgetService) {
+        this.translateService = translateService;
+        this.widgetService = widgetService;
+    }
+    translate(translateKey, key) {
+        return combineLatest([
+            this.widgetService.supportedDisplayTypes$,
+            this.widgetService.supportedDataSources$,
+            this.translateService.stream('key'),
+        ]).pipe(map(([supportedDisplayTypes, supportedDataSources]) => this.getTranslation(supportedDisplayTypes, supportedDataSources, key, translateKey)));
+    }
+    instant(translateKey, displayTypeKey) {
+        return this.getTranslation(this.widgetService.supportedDisplayTypes, this.widgetService.supportedDataSources, displayTypeKey, translateKey);
+    }
+    getTranslation(supportedDisplayTypes, supportedDataSources, key, translateKey) {
+        const currentLang = this.translateService.currentLang;
+        const displayTypeSpecification = supportedDisplayTypes.find(displayType => displayType.displayTypeKey === key);
+        const dataSourceSpecification = supportedDataSources.find(datasource => datasource.dataSourceKey === key);
+        let translation = '';
+        if (displayTypeSpecification &&
+            displayTypeSpecification.translations.hasOwnProperty(currentLang)) {
+            translation = displayTypeSpecification.translations[currentLang][translateKey];
+        }
+        else if (dataSourceSpecification &&
+            dataSourceSpecification.translations.hasOwnProperty(currentLang)) {
+            translation = dataSourceSpecification.translations[currentLang][translateKey];
+        }
+        return translation || `${key}.${translateKey}`;
+    }
+}
+WidgetTranslationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WidgetTranslationService, deps: [{ token: i1.TranslateService }, { token: i2.WidgetService }], target: i0.ɵɵFactoryTarget.Injectable });
+WidgetTranslationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WidgetTranslationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WidgetTranslationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.WidgetService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/widget.service.mjs

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Inject, Injectable } from '@angular/core';
+import { DATA_SOURCE_TOKEN, DISPLAY_TYPE_TOKEN } from '../constants';
+import { BehaviorSubject, filter } from 'rxjs';
+import * as i0 from "@angular/core";
+export class WidgetService {
+    constructor(supportedDisplayTypesFromToken, supportedDataSourcesFromToken) {
+        this.supportedDisplayTypesFromToken = supportedDisplayTypesFromToken;
+        this.supportedDataSourcesFromToken = supportedDataSourcesFromToken;
+        this._supportedDisplayTypes$ = new BehaviorSubject(null);
+        this._supportedDataSources$ = new BehaviorSubject(null);
+        this.setSupportedDisplayTypes(supportedDisplayTypesFromToken);
+        this.setSupportedDataSources(supportedDataSourcesFromToken);
+    }
+    get supportedDisplayTypes$() {
+        return this._supportedDisplayTypes$.pipe(filter(specifications => !!specifications));
+    }
+    get supportedDataSources$() {
+        return this._supportedDataSources$.pipe(filter(specifications => !!specifications));
+    }
+    get supportedDisplayTypes() {
+        return this._supportedDisplayTypes$.getValue() || [];
+    }
+    get supportedDataSources() {
+        return this._supportedDataSources$.getValue() || [];
+    }
+    setSupportedDisplayTypes(supportedDisplayTypes) {
+        this._supportedDisplayTypes$.next(supportedDisplayTypes.filter(displayType => !!displayType));
+    }
+    setSupportedDataSources(supportedDataSources) {
+        this._supportedDataSources$.next(supportedDataSources.filter(dataSource => !!dataSource));
+    }
+}
+WidgetService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WidgetService, deps: [{ token: DISPLAY_TYPE_TOKEN }, { token: DATA_SOURCE_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+WidgetService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WidgetService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WidgetService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: Array, decorators: [{
+                    type: Inject,
+                    args: [DISPLAY_TYPE_TOKEN]
+                }] }, { type: Array, decorators: [{
+                    type: Inject,
+                    args: [DATA_SOURCE_TOKEN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/public_api.mjs

@@ -16,6 +16,14 @@
 /*
  * Public API Surface of dashboard
  */
-export * from './lib/dashboard.component';
+export * from './lib/components/dashboard/dashboard.component';
+export * from './lib/components/widget-dashboard-content/widget-dashboard-content.component';
+export * from './lib/components/widget-dashboard/widget-dashboard.component';
+export * from './lib/constants';
 export * from './lib/dashboard.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vZGFzaGJvYXJkL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUg7O0dBRUc7QUFFSCxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMyBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG4vKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGRhc2hib2FyZFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2Rhc2hib2FyZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZGFzaGJvYXJkLm1vZHVsZSc7XG4iXX0=
+export * from './lib/data-sources';
+export * from './lib/display-types';
+export * from './lib/models';
+export * from './lib/pipes';
+export * from './lib/services';
+//# sourceMappingURL=data:application/json;base64,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