@acorex/platform 21.0.0-next.2 → 21.0.0-next.3

package/fesm2022/acorex-platform-layout-widget-core.mjs

@@ -1,8 +1,8 @@
 import * as i0 from '@angular/core';
-import { computed, signal, Injectable, InjectionToken, inject, ElementRef, effect, untracked, Injector, ChangeDetectorRef, ViewChild, Input, ChangeDetectionStrategy, Component, EventEmitter, Output, input, output, ViewContainerRef, Directive, Optional, Inject, NgModule, createComponent } from '@angular/core';
+import { computed, signal, Injectable, InjectionToken, inject, ElementRef, effect, untracked, Injector, ChangeDetectorRef, ViewChild, Input, ChangeDetectionStrategy, Component, EventEmitter, Output, input, output, ViewContainerRef, Directive, Optional, Inject, NgModule } from '@angular/core';
 import { convertArrayToDataSource, AXDataSource } from '@acorex/cdk/common';
-import { setSmart, AXPDataSourceDefinitionProviderService, extractValue, getSmart, AXPExpressionEvaluatorService } from '@acorex/platform/core';
-import { cloneDeep, isEqual, get, set, merge, isNil, isUndefined, isObjectLike, sum, isEmpty, isString } from 'lodash-es';
+import { setSmart, AXPDataSourceDefinitionProviderService, extractValue, AXPExpressionEvaluatorService, getSmart } from '@acorex/platform/core';
+import { cloneDeep, isEqual, has, get, set, merge, isNil, isUndefined, isObjectLike, sum, isEmpty, isString } from 'lodash-es';
 import { Subject, BehaviorSubject, filter } from 'rxjs';
 import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
 import * as i1$1 from '@acorex/components/skeleton';
@@ -125,6 +125,10 @@ withMethods((store) => ({
     getValue(path) {
         return get(store.data(), path);
     },
+    // Check if a path exists in the context
+    hasValue(path) {
+        return has(store.data(), path);
+    },
 })));
 
 var AXPPageStatus;
@@ -328,8 +332,6 @@ const AXPWidgetsCatalog = {
     advancedGridItem: 'advanced-grid-item-layout',
     grid: 'grid-layout',
     gridItem: 'grid-item-layout',
-    // gridRow: 'grid-row-layout',
-    widgetSelector: 'widget-selector',
     template: 'template',
     templateDesigner: 'template-designer',
     cronJob: 'cron-job',
@@ -391,8 +393,9 @@ const AXPWidgetsCatalog = {
     editorJs: 'editor-js-editor',
     documentUploader: 'document-uploader',
     signatureList: 'signature-list',
-    status: 'status-widget',
     stepWizard: 'step-wizard',
+    progressBar: 'progress-bar-editor',
+    rate: 'rate-picker-editor'
 };
 
 function cloneProperty(property, values) {
@@ -596,7 +599,8 @@ class AXPValueWidgetComponent extends AXPLayoutBaseWidgetComponent {
         this._isValueWidget = this.config.properties?.some((c) => c.name == 'path') ?? false;
         if (this.isValueWidget()) {
             this.detectFullPath();
-            if (!isNil(this.defaultValue) && isNil(this.getValue())) {
+            // Set defaultValue if it exists and the path doesn't exist in context
+            if (!isNil(this.defaultValue) && this.fullPath() && !this.contextService.hasValue(this.fullPath())) {
                 this.setValue(this.defaultValue);
             }
         }
@@ -1212,8 +1216,14 @@ class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
         super(...arguments);
         this.widgetRegistery = inject(AXPWidgetRegistryService);
         this.grid = inject(AXBaseDataTable);
+        this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
         this.mergedOptions = signal({}, ...(ngDevMode ? [{ debugName: "mergedOptions" }] : []));
         this.loadingRow = signal(null, ...(ngDevMode ? [{ debugName: "loadingRow" }] : []));
+        this.rowInjectorsCache = new Map();
+        this.hasExpressions = false;
+        this.pendingEvaluations = new Set();
+        this.changeDetectionScheduled = false;
+        this.MAX_CACHE_SIZE = 1000; // Limit cache size to prevent memory leaks
         this.injector = inject(Injector);
         this.cdr = inject(ChangeDetectorRef);
     }
@@ -1259,6 +1269,8 @@ class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
         }, {});
         //
         this.mergedOptions.set(merge(props, this.node.options) || {});
+        // Check if options contain expressions (performance optimization)
+        this.hasExpressions = this.checkForExpressions(this.mergedOptions());
         const tokenValue = {
             path: this.node.path,
             options: this.mergedOptions(),
@@ -1276,12 +1288,164 @@ class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
         this.allowResizing = this.mergedOptions().allowResizing || true;
         this.cdr.detectChanges();
     }
+    //#region ----   Performance Optimization Methods   ----
+    /**
+     * Check if options contain any expressions that need evaluation
+     */
+    checkForExpressions(obj) {
+        if (typeof obj === 'string') {
+            return this.expressionEvaluator.isExpression(obj);
+        }
+        if (Array.isArray(obj)) {
+            return obj.some((item) => this.checkForExpressions(item));
+        }
+        if (obj && typeof obj === 'object') {
+            return Object.values(obj).some((value) => this.checkForExpressions(value));
+        }
+        return false;
+    }
+    /**
+     * Get cache key for row data - optimized to avoid JSON.stringify when possible
+     */
+    getCacheKey(data) {
+        if (data?.id) {
+            return `row-${data.id}`;
+        }
+        // Use a hash of key properties instead of full JSON.stringify
+        // This is much faster for large objects
+        const keyProps = ['id', 'code', 'name', 'title'];
+        const keyValues = keyProps.map((prop) => data?.[prop]).filter((v) => v != null);
+        if (keyValues.length > 0) {
+            return `row-${keyValues.join('-')}`;
+        }
+        // Fallback to JSON.stringify only if no key properties exist
+        // But limit the stringified size to prevent performance issues
+        try {
+            const str = JSON.stringify(data);
+            return str.length > 1000 ? `row-${str.substring(0, 1000)}` : `row-${str}`;
+        }
+        catch {
+            // If JSON.stringify fails, use a simple hash
+            return `row-${Object.keys(data || {}).length}`;
+        }
+    }
+    /**
+     * Schedule change detection (debounced to batch multiple updates)
+     */
+    scheduleChangeDetection() {
+        if (this.changeDetectionScheduled) {
+            return;
+        }
+        this.changeDetectionScheduled = true;
+        // Use requestAnimationFrame for better performance
+        requestAnimationFrame(() => {
+            this.cdr.detectChanges();
+            this.changeDetectionScheduled = false;
+        });
+    }
+    /**
+     * Limit cache size using simple FIFO eviction
+     */
+    evictCacheIfNeeded() {
+        if (this.rowInjectorsCache.size >= this.MAX_CACHE_SIZE) {
+            // Remove oldest entries (first 25% of cache)
+            const entriesToRemove = Math.floor(this.MAX_CACHE_SIZE * 0.25);
+            const keysToRemove = Array.from(this.rowInjectorsCache.keys()).slice(0, entriesToRemove);
+            keysToRemove.forEach((key) => this.rowInjectorsCache.delete(key));
+        }
+    }
+    //#endregion
     getInputs(data) {
         return {
-            rawValue: getSmart(data, this.node.path),
+            rawValue: get(data, this.node.path),
             rowData: data,
         };
     }
+    getRowInjector(data) {
+        // Optimized cache key generation
+        const cacheKey = this.getCacheKey(data);
+        // Check if we have a cached injector for this row
+        let rowInjector = this.rowInjectorsCache.get(cacheKey);
+        if (!rowInjector) {
+            // If no expressions in options, use original options directly (performance optimization)
+            if (!this.hasExpressions) {
+                const tokenValue = {
+                    path: this.node.path,
+                    options: this.mergedOptions(),
+                };
+                rowInjector = Injector.create({
+                    parent: this.injector,
+                    providers: [
+                        {
+                            provide: AXP_WIDGET_COLUMN_TOKEN,
+                            useValue: tokenValue,
+                        },
+                    ],
+                });
+                this.evictCacheIfNeeded();
+                this.rowInjectorsCache.set(cacheKey, rowInjector);
+                return rowInjector;
+            }
+            // Check if evaluation is already pending for this row
+            if (!this.pendingEvaluations.has(cacheKey)) {
+                this.pendingEvaluations.add(cacheKey);
+                // Evaluate expressions in options based on row data
+                const scope = {
+                    ...(data ?? {}),
+                    context: {
+                        eval: (path) => {
+                            return getSmart(data, path);
+                        },
+                    },
+                };
+                // Start async evaluation - will update injector when complete
+                this.expressionEvaluator.evaluate(this.mergedOptions(), scope).then((evaluatedOptions) => {
+                    // Create injector with evaluated options
+                    const tokenValue = {
+                        path: this.node.path,
+                        options: evaluatedOptions,
+                    };
+                    const newInjector = Injector.create({
+                        parent: this.injector,
+                        providers: [
+                            {
+                                provide: AXP_WIDGET_COLUMN_TOKEN,
+                                useValue: tokenValue,
+                            },
+                        ],
+                    });
+                    // Replace cached injector to force component recreation on next render
+                    this.rowInjectorsCache.delete(cacheKey);
+                    this.evictCacheIfNeeded();
+                    this.rowInjectorsCache.set(cacheKey, newInjector);
+                    this.pendingEvaluations.delete(cacheKey);
+                    // Schedule batched change detection (performance optimization)
+                    this.scheduleChangeDetection();
+                }).catch(() => {
+                    // If evaluation fails, keep using the fallback injector
+                    this.pendingEvaluations.delete(cacheKey);
+                });
+            }
+            // Create injector with original options as fallback (will be updated when evaluation completes)
+            const tokenValue = {
+                path: this.node.path,
+                options: this.mergedOptions(),
+            };
+            rowInjector = Injector.create({
+                parent: this.injector,
+                providers: [
+                    {
+                        provide: AXP_WIDGET_COLUMN_TOKEN,
+                        useValue: tokenValue,
+                    },
+                ],
+            });
+            // Cache the initial injector
+            this.evictCacheIfNeeded();
+            this.rowInjectorsCache.set(cacheKey, rowInjector);
+        }
+        return rowInjector;
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWidgetColumnRendererComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.12", type: AXPWidgetColumnRendererComponent, isStandalone: false, selector: "axp-widget-column-renderer", inputs: { caption: "caption", customExpandIcon: "customExpandIcon", customCollapseIcon: "customCollapseIcon", customWidth: "customWidth", node: "node", footerTemplate: "footerTemplate", expandHandler: "expandHandler", cellTemplate: "cellTemplate", headerTemplate: "headerTemplate" }, providers: [
             AXPWidgetCoreService,
@@ -1309,9 +1473,9 @@ class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
             }
           </div>
         }
-        @if (component && widgetInjector && row?.data) {
+        @if (component && row?.data) {
           <ng-container
-            *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"
+            *ngComponentOutlet="component; injector: getRowInjector(row.data); inputs: getInputs(row.data)"
           ></ng-container>
         }
       </div>
@@ -1346,9 +1510,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
             }
           </div>
         }
-        @if (component && widgetInjector && row?.data) {
+        @if (component && row?.data) {
           <ng-container
-            *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"
+            *ngComponentOutlet="component; injector: getRowInjector(row.data); inputs: getInputs(row.data)"
           ></ng-container>
         }
       </div>
@@ -1472,6 +1636,7 @@ class AXPWidgetRendererDirective {
         this.options = this._options.asReadonly();
         this.onOptionsChanged = output();
         this.onValueChanged = output();
+        this.onLoad = output();
         //#region ----   Public API   ----
         /**
          * Signal that emits the component reference when it's ready
@@ -1496,6 +1661,7 @@ class AXPWidgetRendererDirective {
         this.renderTimeoutId = null;
         this.hasInitialRender = false;
         this.onContextChanged = new Subject();
+        this.onLoadEvent = new Subject();
         //#region ----   Performance Optimization Properties   ----
         this.contextUpdateQueue = new Set();
         this.contextUpdateTimeout = null;
@@ -1514,14 +1680,33 @@ class AXPWidgetRendererDirective {
             const changed = this.contextService.changeEvent();
             // Don't trigger re-render during initial setup
             if (!this.hasInitialRender) {
-                if (changed.path) {
+                // Handle initial context set (state: 'initiated' with empty path means full context update)
+                if (changed.state === 'initiated' && (!changed.path || changed.path === '')) {
+                    // Mark that we need to re-evaluate all expressions when initial render completes
+                    // This handles the case where context is set before/during widget initialization
+                    this.preRenderContextQueue.add('*'); // Use '*' as a marker for full context initialization
+                    // console.log(`📝 [${this.node().type}] Buffered initial context set`);
+                }
+                else if (changed.path) {
                     this.preRenderContextQueue.add(changed.path);
                     // console.log(`📝 [${this.node().type}] Buffered pre-render context change: ${changed.path}`);
                 }
                 return;
             }
             // CRITICAL PERFORMANCE FIX: Only respond to relevant context changes
-            if (changed.path && this.isRelevantContextChange(changed.path)) {
+            // Handle initial context set (full context update)
+            if (changed.state === 'initiated' && (!changed.path || changed.path === '')) {
+                // Full context initialization - trigger re-evaluation of all expressions
+                // console.log(`🎯 [${this.node().type}] Initial context set detected - triggering full re-evaluation`);
+                this.clearExpressionCache();
+                if (this.expressionEvaluators.size > 0) {
+                    await this.updateOptionsBasedOnContext();
+                    this.applyOptions();
+                }
+                await this.updateVisibility();
+                await this.updateValueBasedOnFormula();
+            }
+            else if (changed.path && this.isRelevantContextChange(changed.path)) {
                 // console.log(`🎯 [${this.node().type}] Context change detected: ${changed.path}`);
                 this.queueContextUpdate(changed.path);
             }
@@ -1679,7 +1864,7 @@ class AXPWidgetRendererDirective {
                 let match;
                 while ((match = contextEvalRegex.exec(expressionValue)) !== null) {
                     const evalPath = match[1];
-                    // Normalize Id-suffixed segments to dot-id form (e.g., 'typeId' -> 'type.id', 'party.typeId' -> 'party.type.id')
+                    // Normalize Id-suffixed segments to dot-id form (e.g., 'typeId' -> 'type.id', 'person.typeId' -> 'person.type.id')
                     const normalizePath = (p) => {
                         if (!p)
                             return p;
@@ -1869,6 +2054,7 @@ class AXPWidgetRendererDirective {
         if (this.componentRef) {
             this.componentRef.destroy();
         }
+        this.onLoadEvent.complete();
     }
     async loadComponent() {
         if (this.isLoading()) {
@@ -1916,7 +2102,17 @@ class AXPWidgetRendererDirective {
             // Register expressions from widget defaults and node options to cover related-entity cases
             this.preprocessAndInitialOptions(cloneDeep(widget?.options));
             this.preprocessAndInitialOptions(cloneDeep(this.node().options));
-            await this.updateOptionsBasedOnContext();
+            // Check if context is available before evaluating expressions
+            // If context is empty, expressions will be re-evaluated after initial render
+            const contextData = this.contextService.data();
+            const hasContextData = contextData && Object.keys(contextData).length > 0;
+            if (hasContextData) {
+                await this.updateOptionsBasedOnContext();
+            }
+            else {
+                // Context not yet available - expressions will be evaluated after initial render
+                // when context is set (handled by the effect and preRenderContextQueue)
+            }
             //
             this._options.update((val) => ({ ...val, ...this.mergedOptions() }));
             // Evaluate default value
@@ -1980,13 +2176,33 @@ class AXPWidgetRendererDirective {
             await this.updateVisibility();
             // Process any buffered pre-render context changes now that the component is ready
             if (this.preRenderContextQueue.size > 0) {
-                // console.log(
-                //   `🚀 [${this.node().type}] Processing ${this.preRenderContextQueue.size} buffered pre-render changes`,
-                // );
-                this.preRenderContextQueue.forEach((p) => this.contextUpdateQueue.add(p));
-                this.preRenderContextQueue.clear();
-                await this.processBatchedUpdates();
+                // Check if we have a full context initialization marker
+                const hasFullContextInit = this.preRenderContextQueue.has('*');
+                if (hasFullContextInit) {
+                    // Full context was initialized - clear cache and re-evaluate all expressions
+                    // console.log(`🚀 [${this.node().type}] Processing initial context set - full re-evaluation`);
+                    this.clearExpressionCache();
+                    this.preRenderContextQueue.clear();
+                    // Re-evaluate all expressions since context is now available
+                    if (this.expressionEvaluators.size > 0) {
+                        await this.updateOptionsBasedOnContext();
+                        this.applyOptions();
+                    }
+                    await this.updateVisibility();
+                }
+                else {
+                    // console.log(
+                    //   `🚀 [${this.node().type}] Processing ${this.preRenderContextQueue.size} buffered pre-render changes`,
+                    // );
+                    this.preRenderContextQueue.forEach((p) => this.contextUpdateQueue.add(p));
+                    this.preRenderContextQueue.clear();
+                    await this.processBatchedUpdates();
+                }
             }
+            // Emit load event after widget is fully loaded
+            const loadEvent = { sender: this, widget: this.instance };
+            this.onLoadEvent.next(loadEvent);
+            this.onLoad.emit(loadEvent);
         }
         catch (error) {
             // console.error('Error loading component:', error);
@@ -2258,6 +2474,9 @@ class AXPWidgetRendererDirective {
                 }));
             },
             from: (event) => get(this.instance.api(), event),
+            load: () => {
+                return this.onLoadEvent.asObservable();
+            },
         };
     }
     getWidgetScope() {
@@ -2276,6 +2495,10 @@ class AXPWidgetRendererDirective {
                 if (refresh && typeof refresh === 'function') {
                     refresh.bind(this.instance)();
                 }
+                else {
+                    this.updateOptionsBasedOnContext();
+                    this.applyOptions();
+                }
             },
             output: (name) => {
                 this.instance.output(name);
@@ -2364,7 +2587,7 @@ class AXPWidgetRendererDirective {
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWidgetRendererDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.12", type: AXPWidgetRendererDirective, isStandalone: false, selector: "[axp-widget-renderer]", inputs: { parentNode: { classPropertyName: "parentNode", publicName: "parentNode", isSignal: true, isRequired: false, transformFunction: null }, index: { classPropertyName: "index", publicName: "index", isSignal: true, isRequired: false, transformFunction: null }, mode: { classPropertyName: "mode", publicName: "mode", isSignal: true, isRequired: true, transformFunction: null }, node: { classPropertyName: "node", publicName: "node", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { onOptionsChanged: "onOptionsChanged", onValueChanged: "onValueChanged" }, providers: [
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.12", type: AXPWidgetRendererDirective, isStandalone: false, selector: "[axp-widget-renderer]", inputs: { parentNode: { classPropertyName: "parentNode", publicName: "parentNode", isSignal: true, isRequired: false, transformFunction: null }, index: { classPropertyName: "index", publicName: "index", isSignal: true, isRequired: false, transformFunction: null }, mode: { classPropertyName: "mode", publicName: "mode", isSignal: true, isRequired: true, transformFunction: null }, node: { classPropertyName: "node", publicName: "node", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { onOptionsChanged: "onOptionsChanged", onValueChanged: "onValueChanged", onLoad: "onLoad" }, providers: [
             {
                 provide: AXUnsubscriber,
             },
@@ -2382,7 +2605,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                     ],
                     standalone: false,
                 }]
-        }], ctorParameters: () => [], propDecorators: { parentNode: [{ type: i0.Input, args: [{ isSignal: true, alias: "parentNode", required: false }] }], index: [{ type: i0.Input, args: [{ isSignal: true, alias: "index", required: false }] }], mode: [{ type: i0.Input, args: [{ isSignal: true, alias: "mode", required: true }] }], node: [{ type: i0.Input, args: [{ isSignal: true, alias: "node", required: true }] }], onOptionsChanged: [{ type: i0.Output, args: ["onOptionsChanged"] }], onValueChanged: [{ type: i0.Output, args: ["onValueChanged"] }] } });
+        }], ctorParameters: () => [], propDecorators: { parentNode: [{ type: i0.Input, args: [{ isSignal: true, alias: "parentNode", required: false }] }], index: [{ type: i0.Input, args: [{ isSignal: true, alias: "index", required: false }] }], mode: [{ type: i0.Input, args: [{ isSignal: true, alias: "mode", required: true }] }], node: [{ type: i0.Input, args: [{ isSignal: true, alias: "node", required: true }] }], onOptionsChanged: [{ type: i0.Output, args: ["onOptionsChanged"] }], onValueChanged: [{ type: i0.Output, args: ["onValueChanged"] }], onLoad: [{ type: i0.Output, args: ["onLoad"] }] } });
 
 const COMPONENTS = [AXPWidgetContainerComponent, AXPWidgetColumnRendererComponent, AXPWidgetRendererDirective];
 class AXPWidgetCoreModule {
@@ -2658,158 +2881,9 @@ var AXPWidgetGroupEnum;
     AXPWidgetGroupEnum["UtilityWidget"] = "utility-widget";
 })(AXPWidgetGroupEnum || (AXPWidgetGroupEnum = {}));
 
-class AXPWidgetStandaloneRendererHostComponent {
-    constructor() {
-        this.mode = 'edit';
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWidgetStandaloneRendererHostComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.12", type: AXPWidgetStandaloneRendererHostComponent, isStandalone: true, selector: "axp-widget-standalone-renderer-host", inputs: { mode: "mode", node: "node", context: "context", functions: "functions" }, ngImport: i0, template: `
-    <axp-widgets-container [context]="context" [functions]="functions">
-      <ng-container axp-widget-renderer [mode]="mode" [node]="node"></ng-container>
-    </axp-widgets-container>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: AXPWidgetCoreModule }, { kind: "component", type: AXPWidgetContainerComponent, selector: "axp-widgets-container", inputs: ["context", "functions"], outputs: ["onContextChanged"] }, { kind: "directive", type: AXPWidgetRendererDirective, selector: "[axp-widget-renderer]", inputs: ["parentNode", "index", "mode", "node"], outputs: ["onOptionsChanged", "onValueChanged"], exportAs: ["widgetRenderer"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWidgetStandaloneRendererHostComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'axp-widget-standalone-renderer-host',
-                    template: `
-    <axp-widgets-container [context]="context" [functions]="functions">
-      <ng-container axp-widget-renderer [mode]="mode" [node]="node"></ng-container>
-    </axp-widgets-container>
-  `,
-                    standalone: true,
-                    imports: [AXPWidgetCoreModule]
-                }]
-        }], propDecorators: { mode: [{
-                type: Input
-            }], node: [{
-                type: Input
-            }], context: [{
-                type: Input
-            }], functions: [{
-                type: Input
-            }] } });
-
-const LAYOUT_WIDGET_RENDER_ENGINE = new InjectionToken('LAYOUT_WIDGET_RENDER_ENGINE');
-class WidgetCoreRendererEngine {
-    constructor(appRef, env) {
-        this.appRef = appRef;
-        this.env = env;
-    }
-    render(node, target, context, mode = 'edit') {
-        const compRef = createComponent(AXPWidgetStandaloneRendererHostComponent, { environmentInjector: this.env });
-        compRef.setInput('mode', mode);
-        compRef.setInput('node', node);
-        if (context) {
-            compRef.setInput('context', context);
-        }
-        this.appRef.attachView(compRef.hostView);
-        target.appendChild(compRef.location.nativeElement);
-        return {
-            element: compRef.location.nativeElement,
-            destroy: () => {
-                try {
-                    this.appRef.detachView(compRef.hostView);
-                }
-                catch { }
-                compRef.destroy();
-            },
-        };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: WidgetCoreRendererEngine, deps: [{ token: i0.ApplicationRef }, { token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: WidgetCoreRendererEngine, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: WidgetCoreRendererEngine, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i0.ApplicationRef }, { type: i0.EnvironmentInjector }] });
-class SimpleDomRendererEngine {
-    render(node, target) {
-        const element = this.createElement(node);
-        target.appendChild(element);
-        return {
-            element,
-            destroy: () => {
-                if (element.parentElement) {
-                    element.parentElement.removeChild(element);
-                }
-            },
-        };
-    }
-    createElement(node) {
-        const container = document.createElement('div');
-        container.className = `axp-widget axp-widget-${node.type}`;
-        switch (String(node.type)) {
-            case 'text-block-layout':
-            case 'static-text':
-                this.renderText(container, node);
-                break;
-            case 'tag':
-                this.renderTag(container, node);
-                break;
-            case 'text-editor':
-                this.renderTextBox(container, node);
-                break;
-            default:
-                this.renderGeneric(container, node);
-                break;
-        }
-        return container;
-    }
-    renderText(container, node) {
-        const anyNode = node;
-        const content = (anyNode.options && (anyNode.options.content || anyNode.options.label)) || '';
-        container.innerHTML = typeof content === 'string' ? content : String(content);
-    }
-    renderTag(container, node) {
-        const label = node.options?.label || 'Tag';
-        const tone = node.options?.tone || 'primary';
-        container.innerHTML = `<span class="tag tag-${tone}" style="
-      display: inline-block;
-      padding: 4px 12px;
-      border-radius: 12px;
-      font-size: 12px;
-      font-weight: 500;
-      background: ${tone === 'success' ? '#d4edda' : '#cce5ff'};
-      color: ${tone === 'success' ? '#155724' : '#004085'};
-      border: 1px solid ${tone === 'success' ? '#c3e6cb' : '#b8daff'};
-    ">${label}</span>`;
-    }
-    renderTextBox(container, node) {
-        const placeholder = node.options?.placeholder || '';
-        const input = document.createElement('input');
-        input.type = 'text';
-        input.placeholder = placeholder;
-        input.style.cssText = `
-      width: 100%;
-      padding: 8px 12px;
-      border: 1px solid #ddd;
-      border-radius: 4px;
-      font-size: 14px;
-    `;
-        container.appendChild(input);
-    }
-    renderGeneric(container, node) {
-        const anyNode = node;
-        if (anyNode.options?.content) {
-            container.innerHTML = anyNode.options.content;
-        }
-        else {
-            container.textContent = `[${String(node.type)}]`;
-        }
-    }
-}
-function provideWidgetCoreRenderer() {
-    return [{ provide: LAYOUT_WIDGET_RENDER_ENGINE, useClass: WidgetCoreRendererEngine }];
-}
-function provideSimpleDomRenderer() {
-    return [{ provide: LAYOUT_WIDGET_RENDER_ENGINE, useClass: SimpleDomRendererEngine }];
-}
-
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXPBaseWidgetComponent, AXPBlockBaseLayoutWidgetComponent, AXPBoxModelLayoutWidgetComponent, AXPColumnWidgetComponent, AXPDataListWidgetComponent, AXPFlexBaseLayoutWidgetComponent, AXPFlexItemBaseLayoutWidgetComponent, AXPGridBaseLayoutWidgetComponent, AXPGridItemBaseLayoutWidgetComponent, AXPInlineBaseLayoutWidgetComponent, AXPLayoutBaseWidgetComponent, AXPPageStatus, AXPPropertyEditorHelper, AXPTableBaseLayoutWidgetComponent, AXPTableItemBaseLayoutWidgetComponent, AXPTableItemOpsBaseLayoutWidgetComponent, AXPValueWidgetComponent, AXPWidgetColumnRendererComponent, AXPWidgetContainerComponent, AXPWidgetCoreContextChangeEvent, AXPWidgetCoreContextStore, AXPWidgetCoreElement, AXPWidgetCoreModule, AXPWidgetCoreService, AXPWidgetGroupEnum, AXPWidgetRegistryService, AXPWidgetRendererDirective, AXPWidgetStandaloneRendererHostComponent, AXPWidgetStatus, AXPWidgetsCatalog, AXP_WIDGETS_ACTION_CATEGORY, AXP_WIDGETS_ADVANCE_CATEGORY, AXP_WIDGETS_CATEGORIES, AXP_WIDGETS_EDITOR_CATEGORY, AXP_WIDGETS_LAYOUT_CATEGORY, AXP_WIDGET_COLUMN_TOKEN, AXP_WIDGET_TOKEN, LAYOUT_WIDGET_RENDER_ENGINE, SimpleDomRendererEngine, WidgetCoreRendererEngine, cloneProperty, createBooleanProperty, createNumberProperty, createSelectProperty, createStringProperty, findNonEmptyBreakpoints, provideSimpleDomRenderer, provideWidgetCoreRenderer };
+export { AXPBaseWidgetComponent, AXPBlockBaseLayoutWidgetComponent, AXPBoxModelLayoutWidgetComponent, AXPColumnWidgetComponent, AXPDataListWidgetComponent, AXPFlexBaseLayoutWidgetComponent, AXPFlexItemBaseLayoutWidgetComponent, AXPGridBaseLayoutWidgetComponent, AXPGridItemBaseLayoutWidgetComponent, AXPInlineBaseLayoutWidgetComponent, AXPLayoutBaseWidgetComponent, AXPPageStatus, AXPPropertyEditorHelper, AXPTableBaseLayoutWidgetComponent, AXPTableItemBaseLayoutWidgetComponent, AXPTableItemOpsBaseLayoutWidgetComponent, AXPValueWidgetComponent, AXPWidgetColumnRendererComponent, AXPWidgetContainerComponent, AXPWidgetCoreContextChangeEvent, AXPWidgetCoreContextStore, AXPWidgetCoreElement, AXPWidgetCoreModule, AXPWidgetCoreService, AXPWidgetGroupEnum, AXPWidgetRegistryService, AXPWidgetRendererDirective, AXPWidgetStatus, AXPWidgetsCatalog, AXP_WIDGETS_ACTION_CATEGORY, AXP_WIDGETS_ADVANCE_CATEGORY, AXP_WIDGETS_CATEGORIES, AXP_WIDGETS_EDITOR_CATEGORY, AXP_WIDGETS_LAYOUT_CATEGORY, AXP_WIDGET_COLUMN_TOKEN, AXP_WIDGET_TOKEN, cloneProperty, createBooleanProperty, createNumberProperty, createSelectProperty, createStringProperty, findNonEmptyBreakpoints };
 //# sourceMappingURL=acorex-platform-layout-widget-core.mjs.map