@acorex/platform 1.0.6 → 18.0.1

package/esm2022/layout/builder/lib/builder/widget-column-renderer.mjs

@@ -0,0 +1,110 @@
+import { AXDataTableColumnComponent } from '@acorex/components/data-table';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Injector, Input, TemplateRef, ViewChild, inject, signal } from '@angular/core';
+import { AXP_WIDGET_COLUMN_TOKEN } from './widget.types';
+import { AXPLayoutBuilderService } from './builder.service';
+import { AXPWidgetRegistryService } from './widget-registery.service';
+import { get, merge } from 'lodash-es';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
+    constructor() {
+        super(...arguments);
+        this.widgetRegistery = inject(AXPWidgetRegistryService);
+        this.mergedOptions = signal({});
+        this.injector = inject(Injector);
+        this.cdr = inject(ChangeDetectorRef);
+    }
+    get node() {
+        return this._node;
+    }
+    set node(v) {
+        this._node = v;
+    }
+    get renderFooterTemplate() {
+        return this.footerTemplate ?? this._contentFooterTemplate;
+    }
+    get renderCellTemplate() {
+        return this.cellTemplate ?? this._contentCellTemplate;
+    }
+    get renderHeaderTemplate() {
+        return this.headerTemplate ?? this._contentHeaderTemplate;
+    }
+    get loadingEnabled() {
+        return true;
+    }
+    get name() {
+        return `col-${this.node.path}`;
+    }
+    async ngOnInit() {
+        const widget = this.widgetRegistery.resolve(this.node.type);
+        const mode = 'column';
+        this.component = await widget?.components[mode]?.component();
+        this.mergedOptions.set(merge(widget?.defaultOptions, widget?.components[mode]?.defaultOptions, this.node.options) || {});
+        const tokenValue = {
+            path: this.node.path,
+            options: this.mergedOptions()
+        };
+        this.widgetInjector = Injector.create({
+            parent: this.injector,
+            providers: [
+                {
+                    provide: AXP_WIDGET_COLUMN_TOKEN,
+                    useValue: tokenValue,
+                },
+            ],
+        });
+        this.width = this.mergedOptions().width ?? '200px';
+        this.allowResizing = this.mergedOptions().allowResizing || true;
+        this.cdr.detectChanges();
+    }
+    getInputs(data) {
+        return { rawValue: get(data, this.node.path) };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetColumnRendererComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.2", type: AXPWidgetColumnRendererComponent, selector: "axp-widget-column-renderer", inputs: { caption: "caption", node: "node", footerTemplate: "footerTemplate", cellTemplate: "cellTemplate", headerTemplate: "headerTemplate" }, providers: [AXPLayoutBuilderService, { provide: AXDataTableColumnComponent, useExisting: AXPWidgetColumnRendererComponent }], viewQueries: [{ propertyName: "_contentFooterTemplate", first: true, predicate: ["footer"], descendants: true }, { propertyName: "_contentCellTemplate", first: true, predicate: ["cell"], descendants: true }, { propertyName: "_contentHeaderTemplate", first: true, predicate: ["header"], descendants: true }], usesInheritance: true, ngImport: i0, template: `
+    <ng-template #header>{{ caption }}</ng-template>
+    <ng-template #cell let-row>
+      @if(component && widgetInjector && row?.data) {
+      <ng-container *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"></ng-container>
+      }
+    </ng-template>
+    <ng-template #footer></ng-template>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetColumnRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-widget-column-renderer',
+                    template: `
+    <ng-template #header>{{ caption }}</ng-template>
+    <ng-template #cell let-row>
+      @if(component && widgetInjector && row?.data) {
+      <ng-container *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"></ng-container>
+      }
+    </ng-template>
+    <ng-template #footer></ng-template>
+  `,
+                    providers: [AXPLayoutBuilderService, { provide: AXDataTableColumnComponent, useExisting: AXPWidgetColumnRendererComponent }],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    inputs: ['caption'],
+                }]
+        }], propDecorators: { node: [{
+                type: Input,
+                args: [{ required: true }]
+            }], footerTemplate: [{
+                type: Input
+            }], _contentFooterTemplate: [{
+                type: ViewChild,
+                args: ['footer']
+            }], cellTemplate: [{
+                type: Input
+            }], _contentCellTemplate: [{
+                type: ViewChild,
+                args: ['cell']
+            }], headerTemplate: [{
+                type: Input
+            }], _contentHeaderTemplate: [{
+                type: ViewChild,
+                args: ['header']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-column-renderer.js","sourceRoot":"","sources":["../../../../../../../../libs/platform/layout/builder/src/lib/builder/widget-column-renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { AXDataTableColumnComponent } from '@acorex/components/data-table';\r\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, Injector, Input, TemplateRef, ViewChild, inject, signal } from '@angular/core';\r\nimport { AXPWidgetColumnNode, AXP_WIDGET_COLUMN_TOKEN } from './widget.types';\r\nimport { AXPLayoutBuilderService } from './builder.service';\r\nimport { AXPWidgetRegistryService } from './widget-registery.service';\r\nimport { get, merge } from 'lodash-es';\r\n\r\n@Component({\r\n  selector: 'axp-widget-column-renderer',\r\n  template: `\r\n    <ng-template #header>{{ caption }}</ng-template>\r\n    <ng-template #cell let-row>\r\n      @if(component && widgetInjector && row?.data) {\r\n      <ng-container *ngComponentOutlet=\"component; injector: widgetInjector; inputs: getInputs(row.data)\"></ng-container>\r\n      }\r\n    </ng-template>\r\n    <ng-template #footer></ng-template>\r\n  `,\r\n  providers: [AXPLayoutBuilderService, { provide: AXDataTableColumnComponent, useExisting: AXPWidgetColumnRendererComponent }],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  inputs: ['caption'],\r\n})\r\nexport class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {\r\n\r\n  protected widgetRegistery = inject(AXPWidgetRegistryService);\r\n\r\n  private _node: AXPWidgetColumnNode;\r\n  @Input({ required: true })\r\n  public get node(): AXPWidgetColumnNode {\r\n    return this._node;\r\n  }\r\n  public set node(v: AXPWidgetColumnNode) {\r\n    this._node = v;\r\n  }\r\n\r\n  private mergedOptions = signal<any>({});\r\n\r\n  @Input()\r\n  public footerTemplate: TemplateRef<unknown>;\r\n\r\n  @ViewChild('footer')\r\n  private _contentFooterTemplate: TemplateRef<unknown>;\r\n\r\n  get renderFooterTemplate(): TemplateRef<unknown> {\r\n    return this.footerTemplate ?? this._contentFooterTemplate;\r\n  }\r\n\r\n  @Input()\r\n  public cellTemplate: TemplateRef<unknown>;\r\n\r\n  @ViewChild('cell')\r\n  private _contentCellTemplate: TemplateRef<unknown>;\r\n\r\n  get renderCellTemplate(): TemplateRef<unknown> {\r\n    return this.cellTemplate ?? this._contentCellTemplate;\r\n  }\r\n\r\n  @Input()\r\n  public headerTemplate: TemplateRef<unknown>;\r\n\r\n  @ViewChild('header')\r\n  private _contentHeaderTemplate: TemplateRef<unknown>;\r\n\r\n  get renderHeaderTemplate(): TemplateRef<unknown> {\r\n    return this.headerTemplate ?? this._contentHeaderTemplate;\r\n  }\r\n\r\n  get loadingEnabled(): boolean {\r\n    return true;\r\n  }\r\n\r\n  get name(): string {\r\n    return `col-${this.node.path}`;\r\n  }\r\n\r\n\r\n  private injector = inject(Injector);\r\n  private cdr = inject(ChangeDetectorRef);\r\n  protected widgetInjector!: Injector;\r\n  protected component!: any;\r\n\r\n  async ngOnInit() {\r\n    const widget = this.widgetRegistery.resolve(this.node.type);\r\n    const mode = 'column'\r\n    this.component = await widget?.components[mode]?.component();\r\n    this.mergedOptions.set(\r\n      merge(widget?.defaultOptions, widget?.components[mode]?.defaultOptions, this.node.options) || {}\r\n    );\r\n\r\n    const tokenValue = {\r\n      path: this.node.path,\r\n      options: this.mergedOptions()\r\n    };\r\n    this.widgetInjector = Injector.create({\r\n      parent: this.injector,\r\n      providers: [\r\n        {\r\n          provide: AXP_WIDGET_COLUMN_TOKEN,\r\n          useValue: tokenValue,\r\n        },\r\n      ],\r\n    });\r\n\r\n    this.width = this.mergedOptions().width ?? '200px';\r\n    this.allowResizing = this.mergedOptions().allowResizing || true;\r\n    this.cdr.detectChanges();\r\n  }\r\n\r\n  getInputs(data: any): any {\r\n    return { rawValue: get(data, this.node.path!) };\r\n  }\r\n}\r\n"]}

package/esm2022/layout/builder/lib/builder/widget-container.component.mjs

@@ -0,0 +1,55 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, inject } from "@angular/core";
+import { AXPLayoutBuilderService } from "./builder.service";
+import { AXUnsubscriber } from "@acorex/core/utils";
+import { cloneDeep } from "lodash-es";
+import * as i0 from "@angular/core";
+export class AXPWidgetContainerComponent {
+    constructor() {
+        this.contextChange = new EventEmitter();
+        this.unsubscriber = inject(AXUnsubscriber);
+        this.builderService = inject(AXPLayoutBuilderService);
+    }
+    get context() {
+        return this._context;
+    }
+    set context(v) {
+        this._context = v;
+        this.builderService.initial(this.context);
+    }
+    set variables(v) {
+        this.builderService.setVariables(v);
+    }
+    set functions(v) {
+        this.builderService.setFunctions(v);
+    }
+    ngOnInit() {
+        this.builderService.initial(this.context);
+        this.builderService
+            .onChanged
+            .pipe(this.unsubscriber.takeUntilDestroy)
+            .subscribe(ctx => {
+            this.contextChange.emit(cloneDeep(ctx.data));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetContainerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.2", type: AXPWidgetContainerComponent, selector: "axp-widgets-container", inputs: { context: "context", variables: "variables", functions: "functions" }, outputs: { contextChange: "contextChange" }, host: { styleAttribute: "display: contents;" }, providers: [AXPLayoutBuilderService, AXUnsubscriber], ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-widgets-container',
+                    template: `<ng-content></ng-content>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: { style: 'display: contents;' },
+                    providers: [AXPLayoutBuilderService, AXUnsubscriber],
+                }]
+        }], propDecorators: { contextChange: [{
+                type: Output
+            }], context: [{
+                type: Input
+            }], variables: [{
+                type: Input
+            }], functions: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/layout/builder/lib/builder/widget-registery.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from "@angular/core";
+import { merge } from "lodash-es";
+import * as i0 from "@angular/core";
+export class AXPWidgetRegistryService {
+    constructor() {
+        this.types = new Map();
+    }
+    register(widget) {
+        this.types.set(widget.name, widget);
+    }
+    extend(parentName, widget) {
+        const parentWidget = this.resolve(parentName);
+        const newWidget = merge({}, parentWidget, widget);
+        newWidget.name = widget.name;
+        this.register(newWidget);
+    }
+    resolve(name) {
+        const widget = this.types.get(name);
+        if (!widget) {
+            throw new Error(`Widget with name ${widget} does not exist.`);
+        }
+        return widget;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/layout/builder/lib/builder/widget-renderer.component.mjs

@@ -0,0 +1,293 @@
+import { AXUnsubscriber } from '@acorex/core/utils';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { ChangeDetectionStrategy, Component, Injector, Input, inject, signal } from '@angular/core';
+import { cloneDeep, get, merge, set, sum } from 'lodash-es';
+import { filter } from 'rxjs';
+import { AXPLayoutBuilderService } from './builder.service';
+import { AXPWidgetRegistryService } from './widget-registery.service';
+import { AXP_WIDGET_TOKEN } from './widget.types';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/portal";
+import * as i3 from "@acorex/components/skeleton";
+export class AXPWidgetRendererComponent {
+    get node() {
+        return this._node;
+    }
+    set node(v) {
+        this._node = v;
+        this.loadComponent();
+    }
+    constructor() {
+        this.mergedOptions = signal({});
+        this.injector = inject(Injector);
+        this.builderService = inject(AXPLayoutBuilderService);
+        this.widgetRegistery = inject(AXPWidgetRegistryService);
+        this.unsubscriber = inject(AXUnsubscriber);
+        this.isLoading = signal(true);
+        this.expressionCache = new Map();
+        this.expressionEvaluators = new Map();
+        this.scope = null;
+        this.builderService.onChanged.pipe(this.unsubscriber.takeUntilDestroy).subscribe(async (e) => {
+            if (await this.updateOptionsBasedOnContext() > 0) {
+                this.applyOptions();
+            }
+            if (this.checkFormulaForUpdate(this.node.formula, e.path)) {
+                await this.updateValueBasedOnFormula();
+            }
+        });
+    }
+    async loadComponent() {
+        this.isLoading.set(true);
+        const widget = this.widgetRegistery.resolve(this.node.type);
+        this.mergedOptions.set(merge(cloneDeep(widget?.defaultOptions), cloneDeep(widget?.components[this.node.mode]?.defaultOptions), this.node.options) || {});
+        this.preprocessAndInitialOptions(cloneDeep(this.node.options));
+        await this.updateOptionsBasedOnContext();
+        const tokenValue = {
+            id: this.node.id,
+            path: this.node.path,
+            mode: this.node.mode,
+            type: this.node.type,
+            children: this.node.children,
+            options: this.mergedOptions()
+        };
+        const token = Injector.create({
+            parent: this.injector,
+            providers: [
+                {
+                    provide: AXP_WIDGET_TOKEN,
+                    useValue: tokenValue,
+                },
+            ],
+        });
+        var com = await widget?.components[this.node.mode]?.component();
+        this.portal = new ComponentPortal(com, null, token);
+        this.isLoading.set(false);
+    }
+    async handleAttached(portalOutletRef) {
+        portalOutletRef = portalOutletRef;
+        this.instance = portalOutletRef.instance;
+        await this.updateValueBasedOnFormula();
+        await this.assignTriggers();
+    }
+    applyOptions() {
+        if (!this.instance)
+            return;
+        this.instance.setOptions(this.mergedOptions());
+    }
+    checkFormulaForUpdate(formula, path) {
+        if (formula) {
+            const regex = /context\.eval\('([^']+)'\)/g;
+            const matches = formula.match(regex);
+            const nodes = matches ? matches.map((match) => match.match(/'([^']+)'/)[1]) : [];
+            return nodes.includes(path);
+        }
+        else
+            return false;
+    }
+    preprocessAndInitialOptions(obj, pathPrefix = '') {
+        if (!obj)
+            return;
+        Object.entries(obj).forEach(([key, value]) => {
+            const currentPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+            if (typeof value === 'string' && value.includes('{{')) {
+                // Cache dynamic expression for later evaluation
+                this.expressionEvaluators.set(currentPath, () => this.evaluateExpression(value));
+            }
+            else if (typeof value === 'object' && value !== null && (value.constructor === Object || Array.isArray(value))) {
+                // Recursively handle nested objects
+                this.preprocessAndInitialOptions(value, currentPath);
+            }
+            else {
+                // Apply static values directly
+                this.mergedOptions.update((currentOptions) => {
+                    return set(currentOptions, currentPath, value);
+                });
+            }
+        });
+    }
+    async updateOptionsBasedOnContext() {
+        const updates = [];
+        for (let [path, evaluator] of this.expressionEvaluators) {
+            const newValue = await evaluator();
+            updates.push({ path, newValue });
+        }
+        // Apply updates to mergedOptions
+        if (updates.length > 0) {
+            this.mergedOptions.update(o => {
+                const updatedOptions = { ...o };
+                updates.forEach(({ path, newValue }) => {
+                    // Set the new value in the updatedOptions object by path
+                    set(updatedOptions, path, newValue); // Assuming 'set' can handle paths like 'property.subproperty'
+                });
+                return updatedOptions;
+            });
+        }
+        return updates.length;
+    }
+    async updateValueBasedOnFormula() {
+        if (this.node.formula) {
+            const value = await this.evaluateExpression(this.node.formula);
+            this.instance.setValue(value);
+        }
+    }
+    async evaluateExpression(templateExpression) {
+        try {
+            // Check cache first, but cache the function for evaluation, not the evaluated value
+            if (!this.expressionCache.has(templateExpression)) {
+                const expressionMatch = templateExpression.match(/\{\{\s*(.*?)\s*\}\}/);
+                if (!expressionMatch) {
+                    throw Error(`No valid expression found in "${templateExpression}"`);
+                }
+                const expression = expressionMatch[1];
+                // Cache the evaluation function instead of the result
+                const scope = this.getGlobalScope();
+                const evaluationFunction = async () => {
+                    const sandbox = new Function('scope', `with (scope) { return (async function() { return ${expression}; })(); }`);
+                    return await sandbox(scope);
+                };
+                this.expressionCache.set(templateExpression, evaluationFunction);
+            }
+            // Retrieve the function from the cache and call it to evaluate the expression
+            const evaluate = this.expressionCache.get(templateExpression);
+            if (evaluate) {
+                // Ensure 'evaluate' is not undefined before invoking
+                return await evaluate();
+            }
+            else {
+                throw Error(`Failed to retrieve evaluation function for expression: "${templateExpression}"`);
+            }
+        }
+        catch (error) {
+            console.error('Error evaluating expression:', error);
+            return false;
+        }
+    }
+    getGlobalScope() {
+        if (this.scope)
+            return this.scope;
+        this.scope = {};
+        set(this.scope, 'context', this.getContextScope());
+        set(this.scope, 'events', this.getEventScope());
+        set(this.scope, 'widget', this.getWidgetScope());
+        set(this.scope, 'methods', this.getFunctionScope());
+        set(this.scope, 'vars', this.getVariablesScope());
+        return this.scope;
+    }
+    getContextScope() {
+        const scope = {};
+        set(scope, 'eval', (path) => this.builderService.getValue(path));
+        return scope;
+    }
+    getEventScope() {
+        const scope = {};
+        set(scope, 'context', (path) => this.builderService.onChanged.pipe(filter((c) => c.path == path)));
+        return scope;
+    }
+    getWidgetScope() {
+        const scope = {};
+        set(scope, 'call', (name, ...args) => {
+            this.instance.call(name, ...args);
+        });
+        return scope;
+    }
+    getFunctionScope() {
+        const scope = {};
+        set(scope, 'sum', (values) => {
+            return sum(values);
+        });
+        Object.entries(this.builderService.functions).forEach(i => {
+            set(scope, i[0], (...args) => {
+                return i[1](...args);
+            });
+        });
+        return scope;
+    }
+    getVariablesScope() {
+        const scope = {};
+        set(scope, 'eval', (path) => get(this.builderService.variables, path));
+        return scope;
+    }
+    async assignTriggers() {
+        this.node.triggers?.forEach((t) => {
+            const event = this.evaluateTrigger(t.event);
+            event?.pipe(this.unsubscriber.takeUntilDestroy).subscribe((c) => {
+                this.evaluateAction(t.action);
+            });
+        });
+    }
+    evaluateTrigger(templateExpression) {
+        try {
+            const expressionMatch = templateExpression.match(/\{\{\s*(.*?)\s*\}\}/);
+            if (!expressionMatch) {
+                throw Error(`No valid expression found in "${templateExpression}"`);
+            }
+            const expression = expressionMatch[1];
+            // Cache the evaluation function instead of the result
+            const scope = this.getGlobalScope();
+            const sandbox = new Function('scope', `with (scope) { return (  function() { return ${expression}; })(); }`);
+            return sandbox(scope);
+        }
+        catch (error) {
+            console.error('Error evaluating expression:', error);
+            return null;
+        }
+    }
+    evaluateAction(templateExpression) {
+        try {
+            const expressionMatch = templateExpression.match(/\{\{\s*(.*?)\s*\}\}/);
+            if (!expressionMatch) {
+                throw Error(`No valid expression found in "${templateExpression}"`);
+            }
+            const expression = expressionMatch[1];
+            // Cache the evaluation function instead of the result
+            const scope = this.getGlobalScope();
+            const sandbox = new Function('scope', `with (scope) {  ${expression} }`);
+            sandbox(scope);
+        }
+        catch (error) {
+            console.error('Error evaluating expression:', error);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.2", type: AXPWidgetRendererComponent, selector: "axp-widget-renderer", inputs: { node: "node" }, providers: [
+            {
+                provide: AXUnsubscriber,
+            },
+        ], ngImport: i0, template: `
+    @if(mergedOptions().isVisible!=false) { @if(isLoading()){
+    <ax-skeleton [animated]="true" class="ax-w-full  lg:ax-w-[50%] ax-h-8 ax-rounded"></ax-skeleton>
+    } @else {
+    <ng-container *ngTemplateOutlet="tt"></ng-container>
+    } }
+    <ng-template #tt>
+      <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+    </ng-template>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i3.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-widget-renderer',
+                    template: `
+    @if(mergedOptions().isVisible!=false) { @if(isLoading()){
+    <ax-skeleton [animated]="true" class="ax-w-full  lg:ax-w-[50%] ax-h-8 ax-rounded"></ax-skeleton>
+    } @else {
+    <ng-container *ngTemplateOutlet="tt"></ng-container>
+    } }
+    <ng-template #tt>
+      <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+    </ng-template>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [
+                        {
+                            provide: AXUnsubscriber,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [], propDecorators: { node: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-renderer.component.js","sourceRoot":"","sources":["../../../../../../../../libs/platform/layout/builder/src/lib/builder/widget-renderer.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AXUnsubscriber } from '@acorex/core/utils';\r\nimport { CdkPortalOutletAttachedRef, ComponentPortal } from '@angular/cdk/portal';\r\nimport { ChangeDetectionStrategy, Component, ComponentRef, Injector, Input, WritableSignal, inject, signal } from '@angular/core';\r\nimport { cloneDeep, get, isEmpty, merge, set, sum } from 'lodash-es';\r\nimport { Observable, filter } from 'rxjs';\r\nimport { AXPLayoutBuilderService } from './builder.service';\r\nimport { AXPWidgetRegistryService } from './widget-registery.service';\r\nimport { AXPWidgetBase, AXPWidgetNode, AXP_WIDGET_TOKEN } from './widget.types';\r\n\r\n@Component({\r\n  selector: 'axp-widget-renderer',\r\n  template: `\r\n    @if(mergedOptions().isVisible!=false) { @if(isLoading()){\r\n    <ax-skeleton [animated]=\"true\" class=\"ax-w-full  lg:ax-w-[50%] ax-h-8 ax-rounded\"></ax-skeleton>\r\n    } @else {\r\n    <ng-container *ngTemplateOutlet=\"tt\"></ng-container>\r\n    } }\r\n    <ng-template #tt>\r\n      <ng-template [cdkPortalOutlet]=\"portal\" (attached)=\"handleAttached($event)\"></ng-template>\r\n    </ng-template>\r\n  `,\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  providers: [\r\n    {\r\n      provide: AXUnsubscriber,\r\n    },\r\n  ],\r\n})\r\nexport class AXPWidgetRendererComponent {\r\n\r\n  private _node: AXPWidgetNode;\r\n  @Input({ required: true })\r\n  public get node(): AXPWidgetNode {\r\n    return this._node;\r\n  }\r\n  public set node(v: AXPWidgetNode) {\r\n    this._node = v;\r\n    this.loadComponent();\r\n  }\r\n\r\n\r\n  protected mergedOptions: WritableSignal<any> = signal<any>({});\r\n\r\n  private injector = inject(Injector);\r\n  protected builderService = inject(AXPLayoutBuilderService);\r\n  protected widgetRegistery = inject(AXPWidgetRegistryService);\r\n  protected unsubscriber = inject(AXUnsubscriber);\r\n\r\n  protected isLoading = signal(true);\r\n  private instance!: AXPWidgetBase;\r\n  protected portal!: ComponentPortal<any>;\r\n  private expressionCache: Map<string, () => Promise<any>> = new Map();\r\n  private expressionEvaluators: Map<string, () => Promise<any>> = new Map();\r\n  private scope: any = null;\r\n\r\n\r\n  constructor() {\r\n    this.builderService.onChanged.pipe(this.unsubscriber.takeUntilDestroy).subscribe(async (e) => {\r\n      if (await this.updateOptionsBasedOnContext() > 0) {\r\n        this.applyOptions();\r\n      }\r\n      if (this.checkFormulaForUpdate(this.node.formula, e.path)) {\r\n        await this.updateValueBasedOnFormula();\r\n      }\r\n    });\r\n  }\r\n\r\n  private async loadComponent() {\r\n    this.isLoading.set(true);\r\n    const widget = this.widgetRegistery.resolve(this.node.type);\r\n    this.mergedOptions.set(\r\n      merge(cloneDeep(widget?.defaultOptions), cloneDeep(widget?.components[this.node.mode]?.defaultOptions), this.node.options) || {}\r\n    );\r\n    this.preprocessAndInitialOptions(cloneDeep(this.node.options));\r\n    await this.updateOptionsBasedOnContext();\r\n    const tokenValue = {\r\n      id: this.node.id,\r\n      path: this.node.path,\r\n      mode: this.node.mode,\r\n      type: this.node.type,\r\n      children: this.node.children,\r\n      options: this.mergedOptions()\r\n    };\r\n    const token = Injector.create({\r\n      parent: this.injector,\r\n      providers: [\r\n        {\r\n          provide: AXP_WIDGET_TOKEN,\r\n          useValue: tokenValue,\r\n        },\r\n      ],\r\n    });\r\n    var com = await widget?.components[this.node.mode]?.component();\r\n    this.portal = new ComponentPortal(com, null, token);\r\n    this.isLoading.set(false);\r\n  }\r\n\r\n  protected async handleAttached(portalOutletRef: CdkPortalOutletAttachedRef) {\r\n    portalOutletRef = portalOutletRef as ComponentRef<AXPWidgetBase>;\r\n    this.instance = portalOutletRef.instance as AXPWidgetBase;\r\n    await this.updateValueBasedOnFormula();\r\n    await this.assignTriggers();\r\n  }\r\n\r\n  private applyOptions() {\r\n    if (!this.instance) return;\r\n    this.instance.setOptions(this.mergedOptions());\r\n  }\r\n\r\n  private checkFormulaForUpdate(formula: string | undefined, path?: string | null): boolean {\r\n    if (formula) {\r\n      const regex = /context\\.eval\\('([^']+)'\\)/g;\r\n      const matches = formula.match(regex);\r\n      const nodes = matches ? matches.map((match: any) => match.match(/'([^']+)'/)[1]) : [];\r\n      return nodes.includes(path);\r\n    } else return false;\r\n  }\r\n\r\n  preprocessAndInitialOptions(obj: any, pathPrefix: string = ''): void {\r\n    if (!obj)\r\n      return;\r\n    Object.entries(obj).forEach(([key, value]) => {\r\n      const currentPath = pathPrefix ? `${pathPrefix}.${key}` : key;\r\n      if (typeof value === 'string' && value.includes('{{')) {\r\n        // Cache dynamic expression for later evaluation\r\n        this.expressionEvaluators.set(currentPath, () => this.evaluateExpression(value));\r\n      }\r\n      else if (typeof value === 'object' && value !== null && (value.constructor === Object || Array.isArray(value))) {\r\n        // Recursively handle nested objects\r\n        this.preprocessAndInitialOptions(value, currentPath);\r\n      } else {\r\n        // Apply static values directly\r\n        this.mergedOptions.update((currentOptions) => {\r\n          return set(currentOptions, currentPath, value);\r\n        });\r\n      }\r\n    });\r\n  }\r\n\r\n  async updateOptionsBasedOnContext() {\r\n    const updates: any[] = [];\r\n    for (let [path, evaluator] of this.expressionEvaluators) {\r\n      const newValue = await evaluator();\r\n      updates.push({ path, newValue });\r\n    }\r\n    // Apply updates to mergedOptions\r\n    if (updates.length > 0) {\r\n      this.mergedOptions.update(o => {\r\n        const updatedOptions = { ...o };\r\n        updates.forEach(({ path, newValue }) => {\r\n          // Set the new value in the updatedOptions object by path\r\n          set(updatedOptions, path, newValue); // Assuming 'set' can handle paths like 'property.subproperty'\r\n        });\r\n        return updatedOptions;\r\n      });\r\n    }\r\n    return updates.length;\r\n  }\r\n\r\n  async updateValueBasedOnFormula() {\r\n    if (this.node.formula) {\r\n      const value = await this.evaluateExpression(this.node.formula);\r\n      this.instance.setValue(value);\r\n    }\r\n  }\r\n\r\n  private async evaluateExpression(templateExpression: string): Promise<any> {\r\n    try {\r\n      // Check cache first, but cache the function for evaluation, not the evaluated value\r\n      if (!this.expressionCache.has(templateExpression)) {\r\n        const expressionMatch = templateExpression.match(/\\{\\{\\s*(.*?)\\s*\\}\\}/);\r\n        if (!expressionMatch) {\r\n          throw Error(`No valid expression found in \"${templateExpression}\"`);\r\n        }\r\n        const expression = expressionMatch[1];\r\n\r\n        // Cache the evaluation function instead of the result\r\n        const scope = this.getGlobalScope();\r\n        const evaluationFunction = async () => {\r\n          const sandbox = new Function('scope', `with (scope) { return (async function() { return ${expression}; })(); }`);\r\n          return await sandbox(scope);\r\n        };\r\n\r\n        this.expressionCache.set(templateExpression, evaluationFunction);\r\n      }\r\n\r\n      // Retrieve the function from the cache and call it to evaluate the expression\r\n      const evaluate = this.expressionCache.get(templateExpression);\r\n      if (evaluate) {\r\n        // Ensure 'evaluate' is not undefined before invoking\r\n        return await evaluate();\r\n      } else {\r\n        throw Error(`Failed to retrieve evaluation function for expression: \"${templateExpression}\"`);\r\n      }\r\n    } catch (error) {\r\n      console.error('Error evaluating expression:', error);\r\n      return false;\r\n    }\r\n  }\r\n\r\n  private getGlobalScope() {\r\n    if (this.scope) return this.scope;\r\n    this.scope = {};\r\n    set(this.scope, 'context', this.getContextScope());\r\n    set(this.scope, 'events', this.getEventScope());\r\n    set(this.scope, 'widget', this.getWidgetScope());\r\n    set(this.scope, 'methods', this.getFunctionScope());\r\n    set(this.scope, 'vars', this.getVariablesScope());\r\n    return this.scope;\r\n  }\r\n\r\n  private getContextScope(): any {\r\n    const scope: any = {};\r\n    set(scope, 'eval', (path: string) => this.builderService.getValue(path));\r\n    return scope;\r\n  }\r\n\r\n  private getEventScope(): any {\r\n    const scope: any = {};\r\n    set(scope, 'context', (path: string) =>\r\n      this.builderService.onChanged.pipe(\r\n        filter((c) => c.path == path)\r\n      )\r\n    );\r\n    return scope;\r\n  }\r\n\r\n  private getWidgetScope(): any {\r\n    const scope: any = {};\r\n    set(scope, 'call', (name: string, ...args: any[]) => {\r\n      this.instance.call(name, ...args);\r\n    });\r\n    return scope;\r\n  }\r\n\r\n  private getFunctionScope(): any {\r\n    const scope: any = {};\r\n    set(scope, 'sum', (values: any) => {\r\n      return sum(values);\r\n    });\r\n    Object.entries(this.builderService.functions).forEach(i => {\r\n      set(scope, i[0], (...args: any[]) => {\r\n        return i[1](...args);\r\n      });\r\n    })\r\n    return scope;\r\n  }\r\n\r\n  private getVariablesScope(): any {\r\n    const scope: any = {};\r\n    set(scope, 'eval', (path: string) => get(this.builderService.variables, path));\r\n    return scope;\r\n  }\r\n\r\n  private async assignTriggers() {\r\n    this.node.triggers?.forEach((t) => {\r\n      const event = this.evaluateTrigger(t.event);\r\n      event?.pipe(this.unsubscriber.takeUntilDestroy).subscribe((c) => {\r\n        this.evaluateAction(t.action);\r\n      });\r\n    });\r\n  }\r\n\r\n  private evaluateTrigger(templateExpression: string): Observable<any> | null {\r\n    try {\r\n      const expressionMatch = templateExpression.match(/\\{\\{\\s*(.*?)\\s*\\}\\}/);\r\n      if (!expressionMatch) {\r\n        throw Error(`No valid expression found in \"${templateExpression}\"`);\r\n      }\r\n      const expression = expressionMatch[1];\r\n\r\n      // Cache the evaluation function instead of the result\r\n      const scope = this.getGlobalScope();\r\n      const sandbox = new Function('scope', `with (scope) { return (  function() { return ${expression}; })(); }`);\r\n      return sandbox(scope);\r\n    } catch (error) {\r\n      console.error('Error evaluating expression:', error);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private evaluateAction(templateExpression: string) {\r\n    try {\r\n      const expressionMatch = templateExpression.match(/\\{\\{\\s*(.*?)\\s*\\}\\}/);\r\n      if (!expressionMatch) {\r\n        throw Error(`No valid expression found in \"${templateExpression}\"`);\r\n      }\r\n      const expression = expressionMatch[1];\r\n\r\n      // Cache the evaluation function instead of the result\r\n      const scope: any = this.getGlobalScope();\r\n      const sandbox = new Function('scope', `with (scope) {  ${expression} }`);\r\n      sandbox(scope);\r\n    } catch (error) {\r\n      console.error('Error evaluating expression:', error);\r\n    }\r\n  }\r\n}\r\n"]}