@smartbit4all/ng-client 5.0.21 → 6.0.1

package/esm2022/lib/smart-diagram/component/smart-diagram.component.mjs

@@ -0,0 +1,359 @@
+import { Component, EventEmitter, Inject, Input, Optional, Output, ViewChild, } from '@angular/core';
+import { Chart } from 'chart.js';
+import AnnotationPlugin from 'chartjs-plugin-annotation';
+import ZoomPlugin from 'chartjs-plugin-zoom';
+import { COMPONENT_LIBRARY, ComponentLibrary } from '../../view-context/utility/componentLibrary';
+import { lastValueFrom } from 'rxjs';
+import { deepMerge } from './smart-diagram.util';
+import { SmartStyleUtility } from '../../view-context/utility/smart-style-utility';
+import * as i0 from "@angular/core";
+import * as i1 from "../api";
+import * as i2 from "./default-smart-diagram-options.provider";
+import * as i3 from "@angular/common";
+import * as i4 from "primeng/chart";
+import * as i5 from "../../view-context/utility/componentLibrary";
+export class SmartDiagramComponent {
+    constructor(diagramApi, diagramOptionProvider, compLib) {
+        this.diagramApi = diagramApi;
+        this.diagramOptionProvider = diagramOptionProvider;
+        this.plugins = [];
+        //Output events
+        this.elementSelect = new EventEmitter();
+        this.canvasClick = new EventEmitter();
+        this.dataClick = new EventEmitter();
+        this.componentLibrary = ComponentLibrary;
+        this.compLib = compLib ?? ComponentLibrary.PRIMENG;
+        Chart.register(AnnotationPlugin);
+        Chart.register(ZoomPlugin);
+    }
+    ngOnChanges(changes) {
+        if (changes['diagramModel']) {
+            this.diagramModel = changes['diagramModel'].currentValue;
+            this.setUp();
+        }
+        if (changes['uuid'] && this.uuid !== changes['uuid'].currentValue) {
+            this.uuid = changes['uuid'].currentValue;
+            this.load();
+        }
+    }
+    async load() {
+        if (this.uuid) {
+            this.diagramModel = await lastValueFrom(this.diagramApi.load(this.uuid, this.identifier));
+            this.setUp();
+        }
+    }
+    ngAfterViewInit() {
+        // This will run when we have an input model
+        if (!this.diagramModel) {
+            this.load();
+        }
+    }
+    ngOnInit() {
+        // This will run when we have an input model
+        this.setUp();
+    }
+    setUp() {
+        if (!this.diagramModel) {
+            return;
+        }
+        let options = undefined;
+        const type = !!this.diagramModel.descriptor?.type ? this.diagramModel.descriptor.type : '';
+        const factory = this.diagramOptionProvider.getFactory(type);
+        this.type = factory.chartJsType;
+        options = factory.createOptions(this.diagramModel.diagramData);
+        if (this.diagramModel.descriptor) {
+            options = deepMerge(this.convertBackendOptions(this.diagramModel.descriptor), options);
+        }
+        if (this.options) {
+            options = deepMerge(this.options, options);
+        }
+        this.options = options;
+        this.data = factory.transformData(this.diagramModel.diagramData);
+        this.applyChartClass();
+    }
+    convertBackendOptions(descriptor) {
+        const options = {
+            maintainAspectRatio: descriptor.maintainAspectRatio,
+            plugins: {
+                legend: {
+                    display: descriptor.showLegendForChart ?? true,
+                },
+                ...(descriptor.title
+                    ? {
+                        title: {
+                            display: true,
+                            text: descriptor.title.content ?? '',
+                            color: descriptor.title.color
+                                ? `rgba(${descriptor.title.color.red ?? 0},
+                       ${descriptor.title.color.green ?? 0},
+                       ${descriptor.title.color.blue ?? 0},
+                       ${descriptor.title.color.alpha ?? 1})`
+                                : '#000000ff',
+                            font: {
+                                size: descriptor.title.size ?? undefined,
+                                weight: descriptor.title.weight ?? undefined,
+                                style: descriptor.title.style ?? undefined,
+                                family: descriptor.title.family ?? undefined,
+                            },
+                        },
+                    }
+                    : {}),
+            },
+            scales: {},
+        };
+        if (descriptor.minX !== undefined && descriptor.maxX !== undefined) {
+            options.scales.x = {
+                ticks: {
+                    display: descriptor.showLabelsForXAxis ?? true,
+                },
+                min: descriptor.minX,
+                max: descriptor.maxX,
+            };
+        }
+        else {
+            options.scales.x = {
+                ticks: {
+                    display: descriptor.showLabelsForXAxis ?? true,
+                },
+            };
+        }
+        if (descriptor.minY !== undefined && descriptor.maxY !== undefined) {
+            options.scales.y = {
+                ticks: {
+                    display: descriptor.showLabelsForYAxis ?? true,
+                },
+                min: descriptor.minY,
+                max: descriptor.maxY,
+            };
+        }
+        else {
+            options.scales.y = {
+                ticks: {
+                    display: descriptor.showLabelsForYAxis ?? true,
+                },
+            };
+        }
+        //Create shapes
+        if (descriptor.shapes) {
+            descriptor.shapes.forEach((shape, index) => {
+                options.plugins.annotation = options.plugins.annotation || {};
+                options.plugins.annotation.annotations = options.plugins.annotation.annotations || {};
+                let borderColor = `rgba(
+         ${shape.borderColor?.red ?? 0},
+         ${shape.borderColor?.green ?? 0},
+         ${shape.borderColor?.blue ?? 0},
+         ${shape.borderColor?.alpha ?? 1})`;
+                let backgroundColor = `rgba(
+         ${shape.backgroundColor?.red ?? 0},
+         ${shape.backgroundColor?.green ?? 0},
+         ${shape.backgroundColor?.blue ?? 0},
+         ${shape.backgroundColor?.alpha ?? 1})`;
+                let fontColor = `rgba(
+         ${shape.labelText?.color?.red ?? 0},
+         ${shape.labelText?.color?.green ?? 0},
+         ${shape.labelText?.color?.blue ?? 0},
+         ${shape.labelText?.color?.alpha ?? 1})`;
+                let borderDash;
+                if (shape.borderDashLength && shape.borderDashGap) {
+                    borderDash = [shape.borderDashLength, shape.borderDashGap];
+                }
+                else {
+                    borderDash = undefined;
+                }
+                const baseAnnotation = {
+                    type: shape.shapeType ?? 'line',
+                    backgroundColor: backgroundColor ?? undefined,
+                    borderColor: borderColor ?? undefined,
+                    borderWidth: shape.borderWidth ?? 1,
+                    borderDash: borderDash ?? undefined,
+                    drawTime: shape.drawTime ?? undefined,
+                };
+                switch (shape.shapeType) {
+                    case 'box':
+                    case 'line':
+                    case 'ellipse':
+                        options.plugins.annotation.annotations[`shape${index}`] = {
+                            ...baseAnnotation,
+                            xMin: shape.xMin ?? undefined,
+                            xMax: shape.xMax ?? undefined,
+                            yMin: shape.yMin ?? undefined,
+                            yMax: shape.yMax ?? undefined,
+                        };
+                        break;
+                    case 'label':
+                        options.plugins.annotation.annotations[`shape${index}`] = {
+                            ...baseAnnotation,
+                            xValue: shape.xMin ?? undefined,
+                            yValue: shape.yMin ?? undefined,
+                            content: shape.labelText?.content ?? undefined,
+                            textAlign: shape.labelText?.textAlign ?? undefined,
+                            color: fontColor ?? undefined,
+                            font: {
+                                size: shape.labelText?.size ?? undefined,
+                                weight: shape.labelText?.weight ?? undefined,
+                                style: shape.labelText?.style ?? undefined,
+                            },
+                            backgroundColor: 'transparent',
+                            borderColor: 'transparent',
+                        };
+                        break;
+                    case 'point':
+                    case 'polygon':
+                        options.plugins.annotation.annotations[`shape${index}`] = {
+                            ...baseAnnotation,
+                            xValue: shape.xMin ?? undefined,
+                            yValue: shape.yMin ?? undefined,
+                        };
+                        break;
+                    default:
+                        // Optionally handle any other shape types
+                        console.warn(`Unknown shape type: ${shape.shapeType}`);
+                        break;
+                }
+            });
+        }
+        if (descriptor.backgroundColor) {
+            let backgroundColor = `rgba(
+        ${descriptor.backgroundColor?.red ?? 0},
+        ${descriptor.backgroundColor?.green ?? 0},
+        ${descriptor.backgroundColor?.blue ?? 0},
+        ${descriptor.backgroundColor?.alpha ?? 1})`;
+            let id = 'customCanvasBackgroundColor';
+            const plugin = {
+                id: id,
+                beforeDraw: (chart, args, options) => {
+                    const { ctx, chartArea } = chart;
+                    ctx.save();
+                    ctx.globalCompositeOperation = 'destination-over';
+                    ctx.fillStyle = backgroundColor;
+                    ctx.fillRect(chartArea.left, chartArea.top, chartArea.right - chartArea.left, chartArea.bottom - chartArea.top);
+                    ctx.restore();
+                },
+            };
+            this.plugins.push(plugin);
+            options.plugins[`${id}`] = {
+                color: backgroundColor,
+            };
+        }
+        return options;
+    }
+    onDataSelect(event) {
+        console.log({ event });
+        this.elementSelect.emit(event);
+    }
+    handleChartClick(event) {
+        console.log({ event });
+        this.canvasClick.emit(event);
+    }
+    handleOnDataClicked(event) {
+        const canvas = event.target;
+        const chart = Chart.getChart(canvas);
+        if (chart) {
+            const elements = chart.getElementsAtEventForMode(event, 'nearest', { intersect: true }, false);
+            if (elements.length === 0) {
+                return;
+            }
+            const clickedItems = chart.tooltip?.dataPoints?.map((item) => {
+                return {
+                    datasetIndex: item.datasetIndex,
+                    itemIndex: item.dataIndex,
+                    element: item.element,
+                };
+            });
+            console.log({ event, clickedItems });
+            this.dataClick.emit({ event, clickedItems });
+        }
+    }
+    getBase64Image() {
+        return this.chart?.getBase64Image();
+    }
+    refresh() {
+        return this.chart?.refresh();
+    }
+    getChart() {
+        return this.chart?.chart;
+    }
+    getVisiblePoints() {
+        if (!this.chart)
+            return;
+        const chartInstance = this.chart.chart;
+        if (!chartInstance)
+            return;
+        const visiblePoints = [];
+        chartInstance.data.datasets.forEach((dataset, datasetIndex) => {
+            const meta = chartInstance.getDatasetMeta(datasetIndex);
+            // Check if the dataset is hidden
+            if (!chartInstance.isDatasetVisible(datasetIndex)) {
+                return;
+            }
+            const xMin = meta.xScale.min;
+            const xMax = meta.xScale.max;
+            const yMin = meta.yScale.min;
+            const yMax = meta.yScale.max;
+            dataset.data.forEach((point, dataIndex) => {
+                const { x, y } = point;
+                if (x >= xMin && x <= xMax && y >= yMin && y <= yMax) {
+                    visiblePoints.push({
+                        datasetIndex,
+                        dataIndex,
+                        x,
+                        y,
+                    });
+                }
+            });
+        });
+        return visiblePoints;
+    }
+    applyChartClass() {
+        if (!this.chart) {
+            return;
+        }
+        const chartElement = this.chart.el.nativeElement;
+        switch (this.type) {
+            case 'pie':
+            case 'doughnut':
+            case 'polarArea':
+            case 'radar':
+                chartElement.classList.add('pie-aspect-ratio');
+                break;
+            default:
+                chartElement.classList.add('default-aspect-ratio');
+        }
+    }
+    calcStyle(style) {
+        return SmartStyleUtility.getNgStyles(style);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDiagramComponent, deps: [{ token: i1.DiagramServiceService }, { token: i2.DefaultChartOptionsProvider }, { token: COMPONENT_LIBRARY, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.11", type: SmartDiagramComponent, selector: "smart-diagram", inputs: { uuid: "uuid", identifier: "identifier", parent: "parent", diagramModel: "diagramModel", options: "options", plugins: "plugins" }, outputs: { elementSelect: "elementSelect", canvasClick: "canvasClick", dataClick: "dataClick" }, viewQueries: [{ propertyName: "chart", first: true, predicate: ["chartJSRef"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<!-- @if(compLib === componentLibrary.PRIMENG) { -->\n<p-chart\n  #chartJSRef\n  [type]=\"type\"\n  [data]=\"data\"\n  [options]=\"options\"\n  [plugins]=\"plugins\"\n  [ngStyle]=\"calcStyle(diagramModel?.descriptor?.style)\"\n  (onDataSelect)=\"onDataSelect($event)\"\n  (click)=\"handleChartClick($event)\"\n  (click)=\"handleOnDataClicked($event)\"\n/>\n\n<!-- } @else {\n<p>Only PrimeNg component library is supported</p>\n} -->\n", styles: [":host ::ng-deep .default-aspect-ratio div{width:100%;aspect-ratio:1.78}:host ::ng-deep .pie-aspect-ratio div{width:100%;aspect-ratio:1}:host ::ng-deep p-chart{display:flex}\n"], dependencies: [{ kind: "directive", type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: i4.UIChart, selector: "p-chart", inputs: ["type", "plugins", "width", "height", "responsive", "ariaLabel", "ariaLabelledBy", "data", "options"], outputs: ["onDataSelect"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDiagramComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'smart-diagram', template: "<!-- @if(compLib === componentLibrary.PRIMENG) { -->\n<p-chart\n  #chartJSRef\n  [type]=\"type\"\n  [data]=\"data\"\n  [options]=\"options\"\n  [plugins]=\"plugins\"\n  [ngStyle]=\"calcStyle(diagramModel?.descriptor?.style)\"\n  (onDataSelect)=\"onDataSelect($event)\"\n  (click)=\"handleChartClick($event)\"\n  (click)=\"handleOnDataClicked($event)\"\n/>\n\n<!-- } @else {\n<p>Only PrimeNg component library is supported</p>\n} -->\n", styles: [":host ::ng-deep .default-aspect-ratio div{width:100%;aspect-ratio:1.78}:host ::ng-deep .pie-aspect-ratio div{width:100%;aspect-ratio:1}:host ::ng-deep p-chart{display:flex}\n"] }]
+        }], ctorParameters: () => [{ type: i1.DiagramServiceService }, { type: i2.DefaultChartOptionsProvider }, { type: i5.ComponentLibrary, decorators: [{
+                    type: Inject,
+                    args: [COMPONENT_LIBRARY]
+                }, {
+                    type: Optional
+                }] }], propDecorators: { chart: [{
+                type: ViewChild,
+                args: ['chartJSRef']
+            }], uuid: [{
+                type: Input
+            }], identifier: [{
+                type: Input
+            }], parent: [{
+                type: Input
+            }], diagramModel: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], plugins: [{
+                type: Input
+            }], elementSelect: [{
+                type: Output
+            }], canvasClick: [{
+                type: Output
+            }], dataClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-diagram.component.js","sourceRoot":"","sources":["../../../../../../projects/smart-ng-client/src/lib/smart-diagram/component/smart-diagram.component.ts","../../../../../../projects/smart-ng-client/src/lib/smart-diagram/component/smart-diagram.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  EventEmitter,\n  Inject,\n  Input,\n  Optional,\n  Output,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport { Chart } from 'chart.js';\nimport { UIChart } from 'primeng/chart';\nimport AnnotationPlugin from 'chartjs-plugin-annotation';\nimport ZoomPlugin from 'chartjs-plugin-zoom';\nimport { DiagramModel, DiagramDescriptor, DiagramShape, DiagramServiceService } from '../api';\nimport { COMPONENT_LIBRARY, ComponentLibrary } from '../../view-context/utility/componentLibrary';\nimport { lastValueFrom } from 'rxjs';\nimport { deepMerge } from './smart-diagram.util';\nimport { DefaultChartOptionsProvider } from './default-smart-diagram-options.provider';\nimport { SmartStyleUtility } from '../../view-context/utility/smart-style-utility';\nimport { Style } from '../../view-context/api/model/style';\n\n@Component({\n  selector: 'smart-diagram',\n  templateUrl: './smart-diagram.component.html',\n  styleUrls: ['./smart-diagram.component.css'],\n})\nexport class SmartDiagramComponent {\n  @ViewChild('chartJSRef') chart?: UIChart;\n\n  //Widget inputs\n  @Input() uuid?: string;\n  @Input() identifier!: string;\n  @Input() parent?: any;\n\n  //Standalone inputs\n  @Input() diagramModel?: DiagramModel;\n  @Input() options?: any;\n  @Input() plugins: any[] = [];\n\n  //Output events\n  @Output() elementSelect = new EventEmitter<any>();\n  @Output() canvasClick = new EventEmitter<any>();\n  @Output() dataClick = new EventEmitter<any>();\n\n  data: any;\n  type: any;\n\n  compLib: ComponentLibrary;\n  componentLibrary = ComponentLibrary;\n\n  constructor(\n    private diagramApi: DiagramServiceService,\n    private diagramOptionProvider: DefaultChartOptionsProvider,\n    @Inject(COMPONENT_LIBRARY) @Optional() compLib?: ComponentLibrary\n  ) {\n    this.compLib = compLib ?? ComponentLibrary.PRIMENG;\n    Chart.register(AnnotationPlugin);\n    Chart.register(ZoomPlugin);\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['diagramModel']) {\n      this.diagramModel = changes['diagramModel'].currentValue;\n      this.setUp();\n    }\n    if (changes['uuid'] && this.uuid !== changes['uuid'].currentValue) {\n      this.uuid = changes['uuid'].currentValue;\n      this.load();\n    }\n  }\n\n  async load(): Promise<void> {\n    if (this.uuid) {\n      this.diagramModel = await lastValueFrom(this.diagramApi.load(this.uuid, this.identifier));\n      this.setUp();\n    }\n  }\n\n  ngAfterViewInit() {\n    // This will run when we have an input model\n    if (!this.diagramModel) {\n      this.load();\n    }\n  }\n\n  ngOnInit() {\n    // This will run when we have an input model\n    this.setUp();\n  }\n\n  private setUp() {\n    if (!this.diagramModel) {\n      return;\n    }\n    let options = undefined;\n    const type = !!this.diagramModel.descriptor?.type ? this.diagramModel.descriptor.type : '';\n\n    const factory = this.diagramOptionProvider.getFactory(type);\n    this.type = factory.chartJsType;\n    options = factory.createOptions(this.diagramModel.diagramData!);\n    if (this.diagramModel.descriptor) {\n      options = deepMerge(this.convertBackendOptions(this.diagramModel.descriptor), options);\n    }\n    if (this.options) {\n      options = deepMerge(this.options, options);\n    }\n\n    this.options = options;\n    this.data = factory.transformData(this.diagramModel.diagramData!);\n    this.applyChartClass();\n  }\n\n  private convertBackendOptions(descriptor: DiagramDescriptor) {\n    const options: any = {\n      maintainAspectRatio: descriptor.maintainAspectRatio,\n      plugins: {\n        legend: {\n          display: descriptor.showLegendForChart ?? true,\n        },\n        ...(descriptor.title\n          ? {\n              title: {\n                display: true,\n                text: descriptor.title.content ?? '',\n                color: descriptor.title.color\n                  ? `rgba(${descriptor.title.color.red ?? 0},\n                       ${descriptor.title.color.green ?? 0},\n                       ${descriptor.title.color.blue ?? 0},\n                       ${descriptor.title.color.alpha ?? 1})`\n                  : '#000000ff',\n                font: {\n                  size: descriptor.title.size ?? undefined,\n                  weight: descriptor.title.weight ?? undefined,\n                  style: descriptor.title.style ?? undefined,\n                  family: descriptor.title.family ?? undefined,\n                },\n              },\n            }\n          : {}),\n      },\n      scales: {} as any,\n    };\n\n    if (descriptor.minX !== undefined && descriptor.maxX !== undefined) {\n      options.scales.x = {\n        ticks: {\n          display: descriptor.showLabelsForXAxis ?? true,\n        },\n        min: descriptor.minX,\n        max: descriptor.maxX,\n      };\n    } else {\n      options.scales.x = {\n        ticks: {\n          display: descriptor.showLabelsForXAxis ?? true,\n        },\n      };\n    }\n    if (descriptor.minY !== undefined && descriptor.maxY !== undefined) {\n      options.scales.y = {\n        ticks: {\n          display: descriptor.showLabelsForYAxis ?? true,\n        },\n        min: descriptor.minY,\n        max: descriptor.maxY,\n      };\n    } else {\n      options.scales.y = {\n        ticks: {\n          display: descriptor.showLabelsForYAxis ?? true,\n        },\n      };\n    }\n\n    //Create shapes\n    if (descriptor.shapes) {\n      descriptor.shapes.forEach((shape: DiagramShape, index: number) => {\n        options.plugins.annotation = options.plugins.annotation || {};\n        options.plugins.annotation.annotations = options.plugins.annotation.annotations || {};\n\n        let borderColor = `rgba(\n         ${shape.borderColor?.red ?? 0},\n         ${shape.borderColor?.green ?? 0},\n         ${shape.borderColor?.blue ?? 0},\n         ${shape.borderColor?.alpha ?? 1})`;\n        let backgroundColor = `rgba(\n         ${shape.backgroundColor?.red ?? 0},\n         ${shape.backgroundColor?.green ?? 0},\n         ${shape.backgroundColor?.blue ?? 0},\n         ${shape.backgroundColor?.alpha ?? 1})`;\n\n        let fontColor = `rgba(\n         ${shape.labelText?.color?.red ?? 0},\n         ${shape.labelText?.color?.green ?? 0},\n         ${shape.labelText?.color?.blue ?? 0},\n         ${shape.labelText?.color?.alpha ?? 1})`;\n\n        let borderDash;\n        if (shape.borderDashLength && shape.borderDashGap) {\n          borderDash = [shape.borderDashLength, shape.borderDashGap];\n        } else {\n          borderDash = undefined;\n        }\n\n        const baseAnnotation = {\n          type: shape.shapeType ?? 'line',\n          backgroundColor: backgroundColor ?? undefined,\n          borderColor: borderColor ?? undefined,\n          borderWidth: shape.borderWidth ?? 1,\n          borderDash: borderDash ?? undefined,\n          drawTime: shape.drawTime ?? undefined,\n        };\n\n        switch (shape.shapeType) {\n          case 'box':\n          case 'line':\n          case 'ellipse':\n            options.plugins.annotation.annotations[`shape${index}`] = {\n              ...baseAnnotation,\n              xMin: shape.xMin ?? undefined,\n              xMax: shape.xMax ?? undefined,\n              yMin: shape.yMin ?? undefined,\n              yMax: shape.yMax ?? undefined,\n            };\n            break;\n\n          case 'label':\n            options.plugins.annotation.annotations[`shape${index}`] = {\n              ...baseAnnotation,\n              xValue: shape.xMin ?? undefined,\n              yValue: shape.yMin ?? undefined,\n              content: shape.labelText?.content ?? undefined,\n              textAlign: shape.labelText?.textAlign ?? undefined,\n              color: fontColor ?? undefined,\n              font: {\n                size: shape.labelText?.size ?? undefined,\n                weight: shape.labelText?.weight ?? undefined,\n                style: shape.labelText?.style ?? undefined,\n              },\n              backgroundColor: 'transparent',\n              borderColor: 'transparent',\n            };\n            break;\n\n          case 'point':\n          case 'polygon':\n            options.plugins.annotation.annotations[`shape${index}`] = {\n              ...baseAnnotation,\n              xValue: shape.xMin ?? undefined,\n              yValue: shape.yMin ?? undefined,\n            };\n            break;\n\n          default:\n            // Optionally handle any other shape types\n            console.warn(`Unknown shape type: ${shape.shapeType}`);\n            break;\n        }\n      });\n    }\n\n    if (descriptor.backgroundColor) {\n      let backgroundColor = `rgba(\n        ${descriptor.backgroundColor?.red ?? 0},\n        ${descriptor.backgroundColor?.green ?? 0},\n        ${descriptor.backgroundColor?.blue ?? 0},\n        ${descriptor.backgroundColor?.alpha ?? 1})`;\n\n      let id = 'customCanvasBackgroundColor';\n      const plugin = {\n        id: id,\n        beforeDraw: (chart: any, args: any, options: any) => {\n          const { ctx, chartArea } = chart;\n\n          ctx.save();\n          ctx.globalCompositeOperation = 'destination-over';\n          ctx.fillStyle = backgroundColor;\n          ctx.fillRect(\n            chartArea.left,\n            chartArea.top,\n            chartArea.right - chartArea.left,\n            chartArea.bottom - chartArea.top\n          );\n          ctx.restore();\n        },\n      };\n      this.plugins.push(plugin);\n\n      options.plugins[`${id}`] = {\n        color: backgroundColor,\n      };\n    }\n    return options;\n  }\n\n  onDataSelect(event: any) {\n    console.log({ event });\n    this.elementSelect.emit(event);\n  }\n\n  handleChartClick(event: any): void {\n    console.log({ event });\n    this.canvasClick.emit(event);\n  }\n\n  handleOnDataClicked(event: any): void {\n    const canvas = event.target as HTMLCanvasElement;\n    const chart = Chart.getChart(canvas);\n\n    if (chart) {\n      const elements = chart.getElementsAtEventForMode(\n        event,\n        'nearest',\n        { intersect: true },\n        false\n      );\n      if (elements.length === 0) {\n        return;\n      }\n      const clickedItems = chart.tooltip?.dataPoints?.map((item) => {\n        return {\n          datasetIndex: item.datasetIndex,\n          itemIndex: item.dataIndex,\n          element: item.element,\n        };\n      });\n\n      console.log({ event, clickedItems });\n      this.dataClick.emit({ event, clickedItems });\n    }\n  }\n\n  getBase64Image() {\n    return this.chart?.getBase64Image();\n  }\n\n  refresh() {\n    return this.chart?.refresh();\n  }\n\n  getChart() {\n    return this.chart?.chart;\n  }\n  getVisiblePoints() {\n    if (!this.chart) return;\n\n    const chartInstance = this.chart.chart;\n    if (!chartInstance) return;\n\n    const visiblePoints: any = [];\n\n    chartInstance.data.datasets.forEach((dataset: any, datasetIndex: any) => {\n      const meta = chartInstance.getDatasetMeta(datasetIndex);\n\n      // Check if the dataset is hidden\n      if (!chartInstance.isDatasetVisible(datasetIndex)) {\n        return;\n      }\n\n      const xMin = meta.xScale.min;\n      const xMax = meta.xScale.max;\n      const yMin = meta.yScale.min;\n      const yMax = meta.yScale.max;\n\n      dataset.data.forEach((point: any, dataIndex: number) => {\n        const { x, y } = point;\n\n        if (x >= xMin && x <= xMax && y >= yMin && y <= yMax) {\n          visiblePoints.push({\n            datasetIndex,\n            dataIndex,\n            x,\n            y,\n          });\n        }\n      });\n    });\n\n    return visiblePoints;\n  }\n\n  applyChartClass() {\n    if (!this.chart) {\n      return;\n    }\n\n    const chartElement = this.chart.el.nativeElement;\n    switch (this.type) {\n      case 'pie':\n      case 'doughnut':\n      case 'polarArea':\n      case 'radar':\n        chartElement.classList.add('pie-aspect-ratio');\n        break;\n      default:\n        chartElement.classList.add('default-aspect-ratio');\n    }\n  }\n\n  calcStyle(style?: Style): any {\n    return SmartStyleUtility.getNgStyles(style);\n  }\n}\n","<!-- @if(compLib === componentLibrary.PRIMENG) { -->\n<p-chart\n  #chartJSRef\n  [type]=\"type\"\n  [data]=\"data\"\n  [options]=\"options\"\n  [plugins]=\"plugins\"\n  [ngStyle]=\"calcStyle(diagramModel?.descriptor?.style)\"\n  (onDataSelect)=\"onDataSelect($event)\"\n  (click)=\"handleChartClick($event)\"\n  (click)=\"handleOnDataClicked($event)\"\n/>\n\n<!-- } @else {\n<p>Only PrimeNg component library is supported</p>\n} -->\n"]}

package/esm2022/lib/smart-diagram/component/smart-diagram.module.mjs

@@ -0,0 +1,40 @@
+import { NgModule } from '@angular/core';
+import { BrowserModule } from '@angular/platform-browser';
+import { ChartModule } from 'primeng/chart';
+import { DefaultChartOptionsProvider as DefaultDiagramOptionsProvider, CUSTOM_DIAGRAM_OPTIONS, barChart, scatterChart, bubbleChart, horizontalBarChart, stackedBarChart, multiAxisLineChart, polarAreaChart, radarChart, doughnutChart, pieChart, horizontalStackedBarChart, } from './default-smart-diagram-options.provider';
+import { SmartDiagramComponent } from './smart-diagram.component';
+import * as i0 from "@angular/core";
+const DEFAULT_PROVIDERS = [
+    DefaultDiagramOptionsProvider,
+    { provide: CUSTOM_DIAGRAM_OPTIONS, useValue: barChart, multi: true },
+    { provide: CUSTOM_DIAGRAM_OPTIONS, useValue: scatterChart, multi: true },
+    { provide: CUSTOM_DIAGRAM_OPTIONS, useValue: bubbleChart, multi: true },
+    { provide: CUSTOM_DIAGRAM_OPTIONS, useValue: horizontalBarChart, multi: true },
+    { provide: CUSTOM_DIAGRAM_OPTIONS, useValue: stackedBarChart, multi: true },
+    { provide: CUSTOM_DIAGRAM_OPTIONS, useValue: horizontalStackedBarChart, multi: true },
+    { provide: CUSTOM_DIAGRAM_OPTIONS, useValue: multiAxisLineChart, multi: true },
+    { provide: CUSTOM_DIAGRAM_OPTIONS, useValue: polarAreaChart, multi: true },
+    { provide: CUSTOM_DIAGRAM_OPTIONS, useValue: radarChart, multi: true },
+    { provide: CUSTOM_DIAGRAM_OPTIONS, useValue: doughnutChart, multi: true },
+    { provide: CUSTOM_DIAGRAM_OPTIONS, useValue: pieChart, multi: true },
+];
+export class SmartDiagramModule {
+    static forRoot(providers) {
+        return {
+            ngModule: SmartDiagramModule,
+            providers: [...DEFAULT_PROVIDERS, ...providers],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDiagramModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.11", ngImport: i0, type: SmartDiagramModule, declarations: [SmartDiagramComponent], imports: [BrowserModule, ChartModule], exports: [SmartDiagramComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDiagramModule, imports: [BrowserModule, ChartModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDiagramModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [SmartDiagramComponent],
+                    imports: [BrowserModule, ChartModule],
+                    exports: [SmartDiagramComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/smart-diagram/component/smart-diagram.util.mjs

@@ -0,0 +1,10 @@
+export function deepMerge(target, source) {
+    for (const key of Object.keys(source)) {
+        if (source[key] instanceof Object && target[key]) {
+            Object.assign(source[key], deepMerge(target[key], source[key]));
+        }
+    }
+    Object.assign(target || {}, source);
+    return target;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnQtZGlhZ3JhbS51dGlsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc21hcnQtbmctY2xpZW50L3NyYy9saWIvc21hcnQtZGlhZ3JhbS9jb21wb25lbnQvc21hcnQtZGlhZ3JhbS51dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxTQUFTLENBQUMsTUFBVyxFQUFFLE1BQVc7SUFDaEQsS0FBSyxNQUFNLEdBQUcsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7UUFDdEMsSUFBSSxNQUFNLENBQUMsR0FBRyxDQUFDLFlBQVksTUFBTSxJQUFJLE1BQU0sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO1lBQ2pELE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLEVBQUUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNsRSxDQUFDO0lBQ0gsQ0FBQztJQUNELE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxJQUFJLEVBQUUsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNwQyxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGRlZXBNZXJnZSh0YXJnZXQ6IGFueSwgc291cmNlOiBhbnkpOiBhbnkge1xuICBmb3IgKGNvbnN0IGtleSBvZiBPYmplY3Qua2V5cyhzb3VyY2UpKSB7XG4gICAgaWYgKHNvdXJjZVtrZXldIGluc3RhbmNlb2YgT2JqZWN0ICYmIHRhcmdldFtrZXldKSB7XG4gICAgICBPYmplY3QuYXNzaWduKHNvdXJjZVtrZXldLCBkZWVwTWVyZ2UodGFyZ2V0W2tleV0sIHNvdXJjZVtrZXldKSk7XG4gICAgfVxuICB9XG4gIE9iamVjdC5hc3NpZ24odGFyZ2V0IHx8IHt9LCBzb3VyY2UpO1xuICByZXR1cm4gdGFyZ2V0O1xufVxuIl19

package/esm2022/lib/smart-diagram/projects.mjs

@@ -0,0 +1,5 @@
+export * from './component/smart-diagram.module';
+export * from './component/smart-diagram.component';
+export * from './api/model/models';
+export * from './component/default-smart-diagram-options.provider';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zbWFydC1kaWFncmFtL3Byb2plY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsb0RBQW9ELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudC9zbWFydC1kaWFncmFtLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudC9zbWFydC1kaWFncmFtLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2FwaS9tb2RlbC9tb2RlbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnQvZGVmYXVsdC1zbWFydC1kaWFncmFtLW9wdGlvbnMucHJvdmlkZXInO1xuIl19

package/esm2022/lib/smart-dialog/projects.mjs

@@ -0,0 +1,8 @@
+/*
+ * Public API Surface of smartdialog
+ */
+export * from './smartdialog.service';
+export * from './smartdialog.component';
+export * from './smartdialog.module';
+export * from './smartdialog.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zbWFydC1kaWFsb2cvcHJvamVjdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBzbWFydGRpYWxvZ1xuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vc21hcnRkaWFsb2cuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NtYXJ0ZGlhbG9nLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3NtYXJ0ZGlhbG9nLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3NtYXJ0ZGlhbG9nLm1vZGVsJztcbiJdfQ==

package/esm2022/lib/smart-dialog/smartdialog.component.mjs

@@ -0,0 +1,54 @@
+import { Component, Inject, ViewChild, ViewContainerRef, } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import { SmartformComponent } from '../smart-form/smartform.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/common";
+import * as i3 from "../smart-form/smartform.component";
+import * as i4 from "../smart-table/smarttable.component";
+import * as i5 from "../smart-icon/smart-icon/smart-icon.component";
+export class SmartDialog {
+    constructor(dialogRef, data, resolver) {
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.resolver = resolver;
+    }
+    ngAfterViewInit() {
+        const factory = this.resolver.resolveComponentFactory(this.data.customComponent);
+        const ref = this.vcRef.createComponent(factory);
+        ref.changeDetectorRef.detectChanges();
+    }
+    onActionClick() {
+        const controls = this.smartFormComponent.getForm().controls;
+        for (const control in controls) {
+            if (controls[control].valid) {
+                const widget = this.data.form.widgets.find((k) => k.key === control);
+                if (widget) {
+                    widget.value = controls[control].value;
+                }
+            }
+        }
+        if (this.data.actionCallback) {
+            this.data.actionCallback([this.data]);
+        }
+    }
+    onNoClick() {
+        this.dialogRef.close();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDialog, deps: [{ token: i1.MatDialogRef }, { token: MAT_DIALOG_DATA }, { token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.11", type: SmartDialog, selector: "smartdialog", viewQueries: [{ propertyName: "smartFormComponent", first: true, predicate: SmartformComponent, descendants: true }, { propertyName: "vcRef", first: true, predicate: ["renderComponentHere"], descendants: true, read: ViewContainerRef }], ngImport: i0, template: "<div\n  class=\"dialog-container\"\n  [ngClass]=\"data.size.fullScreen ? 'fullScreen' : ''\"\n  [ngStyle]=\"{ width: data.size.width + 'px', height: data.size.height + 'px' }\"\n>\n  <div class=\"dialog-title-container\" mat-dialog-title>\n    <h1 class=\"dialog-title\">\n      {{ data.content.title }}\n    </h1>\n    <button mat-icon-button [mat-dialog-close]=\"\">\n      <smart-icon aria-hidden=\"false\" aria-label=\"Close\" [icon]=\"'close'\"></smart-icon>\n    </button>\n  </div>\n  <div *ngIf=\"!data.customComponent\" mat-dialog-content class=\"content\">\n    <p>\n      {{ data.content.description }}\n    </p>\n    <smartform *ngIf=\"data.form\" [smartForm]=\"data.form!\"></smartform>\n    <smarttable *ngIf=\"data.table\" [smartTable]=\"data.table!\"></smarttable>\n  </div>\n  <div *ngIf=\"!data.customComponent\" class=\"action-container\" mat-dialog-actions>\n    <button\n      class=\"action-button\"\n      *ngIf=\"data.cancelCallback\"\n      mat-button\n      (click)=\"(data.cancelCallback)\"\n    >\n      Cancel\n    </button>\n    <button\n      class=\"action-button\"\n      *ngIf=\"data.okCallback\"\n      mat-button\n      (click)=\"(data.okCallback)\"\n      cdkFocusInitial\n    >\n      Ok\n    </button>\n    <button\n      class=\"action-button\"\n      *ngIf=\"data.actionCallback\"\n      mat-raised-button\n      (click)=\"onActionClick()\"\n    >\n      {{ data.actionLabel }}\n    </button>\n  </div>\n  <mat-dialog-content>\n    <ng-template #renderComponentHere></ng-template>\n  </mat-dialog-content>\n  <div *ngIf=\"data.customComponent\"></div>\n</div>\n", styles: [".dialog-container{position:relative}.dialog-title-container{display:flex;flex-direction:row;width:100%}.dialog-title-container button{text-align:right!important}.dialog-title{flex:20}.action-container{position:absolute;bottom:0;width:100%;display:flex;flex-direction:row}.action-button{flex:1;max-width:200px;margin-left:auto;margin-right:auto}.content{height:calc(100% - 116px)}.fullScreen{width:100%}\n"], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i1.MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: ["aria-label", "type", "mat-dialog-close", "matDialogClose"], exportAs: ["matDialogClose"] }, { kind: "directive", type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i1.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", inputs: ["align"] }, { kind: "directive", type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "component", type: i3.SmartformComponent, selector: "smartform", inputs: ["smartForm"] }, { kind: "component", type: i4.SmarttableComponent, selector: "smarttable", inputs: ["maxWidthForMobile", "smartTable"] }, { kind: "component", type: i5.SmartIconComponent, selector: "smart-icon", inputs: ["icon", "color", "imageResource"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDialog, decorators: [{
+            type: Component,
+            args: [{ selector: 'smartdialog', template: "<div\n  class=\"dialog-container\"\n  [ngClass]=\"data.size.fullScreen ? 'fullScreen' : ''\"\n  [ngStyle]=\"{ width: data.size.width + 'px', height: data.size.height + 'px' }\"\n>\n  <div class=\"dialog-title-container\" mat-dialog-title>\n    <h1 class=\"dialog-title\">\n      {{ data.content.title }}\n    </h1>\n    <button mat-icon-button [mat-dialog-close]=\"\">\n      <smart-icon aria-hidden=\"false\" aria-label=\"Close\" [icon]=\"'close'\"></smart-icon>\n    </button>\n  </div>\n  <div *ngIf=\"!data.customComponent\" mat-dialog-content class=\"content\">\n    <p>\n      {{ data.content.description }}\n    </p>\n    <smartform *ngIf=\"data.form\" [smartForm]=\"data.form!\"></smartform>\n    <smarttable *ngIf=\"data.table\" [smartTable]=\"data.table!\"></smarttable>\n  </div>\n  <div *ngIf=\"!data.customComponent\" class=\"action-container\" mat-dialog-actions>\n    <button\n      class=\"action-button\"\n      *ngIf=\"data.cancelCallback\"\n      mat-button\n      (click)=\"(data.cancelCallback)\"\n    >\n      Cancel\n    </button>\n    <button\n      class=\"action-button\"\n      *ngIf=\"data.okCallback\"\n      mat-button\n      (click)=\"(data.okCallback)\"\n      cdkFocusInitial\n    >\n      Ok\n    </button>\n    <button\n      class=\"action-button\"\n      *ngIf=\"data.actionCallback\"\n      mat-raised-button\n      (click)=\"onActionClick()\"\n    >\n      {{ data.actionLabel }}\n    </button>\n  </div>\n  <mat-dialog-content>\n    <ng-template #renderComponentHere></ng-template>\n  </mat-dialog-content>\n  <div *ngIf=\"data.customComponent\"></div>\n</div>\n", styles: [".dialog-container{position:relative}.dialog-title-container{display:flex;flex-direction:row;width:100%}.dialog-title-container button{text-align:right!important}.dialog-title{flex:20}.action-container{position:absolute;bottom:0;width:100%;display:flex;flex-direction:row}.action-button{flex:1;max-width:200px;margin-left:auto;margin-right:auto}.content{height:calc(100% - 116px)}.fullScreen{width:100%}\n"] }]
+        }], ctorParameters: () => [{ type: i1.MatDialogRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }, { type: i0.ComponentFactoryResolver }], propDecorators: { smartFormComponent: [{
+                type: ViewChild,
+                args: [SmartformComponent]
+            }], vcRef: [{
+                type: ViewChild,
+                args: ['renderComponentHere', { read: ViewContainerRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/smart-dialog/smartdialog.model.mjs

@@ -0,0 +1,16 @@
+/**
+ * This enum helps to define the action of a dialog.
+ *
+ * @author Roland Fényes
+ */
+export var SmartActionType;
+(function (SmartActionType) {
+    SmartActionType[SmartActionType["ADD"] = 0] = "ADD";
+    SmartActionType[SmartActionType["CREATE"] = 1] = "CREATE";
+    SmartActionType[SmartActionType["UPDATE"] = 2] = "UPDATE";
+    SmartActionType[SmartActionType["REMOVE"] = 3] = "REMOVE";
+    SmartActionType[SmartActionType["DELETE"] = 4] = "DELETE";
+    SmartActionType[SmartActionType["SAVE"] = 5] = "SAVE";
+    SmartActionType[SmartActionType["OK"] = 6] = "OK";
+})(SmartActionType || (SmartActionType = {}));
+//# sourceMappingURL=data:application/json;base64,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