nuxeo-development-framework 5.6.4 → 5.6.5

package/esm2015/lib/components/reports/ndf-reports/services/chart-data-transformers.service.js

@@ -0,0 +1,119 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ChartDataTransformers {
+    constructor() {
+        this.graphTransformers = new Map();
+        this.digitsTransformers = new Map();
+    }
+    /**
+     * Registers a graph Transformer function with the specified key
+     * @param key The unique identifier for the Transformer
+     * @param Transformer The Transformer function that transforms data into StatisticBucket[]
+     */
+    registerGraphTransformer(key, Transformer) {
+        this.graphTransformers.set(key, Transformer);
+    }
+    /**
+     * Gets all registered graph Transformers
+     * @returns A map of all registered graph Transformers
+     */
+    getGraphTransformers() {
+        return this.graphTransformers;
+    }
+    /**
+     * Gets all registered digits Transformers
+     * @returns A map of all registered digits Transformers
+     */
+    getDigitsTransformers() {
+        return this.digitsTransformers;
+    }
+    /**
+     * Gets a graph Transformer function by its key
+     * @param key The unique identifier for the Transformer
+     * @returns The Transformer function or undefined if not found
+     */
+    getGraphTransformer(key) {
+        const transformer = this.graphTransformers.get(key);
+        if (!transformer) {
+            console.error(`Transformer '${key}' not registered `);
+        }
+        return transformer;
+    }
+    /**
+     * Registers a digits Transformer function with the specified key
+     * @param key The unique identifier for the Transformer
+     * @param Transformer The Transformer function that transforms data into a number
+     */
+    registerDigitsTransformer(key, Transformer) {
+        this.digitsTransformers.set(key, Transformer);
+    }
+    /**
+     * Gets a digits Transformer function by its key
+     * @param key The unique identifier for the Transformer
+     * @returns The Transformer function or undefined if not found
+     */
+    getDigitsTransformer(key) {
+        const transformer = this.digitsTransformers.get(key);
+        if (!transformer) {
+            console.error(`Transformer '${key}' not registered `);
+        }
+        return transformer;
+    }
+    /**
+     * Registers multiple graph Transformers at once using a key-value object
+     * @param Transformers An object containing key-Transformer pairs to register
+     */
+    registerGraphTransformers(Transformers) {
+        Object.entries(Transformers).forEach(([key, Transformer]) => {
+            this.graphTransformers.set(key, Transformer);
+        });
+    }
+    /**
+     * Registers multiple digits Transformers at once using a key-value object
+     * @param Transformers An object containing key-Transformer pairs to register
+     */
+    registerDigitsTransformers(Transformers) {
+        Object.entries(Transformers).forEach(([key, Transformer]) => {
+            this.digitsTransformers.set(key, Transformer);
+        });
+    }
+    /**
+     * Checks if a graph Transformer exists with the specified key
+     * @param key The unique identifier for the Transformer
+     * @returns True if the Transformer exists, false otherwise
+     */
+    hasGraphTransformer(key) {
+        return this.graphTransformers.has(key);
+    }
+    /**
+     * Checks if a digits Transformer exists with the specified key
+     * @param key The unique identifier for the Transformer
+     * @returns True if the Transformer exists, false otherwise
+     */
+    hasDigitsTransformer(key) {
+        return this.digitsTransformers.has(key);
+    }
+    /**
+     * Deletes a graph Transformer with the specified key
+     * @param key The unique identifier for the Transformer to delete
+     * @returns True if the Transformer was deleted, false if it didn't exist
+     */
+    deleteGraphTransformer(key) {
+        return this.graphTransformers.delete(key);
+    }
+    /**
+     * Deletes a digits Transformer with the specified key
+     * @param key The unique identifier for the Transformer to delete
+     * @returns True if the Transformer was deleted, false if it didn't exist
+     */
+    deleteDigitsTransformer(key) {
+        return this.digitsTransformers.delete(key);
+    }
+}
+ChartDataTransformers.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartDataTransformers, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ChartDataTransformers.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartDataTransformers, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartDataTransformers, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-data-transformers.service.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/reports/ndf-reports/services/chart-data-transformers.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAqB3C,MAAM,OAAO,qBAAqB;IADlC;QAEkB,sBAAiB,GAAG,IAAI,GAAG,EAA4B,CAAC;QACxD,uBAAkB,GAAG,IAAI,GAAG,EAA4B,CAAC;KAqH1E;IAnHA;;;;OAIG;IACH,wBAAwB,CAAC,GAAW,EAAE,WAA6B;QAClE,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACH,oBAAoB;QACnB,OAAO,IAAI,CAAC,iBAA0D,CAAC;IACxE,CAAC;IAED;;;OAGG;IACH,qBAAqB;QACpB,OAAO,IAAI,CAAC,kBAA2D,CAAC;IACzE,CAAC;IAED;;;;OAIG;IACH,mBAAmB,CAAC,GAAW;QAC9B,MAAM,WAAW,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpD,IAAI,CAAC,WAAW,EAAE;YACjB,OAAO,CAAC,KAAK,CAAC,gBAAgB,GAAG,mBAAmB,CAAC,CAAC;SACtD;QACD,OAAO,WAAW,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACH,yBAAyB,CAAC,GAAW,EAAE,WAA6B;QACnE,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACH,oBAAoB,CAAC,GAAW;QAC7B,MAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACrD,IAAI,CAAC,WAAW,EAAE;YAChB,OAAO,CAAC,KAAK,CAAC,gBAAgB,GAAG,mBAAmB,CAAC,CAAC;SACvD;QACD,OAAO,WAAW,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,yBAAyB,CAAC,YAA8C;QACvE,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,WAAW,CAAC,EAAE,EAAE;YAC3D,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,0BAA0B,CAAC,YAA8C;QACxE,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,WAAW,CAAC,EAAE,EAAE;YAC3D,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,mBAAmB,CAAC,GAAW;QAC9B,OAAO,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACxC,CAAC;IAED;;;;OAIG;IACH,oBAAoB,CAAC,GAAW;QAC/B,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACzC,CAAC;IAED;;;;OAIG;IACH,sBAAsB,CAAC,GAAW;QACjC,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC3C,CAAC;IAED;;;;OAIG;IACH,uBAAuB,CAAC,GAAW;QAClC,OAAO,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC5C,CAAC;;mHAtHW,qBAAqB;uHAArB,qBAAqB,cADR,MAAM;4FACnB,qBAAqB;kBADjC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { StatisticBucket } from '../../charts';\r\nimport { CriteriaModel } from '../models';\r\n\r\n/**\r\n *\r\n */\r\nexport type DigitTransformer = (data: any, response?: any, filterCriteria?: CriteriaModel) => number;\r\n\r\n/**\r\n *\r\n */\r\nexport type GraphTransformer = (\r\n\tdata: any,\r\n\tresponse?: any,\r\n\tfilterCriteria?: CriteriaModel,\r\n\tcurrentLanguage?: string\r\n) => StatisticBucket[];\r\n\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class ChartDataTransformers {\r\n\tprivate readonly graphTransformers = new Map<string, GraphTransformer>();\r\n\tprivate readonly digitsTransformers = new Map<string, DigitTransformer>();\r\n\r\n\t/**\r\n\t * Registers a graph Transformer function with the specified key\r\n\t * @param key The unique identifier for the Transformer\r\n\t * @param Transformer The Transformer function that transforms data into StatisticBucket[]\r\n\t */\r\n\tregisterGraphTransformer(key: string, Transformer: GraphTransformer): void {\r\n\t\tthis.graphTransformers.set(key, Transformer);\r\n\t}\r\n\r\n\t/**\r\n\t * Gets all registered graph Transformers\r\n\t * @returns A map of all registered graph Transformers\r\n\t */\r\n\tgetGraphTransformers() {\r\n\t\treturn this.graphTransformers as ReadonlyMap<string, GraphTransformer>;\r\n\t}\r\n\r\n\t/**\r\n\t * Gets all registered digits Transformers\r\n\t * @returns A map of all registered digits Transformers\r\n\t */\r\n\tgetDigitsTransformers() {\r\n\t\treturn this.digitsTransformers as ReadonlyMap<string, DigitTransformer>;\r\n\t}\r\n\r\n\t/**\r\n\t * Gets a graph Transformer function by its key\r\n\t * @param key The unique identifier for the Transformer\r\n\t * @returns The Transformer function or undefined if not found\r\n\t */\r\n\tgetGraphTransformer(key: string): GraphTransformer | undefined {\r\n\t\tconst transformer = this.graphTransformers.get(key);\r\n\t\tif (!transformer) {\r\n\t\t\tconsole.error(`Transformer '${key}' not registered `);\r\n\t\t}\r\n\t\treturn transformer;\r\n\t}\r\n\r\n\t/**\r\n\t * Registers a digits Transformer function with the specified key\r\n\t * @param key The unique identifier for the Transformer\r\n\t * @param Transformer The Transformer function that transforms data into a number\r\n\t */\r\n\tregisterDigitsTransformer(key: string, Transformer: DigitTransformer): void {\r\n\t\tthis.digitsTransformers.set(key, Transformer);\r\n\t}\r\n\r\n\t/**\r\n\t * Gets a digits Transformer function by its key\r\n\t * @param key The unique identifier for the Transformer\r\n\t * @returns The Transformer function or undefined if not found\r\n\t */\r\n\tgetDigitsTransformer(key: string): DigitTransformer | undefined {\r\n    const transformer = this.digitsTransformers.get(key);\r\n    if (!transformer) {\r\n      console.error(`Transformer '${key}' not registered `);\r\n    }\r\n    return transformer;\r\n\t}\r\n\r\n\t/**\r\n\t * Registers multiple graph Transformers at once using a key-value object\r\n\t * @param Transformers An object containing key-Transformer pairs to register\r\n\t */\r\n\tregisterGraphTransformers(Transformers: Record<string, GraphTransformer>): void {\r\n\t\tObject.entries(Transformers).forEach(([key, Transformer]) => {\r\n\t\t\tthis.graphTransformers.set(key, Transformer);\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Registers multiple digits Transformers at once using a key-value object\r\n\t * @param Transformers An object containing key-Transformer pairs to register\r\n\t */\r\n\tregisterDigitsTransformers(Transformers: Record<string, DigitTransformer>): void {\r\n\t\tObject.entries(Transformers).forEach(([key, Transformer]) => {\r\n\t\t\tthis.digitsTransformers.set(key, Transformer);\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Checks if a graph Transformer exists with the specified key\r\n\t * @param key The unique identifier for the Transformer\r\n\t * @returns True if the Transformer exists, false otherwise\r\n\t */\r\n\thasGraphTransformer(key: string): boolean {\r\n\t\treturn this.graphTransformers.has(key);\r\n\t}\r\n\r\n\t/**\r\n\t * Checks if a digits Transformer exists with the specified key\r\n\t * @param key The unique identifier for the Transformer\r\n\t * @returns True if the Transformer exists, false otherwise\r\n\t */\r\n\thasDigitsTransformer(key: string): boolean {\r\n\t\treturn this.digitsTransformers.has(key);\r\n\t}\r\n\r\n\t/**\r\n\t * Deletes a graph Transformer with the specified key\r\n\t * @param key The unique identifier for the Transformer to delete\r\n\t * @returns True if the Transformer was deleted, false if it didn't exist\r\n\t */\r\n\tdeleteGraphTransformer(key: string): boolean {\r\n\t\treturn this.graphTransformers.delete(key);\r\n\t}\r\n\r\n\t/**\r\n\t * Deletes a digits Transformer with the specified key\r\n\t * @param key The unique identifier for the Transformer to delete\r\n\t * @returns True if the Transformer was deleted, false if it didn't exist\r\n\t */\r\n\tdeleteDigitsTransformer(key: string): boolean {\r\n\t\treturn this.digitsTransformers.delete(key);\r\n\t}\r\n}\r\n"]}

package/esm2015/lib/components/reports/ndf-reports/services/chart-manager.service.js

@@ -0,0 +1,160 @@
+import { __awaiter } from "tslib";
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { Chart } from 'chart.js/auto';
+import * as moment from 'moment';
+import { ChartPlugins } from '../../charts';
+import _ from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class ChartManagerService {
+    constructor(_translateService, _document) {
+        this._translateService = _translateService;
+        this._document = _document;
+        this._charts = new Map();
+    }
+    setChart(chart) {
+        this._charts.set(chart.id, chart);
+    }
+    getChart(id) {
+        return this._charts.get(id);
+    }
+    resizeCharts() {
+        this._charts.forEach((chart) => {
+            if (chart.canvas && chart.canvas.ownerDocument) {
+                chart.resize();
+            }
+        });
+    }
+    destroy(id) {
+        const _chart = this._charts.get(id);
+        if (_chart) {
+            _chart.destroy();
+            this._charts.delete(id);
+        }
+    }
+    destroyAll() {
+        this._charts.forEach((chart) => {
+            chart.destroy();
+        });
+        this._charts.clear();
+    }
+    printChart(id, label, options = {}, plugins = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _chart = this._charts.get(id);
+            if (!_chart) {
+                return;
+            }
+            const _tempColors = {
+                color: Chart.defaults.color,
+                backgroundColor: Chart.defaults.backgroundColor,
+                borderColor: Chart.defaults.borderColor
+            };
+            this._setDefaultsColors({
+                color: 'black',
+                backgroundColor: 'rgba(0,0,0,0.1)',
+                borderColor: 'rgba(0,0,0,0.1)'
+            });
+            const { chart, destroy: destroyTempChart } = yield this._createHiddenCanvasForExport(_chart, label, options, plugins);
+            if (!chart) {
+                return;
+            }
+            const imageLink = this._document.createElement('a');
+            const date = moment().format('YYYY-MM-DD_HH-mm-ss');
+            imageLink.href = chart.canvas.toDataURL('image/jpeg', 0.9);
+            imageLink.download = `${label}-${date}.jpg`;
+            imageLink.click();
+            destroyTempChart();
+            this._setDefaultsColors(_tempColors);
+        });
+    }
+    _createHiddenCanvasForExport(chart, label, options = {}, plugins = []) {
+        const currentLang = this._translateService.currentLang;
+        return new Promise((resolve) => {
+            var _a;
+            const padding = 40;
+            const hiddenCanvas = this._document.createElement('canvas');
+            const [width, height] = [1024, 600];
+            hiddenCanvas.style.width = `${width}px`;
+            hiddenCanvas.style.height = `${height}px`;
+            hiddenCanvas.width = width;
+            hiddenCanvas.height = height;
+            hiddenCanvas.id = 'hiddenCanvas';
+            this._document.body.appendChild(hiddenCanvas);
+            const hiddenChart = new Chart(hiddenCanvas, {
+                type: (_a = chart.config) === null || _a === void 0 ? void 0 : _a.type,
+                data: chart.config.data,
+                options: _.merge({}, chart.config.options, {
+                    animation: false,
+                    responsive: false,
+                    layout: {
+                        padding: padding
+                    },
+                    plugins: Object.assign(Object.assign({}, chart.config.options.plugins), { title: {
+                            display: true,
+                            text: label,
+                            padding: {
+                                top: 0,
+                                bottom: 30
+                            }
+                        }, legend: {
+                            display: true,
+                            rtl: currentLang == 'ar',
+                            position: currentLang == 'ar' ? 'right' : 'left'
+                        } })
+                }, 'scales' in chart.config.options
+                    ? {
+                        scales: {
+                            x: { grid: { color: '#888' }, ticks: { color: '#222' }, title: { color: '#222' } },
+                            y: { grid: { color: '#888' }, ticks: { color: '#222' }, title: { color: '#222' } }
+                        }
+                    }
+                    : {}, options),
+                plugins: _.merge([], [
+                    ChartPlugins.chartDataLabels,
+                    {
+                        id: 'canvasBackgroundColor',
+                        beforeDraw: (chart, args, options) => {
+                            const { ctx } = chart;
+                            ctx.save();
+                            ctx.globalCompositeOperation = 'destination-over';
+                            ctx.fillStyle = 'white';
+                            ctx.fillRect(0, 0, chart.width, chart.height);
+                            ctx.restore();
+                        }
+                    },
+                    {
+                        id: 'onReady',
+                        afterRender: function (chart, options) {
+                            resolve({
+                                chart: chart,
+                                destroy: () => {
+                                    chart.destroy();
+                                    document.body.removeChild(hiddenCanvas);
+                                }
+                            });
+                        }
+                    }
+                ], plugins)
+            });
+            hiddenChart.render();
+        });
+    }
+    _setDefaultsColors(colors) {
+        Chart.defaults.color = colors.color;
+        Chart.defaults.backgroundColor = colors.backgroundColor;
+        Chart.defaults.borderColor = colors.borderColor;
+    }
+}
+ChartManagerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartManagerService, deps: [{ token: i1.TranslateService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+ChartManagerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartManagerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-manager.service.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/reports/ndf-reports/services/chart-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\r\nimport { Inject, Injectable } from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { Chart, Plugin } from 'chart.js/auto';\r\nimport * as moment from 'moment';\r\nimport { ChartConfiguration } from 'chart.js/dist/types';\r\nimport { ChartPlugins } from '../../charts';\r\nimport _ from 'lodash';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class ChartManagerService {\r\n\tprivate _charts = new Map<string | number, Chart>();\r\n\r\n\tconstructor(\r\n\t\tprivate _translateService: TranslateService,\r\n\t\t@Inject(DOCUMENT) private _document: Document\r\n\t) {}\r\n\r\n\tsetChart(chart: Chart) {\r\n\t\tthis._charts.set(chart.id, chart);\r\n\t}\r\n\r\n\tgetChart(id: string | number): Chart {\r\n\t\treturn this._charts.get(id);\r\n\t}\r\n\r\n\tresizeCharts() {\r\n\t\tthis._charts.forEach((chart) => {\r\n\t\t\tif (chart.canvas && chart.canvas.ownerDocument) {\r\n\t\t\t\tchart.resize();\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tdestroy(id: string | number) {\r\n\t\tconst _chart = this._charts.get(id);\r\n\t\tif (_chart) {\r\n\t\t\t_chart.destroy();\r\n\t\t\tthis._charts.delete(id);\r\n\t\t}\r\n\t}\r\n\r\n\tdestroyAll() {\r\n\t\tthis._charts.forEach((chart) => {\r\n\t\t\tchart.destroy();\r\n\t\t});\r\n\t\tthis._charts.clear();\r\n\t}\r\n\r\n\tasync printChart(id: string | number, label: string, options: Record<string, any> = {}, plugins: Plugin<any>[] = []) {\r\n\t\tconst _chart = this._charts.get(id);\r\n\t\tif (!_chart) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst _tempColors = {\r\n\t\t\tcolor: Chart.defaults.color,\r\n\t\t\tbackgroundColor: Chart.defaults.backgroundColor,\r\n\t\t\tborderColor: Chart.defaults.borderColor\r\n\t\t};\r\n\r\n\t\tthis._setDefaultsColors({\r\n\t\t\tcolor: 'black',\r\n\t\t\tbackgroundColor: 'rgba(0,0,0,0.1)',\r\n\t\t\tborderColor: 'rgba(0,0,0,0.1)'\r\n\t\t});\r\n\r\n\t\tconst { chart, destroy: destroyTempChart } = await this._createHiddenCanvasForExport(\r\n\t\t\t_chart,\r\n\t\t\tlabel,\r\n\t\t\toptions,\r\n\t\t\tplugins\r\n\t\t);\r\n\t\tif (!chart) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst imageLink = this._document.createElement('a');\r\n\t\tconst date = moment().format('YYYY-MM-DD_HH-mm-ss');\r\n\t\timageLink.href = chart.canvas.toDataURL('image/jpeg', 0.9);\r\n\t\timageLink.download = `${label}-${date}.jpg`;\r\n\t\timageLink.click();\r\n\t\tdestroyTempChart();\r\n\r\n\t\tthis._setDefaultsColors(_tempColors);\r\n\t}\r\n\r\n\tprivate _createHiddenCanvasForExport(\r\n\t\tchart: Chart,\r\n\t\tlabel: string,\r\n\t\toptions: Record<string, any> = {},\r\n\t\tplugins: Plugin<any>[] = []\r\n\t) {\r\n\t\tconst currentLang = this._translateService.currentLang;\r\n\r\n\t\treturn new Promise<{ chart: Chart; destroy: () => void }>((resolve) => {\r\n\t\t\tconst padding = 40;\r\n\r\n\t\t\tconst hiddenCanvas = this._document.createElement('canvas');\r\n\t\t\tconst [width, height] = [1024, 600];\r\n\r\n\t\t\thiddenCanvas.style.width = `${width}px`;\r\n\t\t\thiddenCanvas.style.height = `${height}px`;\r\n\t\t\thiddenCanvas.width = width;\r\n\t\t\thiddenCanvas.height = height;\r\n\t\t\thiddenCanvas.id = 'hiddenCanvas';\r\n\r\n\t\t\tthis._document.body.appendChild(hiddenCanvas);\r\n\r\n\t\t\tconst hiddenChart = new Chart(hiddenCanvas, {\r\n\t\t\t\ttype: (chart.config as ChartConfiguration)?.type,\r\n\t\t\t\tdata: chart.config.data,\r\n\t\t\t\toptions: _.merge(\r\n\t\t\t\t\t{},\r\n\t\t\t\t\tchart.config.options,\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tanimation: false,\r\n\t\t\t\t\t\tresponsive: false,\r\n\t\t\t\t\t\tlayout: {\r\n\t\t\t\t\t\t\tpadding: padding\r\n\t\t\t\t\t\t},\r\n\t\t\t\t\t\tplugins: {\r\n\t\t\t\t\t\t\t...chart.config.options.plugins,\r\n\t\t\t\t\t\t\ttitle: {\r\n\t\t\t\t\t\t\t\tdisplay: true,\r\n\t\t\t\t\t\t\t\ttext: label,\r\n\t\t\t\t\t\t\t\tpadding: {\r\n\t\t\t\t\t\t\t\t\ttop: 0,\r\n\t\t\t\t\t\t\t\t\tbottom: 30\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t},\r\n\t\t\t\t\t\t\tlegend: {\r\n\t\t\t\t\t\t\t\tdisplay: true,\r\n\t\t\t\t\t\t\t\trtl: currentLang == 'ar',\r\n\t\t\t\t\t\t\t\tposition: currentLang == 'ar' ? 'right' : 'left'\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\t\t\t\t\t'scales' in chart.config.options\r\n\t\t\t\t\t\t? {\r\n\t\t\t\t\t\t\t\tscales: {\r\n\t\t\t\t\t\t\t\t\tx: { grid: { color: '#888' }, ticks: { color: '#222' }, title: { color: '#222' } },\r\n\t\t\t\t\t\t\t\t\ty: { grid: { color: '#888' }, ticks: { color: '#222' }, title: { color: '#222' } }\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t: {},\r\n\t\t\t\t\toptions\r\n\t\t\t\t),\r\n\t\t\t\tplugins: _.merge(\r\n\t\t\t\t\t[],\r\n\t\t\t\t\t[\r\n\t\t\t\t\t\tChartPlugins.chartDataLabels,\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tid: 'canvasBackgroundColor',\r\n\t\t\t\t\t\t\tbeforeDraw: (chart, args, options) => {\r\n\t\t\t\t\t\t\t\tconst { ctx } = chart;\r\n\t\t\t\t\t\t\t\tctx.save();\r\n\t\t\t\t\t\t\t\tctx.globalCompositeOperation = 'destination-over';\r\n\t\t\t\t\t\t\t\tctx.fillStyle = 'white';\r\n\t\t\t\t\t\t\t\tctx.fillRect(0, 0, chart.width, chart.height);\r\n\t\t\t\t\t\t\t\tctx.restore();\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t},\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tid: 'onReady',\r\n\t\t\t\t\t\t\tafterRender: function (chart, options) {\r\n\t\t\t\t\t\t\t\tresolve({\r\n\t\t\t\t\t\t\t\t\tchart: chart,\r\n\t\t\t\t\t\t\t\t\tdestroy: () => {\r\n\t\t\t\t\t\t\t\t\t\tchart.destroy();\r\n\t\t\t\t\t\t\t\t\t\tdocument.body.removeChild(hiddenCanvas);\r\n\t\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t],\r\n\t\t\t\t\tplugins\r\n\t\t\t\t)\r\n\t\t\t});\r\n\t\t\thiddenChart.render();\r\n\t\t});\r\n\t}\r\n\r\n\tprivate _setDefaultsColors(colors: { color: any; backgroundColor: any; borderColor: any }) {\r\n\t\tChart.defaults.color = colors.color;\r\n\t\tChart.defaults.backgroundColor = colors.backgroundColor;\r\n\t\tChart.defaults.borderColor = colors.borderColor;\r\n\t}\r\n}\r\n"]}

package/esm2015/lib/components/reports/ndf-reports/services/chart-plugins-registry.service.js

@@ -0,0 +1,61 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ChartPluginsRegistry {
+    constructor() {
+        this._plugins = new Map();
+    }
+    register(key, plugin) {
+        if (typeof key === 'object') {
+            Object.entries(key).forEach(([key, fn]) => this._plugins.set(key, fn));
+            return;
+        }
+        if (typeof key === 'string' && plugin) {
+            this._plugins.set(key, plugin);
+        }
+    }
+    /**
+     * Returns all registered chart plugins as a read-only map.
+     *
+     * @returns {ReadonlyMap<string, Plugin<ChartType>>} A map of plugin keys to plugin instances.
+     */
+    getAll() {
+        return this._plugins;
+    }
+    /**
+     * Check if a plugin exists with the given key
+     * @param key The plugin key to check
+     * @returns True if the plugin exists, false otherwise
+     */
+    has(key) {
+        return this._plugins.has(key);
+    }
+    /**
+     * Get a plugin by its key
+     * @param key The key of the plugin to retrieve
+     * @returns The plugin instance or undefined if not found
+     */
+    get(key) {
+        const plugin = this._plugins.get(key);
+        if (!plugin) {
+            console.error(`Plugin with key '${key}' not found.`);
+        }
+        return plugin;
+    }
+    /**
+     * Remove a plugin by its key
+     * @param key The key of the plugin to remove
+     * @returns True if the plugin was removed, false if it didn't exist
+     */
+    delete(key) {
+        return this._plugins.delete(key);
+    }
+}
+ChartPluginsRegistry.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartPluginsRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ChartPluginsRegistry.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartPluginsRegistry, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartPluginsRegistry, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhcnQtcGx1Z2lucy1yZWdpc3RyeS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbnV4ZW8tZGV2ZWxvcG1lbnQtZnJhbWV3b3JrL3NyYy9saWIvY29tcG9uZW50cy9yZXBvcnRzL25kZi1yZXBvcnRzL3NlcnZpY2VzL2NoYXJ0LXBsdWdpbnMtcmVnaXN0cnkuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU0zQyxNQUFNLE9BQU8sb0JBQW9CO0lBSGpDO1FBSWtCLGFBQVEsR0FBbUMsSUFBSSxHQUFHLEVBQUUsQ0FBQztLQTREdEU7SUFqREEsUUFBUSxDQUFDLEdBQStDLEVBQUUsTUFBMEI7UUFDbkYsSUFBSSxPQUFPLEdBQUcsS0FBSyxRQUFRLEVBQUU7WUFDNUIsTUFBTSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUM7WUFDdkUsT0FBTztTQUNQO1FBRUQsSUFBSSxPQUFPLEdBQUcsS0FBSyxRQUFRLElBQUksTUFBTSxFQUFFO1lBQ3RDLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxNQUFNLENBQUMsQ0FBQztTQUMvQjtJQUNGLENBQUM7SUFFRDs7OztPQUlHO0lBQ0ksTUFBTTtRQUNaLE9BQU8sSUFBSSxDQUFDLFFBQWtELENBQUM7SUFDaEUsQ0FBQztJQUNEOzs7O09BSUc7SUFDSSxHQUFHLENBQUMsR0FBVztRQUNyQixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQy9CLENBQUM7SUFFRDs7OztPQUlHO0lBQ0ksR0FBRyxDQUFDLEdBQVc7UUFDckIsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDdEMsSUFBSSxDQUFDLE1BQU0sRUFBRTtZQUNaLE9BQU8sQ0FBQyxLQUFLLENBQUMsb0JBQW9CLEdBQUcsY0FBYyxDQUFDLENBQUM7U0FDckQ7UUFDRCxPQUFPLE1BQU0sQ0FBQztJQUNmLENBQUM7SUFFRDs7OztPQUlHO0lBQ0ksTUFBTSxDQUFDLEdBQVc7UUFDeEIsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNsQyxDQUFDOztrSEE1RFcsb0JBQW9CO3NIQUFwQixvQkFBb0IsY0FGcEIsTUFBTTs0RkFFTixvQkFBb0I7a0JBSGhDLFVBQVU7bUJBQUM7b0JBQ1gsVUFBVSxFQUFFLE1BQU07aUJBQ2xCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBDaGFydFR5cGUsIFBsdWdpbiB9IGZyb20gJ2NoYXJ0LmpzJztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuXHRwcm92aWRlZEluOiAncm9vdCdcclxufSlcclxuZXhwb3J0IGNsYXNzIENoYXJ0UGx1Z2luc1JlZ2lzdHJ5IHtcclxuXHRwcml2YXRlIHJlYWRvbmx5IF9wbHVnaW5zOiBNYXA8c3RyaW5nLCBQbHVnaW48Q2hhcnRUeXBlPj4gPSBuZXcgTWFwKCk7XHJcblxyXG5cdC8qKlxyXG5cdCAqIFJlZ2lzdGVyIGEgcGx1Z2luIG9yIG11bHRpcGxlIHBsdWdpbnMuXHJcblx0ICpcclxuXHQgKiBAcGFyYW0ge3N0cmluZyB8IFJlY29yZDxzdHJpbmcsIFBsdWdpbjxDaGFydFR5cGU+Pn0ga2V5IC0gVGhlIGtleSBvZiB0aGUgcGx1Z2luIHRvIHJlZ2lzdGVyIG9yIGFuIG9iamVjdCBjb250YWluaW5nIG11bHRpcGxlIHBsdWdpbnMuXHJcblx0ICogQHBhcmFtIHtQbHVnaW48Q2hhcnRUeXBlPn0gW3BsdWdpbl0gLSBUaGUgcGx1Z2luIGluc3RhbmNlIHRvIHJlZ2lzdGVyIChpZiBga2V5YCBpcyBhIHN0cmluZykuXHJcblx0ICogQHJldHVybnMge3ZvaWR9XHJcblx0ICovXHJcblx0cmVnaXN0ZXIoa2V5OiBzdHJpbmcsIHBsdWdpbjogUGx1Z2luPENoYXJ0VHlwZT4pOiB2b2lkO1xyXG5cdHJlZ2lzdGVyKHBsdWdpbnM6IFJlY29yZDxzdHJpbmcsIFBsdWdpbjxDaGFydFR5cGU+Pik6IHZvaWQ7XHJcblx0cmVnaXN0ZXIoa2V5OiBzdHJpbmcgfCBSZWNvcmQ8c3RyaW5nLCBQbHVnaW48Q2hhcnRUeXBlPj4sIHBsdWdpbj86IFBsdWdpbjxDaGFydFR5cGU+KTogdm9pZCB7XHJcblx0XHRpZiAodHlwZW9mIGtleSA9PT0gJ29iamVjdCcpIHtcclxuXHRcdFx0T2JqZWN0LmVudHJpZXMoa2V5KS5mb3JFYWNoKChba2V5LCBmbl0pID0+IHRoaXMuX3BsdWdpbnMuc2V0KGtleSwgZm4pKTtcclxuXHRcdFx0cmV0dXJuO1xyXG5cdFx0fVxyXG5cclxuXHRcdGlmICh0eXBlb2Yga2V5ID09PSAnc3RyaW5nJyAmJiBwbHVnaW4pIHtcclxuXHRcdFx0dGhpcy5fcGx1Z2lucy5zZXQoa2V5LCBwbHVnaW4pO1xyXG5cdFx0fVxyXG5cdH1cclxuXHJcblx0LyoqXHJcblx0ICogUmV0dXJucyBhbGwgcmVnaXN0ZXJlZCBjaGFydCBwbHVnaW5zIGFzIGEgcmVhZC1vbmx5IG1hcC5cclxuXHQgKlxyXG5cdCAqIEByZXR1cm5zIHtSZWFkb25seU1hcDxzdHJpbmcsIFBsdWdpbjxDaGFydFR5cGU+Pn0gQSBtYXAgb2YgcGx1Z2luIGtleXMgdG8gcGx1Z2luIGluc3RhbmNlcy5cclxuXHQgKi9cclxuXHRwdWJsaWMgZ2V0QWxsKCkge1xyXG5cdFx0cmV0dXJuIHRoaXMuX3BsdWdpbnMgYXMgUmVhZG9ubHlNYXA8c3RyaW5nLCBQbHVnaW48Q2hhcnRUeXBlPj47XHJcblx0fVxyXG5cdC8qKlxyXG5cdCAqIENoZWNrIGlmIGEgcGx1Z2luIGV4aXN0cyB3aXRoIHRoZSBnaXZlbiBrZXlcclxuXHQgKiBAcGFyYW0ga2V5IFRoZSBwbHVnaW4ga2V5IHRvIGNoZWNrXHJcblx0ICogQHJldHVybnMgVHJ1ZSBpZiB0aGUgcGx1Z2luIGV4aXN0cywgZmFsc2Ugb3RoZXJ3aXNlXHJcblx0ICovXHJcblx0cHVibGljIGhhcyhrZXk6IHN0cmluZyk6IGJvb2xlYW4ge1xyXG5cdFx0cmV0dXJuIHRoaXMuX3BsdWdpbnMuaGFzKGtleSk7XHJcblx0fVxyXG5cclxuXHQvKipcclxuXHQgKiBHZXQgYSBwbHVnaW4gYnkgaXRzIGtleVxyXG5cdCAqIEBwYXJhbSBrZXkgVGhlIGtleSBvZiB0aGUgcGx1Z2luIHRvIHJldHJpZXZlXHJcblx0ICogQHJldHVybnMgVGhlIHBsdWdpbiBpbnN0YW5jZSBvciB1bmRlZmluZWQgaWYgbm90IGZvdW5kXHJcblx0ICovXHJcblx0cHVibGljIGdldChrZXk6IHN0cmluZyk6IFBsdWdpbjxDaGFydFR5cGU+IHtcclxuXHRcdGNvbnN0IHBsdWdpbiA9IHRoaXMuX3BsdWdpbnMuZ2V0KGtleSk7XHJcblx0XHRpZiAoIXBsdWdpbikge1xyXG5cdFx0XHRjb25zb2xlLmVycm9yKGBQbHVnaW4gd2l0aCBrZXkgJyR7a2V5fScgbm90IGZvdW5kLmApO1xyXG5cdFx0fVxyXG5cdFx0cmV0dXJuIHBsdWdpbjtcclxuXHR9XHJcblxyXG5cdC8qKlxyXG5cdCAqIFJlbW92ZSBhIHBsdWdpbiBieSBpdHMga2V5XHJcblx0ICogQHBhcmFtIGtleSBUaGUga2V5IG9mIHRoZSBwbHVnaW4gdG8gcmVtb3ZlXHJcblx0ICogQHJldHVybnMgVHJ1ZSBpZiB0aGUgcGx1Z2luIHdhcyByZW1vdmVkLCBmYWxzZSBpZiBpdCBkaWRuJ3QgZXhpc3RcclxuXHQgKi9cclxuXHRwdWJsaWMgZGVsZXRlKGtleTogc3RyaW5nKTogYm9vbGVhbiB7XHJcblx0XHRyZXR1cm4gdGhpcy5fcGx1Z2lucy5kZWxldGUoa2V5KTtcclxuXHR9XHJcbn1cclxuIl19

package/esm2015/lib/components/reports/ndf-reports/services/chart-theme.service.js

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ChartThemeService {
+    constructor() {
+        this.currentTheme = new BehaviorSubject('light');
+        this.theme$ = this.currentTheme.asObservable();
+        this._initializeThemeDetection();
+    }
+    getCurrentTheme() {
+        return this._getThemeFromBody();
+    }
+    destroy() {
+        if (this.observer) {
+            this.observer.disconnect();
+        }
+    }
+    _initializeThemeDetection() {
+        const initialTheme = this._getThemeFromBody();
+        if (initialTheme !== this.currentTheme.value) {
+            this.currentTheme.next(initialTheme);
+        }
+        this._setupThemeWatcher();
+    }
+    _getThemeFromBody() {
+        const bodyTheme = document.body.getAttribute('data-theme');
+        return bodyTheme === 'dark' || bodyTheme === 'light' ? bodyTheme : 'light';
+    }
+    _setupThemeWatcher() {
+        this.observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type === 'attributes' && mutation.attributeName === 'data-theme') {
+                    const newTheme = this._getThemeFromBody();
+                    if (newTheme !== this.currentTheme.value) {
+                        this.currentTheme.next(newTheme);
+                    }
+                }
+            });
+        });
+        this.observer.observe(document.body, {
+            attributes: true,
+            attributeFilter: ['data-theme']
+        });
+    }
+}
+ChartThemeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ChartThemeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartThemeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/reports/ndf-reports/services/custom-reports-registry.service.js

@@ -0,0 +1,132 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CustomReportsRegistry {
+    constructor(_factoryResolver) {
+        this._factoryResolver = _factoryResolver;
+        this._components = new Map();
+    }
+    /**
+     * Register a component with the registry
+     * @param config Component configuration
+     */
+    registerComponent(config) {
+        if (!config.type || !config.component) {
+            throw new Error('Invalid component configuration: type and component are required');
+        }
+        if (this._components.has(config.type)) {
+            console.warn(`Component with type '${config.type}' is already registered. Overwriting...`);
+        }
+        this._components.set(config.type, config);
+    }
+    /**
+     * Register multiple components at once
+     * @param configs Array of component configurations
+     */
+    registerComponents(configs) {
+        configs.forEach((config) => this.registerComponent(config));
+    }
+    /**
+     * Render a component by type into a ViewContainerRef
+     * @param type Component type identifier
+     * @param vcr ViewContainerRef to render into
+     */
+    renderComponent(type, vcr) {
+        if (!this._components.has(type)) {
+            throw new Error(`Unknown component with type: '${type}'`);
+        }
+        const config = this._components.get(type);
+        return this.loadComponent(config, vcr);
+    }
+    /**
+     * Load a component into a ViewContainerRef
+     * @param config Component configuration
+     * @param vcr ViewContainerRef to render into
+     */
+    loadComponent(config, vcr) {
+        const componentFactory = this._factoryResolver.resolveComponentFactory(config.component);
+        return vcr.createComponent(componentFactory);
+    }
+    /**
+     * Check if a component is registered
+     * @param type Component type identifier
+     */
+    hasComponent(type) {
+        return this._components.has(type);
+    }
+    /**
+     * Get component configuration by type
+     * @param type Component type identifier
+     */
+    getComponent(type) {
+        return this._components.get(type);
+    }
+    /**
+     * Get all registered component types
+     */
+    getComponentTypes() {
+        return Array.from(this._components.keys());
+    }
+    /**
+     * Get all registered components
+     */
+    getAllComponents() {
+        return Array.from(this._components.values());
+    }
+    /**
+     * Get components by category
+     * @param category Category to filter by
+     */
+    getComponentsByCategory(category) {
+        return Array.from(this._components.values()).filter((config) => config.category === category);
+    }
+    /**
+     * Get all unique categories
+     */
+    getCategories() {
+        const categories = Array.from(this._components.values())
+            .map((config) => config.category)
+            .filter((category) => !!category);
+        return [...new Set(categories)];
+    }
+    /**
+     * Unregister a component
+     * @param type Component type identifier
+     */
+    unregisterComponent(type) {
+        return this._components.delete(type);
+    }
+    /**
+     * Clear all registered components
+     */
+    clearComponents() {
+        this._components.clear();
+    }
+    /**
+     * Get the total number of registered components
+     */
+    getComponentCount() {
+        return this._components.size;
+    }
+    /**
+     * Search components by name or type
+     * @param searchTerm Search term
+     */
+    searchComponents(searchTerm) {
+        const term = searchTerm.toLowerCase();
+        return Array.from(this._components.values()).filter((config) => {
+            var _a, _b;
+            return config.type.toLowerCase().includes(term) ||
+                ((_a = config.name) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes(term)) ||
+                ((_b = config.description) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes(term));
+        });
+    }
+}
+CustomReportsRegistry.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CustomReportsRegistry, deps: [{ token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Injectable });
+CustomReportsRegistry.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CustomReportsRegistry, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CustomReportsRegistry, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-reports-registry.service.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/reports/ndf-reports/services/custom-reports-registry.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentFactoryResolver, Injectable, Type, ViewContainerRef, ComponentRef } from '@angular/core';\r\nimport { ComponentType } from '@angular/cdk/portal';\r\n\r\nexport interface CustomReportRegistryDefinition {\r\n\ttype: string; // Using 'type' as the unique identifier\r\n\tcomponent: ComponentType<any>;\r\n\tcategory?: string;\r\n\tname?: string;\r\n\tdescription?: string;\r\n}\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class CustomReportsRegistry {\r\n\tprivate readonly _components = new Map<string, CustomReportRegistryDefinition>();\r\n\r\n\tconstructor(private _factoryResolver: ComponentFactoryResolver) {}\r\n\r\n\t/**\r\n\t * Register a component with the registry\r\n\t * @param config Component configuration\r\n\t */\r\n\tregisterComponent(config: CustomReportRegistryDefinition): void {\r\n\t\tif (!config.type || !config.component) {\r\n\t\t\tthrow new Error('Invalid component configuration: type and component are required');\r\n\t\t}\r\n\r\n\t\tif (this._components.has(config.type)) {\r\n\t\t\tconsole.warn(`Component with type '${config.type}' is already registered. Overwriting...`);\r\n\t\t}\r\n\r\n\t\tthis._components.set(config.type, config);\r\n\t}\r\n\r\n\t/**\r\n\t * Register multiple components at once\r\n\t * @param configs Array of component configurations\r\n\t */\r\n\tregisterComponents(configs: CustomReportRegistryDefinition[]): void {\r\n\t\tconfigs.forEach((config) => this.registerComponent(config));\r\n\t}\r\n\r\n\t/**\r\n\t * Render a component by type into a ViewContainerRef\r\n\t * @param type Component type identifier\r\n\t * @param vcr ViewContainerRef to render into\r\n\t */\r\n\trenderComponent(type: string, vcr: ViewContainerRef): ComponentRef<any> {\r\n\t\tif (!this._components.has(type)) {\r\n\t\t\tthrow new Error(`Unknown component with type: '${type}'`);\r\n\t\t}\r\n\r\n\t\tconst config = this._components.get(type)!;\r\n\t\treturn this.loadComponent(config, vcr);\r\n\t}\r\n\r\n\t/**\r\n\t * Load a component into a ViewContainerRef\r\n\t * @param config Component configuration\r\n\t * @param vcr ViewContainerRef to render into\r\n\t */\r\n\tloadComponent(config: CustomReportRegistryDefinition, vcr: ViewContainerRef): ComponentRef<any> {\r\n\t\tconst componentFactory = this._factoryResolver.resolveComponentFactory(config.component);\r\n\t\treturn vcr.createComponent(componentFactory);\r\n\t}\r\n\r\n\t/**\r\n\t * Check if a component is registered\r\n\t * @param type Component type identifier\r\n\t */\r\n\thasComponent(type: string): boolean {\r\n\t\treturn this._components.has(type);\r\n\t}\r\n\r\n\t/**\r\n\t * Get component configuration by type\r\n\t * @param type Component type identifier\r\n\t */\r\n\tgetComponent(type: string): CustomReportRegistryDefinition | undefined {\r\n\t\treturn this._components.get(type);\r\n\t}\r\n\r\n\t/**\r\n\t * Get all registered component types\r\n\t */\r\n\tgetComponentTypes(): string[] {\r\n\t\treturn Array.from(this._components.keys());\r\n\t}\r\n\r\n\t/**\r\n\t * Get all registered components\r\n\t */\r\n\tgetAllComponents(): CustomReportRegistryDefinition[] {\r\n\t\treturn Array.from(this._components.values());\r\n\t}\r\n\r\n\t/**\r\n\t * Get components by category\r\n\t * @param category Category to filter by\r\n\t */\r\n\tgetComponentsByCategory(category: string): CustomReportRegistryDefinition[] {\r\n\t\treturn Array.from(this._components.values()).filter((config) => config.category === category);\r\n\t}\r\n\r\n\t/**\r\n\t * Get all unique categories\r\n\t */\r\n\tgetCategories(): string[] {\r\n\t\tconst categories = Array.from(this._components.values())\r\n\t\t\t.map((config) => config.category)\r\n\t\t\t.filter((category): category is string => !!category);\r\n\r\n\t\treturn [...new Set(categories)];\r\n\t}\r\n\r\n\t/**\r\n\t * Unregister a component\r\n\t * @param type Component type identifier\r\n\t */\r\n\tunregisterComponent(type: string): boolean {\r\n\t\treturn this._components.delete(type);\r\n\t}\r\n\r\n\t/**\r\n\t * Clear all registered components\r\n\t */\r\n\tclearComponents(): void {\r\n\t\tthis._components.clear();\r\n\t}\r\n\r\n\t/**\r\n\t * Get the total number of registered components\r\n\t */\r\n\tgetComponentCount(): number {\r\n\t\treturn this._components.size;\r\n\t}\r\n\r\n\t/**\r\n\t * Search components by name or type\r\n\t * @param searchTerm Search term\r\n\t */\r\n\tsearchComponents(searchTerm: string): CustomReportRegistryDefinition[] {\r\n\t\tconst term = searchTerm.toLowerCase();\r\n\t\treturn Array.from(this._components.values()).filter(\r\n\t\t\t(config) =>\r\n\t\t\t\tconfig.type.toLowerCase().includes(term) ||\r\n\t\t\t\tconfig.name?.toLowerCase().includes(term) ||\r\n\t\t\t\tconfig.description?.toLowerCase().includes(term)\r\n\t\t);\r\n\t}\r\n}\r\n"]}