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

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 } 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 { convertArrayToDataSource, AXDataSource } from '@acorex/cdk/common';
-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 { 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 { Subject, BehaviorSubject, filter } from 'rxjs';
 import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
 import * as i1$1 from '@acorex/components/skeleton';
@@ -125,10 +125,6 @@ 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;
@@ -332,6 +328,8 @@ 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',
@@ -393,9 +391,8 @@ 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) {
@@ -599,8 +596,7 @@ class AXPValueWidgetComponent extends AXPLayoutBaseWidgetComponent {
         this._isValueWidget = this.config.properties?.some((c) => c.name == 'path') ?? false;
         if (this.isValueWidget()) {
             this.detectFullPath();
-            // Set defaultValue if it exists and the path doesn't exist in context
-            if (!isNil(this.defaultValue) && this.fullPath() && !this.contextService.hasValue(this.fullPath())) {
+            if (!isNil(this.defaultValue) && isNil(this.getValue())) {
                 this.setValue(this.defaultValue);
             }
         }
@@ -1216,14 +1212,8 @@ 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);
     }
@@ -1269,8 +1259,6 @@ 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(),
@@ -1288,164 +1276,12 @@ 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: get(data, this.node.path),
+            rawValue: getSmart(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,
@@ -1473,9 +1309,9 @@ class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
             }
           </div>
         }
-        @if (component && row?.data) {
+        @if (component && widgetInjector && row?.data) {
           <ng-container
-            *ngComponentOutlet="component; injector: getRowInjector(row.data); inputs: getInputs(row.data)"
+            *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"
           ></ng-container>
         }
       </div>
@@ -1510,9 +1346,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
             }
           </div>
         }
-        @if (component && row?.data) {
+        @if (component && widgetInjector && row?.data) {
           <ng-container
-            *ngComponentOutlet="component; injector: getRowInjector(row.data); inputs: getInputs(row.data)"
+            *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"
           ></ng-container>
         }
       </div>
@@ -1636,7 +1472,6 @@ 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
@@ -1661,7 +1496,6 @@ 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;
@@ -1680,33 +1514,14 @@ class AXPWidgetRendererDirective {
             const changed = this.contextService.changeEvent();
             // Don't trigger re-render during initial setup
             if (!this.hasInitialRender) {
-                // 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) {
+                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
-            // 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)) {
+            if (changed.path && this.isRelevantContextChange(changed.path)) {
                 // console.log(`🎯 [${this.node().type}] Context change detected: ${changed.path}`);
                 this.queueContextUpdate(changed.path);
             }
@@ -1864,7 +1679,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', 'person.typeId' -> 'person.type.id')
+                    // Normalize Id-suffixed segments to dot-id form (e.g., 'typeId' -> 'type.id', 'party.typeId' -> 'party.type.id')
                     const normalizePath = (p) => {
                         if (!p)
                             return p;
@@ -2054,7 +1869,6 @@ class AXPWidgetRendererDirective {
         if (this.componentRef) {
             this.componentRef.destroy();
         }
-        this.onLoadEvent.complete();
     }
     async loadComponent() {
         if (this.isLoading()) {
@@ -2102,17 +1916,7 @@ 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));
-            // 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)
-            }
+            await this.updateOptionsBasedOnContext();
             //
             this._options.update((val) => ({ ...val, ...this.mergedOptions() }));
             // Evaluate default value
@@ -2176,33 +1980,13 @@ class AXPWidgetRendererDirective {
             await this.updateVisibility();
             // Process any buffered pre-render context changes now that the component is ready
             if (this.preRenderContextQueue.size > 0) {
-                // 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();
-                }
+                // 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);
@@ -2474,9 +2258,6 @@ class AXPWidgetRendererDirective {
                 }));
             },
             from: (event) => get(this.instance.api(), event),
-            load: () => {
-                return this.onLoadEvent.asObservable();
-            },
         };
     }
     getWidgetScope() {
@@ -2495,10 +2276,6 @@ class AXPWidgetRendererDirective {
                 if (refresh && typeof refresh === 'function') {
                     refresh.bind(this.instance)();
                 }
-                else {
-                    this.updateOptionsBasedOnContext();
-                    this.applyOptions();
-                }
             },
             output: (name) => {
                 this.instance.output(name);
@@ -2587,7 +2364,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", onLoad: "onLoad" }, 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" }, providers: [
             {
                 provide: AXUnsubscriber,
             },
@@ -2605,7 +2382,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"] }], onLoad: [{ type: i0.Output, args: ["onLoad"] }] } });
+        }], 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"] }] } });
 
 const COMPONENTS = [AXPWidgetContainerComponent, AXPWidgetColumnRendererComponent, AXPWidgetRendererDirective];
 class AXPWidgetCoreModule {
@@ -2881,9 +2658,158 @@ 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, 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 };
+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 };
 //# sourceMappingURL=acorex-platform-layout-widget-core.mjs.map