@acorex/platform 1.0.0 → 1.0.2

package/esm2022/layout/lib/builder/index.mjs

@@ -0,0 +1,8 @@
+export * from './widget.types';
+export * from './context.service';
+export * from './widget-container';
+export * from './widget-renderer';
+export * from './widget-column-renderer';
+export * from './widget-registery.service';
+export * from './builder.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3BsYXRmb3JtL2xheW91dC9zcmMvbGliL2J1aWxkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vd2lkZ2V0LnR5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vd2lkZ2V0LWNvbnRhaW5lcic7XG5leHBvcnQgKiBmcm9tICcuL3dpZGdldC1yZW5kZXJlcic7XG5leHBvcnQgKiBmcm9tICcuL3dpZGdldC1jb2x1bW4tcmVuZGVyZXInO1xuZXhwb3J0ICogZnJvbSAnLi93aWRnZXQtcmVnaXN0ZXJ5LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9idWlsZGVyLm1vZHVsZSc7Il19

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

@@ -0,0 +1,75 @@
+import { AXDataTableColumnComponent } from '@acorex/components/data-table';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Injector, Input, TemplateRef, ViewChild, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
+    constructor() {
+        super(...arguments);
+        this.mergedOptions = {};
+        this.injector = inject(Injector);
+        this.cdr = inject(ChangeDetectorRef);
+    }
+    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.dataField}`;
+    }
+    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: "14.0.0", version: "18.0.2", type: AXPWidgetColumnRendererComponent, selector: "axp-widget-column-renderer", inputs: { width: "width", caption: "caption", headerTemplate: "headerTemplate", allowSorting: "allowSorting", fixed: "fixed", node: "node", footerTemplate: "footerTemplate", cellTemplate: "cellTemplate", options: "options", dataField: "dataField", displayFormat: "displayFormat" }, providers: [{ 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>
+      {{ node.path }}
+    </ng-template>
+    <ng-template #footer></ng-template>
+  `, isInline: true, 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>
+      {{ node.path }}
+    </ng-template>
+    <ng-template #footer></ng-template>
+  `,
+                    providers: [{ provide: AXDataTableColumnComponent, useExisting: AXPWidgetColumnRendererComponent }],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    inputs: ['width', 'caption', 'headerTemplate', 'allowSorting', 'fixed'],
+                }]
+        }], 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']
+            }], options: [{
+                type: Input
+            }], dataField: [{
+                type: Input
+            }], displayFormat: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,45 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, inject } from "@angular/core";
+import { AXPLayoutContextService } from "./context.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.contextService = inject(AXPLayoutContextService);
+    }
+    get context() {
+        return this._context;
+    }
+    set context(v) {
+        this._context = v;
+        this.contextChange.emit(v);
+    }
+    ngOnInit() {
+        this.contextService.initial(this.context);
+        this.contextService
+            .onChanged
+            .pipe(this.unsubscriber.takeUntilDestroy)
+            .subscribe(ctx => {
+            this.context = 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" }, outputs: { contextChange: "contextChange" }, host: { styleAttribute: "display: contents;" }, providers: [AXPLayoutContextService, 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: [AXPLayoutContextService, AXUnsubscriber],
+                }]
+        }], propDecorators: { contextChange: [{
+                type: Output
+            }], context: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/layout/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/lib/builder/widget-renderer.mjs

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

package/esm2022/layout/lib/builder/widget.types.mjs

@@ -0,0 +1,49 @@
+import { ChangeDetectorRef, Injectable, InjectionToken, computed, inject } from '@angular/core';
+import { get, merge, set } from 'lodash-es';
+import { AXPLayoutContextService } from './context.service';
+import * as i0 from "@angular/core";
+export const AXP_WIDGET_TOKEN = new InjectionToken('AXP_WIDGET_TOKEN');
+export class AXPWidgetBase {
+    constructor() {
+        this.token = inject(AXP_WIDGET_TOKEN);
+        this.cdr = inject(ChangeDetectorRef);
+        this.id = this.token.id;
+        this.path = this.token.path;
+        this.mode = this.token.mode;
+        this.type = this.token.type;
+        this.children = this.token.children;
+        this.contextService = inject(AXPLayoutContextService);
+        this.value = computed(() => (this.path ? get(this.contextService.context, this.path) : null));
+    }
+    ngOnInit() {
+        this.setOptions(this.token.options);
+    }
+    getValue() {
+        return this.value();
+    }
+    setValue(value) {
+        if (this.path) {
+            this.contextService.setValue(this.path, value);
+        }
+    }
+    setOption(path, value) {
+        set(this, path, value);
+        this.cdr.markForCheck();
+    }
+    setOptions(values) {
+        merge(this, values);
+        this.cdr.markForCheck();
+    }
+    call(name, ...args) {
+        const fn = get(this, name);
+        if (fn && typeof fn == 'function') {
+            fn.bind(this)(...args);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetBase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetBase }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetBase, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/layout/lib/component-slot/component-slot-loader.service.mjs

@@ -0,0 +1,56 @@
+import { Injectable, Injector, runInInjectionContext } from "@angular/core";
+import { AXPComponentSlotRegistryService } from "./component-slot-registery.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./component-slot-registery.service";
+export class AXPComponentSlotLoaderService {
+    constructor(registryService, injector) {
+        this.registryService = registryService;
+        this.injector = injector;
+    }
+    loadComponent(slotName, viewContainerRef) {
+        const configs = this.registryService.get(slotName);
+        if (configs) {
+            viewContainerRef.clear();
+            configs.forEach(async (config) => {
+                let component;
+                let options = {};
+                if (typeof config.loadComponent === 'function') {
+                    // If component is a function
+                    runInInjectionContext(this.injector, () => {
+                        component = config.loadComponent?.();
+                    });
+                }
+                else if (config.component) {
+                    // If component is a Type
+                    component = config.component;
+                }
+                //
+                if (typeof config.options === 'function') {
+                    // If options is a function
+                    runInInjectionContext(this.injector, () => {
+                        const fun = config.options;
+                        options = fun();
+                    });
+                }
+                else if (config.options) {
+                    // If options is a object
+                    options = config.options;
+                }
+                //
+                if (component != null) {
+                    const componentRef = viewContainerRef.createComponent(component);
+                    Object.assign(componentRef.instance, options);
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotLoaderService, deps: [{ token: i1.AXPComponentSlotRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotLoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AXPComponentSlotRegistryService }, { type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,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