@acorex/platform 0.0.0-ACOREX

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

@@ -0,0 +1,2950 @@
+import * as i0 from '@angular/core';
+import { signal, computed, Injectable, InjectionToken, inject, ElementRef, effect, untracked, Injector, ChangeDetectorRef, ViewChild, Input, ChangeDetectionStrategy, Component, EventEmitter, Output, input, output, ViewContainerRef, Directive, NgModule } from '@angular/core';
+import { convertArrayToDataSource, AXDataSource } from '@acorex/cdk/common';
+import { AXPContextStore, AXPDataSourceDefinitionProviderService, extractValue, AXPExpressionEvaluatorService, getSmart } from '@acorex/platform/core';
+import { set, merge, cloneDeep, isNil, get, isEqual, isUndefined, isObjectLike, sum, isEmpty, isString } from 'lodash-es';
+import { Subject, BehaviorSubject, filter } from 'rxjs';
+import * as i1$1 from '@acorex/components/skeleton';
+import { AXSkeletonModule } from '@acorex/components/skeleton';
+import * as i2 from '@acorex/core/translation';
+import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
+import { PortalModule } from '@angular/cdk/portal';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { AXDataTableColumnComponent, AXBaseDataTable } from '@acorex/components/data-table';
+import { AXUnsubscriber } from '@acorex/core/utils';
+
+var AXPPageStatus;
+(function (AXPPageStatus) {
+    // Idle statuses
+    AXPPageStatus["Idle"] = "idle";
+    // Rendering statuses
+    AXPPageStatus["Rendering"] = "rendering";
+    AXPPageStatus["Rendered"] = "rendered";
+    // Processing statuses
+    AXPPageStatus["Processing"] = "processing";
+    // Submission statuses
+    AXPPageStatus["Submitting"] = "submitting";
+    AXPPageStatus["Submitted"] = "submitted";
+    // Validation statuses
+    AXPPageStatus["Validating"] = "validating";
+    AXPPageStatus["Validated"] = "validated";
+    // Error handling
+    AXPPageStatus["Error"] = "error";
+})(AXPPageStatus || (AXPPageStatus = {}));
+var AXPWidgetStatus;
+(function (AXPWidgetStatus) {
+    // Rendering statuses
+    AXPWidgetStatus["Rendering"] = "rendering";
+    AXPWidgetStatus["Rendered"] = "rendered";
+    // Processing statuses
+    AXPWidgetStatus["Processing"] = "processing";
+    // Error handling
+    AXPWidgetStatus["Error"] = "error";
+})(AXPWidgetStatus || (AXPWidgetStatus = {}));
+
+class AXPWidgetCoreElement {
+    api() {
+        return {};
+    }
+    actions() {
+        return [];
+    }
+}
+class AXPWidgetCoreService {
+    constructor() {
+        this.variables$ = signal({}, ...(ngDevMode ? [{ debugName: "variables$" }] : /* istanbul ignore next */ []));
+        this.functions$ = signal({}, ...(ngDevMode ? [{ debugName: "functions$" }] : /* istanbul ignore next */ []));
+        this.onRefresh = new Subject();
+        this.widgets = new Map();
+        this.onWidgetRegistered = new Subject();
+        this.status$ = signal(AXPPageStatus.Rendering, ...(ngDevMode ? [{ debugName: "status$" }] : /* istanbul ignore next */ []));
+        this.status = this.status$.asReadonly();
+        this.isBusy = computed(() => {
+            return [AXPPageStatus.Processing, AXPPageStatus.Submitting, AXPPageStatus.Rendering].includes(this.status());
+        }, ...(ngDevMode ? [{ debugName: "isBusy" }] : /* istanbul ignore next */ []));
+        this.registeredWidgetsCount = signal(0, ...(ngDevMode ? [{ debugName: "registeredWidgetsCount" }] : /* istanbul ignore next */ []));
+    }
+    get variables() {
+        return this.variables$();
+    }
+    get functions() {
+        return this.functions$();
+    }
+    updateStatus() {
+        this.status$.update(() => this.detectStatus());
+        this.registeredWidgetsCount.set(this.widgets.size);
+    }
+    detectStatus() {
+        const statuses = Array.from(this.widgets.values()).map((c) => c.status());
+        // Rendering statuses
+        if (statuses.some((status) => status === AXPWidgetStatus.Rendering)) {
+            return AXPPageStatus.Rendering;
+        }
+        if (statuses.every((status) => status === AXPWidgetStatus.Rendered)) {
+            return AXPPageStatus.Rendered;
+        }
+        // Processing statuses
+        if (statuses.some((status) => status === AXPWidgetStatus.Processing)) {
+            return AXPPageStatus.Processing;
+        }
+        // Error handling
+        if (statuses.some((status) => status === AXPWidgetStatus.Error)) {
+            return AXPPageStatus.Error;
+        }
+        return AXPPageStatus.Rendered; // Default to Loaded when all widgets are in a completed state
+    }
+    refresh() {
+        setTimeout(() => {
+            this.onRefresh.next();
+        }, 0);
+    }
+    setStatus(status) {
+        this.status$.set(status);
+    }
+    setVariables(...args) {
+        if (args.length == 0)
+            return;
+        else if (args.length == 1)
+            this.variables$.set(args[0]);
+        else if (args.length == 2) {
+            this.variables$.update((v) => set(v, args[0], args[1]));
+        }
+    }
+    setFunctions(...args) {
+        if (args.length == 0)
+            return;
+        else if (args.length == 1)
+            this.functions$.set(args[0]);
+        else if (args.length == 2) {
+            this.functions$.update((v) => set(v, args[0], args[1]));
+        }
+    }
+    registerWidget(id, widget) {
+        this.widgets.set(id, widget);
+        this.onWidgetRegistered.next({ id, widget });
+    }
+    getWidget(id) {
+        return this.widgets.get(id);
+    }
+    /**
+     * Waits until a widget with the given id is registered, then resolves with it.
+     * If the widget is already registered, resolves immediately.
+     * Optionally accepts a timeout (in ms) after which it resolves with undefined.
+     */
+    async waitForWidget(id, timeoutMs) {
+        const existing = this.widgets.get(id);
+        if (existing) {
+            return existing;
+        }
+        return new Promise((resolve) => {
+            let resolved = false;
+            let timer = null;
+            const sub = this.onWidgetRegistered.subscribe(({ id: registeredId, widget }) => {
+                if (registeredId === id && !resolved) {
+                    resolved = true;
+                    sub.unsubscribe();
+                    if (timer) {
+                        clearTimeout(timer);
+                    }
+                    resolve(widget);
+                }
+            });
+            if (timeoutMs != null && timeoutMs > 0) {
+                timer = setTimeout(() => {
+                    if (!resolved) {
+                        resolved = true;
+                        sub.unsubscribe();
+                        resolve(undefined);
+                    }
+                }, timeoutMs);
+            }
+        });
+    }
+    /**
+     * Returns a list of registered widget ids (names).
+     */
+    listRegisteredWidgetNames() {
+        return Array.from(this.widgets.keys());
+    }
+    ngOnDestroy() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetCoreService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetCoreService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetCoreService, decorators: [{
+            type: Injectable
+        }] });
+
+//
+// @deprecated
+// use AXPWidgetsList instead
+const AXPWidgetsCatalog = {
+    timeDuration: 'time-duration',
+    timeDurationFilter: 'time-duration-filter',
+    checkbox: 'checkbox-editor',
+    color: 'color-editor',
+    connectedLists: 'connected-lists-editor',
+    list: 'list-editor',
+    contact: 'contact-editor',
+    dateTime: 'date-time-editor',
+    largeText: 'large-text-editor',
+    number: 'number-editor',
+    numberUnit: 'number-unit-editor',
+    password: 'password-editor',
+    richText: 'rich-text-editor',
+    select: 'select-editor',
+    selectionList: 'selection-list-editor',
+    text: 'text-editor',
+    table: 'table-editor',
+    toggle: 'toggle-editor',
+    blockLayout: 'block-layout',
+    pageLayout: 'page-layout',
+    repeaterLayout: 'repeater-layout',
+    textBlockLayout: 'text-block-layout',
+    alertBoxLayout: 'alert-box-layout',
+    fileUploader: 'file-uploader',
+    fileTypeExtension: 'file-type-extension',
+    map: 'map',
+    imageMarker: 'image-marker',
+    image: 'image',
+    gallery: 'gallery',
+    signature: 'signature',
+    buttonAction: 'button-action',
+    document: 'document-layout',
+    lookup: 'lookup-editor',
+    formField: 'form-field',
+    qrcode: 'qrcode',
+    schedulerPicker: 'scheduler-picker',
+    advancedGrid: 'advanced-grid-layout',
+    advancedGridItem: 'advanced-grid-item-layout',
+    grid: 'grid-layout',
+    gridItem: 'grid-item-layout',
+    template: 'template',
+    templateDesigner: 'template-designer',
+    cronJob: 'cron-job',
+    spacing: 'spacing',
+    direction: 'direction',
+    border: 'border',
+    flexLayout: 'flex-layout',
+    flexItem: 'flex-item-layout',
+    tableLayout: 'table-layout',
+    tableItem: 'table-item-layout',
+    avatar: 'avatar',
+    themePaletteChooser: 'theme-palette-chooser',
+    themeModeChooser: 'theme-mode-chooser',
+    menuOrientationChooser: 'menu-orientation-chooser',
+    fontStyleChooser: 'font-style-chooser',
+    fontSizeChooser: 'font-size-chooser',
+    iconChooser: 'icon-chooser',
+    icon: 'icon',
+    themeColorChooser: 'theme-color-chooser',
+    gridOptions: 'grid-options',
+    gridItemOptions: 'grid-item-options',
+    advancedGridOptions: 'advanced-grid-options',
+    stringFilter: 'string-filter',
+    numberFilter: 'number-filter',
+    dateTimeFilter: 'datetime-filter',
+    booleanFilter: 'boolean-filter',
+    lookupFilter: 'lookup-filter',
+    flexOptions: 'flex-options',
+    flexItemOptions: 'flex-item-options',
+    selectFilter: 'select-filter',
+    requiredValidation: 'required-validation',
+    regularExpressionValidation: 'regular-expression-validation',
+    minLengthValidation: 'min-length-validation',
+    maxLengthValidation: 'max-length-validation',
+    lessThanValidation: 'less-than-validation',
+    greaterThanValidation: 'greater-than-validation',
+    betweenValidation: 'between-validation',
+    equalValidation: 'equal-validation',
+    callbackValidation: 'callback-validation',
+    donutChart: 'donut-chart',
+    lineChart: 'line-chart',
+    barChart: 'bar-chart',
+    gaugeChart: 'gauge-chart',
+    stickyNote: 'sticky-note',
+    clockCalendar: 'clock-calendar',
+    analogClock: 'analog-clock',
+    weather: 'weather',
+    minimalWeather: 'minimal-weather',
+    advancedWeather: 'advanced-weather',
+    metaData: 'meta-data-editor',
+    templateEditor: 'template-box-editor',
+    templateContentEditor: 'template-content-editor',
+    panel: 'panel',
+    notification: 'notification',
+    taskBoard: 'task-board',
+    comment: 'comment',
+    dataList: 'data-list',
+    listToolbar: 'list-toolbar',
+    entityList: 'entity-list',
+    editorJs: 'editor-js-editor',
+    documentUploader: 'document-uploader',
+    stepWizard: 'step-wizard',
+    progressBar: 'progress-bar-editor',
+    rate: 'rate-picker-editor',
+    documentFileTypeFilter: 'document-file-type-filter',
+    entityDefinitionProvider: 'entity-definition-provider-editor',
+};
+
+function cloneProperty(property, values) {
+    return merge(cloneDeep(property), values);
+}
+function createStringProperty(ctor) {
+    return {
+        name: ctor.name,
+        title: ctor.title,
+        group: ctor.group,
+        schema: {
+            dataType: 'string',
+            defaultValue: ctor.defaultValue,
+            interface: {
+                name: ctor.name,
+                path: ctor.path ?? ctor.name,
+                type: AXPWidgetsCatalog.text,
+            },
+        },
+        visible: !isNil(ctor.visible) ? ctor.visible : true,
+    };
+}
+function createNumberProperty(ctor) {
+    return {
+        name: ctor.name,
+        title: ctor.title,
+        group: ctor.group,
+        schema: {
+            dataType: 'number',
+            defaultValue: ctor.defaultValue,
+            interface: {
+                name: ctor.name,
+                path: ctor.path ?? ctor.name,
+                type: AXPWidgetsCatalog.number,
+                options: ctor.options,
+            },
+        },
+        visible: !isNil(ctor.visible) ? ctor.visible : true,
+    };
+}
+function createBooleanProperty(ctor) {
+    return {
+        name: ctor.name,
+        title: ctor.title,
+        group: ctor.group,
+        schema: {
+            dataType: 'boolean',
+            defaultValue: ctor.defaultValue ?? false,
+            interface: {
+                name: ctor.name,
+                path: ctor.path ?? ctor.name,
+                type: AXPWidgetsCatalog.toggle,
+            },
+        },
+        visible: !isNil(ctor.visible) ? ctor.visible : true,
+        binding: {
+            enabled: true,
+        },
+    };
+}
+function createSelectProperty(ctor) {
+    return {
+        name: ctor.name,
+        title: ctor.title,
+        group: ctor.group,
+        schema: {
+            dataType: 'string',
+            defaultValue: Array.isArray(ctor.defaultValue)
+                ? ctor.defaultValue.map((item) => (typeof item === 'string' ? { id: item } : item))
+                : typeof ctor.defaultValue === 'string'
+                    ? { id: ctor.defaultValue, title: ctor.defaultValue }
+                    : ctor.defaultValue,
+            interface: {
+                name: ctor.name,
+                path: ctor.path ?? ctor.name,
+                type: AXPWidgetsCatalog.select,
+                options: {
+                    dataSource: ctor.dataSource.map((item) => (typeof item === 'string' ? { id: item, title: item } : item)),
+                },
+            },
+        },
+        visible: !isNil(ctor.visible) ? ctor.visible : true,
+    };
+}
+const AXP_WIDGET_TOKEN = new InjectionToken('AXP_WIDGET_TOKEN');
+const AXP_WIDGET_COLUMN_TOKEN = new InjectionToken('AXP_WIDGET_COLUMN_TOKEN');
+
+class AXPBaseWidgetComponent extends AXPWidgetCoreElement {
+    constructor() {
+        super(...arguments);
+        this.token = inject(AXP_WIDGET_TOKEN);
+        this.host = inject(ElementRef).nativeElement;
+        this.layoutService = inject(AXPWidgetCoreService);
+        this.contextService = inject(AXPContextStore);
+        this.config = this.token.config;
+        this.node = this.token.node;
+        this.name = this.token.node.name;
+        this.component = this;
+        this._options = signal(this.token.options ?? {}, ...(ngDevMode ? [{ debugName: "_options" }] : /* istanbul ignore next */ []));
+        this.options = this._options.asReadonly();
+        this.onOptionsChanged = new Subject();
+        this._status = signal(AXPWidgetStatus.Rendering, ...(ngDevMode ? [{ debugName: "_status" }] : /* istanbul ignore next */ []));
+        this.status = this._status.asReadonly();
+        this.onStatusChanged = new BehaviorSubject(this._status());
+        this.#statusEffect = effect(() => {
+            this.onStatusChanged.next(this.status());
+        }, ...(ngDevMode ? [{ debugName: "#statusEffect" }] : /* istanbul ignore next */ []));
+        this.isBusy = computed(() => [AXPWidgetStatus.Rendering, AXPWidgetStatus.Processing].includes(this.status()), ...(ngDevMode ? [{ debugName: "isBusy" }] : /* istanbul ignore next */ []));
+        this._children = signal(this.token.node.children ?? [], ...(ngDevMode ? [{ debugName: "_children" }] : /* istanbul ignore next */ []));
+        this.children = this._children.asReadonly();
+    }
+    get id() {
+        return this._id;
+    }
+    #statusEffect;
+    outputs() {
+        return [];
+    }
+    ngOnInit() {
+        if (get(this.node, '__meta__.added')) {
+            this.onAdded();
+        }
+        this.setStatus(AXPWidgetStatus.Rendered);
+    }
+    setStatus(status) {
+        this._status.set(status);
+        this.layoutService.updateStatus();
+    }
+    setOptions(values) {
+        const oldValue = this.options();
+        const value = cloneDeep(values);
+        this._options.set({ ...oldValue, ...value });
+        this.onOptionsChanged.next({ sender: this });
+    }
+    output(name) {
+        const outputs = this.outputs().map((c) => (typeof c == 'string' ? { name: c, value: c } : c));
+        if (outputs.some((c) => c.name == name)) {
+            const opt = get(this, name);
+            if (typeof opt == 'function') {
+                return opt();
+            }
+            return opt;
+        }
+        return null;
+    }
+    call(name, ...args) {
+        const fn = get(this, name);
+        if (fn && typeof fn == 'function') {
+            fn.bind(this)(...args);
+        }
+    }
+    setChildren(children) {
+        this._children.set([...children]);
+    }
+    onAdded() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBaseWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBaseWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBaseWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+class AXPLayoutBaseWidgetComponent extends AXPBaseWidgetComponent {
+    //TODO change this approach
+    ngOnInit() {
+        if (this.name && !(this instanceof AXPValueWidgetComponent)) {
+            this.layoutService.registerWidget(this.name, this);
+        }
+        super.ngOnInit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPLayoutBaseWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPLayoutBaseWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPLayoutBaseWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+class AXPValueWidgetComponent extends AXPLayoutBaseWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.path = this.token.node.path;
+        this.defaultValue = this.token.defaultValue ?? this.token.node.defaultValue;
+        this._isValueWidget = false;
+        this.isValueWidget = () => this._isValueWidget;
+        this.onValueChanged = new Subject();
+        this.fullPath = signal(null, ...(ngDevMode ? [{ debugName: "fullPath" }] : /* istanbul ignore next */ []));
+        this.parentPath = signal(null, ...(ngDevMode ? [{ debugName: "parentPath" }] : /* istanbul ignore next */ []));
+        this.getValue = computed(() => {
+            return this.fullPath() ? this.extractValue(this.fullPath()) : null;
+        }, { ...(ngDevMode ? { debugName: "getValue" } : /* istanbul ignore next */ {}), equal: isEqual });
+        this.validationRules = computed(() => {
+            const validationsRaw = this.options()['validations'];
+            if (validationsRaw == null) {
+                return [];
+            }
+            return Object.values(this.options()['validations'])
+                .filter((c) => c != null)
+                .map((c) => ({
+                rule: c.rule,
+                message: c.message,
+                options: c.options,
+            }));
+        }, ...(ngDevMode ? [{ debugName: "validationRules" }] : /* istanbul ignore next */ []));
+    }
+    ngOnInit() {
+        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())) {
+                this.setValue(this.defaultValue);
+            }
+        }
+        //
+        super.ngOnInit();
+    }
+    extractValue(path) {
+        const rawValue = this.contextService.getValue(path);
+        if (this.node.valueTransforms?.getter) {
+            return this.node.valueTransforms?.getter(rawValue);
+        }
+        return rawValue;
+    }
+    setValue(value) {
+        if (this.node.valueTransforms?.setter) {
+            value = this.node.valueTransforms?.setter(value);
+        }
+        const oldValue = this.getValue();
+        value = isUndefined(value) ? null : value;
+        if (isNil(value) && isNil(oldValue)) {
+            return;
+        }
+        // Reordered arrays must persist even when items are deep-equal (e.g. empty row objects).
+        const isArrayReorder = Array.isArray(oldValue) &&
+            Array.isArray(value) &&
+            oldValue.length === value.length &&
+            oldValue.some((v, i) => v !== value[i]);
+        if (!isArrayReorder && isEqual(oldValue, value)) {
+            return;
+        }
+        if (this.fullPath()) {
+            this.contextService.update(this.fullPath(), value);
+            this.onValueChanged.next({ sender: this });
+        }
+    }
+    detectFullPath() {
+        const sections = [];
+        const ids = [];
+        //
+        let parent = this;
+        //
+        while (parent) {
+            const isValueWidget = parent instanceof AXPValueWidgetComponent && parent.isValueWidget();
+            const valueParent = parent;
+            const path = valueParent.path ?? (isValueWidget ? valueParent.name : null);
+            const id = valueParent.name;
+            //
+            if (path) {
+                sections.push(path);
+            }
+            if (parent.index != null && isValueWidget) {
+                sections.push(`[${parent.index}]`);
+            }
+            if (id) {
+                ids.push(id);
+                if (parent.index != null) {
+                    ids.push(`${parent.index}`);
+                }
+            }
+            parent = parent.parent;
+        }
+        //
+        this.fullPath.set(sections.reverse().join('.'));
+        this.parentPath.set(sections.slice(0, sections.length - 1).join('.'));
+        this._id = this.name || this.parent ? ids.reverse().join('_') : null;
+        if (this._id) {
+            this.layoutService.registerWidget(this._id, this);
+        }
+    }
+    handleValueChanged(e) {
+        if (e.isUserInteraction) {
+            this.setValue(e.value);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPValueWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPValueWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPValueWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+class AXPDataListWidgetComponent extends AXPValueWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.dataService = inject(AXPDataSourceDefinitionProviderService);
+        this.textField = computed(() => this.options()['textField'] ?? 'title', ...(ngDevMode ? [{ debugName: "textField" }] : /* istanbul ignore next */ []));
+        this.valueField = computed(() => this.options()['valueField'] ?? 'id', ...(ngDevMode ? [{ debugName: "valueField" }] : /* istanbul ignore next */ []));
+        this.textTemplate = computed(() => isNil(this.options()['textTemplate'])
+            ? undefined
+            : this.options()['textTemplate'].replace(/{/g, '{{').replace(/}/g, '}}'), ...(ngDevMode ? [{ debugName: "textTemplate" }] : /* istanbul ignore next */ []));
+        this.dataSource = signal(convertArrayToDataSource([]), ...(ngDevMode ? [{ debugName: "dataSource" }] : /* istanbul ignore next */ []));
+        this.selectedItems = signal([], ...(ngDevMode ? [{ debugName: "selectedItems" }] : /* istanbul ignore next */ []));
+        //#region ----   DataSource Loading Effect   ----
+        /**
+         * Track the last loaded string dataSource reference to prevent infinite loops
+         * Only used for string-based datasources (not arrays or AXDataSource instances)
+         */
+        this.lastStringDataSourceRef = null;
+        this.rf = effect(async () => {
+            const rawValue = this.options()['dataSource'];
+            // For string datasources: prevent infinite loop by checking reference
+            if (typeof rawValue === 'string') {
+                if (rawValue === this.lastStringDataSourceRef) {
+                    return;
+                }
+                this.lastStringDataSourceRef = rawValue;
+            }
+            else {
+                // Reset string reference when dataSource changes to non-string
+                this.lastStringDataSourceRef = null;
+            }
+            // Process dataSource creation in untracked context
+            await untracked(async () => {
+                if (rawValue instanceof AXDataSource) {
+                    // For AXDataSource instances, check if config changed
+                    if (!isEqual(rawValue.config, this.dataSource().config)) {
+                        this.dataSource.set(rawValue);
+                    }
+                }
+                // static array datasource - always recreate when options change
+                else if (Array.isArray(rawValue)) {
+                    const ds = new AXDataSource({
+                        key: this.valueField(),
+                        pageSize: 10,
+                        load: async (e) => {
+                            const raw = this.options()['dataSource'];
+                            const skip = e.skip ?? 0;
+                            const take = e.take ?? raw.length;
+                            return {
+                                items: raw.slice(skip, skip + take),
+                                total: raw.length,
+                            };
+                        },
+                        byKey: (key) => {
+                            const raw = this.options()['dataSource'];
+                            const item = raw.filter((c) => c[this.valueField()] == key);
+                            return Promise.resolve(item[0]);
+                        },
+                    });
+                    this.dataSource.set(ds);
+                }
+                // resolve data source by name (string or object with id)
+                else if (rawValue && (typeof rawValue == 'string' || typeof rawValue == 'object')) {
+                    const id = typeof rawValue == 'object' ? rawValue['id'] : rawValue;
+                    const c = await this.dataService.get(id);
+                    if (this.mode == 'designer' && c?.samples?.length) {
+                        this.dataSource.set(convertArrayToDataSource(c.samples, {
+                            key: this.valueField(),
+                            pageSize: 500,
+                        }));
+                    }
+                    else {
+                        const ds = c?.source();
+                        if (ds && ds instanceof Promise) {
+                            const d = await ds;
+                            this.dataSource.set(d);
+                        }
+                        else if (ds) {
+                            this.dataSource.set(ds);
+                        }
+                        // empty datasource
+                        else {
+                            this.dataSource.set(convertArrayToDataSource([]));
+                        }
+                    }
+                }
+                // empty datasource
+                else {
+                    this.dataSource.set(convertArrayToDataSource([]));
+                }
+            });
+        }, ...(ngDevMode ? [{ debugName: "rf" }] : /* istanbul ignore next */ []));
+        this.effect2 = effect(async () => {
+            const value = this.getValue();
+            const items = [];
+            if (Array.isArray(value)) {
+                items.push(...(await Promise.all(value.map((item) => this.extractItem(item)))));
+            }
+            else {
+                items.push(await this.extractItem(value));
+            }
+            this.selectedItems.set(items.filter((c) => c != null));
+        }, ...(ngDevMode ? [{ debugName: "effect2" }] : /* istanbul ignore next */ []));
+    }
+    //#endregion
+    async extractItem(item) {
+        if (isNil(item)) {
+            return null;
+        }
+        if (isObjectLike(item) && get(item, this.textField()) != null) {
+            return item;
+        }
+        const key = extractValue(item, this.valueField());
+        const ds = this.dataSource();
+        if (ds.config?.byKey) {
+            const found = await ds.config?.byKey(key);
+            if (found) {
+                return found;
+            }
+        }
+        return isObjectLike(item)
+            ? item
+            : {
+                [this.valueField()]: item,
+                [this.textField()]: item,
+            };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDataListWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDataListWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDataListWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+class AXPColumnWidgetComponent {
+    constructor() {
+        this.token = inject(AXP_WIDGET_COLUMN_TOKEN);
+        this.path = this.token.path;
+        this.options = this.token.options ?? {};
+        this.rawValue = null;
+        this.nullText = this.options['nullText'];
+        this.nullValue = this.options['nullValue'];
+        this.value = () => {
+            if (isNil(this.rawValue) && !isNil(this.nullValue)) {
+                return this.nullValue;
+            }
+            return this.rawValue;
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColumnWidgetComponent, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColumnWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColumnWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPBoxModelLayoutWidgetComponent extends AXPLayoutBaseWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.hostBoxStyle = computed(() => {
+            const options = this.options();
+            const style = {};
+            const spacing = options?.['spacing'];
+            const border = options?.['border'];
+            const backgroundColor = options?.['backgroundColor'];
+            const direction = options?.['direction'];
+            const overflow = options?.['overflow'];
+            const overflowX = options?.['overflowX'];
+            const overflowY = options?.['overflowY'];
+            style['background-color'] = backgroundColor ?? '';
+            style['padding'] = spacing?.padding ?? '';
+            style['margin'] = spacing?.margin ?? '';
+            style['border-radius'] = border?.radius ?? '';
+            style['border-width'] = border?.width ?? '';
+            style['border-color'] = border?.color ?? '';
+            style['border-style'] = border?.style ?? '';
+            style['overflow'] = overflow ?? '';
+            style['overflow-x'] = overflowX ?? '';
+            style['overflow-y'] = overflowY ?? '';
+            style['direction'] = direction ?? '';
+            return style;
+        }, ...(ngDevMode ? [{ debugName: "hostBoxStyle" }] : /* istanbul ignore next */ []));
+        this.blockStyle = computed(() => {
+            const options = this.options();
+            const style = { ...this.hostBoxStyle() };
+            const width = options?.['width'];
+            const minWidth = options?.['minWidth'];
+            const maxWidth = options?.['maxWidth'];
+            const height = options?.['height'];
+            const minHeight = options?.['minHeight'];
+            const maxHeight = options?.['maxHeight'];
+            style['min-width'] = minWidth ?? '';
+            style['width'] = width ?? '';
+            style['max-width'] = maxWidth ?? '';
+            style['min-height'] = minHeight ?? '';
+            style['height'] = height ?? '';
+            style['max-height'] = maxHeight ?? '';
+            return style;
+        }, ...(ngDevMode ? [{ debugName: "blockStyle" }] : /* istanbul ignore next */ []));
+        this.inlineStyle = computed(() => {
+            return { ...this.hostBoxStyle() };
+        }, ...(ngDevMode ? [{ debugName: "inlineStyle" }] : /* istanbul ignore next */ []));
+        this.blockClass = computed(() => {
+            return {
+                'ax-block': true,
+                'ax-w-full': true,
+                // 'ax-widget-outline': true,
+            };
+        }, ...(ngDevMode ? [{ debugName: "blockClass" }] : /* istanbul ignore next */ []));
+        this.inlineClass = computed(() => {
+            return {
+                'ax-inline-block': true,
+            };
+        }, ...(ngDevMode ? [{ debugName: "inlineClass" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBoxModelLayoutWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBoxModelLayoutWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBoxModelLayoutWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPBlockBaseLayoutWidgetComponent extends AXPBoxModelLayoutWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.hostClass = computed(() => this.blockClass(), ...(ngDevMode ? [{ debugName: "hostClass" }] : /* istanbul ignore next */ []));
+        this.hostStyle = computed(() => this.blockStyle(), ...(ngDevMode ? [{ debugName: "hostStyle" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBlockBaseLayoutWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBlockBaseLayoutWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBlockBaseLayoutWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPFlexBaseLayoutWidgetComponent extends AXPBlockBaseLayoutWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.flex = computed(() => this.options(), ...(ngDevMode ? [{ debugName: "flex" }] : /* istanbul ignore next */ []));
+        this.hostFlexStyle = computed(() => {
+            const blockStyle = this.blockStyle();
+            const style = { ...blockStyle };
+            const flex = this.flex();
+            if (isNil(flex?.flexDirection)) {
+                style['flex-direction'] = '';
+            }
+            else {
+                style['flex-direction'] = flex.flexDirection;
+            }
+            if (isNil(flex?.flexWrap)) {
+                style['flex-wrap'] = '';
+            }
+            else {
+                style['flex-wrap'] = flex.flexWrap;
+            }
+            //TODO NEED TO FIX LATER
+            style['overflow'] = flex?.flexWrap === 'nowrap' ? 'auto' : '';
+            //END
+            if (isNil(flex?.justifyContent)) {
+                style['justify-content'] = '';
+            }
+            else {
+                style['justify-content'] = flex.justifyContent;
+            }
+            if (isNil(flex?.alignItems)) {
+                style['align-items'] = '';
+            }
+            else {
+                style['align-items'] = flex.alignItems;
+            }
+            if (isNil(flex?.gap)) {
+                style['gap'] = '';
+            }
+            else {
+                style['gap'] = flex.gap;
+            }
+            return style;
+        }, ...(ngDevMode ? [{ debugName: "hostFlexStyle" }] : /* istanbul ignore next */ []));
+        this.hostFlexClass = computed(() => {
+            return {
+                ...this.blockClass(),
+                'ax-flex': true,
+                'ax-h-full': true,
+            };
+        }, ...(ngDevMode ? [{ debugName: "hostFlexClass" }] : /* istanbul ignore next */ []));
+        this.hostClass = computed(() => {
+            return this.hostFlexClass();
+        }, ...(ngDevMode ? [{ debugName: "hostClass" }] : /* istanbul ignore next */ []));
+        this.hostStyle = computed(() => {
+            return this.hostFlexStyle();
+        }, ...(ngDevMode ? [{ debugName: "hostStyle" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFlexBaseLayoutWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFlexBaseLayoutWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFlexBaseLayoutWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPInlineBaseLayoutWidgetComponent extends AXPBoxModelLayoutWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.hostClass = computed(() => this.inlineClass(), ...(ngDevMode ? [{ debugName: "hostClass" }] : /* istanbul ignore next */ []));
+        this.hostStyle = computed(() => this.inlineStyle(), ...(ngDevMode ? [{ debugName: "hostStyle" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPInlineBaseLayoutWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPInlineBaseLayoutWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPInlineBaseLayoutWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPFlexItemBaseLayoutWidgetComponent extends AXPInlineBaseLayoutWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.flexItem = computed(() => this.options(), ...(ngDevMode ? [{ debugName: "flexItem" }] : /* istanbul ignore next */ []));
+        this.hostFlexItemStyle = computed(() => {
+            const inlineStyle = this.blockStyle();
+            const style = { ...inlineStyle };
+            const fi = this.flexItem();
+            if (isNil(fi?.order)) {
+                style['order'] = '';
+            }
+            else {
+                style['order'] = fi.order;
+            }
+            if (isNil(fi?.grow)) {
+                style['flex-grow'] = '';
+            }
+            else {
+                style['flex-grow'] = fi.grow;
+            }
+            if (isNil(fi?.shrink)) {
+                style['flex-shrink'] = '';
+            }
+            else {
+                style['flex-shrink'] = fi.shrink;
+            }
+            if (isNil(fi?.basis)) {
+                style['flex-basis'] = '';
+            }
+            else {
+                style['flex-basis'] = fi.basis;
+            }
+            if (isNil(fi?.alignSelf)) {
+                style['align-self'] = '';
+            }
+            else {
+                style['align-self'] = fi.alignSelf;
+            }
+            return style;
+        }, ...(ngDevMode ? [{ debugName: "hostFlexItemStyle" }] : /* istanbul ignore next */ []));
+        this.hostFlexItemClass = computed(() => {
+            return {
+                ...this.blockClass(),
+            };
+        }, ...(ngDevMode ? [{ debugName: "hostFlexItemClass" }] : /* istanbul ignore next */ []));
+        this.hostClass = computed(() => {
+            return this.hostFlexItemClass();
+        }, ...(ngDevMode ? [{ debugName: "hostClass" }] : /* istanbul ignore next */ []));
+        this.hostStyle = computed(() => {
+            return this.hostFlexItemStyle();
+        }, ...(ngDevMode ? [{ debugName: "hostStyle" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFlexItemBaseLayoutWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFlexItemBaseLayoutWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFlexItemBaseLayoutWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPGridBaseLayoutWidgetComponent extends AXPBlockBaseLayoutWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.grid = computed(() => this.options()?.['grid'], ...(ngDevMode ? [{ debugName: "grid" }] : /* istanbul ignore next */ []));
+        this.hostGridStyle = computed(() => {
+            const style = { ...this.inlineStyle() };
+            const g = this.grid()?.default;
+            if (g?.gap)
+                style['gap'] = g.gap;
+            return style;
+        }, ...(ngDevMode ? [{ debugName: "hostGridStyle" }] : /* istanbul ignore next */ []));
+        this.hostGridClass = computed(() => {
+            const cls = {
+                ...this.inlineClass(),
+                'ax-grid': true,
+            };
+            const g = this.grid()?.default;
+            if (g?.columns)
+                cls[`lg:ax-grid-cols-${g.columns}`] = true;
+            // if (g?.rows) cls[`lg:ax-grid-rows-${g.rows}`] = true;
+            if (g?.justifyItems)
+                cls[`lg:ax-justify-items-${g.justifyItems}`] = true;
+            if (g?.alignItems)
+                cls[`lg:ax-align-items-${g.alignItems}`] = true;
+            if (g?.autoFlow)
+                cls[`lg:ax-grid-flow-${g.autoFlow}`] = true;
+            return cls;
+        }, ...(ngDevMode ? [{ debugName: "hostGridClass" }] : /* istanbul ignore next */ []));
+        this.hostClass = computed(() => this.hostGridClass(), ...(ngDevMode ? [{ debugName: "hostClass" }] : /* istanbul ignore next */ []));
+        this.hostStyle = computed(() => this.hostGridStyle(), ...(ngDevMode ? [{ debugName: "hostStyle" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGridBaseLayoutWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGridBaseLayoutWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGridBaseLayoutWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPGridItemBaseLayoutWidgetComponent extends AXPFlexBaseLayoutWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.gridItem = computed(() => this.options(), ...(ngDevMode ? [{ debugName: "gridItem" }] : /* istanbul ignore next */ []));
+        this.hostGridItemStyle = computed(() => {
+            const style = { ...this.hostFlexStyle() };
+            const g = this.gridItem();
+            if (g?.alignSelf)
+                style['align-self'] = g.alignSelf;
+            if (g?.justifySelf)
+                style['justify-self'] = g.justifySelf;
+            return style;
+        }, ...(ngDevMode ? [{ debugName: "hostGridItemStyle" }] : /* istanbul ignore next */ []));
+        this.hostGridItemClass = computed(() => {
+            const cls = { ...this.hostFlexClass() };
+            const g = this.gridItem();
+            // Mobile-first: full width on small screens so items stack vertically and don't overflow
+            cls['ax-col-span-12'] = true;
+            // Large screens: apply defined placement so multi-column layout works on desktop
+            if (g?.colSpan)
+                cls[`lg:ax-col-span-${g.colSpan}`] = true;
+            if (g?.colStart)
+                cls[`lg:ax-col-start-${g.colStart}`] = true;
+            if (g?.colEnd)
+                cls[`lg:ax-col-end-${g.colEnd}`] = true;
+            if (g?.rowSpan)
+                cls[`lg:ax-row-span-${g.rowSpan}`] = true;
+            if (g?.rowStart)
+                cls[`lg:ax-row-start-${g.rowStart}`] = true;
+            if (g?.rowEnd)
+                cls[`lg:ax-row-end-${g.rowEnd}`] = true;
+            return cls;
+        }, ...(ngDevMode ? [{ debugName: "hostGridItemClass" }] : /* istanbul ignore next */ []));
+        this.hostClass = computed(() => this.hostGridItemClass(), ...(ngDevMode ? [{ debugName: "hostClass" }] : /* istanbul ignore next */ []));
+        this.hostStyle = computed(() => this.hostGridItemStyle(), ...(ngDevMode ? [{ debugName: "hostStyle" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGridItemBaseLayoutWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGridItemBaseLayoutWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGridItemBaseLayoutWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPTableBaseLayoutWidgetComponent extends AXPBlockBaseLayoutWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.hostTableClass = computed(() => ({
+            ...this.blockClass(),
+        }), ...(ngDevMode ? [{ debugName: "hostTableClass" }] : /* istanbul ignore next */ []));
+        this.hostTableStyle = computed(() => {
+            const style = { ...this.blockStyle() };
+            style['overflow-x'] = 'auto';
+            return style;
+        }, ...(ngDevMode ? [{ debugName: "hostTableStyle" }] : /* istanbul ignore next */ []));
+        this.hostClass = computed(() => this.hostTableClass(), ...(ngDevMode ? [{ debugName: "hostClass" }] : /* istanbul ignore next */ []));
+        this.hostStyle = computed(() => this.hostTableStyle(), ...(ngDevMode ? [{ debugName: "hostStyle" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTableBaseLayoutWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTableBaseLayoutWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTableBaseLayoutWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPTableItemOpsBaseLayoutWidgetComponent extends AXPBlockBaseLayoutWidgetComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTableItemOpsBaseLayoutWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTableItemOpsBaseLayoutWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTableItemOpsBaseLayoutWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPTableItemBaseLayoutWidgetComponent extends AXPTableItemOpsBaseLayoutWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.colSpan = computed(() => {
+            const v = this.options()?.colSpan;
+            return v ? Math.max(1, v) : 1;
+        }, ...(ngDevMode ? [{ debugName: "colSpan" }] : /* istanbul ignore next */ []));
+        this.rowSpan = computed(() => {
+            const v = this.options()?.rowSpan;
+            return v ? Math.max(1, v) : 1;
+        }, ...(ngDevMode ? [{ debugName: "rowSpan" }] : /* istanbul ignore next */ []));
+        this.hostClass = computed(() => this.blockClass(), ...(ngDevMode ? [{ debugName: "hostClass" }] : /* istanbul ignore next */ []));
+        this.hostStyle = computed(() => this.blockStyle(), ...(ngDevMode ? [{ debugName: "hostStyle" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTableItemBaseLayoutWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTableItemBaseLayoutWidgetComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTableItemBaseLayoutWidgetComponent, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----   Imports   ----
+/**
+ * Injection token for widget definition providers.
+ * Modules register their widget providers using this token (multi: true).
+ */
+const AXP_WIDGET_DEFINITION_PROVIDER = new InjectionToken('AXP_WIDGET_DEFINITION_PROVIDER', {
+    factory: () => [],
+});
+//#endregion
+
+//#region ----   Build widget map (shared with tooling / snapshot scripts)   ----
+//TODO RECHECK THIS FUNCTION s.hosseini
+/**
+ * Merges core + extended widgets the same way as AXPWidgetRegistryService.ensureBuilt().
+ * Use with concrete providers (e.g. AXPCoreWidgetsProvider, AXPEntityWidgetsProvider) in Node scripts without DI.
+ */
+function buildWidgetRegistryMapFromProviders(providers) {
+    const types = new Map();
+    const extendedWidgets = [];
+    for (const provider of providers) {
+        const widgets = provider.getWidgets?.() ?? [];
+        for (const w of widgets) {
+            types.set(w.name, w);
+        }
+        const extended = provider.getExtendedWidgets?.() ?? [];
+        extendedWidgets.push(...extended);
+    }
+    for (const { parentName, widget } of extendedWidgets) {
+        const parent = types.get(parentName);
+        if (parent) {
+            const merged = merge({}, parent, widget);
+            merged.name = widget.name;
+            types.set(merged.name, merged);
+        }
+    }
+    return types;
+}
+//#endregion
+//#region ----   Widget Registry Service (Token-Based)   ----
+/**
+ * Aggregates widgets from all AXP_WIDGET_DEFINITION_PROVIDER instances.
+ * Token-based like AXP_MENU_PROVIDER / AXP_PERMISSION_DEFINITION_PROVIDER / AXP_SETTING_DEFINITION_PROVIDER.
+ * No separate registry - widgets come solely from providers.
+ */
+class AXPWidgetRegistryService {
+    constructor() {
+        this._providers = inject(AXP_WIDGET_DEFINITION_PROVIDER, { optional: true }) ?? [];
+        this._types = null;
+    }
+    /**
+     * Lazy-build widget map from all providers.
+     */
+    ensureBuilt() {
+        if (this._types)
+            return this._types;
+        this._types = buildWidgetRegistryMapFromProviders(this._providers);
+        return this._types;
+    }
+    resolve(name) {
+        const widget = this.ensureBuilt().get(name);
+        if (!widget) {
+            throw new Error(`Widget with name "${name}" does not exist.`);
+        }
+        return widget;
+    }
+    /**
+     * Registered widget config when present; otherwise `undefined`. Does not throw — use when
+     * {@link resolve}'s value may be a non-widget id (e.g. data-source row id in dynamic field configurator).
+     */
+    getOptional(name) {
+        return this.ensureBuilt().get(name);
+    }
+    all() {
+        return Array.from(this.ensureBuilt().values());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
+    constructor() {
+        super(...arguments);
+        this.widgetRegistery = inject(AXPWidgetRegistryService);
+        this.grid = inject(AXBaseDataTable);
+        this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        this.mergedOptions = signal({}, ...(ngDevMode ? [{ debugName: "mergedOptions" }] : /* istanbul ignore next */ []));
+        this.loadingRow = signal(null, ...(ngDevMode ? [{ debugName: "loadingRow" }] : /* istanbul ignore next */ []));
+        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);
+    }
+    get node() {
+        return this._node;
+    }
+    set node(v) {
+        this._node = v;
+    }
+    get renderFooterTemplate() {
+        return this.footerTemplate ?? this._contentFooterTemplate;
+    }
+    get renderCellTemplate() {
+        return this.cellTemplate ?? this._contentCellTemplate;
+    }
+    /**
+     * True when the row should show the expand icon: either hasChild is true (from server/initial load)
+     * or the row has loaded children (e.g. after refreshItemChildren when children go from 0 to 1).
+     */
+    hasExpandableRow(row) {
+        const data = row?.data;
+        if (!data)
+            return false;
+        if (data['hasChild'] === true)
+            return true;
+        const children = data['__meta__']?.['children'];
+        return Array.isArray(children) && children.length > 0;
+    }
+    async handleExpandRow(row) {
+        this.loadingRow.set(row);
+        await this.grid.expandRow(row);
+        this.loadingRow.set(null);
+        // if (row.data?.__meta__?.expanded === undefined) {
+        //   this.width = `${parseInt(this.width as string) + 24}px`;
+        // }
+    }
+    get renderHeaderTemplate() {
+        return this.headerTemplate ?? this._contentHeaderTemplate;
+    }
+    get loadingEnabled() {
+        return true;
+    }
+    get name() {
+        return `col-${this.node.path}`;
+    }
+    async ngOnInit() {
+        const widget = this.widgetRegistery.resolve(this.node.type);
+        const mode = 'column';
+        this.component = await widget?.components[mode]?.component();
+        //
+        const props = widget?.components[mode]?.properties
+            ?.filter((c) => c.schema.defaultValue)
+            .map((c) => ({ [c.name]: c.schema.defaultValue }))
+            .reduce((acc, curr) => {
+            return { ...acc, ...curr };
+        }, {});
+        //
+        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(),
+        };
+        this.widgetInjector = Injector.create({
+            parent: this.injector,
+            providers: [
+                {
+                    provide: AXP_WIDGET_COLUMN_TOKEN,
+                    useValue: tokenValue,
+                },
+            ],
+        });
+        this.width = this.mergedOptions().width === 'auto' ? 'auto' : this.customWidth ? this.customWidth : (this.mergedOptions().width ?? '200px');
+        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),
+            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: "21.2.9", ngImport: i0, type: AXPWidgetColumnRendererComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.9", 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,
+            { 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 | translate | async }}</ng-template>
+    <ng-template #cell let-row>
+      <div [class]="expandHandler ? 'ax-flex ax-gap-2 ax-items-center' : ''">
+        @if (expandHandler) {
+          <div
+            (click)="handleExpandRow(row)"
+            class="ax-expand-handler"
+            [class.ax-invisible]="!hasExpandableRow(row)"
+            id="ax-expand-handler-container"
+            [style.padding-inline-start.rem]="row.data?.__meta__?.level * 2"
+          >
+            @if (loadingRow() === row) {
+              <i class="fas fa-spinner-third ax-animate-twSpin ax-animate-infinite"></i>
+            } @else {
+              @if (row.data?.__meta__?.expanded) {
+                <i [class]="customCollapseIcon || 'far fa-minus-square ax-text-md ax-opacity-75'"></i>
+              } @else {
+                <i [class]="customExpandIcon || 'far fa-plus-square ax-text-md  ax-opacity-75'"></i>
+              }
+            }
+          </div>
+        }
+        @if (component && row?.data) {
+          <ng-container
+            *ngComponentOutlet="component; injector: getRowInjector(row.data); inputs: getInputs(row.data)"
+          ></ng-container>
+        }
+      </div>
+    </ng-template>
+    <ng-template #footer></ng-template>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i2.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetColumnRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-widget-column-renderer',
+                    template: `
+    <ng-template #header>{{ caption | translate | async }}</ng-template>
+    <ng-template #cell let-row>
+      <div [class]="expandHandler ? 'ax-flex ax-gap-2 ax-items-center' : ''">
+        @if (expandHandler) {
+          <div
+            (click)="handleExpandRow(row)"
+            class="ax-expand-handler"
+            [class.ax-invisible]="!hasExpandableRow(row)"
+            id="ax-expand-handler-container"
+            [style.padding-inline-start.rem]="row.data?.__meta__?.level * 2"
+          >
+            @if (loadingRow() === row) {
+              <i class="fas fa-spinner-third ax-animate-twSpin ax-animate-infinite"></i>
+            } @else {
+              @if (row.data?.__meta__?.expanded) {
+                <i [class]="customCollapseIcon || 'far fa-minus-square ax-text-md ax-opacity-75'"></i>
+              } @else {
+                <i [class]="customExpandIcon || 'far fa-plus-square ax-text-md  ax-opacity-75'"></i>
+              }
+            }
+          </div>
+        }
+        @if (component && row?.data) {
+          <ng-container
+            *ngComponentOutlet="component; injector: getRowInjector(row.data); inputs: getInputs(row.data)"
+          ></ng-container>
+        }
+      </div>
+    </ng-template>
+    <ng-template #footer></ng-template>
+  `,
+                    providers: [
+                        AXPWidgetCoreService,
+                        { provide: AXDataTableColumnComponent, useExisting: AXPWidgetColumnRendererComponent },
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    inputs: ['caption'],
+                    standalone: false,
+                }]
+        }], propDecorators: { customExpandIcon: [{
+                type: Input
+            }], customCollapseIcon: [{
+                type: Input
+            }], customWidth: [{
+                type: Input
+            }], node: [{
+                type: Input,
+                args: [{ required: true }]
+            }], footerTemplate: [{
+                type: Input
+            }], _contentFooterTemplate: [{
+                type: ViewChild,
+                args: ['footer']
+            }], expandHandler: [{
+                type: Input
+            }], cellTemplate: [{
+                type: Input
+            }], _contentCellTemplate: [{
+                type: ViewChild,
+                args: ['cell']
+            }], headerTemplate: [{
+                type: Input
+            }], _contentHeaderTemplate: [{
+                type: ViewChild,
+                args: ['header']
+            }] } });
+
+class AXPWidgetContainerComponent {
+    set context(value) {
+        this.contextService.set(value);
+    }
+    set functions(v) {
+        this.builderService.setFunctions(v);
+    }
+    constructor() {
+        this.contextService = inject(AXPContextStore);
+        this.builderService = inject(AXPWidgetCoreService);
+        this.onContextChanged = new EventEmitter();
+        this.status = computed(() => {
+            return this.builderService.status();
+        }, ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
+        this.isBusy = computed(() => {
+            return this.builderService.isBusy();
+        }, ...(ngDevMode ? [{ debugName: "isBusy" }] : /* istanbul ignore next */ []));
+        effect(() => {
+            if (this.contextService.isChanged()) {
+                this.onContextChanged.emit(this.contextService.changeEvent());
+            }
+        });
+    }
+    refresh() {
+        this.builderService.refresh();
+    }
+    find(name) {
+        return this.builderService.waitForWidget(name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetContainerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.9", type: AXPWidgetContainerComponent, isStandalone: false, selector: "axp-widgets-container", inputs: { context: "context", functions: "functions" }, outputs: { onContextChanged: "onContextChanged" }, host: { styleAttribute: "display: contents;" }, providers: [AXPWidgetCoreService, AXPContextStore], ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", 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: [AXPWidgetCoreService, AXPContextStore],
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [], propDecorators: { onContextChanged: [{
+                type: Output
+            }], context: [{
+                type: Input
+            }], functions: [{
+                type: Input
+            }] } });
+
+class AXPWidgetPlaceholderComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetPlaceholderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.9", type: AXPWidgetPlaceholderComponent, isStandalone: true, selector: "axp-widget-placeholder", ngImport: i0, template: `<div>
+    <ax-skeleton class="ax-w-full ax-h-10 ax-rounded-md"></ax-skeleton>
+  </div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: AXSkeletonModule }, { kind: "component", type: i1$1.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetPlaceholderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-widget-placeholder',
+                    template: `<div>
+    <ax-skeleton class="ax-w-full ax-h-10 ax-rounded-md"></ax-skeleton>
+  </div>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [AXSkeletonModule],
+                    standalone: true,
+                }]
+        }] });
+
+class AXPWidgetRendererDirective {
+    //#endregion
+    //#endregion
+    constructor() {
+        this.parentNode = input(...(ngDevMode ? [undefined, { debugName: "parentNode" }] : /* istanbul ignore next */ []));
+        this.index = input(...(ngDevMode ? [undefined, { debugName: "index" }] : /* istanbul ignore next */ []));
+        this.mode = input.required(...(ngDevMode ? [{ debugName: "mode" }] : /* istanbul ignore next */ []));
+        this.node = input.required(...(ngDevMode ? [{ debugName: "node" }] : /* istanbul ignore next */ []));
+        this._options = signal({}, ...(ngDevMode ? [{ debugName: "_options" }] : /* istanbul ignore next */ []));
+        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
+         */
+        this._componentRefSignal = signal(null, ...(ngDevMode ? [{ debugName: "_componentRefSignal" }] : /* istanbul ignore next */ []));
+        this.componentRefSignal = this._componentRefSignal.asReadonly();
+        //#endregion
+        //#region ----   Properties   ----
+        this.mergedOptions = signal({}, ...(ngDevMode ? [{ debugName: "mergedOptions" }] : /* istanbul ignore next */ []));
+        this.injector = inject(Injector);
+        this.builderService = inject(AXPWidgetCoreService);
+        this.contextService = inject(AXPContextStore);
+        this.widgetRegistery = inject(AXPWidgetRegistryService);
+        this.unsubscriber = inject(AXUnsubscriber);
+        this.translateService = inject(AXTranslationService);
+        this.widgetService = inject(AXPWidgetRegistryService);
+        this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        this.viewContainerRef = inject(ViewContainerRef);
+        this.isLoading = signal(false, ...(ngDevMode ? [{ debugName: "isLoading" }] : /* istanbul ignore next */ []));
+        this.isVisible = signal(true, ...(ngDevMode ? [{ debugName: "isVisible" }] : /* istanbul ignore next */ []));
+        this.expressionEvaluators = new Map();
+        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;
+        this.CONTEXT_UPDATE_DEBOUNCE_MS = 4; // ~250fps for large forms
+        // Removed visibility detection - not needed for current implementation
+        // Expression result caching
+        this.expressionCache = new Map();
+        this.EXPRESSION_CACHE_TTL = 500; // Cache for 500ms (increased for better hit rate)
+        // Options change tracking
+        this.lastAppliedOptions = null;
+        // Expression result tracking
+        this.lastExpressionResults = new Map();
+        // Buffer for context changes that happen before initial render completes
+        this.preRenderContextQueue = new Set();
+        effect(async () => {
+            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) {
+                    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();
+                }
+            }
+            else if (changed.path && this.isRelevantContextChange(changed.path)) {
+                // console.log(`🎯 [${this.node().type}] Context change detected: ${changed.path}`);
+                this.queueContextUpdate(changed.path);
+            }
+            await this.updateVisibility();
+        });
+        this.builderService.onRefresh.pipe(this.unsubscriber.takeUntilDestroy).subscribe(async () => {
+            await this.processBatchedUpdates();
+        });
+    }
+    //#region ----   Expression Caching Methods   ----
+    getCachedExpressionResult(expressionKey) {
+        const cached = this.expressionCache.get(expressionKey);
+        if (cached && performance.now() - cached.timestamp < this.EXPRESSION_CACHE_TTL) {
+            // console.log(`💾 [${this.node().type}] Using cached expression result for '${expressionKey}'`);
+            return cached.value;
+        }
+        return null;
+    }
+    setCachedExpressionResult(expressionKey, value) {
+        this.expressionCache.set(expressionKey, {
+            value,
+            timestamp: performance.now(),
+        });
+    }
+    clearExpressionCache() {
+        this.expressionCache.clear();
+    }
+    isPathAffectingExpressions(changedPath) {
+        // console.log(
+        //   `🔍 [${this.node().type}] Checking if path '${changedPath}' affects expressions. Expression count: ${this.expressionEvaluators.size}`,
+        // );
+        // If widget has no expressions, no need to clear cache
+        if (this.expressionEvaluators.size === 0) {
+            // console.log(`🔍 [${this.node().type}] Path '${changedPath}' - no expressions, keeping cache`);
+            return false;
+        }
+        // Use the same logic as hasExpressionDependency to check for actual dependencies
+        if (this.hasExpressionDependency(changedPath)) {
+            // console.log(`🔍 [${this.node().type}] Path '${changedPath}' affects expressions - clearing cache`);
+            return true;
+        }
+        // console.log(`🔍 [${this.node().type}] Path '${changedPath}' does not affect expressions - keeping cache`);
+        return false;
+    }
+    //#endregion
+    //#region ----   Context Batching Methods   ----
+    queueContextUpdate(path) {
+        if (path) {
+            // console.log(`🔄 [${this.node().type}] Queueing context update for path: ${path}`);
+            this.contextUpdateQueue.add(path);
+            // Clear existing timeout
+            if (this.contextUpdateTimeout) {
+                clearTimeout(this.contextUpdateTimeout);
+            }
+            // Debounce updates
+            this.contextUpdateTimeout = setTimeout(() => {
+                // console.log(`⚡ [${this.node().type}] Processing batched updates for ${this.contextUpdateQueue.size} paths`);
+                this.processBatchedUpdates();
+            }, this.CONTEXT_UPDATE_DEBOUNCE_MS);
+        }
+    }
+    async processBatchedUpdates() {
+        if (this.contextUpdateQueue.size === 0)
+            return;
+        const startTime = performance.now();
+        const paths = Array.from(this.contextUpdateQueue);
+        this.contextUpdateQueue.clear();
+        // console.log(`📊 [${this.node().type}] Processing ${paths.length} paths:`, paths);
+        // Clear expression cache only if changed paths affect this widget's expressions
+        const shouldClearCache = paths.some((path) => this.isPathAffectingExpressions(path));
+        if (shouldClearCache) {
+            // console.log(`🗑️ [${this.node().type}] Clearing expression cache due to expression-affecting path change`);
+            this.clearExpressionCache();
+        }
+        // Process updates in batches
+        const optionsStartTime = performance.now();
+        const hasOptionsUpdate = await this.updateOptionsBasedOnContext();
+        const optionsTime = performance.now() - optionsStartTime;
+        if (typeof hasOptionsUpdate === 'number' && hasOptionsUpdate > 0) {
+            // console.log(`🔧 [${this.node().type}] Options updated (${optionsTime.toFixed(2)}ms)`);
+            this.applyOptions();
+        }
+        // Check visibility for any of the changed paths
+        const visibilityStartTime = performance.now();
+        const visibilityNeedsUpdate = paths.some((path) => this.hasVisibilityDependency(path));
+        if (visibilityNeedsUpdate) {
+            // console.log(`👁️ [${this.node().type}] Visibility needs update`);
+            await this.updateVisibility();
+        }
+        const visibilityTime = performance.now() - visibilityStartTime;
+        // Emit context changes
+        paths.forEach((path) => {
+            this.onContextChanged.next({ path });
+        });
+        const totalTime = performance.now() - startTime;
+        // console.log(
+        //   `✅ [${this.node().type}] Batch processing completed in ${totalTime.toFixed(2)}ms (options: ${optionsTime.toFixed(2)}ms, visibility: ${visibilityTime.toFixed(2)}ms)`,
+        // );
+    }
+    //#endregion
+    //#region ----   Context Relevance Filtering   ----
+    isRelevantContextChange(changedPath) {
+        const node = this.node();
+        // 1. Direct path match - widget's own field
+        if (node.path === changedPath) {
+            return true;
+        }
+        // 2. Parent path match - widget is inside the changed container
+        if (node.path && changedPath.startsWith(node.path + '.')) {
+            return true;
+        }
+        // 3. Child path match - changed field is inside this widget's container
+        if (node.path && node.path.startsWith(changedPath + '.')) {
+            return true;
+        }
+        // 4. Expression dependency check - if widget has expressions that depend on this path
+        if (this.hasExpressionDependency(changedPath)) {
+            return true;
+        }
+        // 5. Trigger dependency check - if widget has triggers that depend on this path
+        if (this.hasTriggerDependency(changedPath)) {
+            return true;
+        }
+        // 7. Visibility dependency check - if widget's visibility depends on this path
+        if (this.hasVisibilityDependency(changedPath)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * True when a context store path used in an expression (`context.eval`, `context.options`) is
+     * affected by `changedPath`.
+     */
+    contextStorePathDependsOnChangedPath(evalPath, changedPath) {
+        const normalizePath = (p) => {
+            if (!p)
+                return p;
+            const parts = p.split('.');
+            const last = parts[parts.length - 1];
+            if (last && last.endsWith('Id')) {
+                parts.splice(parts.length - 1, 1, last.slice(0, -2), 'id');
+            }
+            return parts.join('.');
+        };
+        const isSegmentSuffix = (a, b) => {
+            if (!a || !b)
+                return false;
+            const pa = a.split('.');
+            const pb = b.split('.');
+            if (pb.length > pa.length)
+                return false;
+            for (let i = 1; i <= pb.length; i++) {
+                if (pa[pa.length - i] !== pb[pb.length - i])
+                    return false;
+            }
+            return true;
+        };
+        const evalNorm = normalizePath(evalPath);
+        const changedNorm = normalizePath(changedPath);
+        const rawMatch = evalPath === changedPath ||
+            evalPath.startsWith(changedPath + '.') ||
+            changedPath.startsWith(evalPath + '.') ||
+            isSegmentSuffix(evalPath, changedPath) ||
+            isSegmentSuffix(changedPath, evalPath);
+        const normMatch = evalNorm === changedNorm ||
+            evalNorm.startsWith(changedNorm + '.') ||
+            changedNorm.startsWith(evalNorm + '.') ||
+            isSegmentSuffix(evalNorm, changedNorm) ||
+            isSegmentSuffix(changedNorm, evalNorm);
+        if (rawMatch || normMatch) {
+            return true;
+        }
+        return this.isPathAlias(evalPath, changedPath);
+    }
+    /**
+     * Whether an expression template string reads context store paths affected by `changedPath`.
+     */
+    expressionTextDependsOnContextPath(expressionValue, changedPath) {
+        const contextEvalRegex = /context\.eval\(['"]([^'\"]+)['"]\)/g;
+        let match;
+        while ((match = contextEvalRegex.exec(expressionValue)) !== null) {
+            if (this.contextStorePathDependsOnChangedPath(match[1], changedPath)) {
+                return true;
+            }
+        }
+        const contextOptionsQuoted = /context\.options\(\s*['"]([^'"]*)['"]\s*\)/g;
+        while ((match = contextOptionsQuoted.exec(expressionValue)) !== null) {
+            const sub = match[1];
+            const evalPath = sub === '' ? 'options' : `options.${sub}`;
+            if (this.contextStorePathDependsOnChangedPath(evalPath, changedPath)) {
+                return true;
+            }
+        }
+        const contextOptionsEmpty = /context\.options\(\s*\)/g;
+        while ((match = contextOptionsEmpty.exec(expressionValue)) !== null) {
+            if (this.contextStorePathDependsOnChangedPath('options', changedPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    hasExpressionDependency(changedPath) {
+        for (const [path, evaluator] of this.expressionEvaluators) {
+            if (path.includes(changedPath)) {
+                return true;
+            }
+            const node = this.node();
+            const expressionValue = this.getExpressionValueFromNode(node, path);
+            if (expressionValue && typeof expressionValue === 'string') {
+                if (this.expressionTextDependsOnContextPath(expressionValue, changedPath)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    isPathAlias(evalPath, changedPath) {
+        // Dynamic path alias detection based on 'Id' suffix pattern
+        // Examples: typeId.id <-> type.id, categoryId.name <-> category.name
+        // Check if evalPath ends with 'Id' and has a property
+        if (evalPath.endsWith('Id') && evalPath.includes('.')) {
+            const basePath = evalPath.substring(0, evalPath.lastIndexOf('Id'));
+            const property = evalPath.substring(evalPath.lastIndexOf('.') + 1);
+            const mappedPath = `${basePath}.${property}`;
+            if (changedPath === mappedPath) {
+                // console.log(`🔍 [${this.node().type}] Path alias detected: '${evalPath}' <-> '${changedPath}'`);
+                return true;
+            }
+        }
+        // Check if changedPath ends with 'Id' and has a property
+        if (changedPath.endsWith('Id') && changedPath.includes('.')) {
+            const basePath = changedPath.substring(0, changedPath.lastIndexOf('Id'));
+            const property = changedPath.substring(changedPath.lastIndexOf('.') + 1);
+            const mappedPath = `${basePath}.${property}`;
+            if (evalPath === mappedPath) {
+                // console.log(`🔍 [${this.node().type}] Path alias detected: '${evalPath}' <-> '${changedPath}'`);
+                return true;
+            }
+        }
+        // Check for direct 'Id' suffix mapping (e.g., typeId <-> type.id)
+        if (evalPath.endsWith('Id') && !evalPath.includes('.')) {
+            const basePath = evalPath.substring(0, evalPath.lastIndexOf('Id'));
+            const mappedPath = `${basePath}.id`;
+            if (changedPath === mappedPath) {
+                // console.log(`🔍 [${this.node().type}] Path alias detected: '${evalPath}' <-> '${changedPath}'`);
+                return true;
+            }
+        }
+        if (changedPath.endsWith('Id') && !changedPath.includes('.')) {
+            const basePath = changedPath.substring(0, changedPath.lastIndexOf('Id'));
+            const mappedPath = `${basePath}.id`;
+            if (evalPath === mappedPath) {
+                // console.log(`🔍 [${this.node().type}] Path alias detected: '${evalPath}' <-> '${changedPath}'`);
+                return true;
+            }
+        }
+        return false;
+    }
+    getExpressionValueFromNode(node, path) {
+        try {
+            // Navigate through the node structure to find the expression value
+            const pathParts = path.split('.');
+            let current = node.options || {};
+            // Navigate through the path parts
+            for (const part of pathParts) {
+                if (current && typeof current === 'object' && part in current) {
+                    current = current[part];
+                }
+                else {
+                    return null;
+                }
+            }
+            return typeof current === 'string' ? current : null;
+        }
+        catch (error) {
+            // console.error('Error extracting expression value from node:', error);
+            return null;
+        }
+    }
+    hasTriggerDependency(changedPath) {
+        const node = this.node();
+        const triggers = node.triggers || node.options?.['triggers'] || this.mergedOptions()?.triggers;
+        if (!triggers)
+            return false;
+        // Check if any trigger event depends on the changed path
+        for (const trigger of triggers) {
+            if (trigger.event && trigger.event.includes(changedPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    hasVisibilityDependency(changedPath) {
+        const node = this.node();
+        const visibility = node.options?.['visible'] || this.mergedOptions()?.visible;
+        if (!visibility || typeof visibility !== 'string')
+            return false;
+        if (this.expressionEvaluator.isExpression(visibility)) {
+            return this.expressionTextDependsOnContextPath(visibility, changedPath);
+        }
+        return false;
+    }
+    //#endregion
+    // Removed visibility detection methods - not needed for current implementation
+    // Detect input changes
+    ngOnChanges(changes) {
+        if (changes['mode'] || changes['node']) {
+            // Check if either 'mode' or 'node' has changed
+            this.rerenderComponent();
+        }
+    }
+    rerenderComponent() {
+        // Clear any pending render operation to prevent double rendering
+        if (this.renderTimeoutId) {
+            clearTimeout(this.renderTimeoutId);
+            this.renderTimeoutId = null;
+        }
+        // Reset loading state to allow re-rendering
+        this.isLoading.set(false);
+        // Schedule the component loading
+        this.renderTimeoutId = setTimeout(async () => {
+            await this.loadComponent();
+            this.renderTimeoutId = null;
+        });
+    }
+    ngOnDestroy() {
+        if (this.renderTimeoutId) {
+            clearTimeout(this.renderTimeoutId);
+        }
+        if (this.contextUpdateTimeout) {
+            clearTimeout(this.contextUpdateTimeout);
+        }
+        if (this.componentRef) {
+            this.componentRef.destroy();
+        }
+        this.onLoadEvent.complete();
+    }
+    async loadComponent() {
+        if (this.isLoading()) {
+            return;
+        }
+        this.isLoading.set(true);
+        try {
+            // Destroy the existing component if it exists
+            if (this.componentRef) {
+                this.componentRef.destroy();
+            }
+            this.viewContainerRef.clear();
+            // Reset the component ref signal
+            this._componentRefSignal.set(null);
+            //
+            const widget = this.widgetRegistery.resolve(this.node().type);
+            //
+            const propertiesToProcess = [
+                ...(widget?.properties ?? []),
+                ...(widget?.components[this.mode()]?.properties ?? []),
+            ]?.filter((c) => c.schema.defaultValue != null);
+            // Process default values (evaluate expressions if needed)
+            const props = {};
+            for (const property of propertiesToProcess) {
+                const defaultValue = property.schema.defaultValue;
+                if (typeof defaultValue === 'string' && this.expressionEvaluator.isExpression(defaultValue)) {
+                    // Evaluate expression for default value
+                    try {
+                        const evaluatedValue = await this.evaluateExpression(defaultValue);
+                        props[property.name] = evaluatedValue;
+                    }
+                    catch (error) {
+                        // console.error(`Error evaluating default value expression for property ${property.name}:`, error);
+                        props[property.name] = cloneDeep(defaultValue); // Fallback to original value
+                    }
+                }
+                else {
+                    // Use static default value
+                    props[property.name] = cloneDeep(defaultValue);
+                }
+            }
+            //
+            this.mergedOptions.set(merge(props, widget?.options, this.node().options) || {});
+            this.expressionEvaluators.clear();
+            // 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)
+            }
+            //
+            this._options.update((val) => ({ ...val, ...this.mergedOptions() }));
+            // Evaluate default value
+            let defaultValue = this.node().defaultValue;
+            if (defaultValue && this.expressionEvaluator.isExpression(defaultValue)) {
+                defaultValue = await this.evaluateExpression(defaultValue);
+            }
+            //
+            const tokenValue = {
+                node: this.node(),
+                defaultValue: defaultValue,
+                options: this.mergedOptions(),
+                config: widget,
+            };
+            const token = Injector.create({
+                parent: this.injector,
+                providers: [
+                    {
+                        provide: AXP_WIDGET_TOKEN,
+                        useValue: tokenValue,
+                    },
+                ],
+            });
+            //
+            const loadingRef = this.viewContainerRef.createComponent(AXPWidgetPlaceholderComponent);
+            //
+            const com = await widget?.components[this.mode()]?.component();
+            if (!com) {
+                // console.error(`${this.node().type} widget component not found with mode: ${this.mode()}`);
+                return;
+            }
+            this.componentRef = this.viewContainerRef.createComponent(com, { injector: token });
+            this.instance = this.componentRef.instance;
+            this.instance.setStatus(AXPWidgetStatus.Rendering);
+            this.instance.parent = this.parentNode();
+            this.instance.index = this.index();
+            this.instance.mode = this.mode();
+            this.instance.setStatus(AXPWidgetStatus.Rendered);
+            // Update the component ref signal for reactive access
+            this._componentRefSignal.set(this.componentRef);
+            this.instance?.onOptionsChanged?.pipe(this.unsubscriber.takeUntilDestroy).subscribe((c) => {
+                this.onOptionsChanged.emit({ sender: this, widget: c.sender });
+            });
+            this.instance?.onValueChanged?.pipe(this.unsubscriber.takeUntilDestroy).subscribe((c) => {
+                this.onValueChanged.emit({ sender: this, widget: c.sender });
+            });
+            await this.updateVisibility();
+            await this.assignTriggers();
+            //
+            loadingRef.destroy();
+            // Mark that initial render is complete
+            this.hasInitialRender = true;
+            // Re-evaluate expressions after initial render to catch late-arriving related context
+            if (this.expressionEvaluators.size > 0) {
+                // console.log(`🔄 [${this.node().type}] Re-evaluating expressions after initial render`);
+                await this.updateOptionsBasedOnContext();
+                this.applyOptions();
+            }
+            // Re-evaluate visibility after initial render
+            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();
+                }
+            }
+            // 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);
+        }
+        finally {
+            this.isLoading.set(false);
+        }
+    }
+    applyOptions() {
+        if (!this.instance)
+            return;
+        const currentOptions = this.mergedOptions();
+        // Check if options have actually changed
+        if (this.hasOptionsChanged(currentOptions)) {
+            // console.log('applyOptions', this.node().path, '- options changed');
+            this._options.update((val) => ({ ...val, ...currentOptions }));
+            this.instance.setOptions(currentOptions);
+            this.lastAppliedOptions = cloneDeep(currentOptions); // Deep clone using Lodash
+        }
+        else {
+            // console.log('applyOptions', this.node().path, '- no changes, skipping');
+        }
+    }
+    hasOptionsChanged(newOptions) {
+        if (!this.lastAppliedOptions) {
+            return true; // First time, always apply
+        }
+        // Deep comparison of options using Lodash isEqual
+        return !isEqual(newOptions, this.lastAppliedOptions);
+    }
+    // Removed deepCloneValue method - now using Lodash cloneDeep
+    preprocessAndInitialOptions(obj, pathPrefix = '') {
+        if (!obj) {
+            return;
+        }
+        Object.entries(obj).forEach(([key, value]) => {
+            const currentPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+            // CRITICAL FIX: Skip trigger actions during options processing
+            //
+            // PROBLEM: Trigger actions were being evaluated immediately during widget setup/options processing,
+            // causing them to execute before the actual trigger event occurred. This meant triggers would fire
+            // during initialization instead of when the specified context path actually changed.
+            //
+            // ROOT CAUSE: The expression evaluator was processing trigger action expressions (like console.log
+            // or widget.setValue calls) as part of the normal options preprocessing, treating them as dynamic
+            // expressions that needed immediate evaluation.
+            //
+            // SOLUTION: Detect when we're processing trigger actions and store them as static values without
+            // expression evaluation. This ensures trigger actions are only evaluated when the trigger's
+            // subscription callback actually fires (when the event condition is met).
+            //
+            // RESULT: Triggers now only execute when their event filters pass (e.g., when the specified
+            // context path changes), not during widget initialization.
+            if (currentPath.includes('triggers') && (key === 'action' || currentPath.endsWith('.action'))) {
+                // Apply static values directly without expression evaluation
+                this.mergedOptions.update((currentOptions) => {
+                    return set(currentOptions, currentPath, value);
+                });
+                return;
+            }
+            if (typeof value === 'string' && this.expressionEvaluator.isExpression(value)) {
+                // 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() {
+        // Early return if no expressions to evaluate
+        if (this.expressionEvaluators.size === 0) {
+            return 0;
+        }
+        // console.log(`🔍 [${this.node().type}] Evaluating ${this.expressionEvaluators.size} expressions`);
+        const updatePromises = Array.from(this.expressionEvaluators).map(async ([path, evaluator]) => {
+            // Check cache first
+            const cachedValue = this.getCachedExpressionResult(path);
+            if (cachedValue !== null) {
+                // console.log(`💾 [${this.node().type}] Using cached expression result for '${path}'`);
+                return { path, newValue: cachedValue, fromCache: true };
+            }
+            // Evaluate expression if not cached
+            const evalStartTime = performance.now();
+            const newValue = await evaluator();
+            const evalTime = performance.now() - evalStartTime;
+            // Check if result has actually changed using Lodash isEqual
+            // Important: We must check if the key exists in the map, not just compare values
+            // This handles the case where the expression evaluates to `undefined` for the first time
+            // Without this check, `undefined` would be incorrectly treated as "no change"
+            // because Map.get() returns `undefined` for non-existent keys
+            const hasLastValue = this.lastExpressionResults.has(path);
+            const lastValue = this.lastExpressionResults.get(path);
+            const hasChanged = !hasLastValue || !isEqual(newValue, lastValue);
+            if (hasChanged) {
+                // console.log(
+                //   `📝 [${this.node().type}] Expression '${path}' evaluated in ${evalTime.toFixed(2)}ms - value changed`,
+                // );
+                // Cache the result and track it
+                this.setCachedExpressionResult(path, newValue);
+                this.lastExpressionResults.set(path, cloneDeep(newValue));
+                return { path, newValue, fromCache: false, hasChanged: true };
+            }
+            else {
+                // console.log(
+                //   `📝 [${this.node().type}] Expression '${path}' evaluated in ${evalTime.toFixed(2)}ms - value unchanged, skipping update`,
+                // );
+                // Cache the result but don't update
+                this.setCachedExpressionResult(path, newValue);
+                this.lastExpressionResults.set(path, cloneDeep(newValue));
+                return { path, newValue, fromCache: false, hasChanged: false };
+            }
+        });
+        // Wait for all evaluators to complete
+        const updates = await Promise.all(updatePromises);
+        // Filter updates to only include those that have actually changed
+        const changedUpdates = updates.filter((update) => update.hasChanged !== false);
+        // Apply updates to mergedOptions only for changed values
+        if (changedUpdates.length > 0) {
+            this.mergedOptions.update((o) => {
+                const updatedOptions = { ...o };
+                changedUpdates.forEach(({ path, newValue }) => {
+                    set(updatedOptions, path, newValue);
+                });
+                return updatedOptions;
+            });
+        }
+        const cacheHits = updates.filter((update) => update.fromCache).length;
+        const skippedUpdates = updates.length - changedUpdates.length;
+        // console.log(
+        //   `📋 [${this.node().type}] Applied ${changedUpdates.length} expression updates (${cacheHits} cache hits, ${skippedUpdates} skipped)`,
+        // );
+        return changedUpdates.length;
+    }
+    async updateVisibility() {
+        const node = this.node();
+        const visibility = node.options?.['visible'] || this.mergedOptions()?.visible;
+        if (visibility === undefined || visibility === null) {
+            // Default to visible if no visibility option is set
+            this.show();
+            return;
+        }
+        let shouldBeVisible;
+        if (typeof visibility === 'boolean') {
+            shouldBeVisible = visibility;
+        }
+        else if (typeof visibility === 'string' && this.expressionEvaluator.isExpression(visibility)) {
+            // Evaluate expression for visibility
+            try {
+                const result = await this.evaluateExpression(visibility);
+                shouldBeVisible = Boolean(result);
+            }
+            catch (error) {
+                // console.error('Error evaluating visibility expression:', error);
+                shouldBeVisible = true; // Default to visible on error
+            }
+        }
+        else {
+            // Treat other values as truthy/falsy
+            shouldBeVisible = Boolean(visibility);
+        }
+        if (shouldBeVisible) {
+            this.show();
+        }
+        else {
+            this.hide();
+        }
+    }
+    show() {
+        if (!this.isVisible()) {
+            this.isVisible.set(true);
+            if (this.componentRef && this.componentRef.location) {
+                this.loadComponent();
+                // this.componentRef.location.nativeElement.style.display = '';
+            }
+        }
+    }
+    hide() {
+        if (this.isVisible()) {
+            this.isVisible.set(false);
+            if (this.componentRef && this.componentRef.location) {
+                this.componentRef.destroy();
+                // this.componentRef.location.nativeElement.style.display = 'none';
+            }
+        }
+    }
+    async evaluateExpression(templateExpression) {
+        try {
+            const scope = this.buildExpressionScope();
+            return await this.expressionEvaluator.evaluate(templateExpression, scope);
+        }
+        catch (error) {
+            // console.error('Error evaluating expression:', error);
+            return false;
+        }
+    }
+    buildExpressionScope() {
+        return {
+            context: this.getContextScope(),
+            events: this.getEventScope(),
+            widget: this.getWidgetScope(),
+            methods: this.getFunctionScope(),
+            vars: this.getVariablesScope(),
+        };
+    }
+    getContextScope() {
+        return {
+            eval: (path) => {
+                //TODO: Handle array index
+                const fullPath = path.startsWith('>') ? `${this.instance?.parentPath()}.${path.substring(1)}` : path;
+                const value = this.contextService.getValue(fullPath);
+                return value;
+            },
+            set: (path, value) => {
+                this.contextService.update(path, value);
+            },
+            data: () => {
+                return this.contextService.data();
+            },
+            isDirty: () => {
+                return this.contextService.isDirty();
+            },
+            /**
+             * Host/widget-under-edit `options` from the shared context store (same values as
+             * `context.eval('options' + (path ? '.' + path : ''))`), not `widget.options` on the nested
+             * property field instance. Uses one `getValue` so smart-path behavior matches `context.eval`.
+             */
+            options: (path) => {
+                if (path == null || path === '') {
+                    return this.contextService.getValue('options');
+                }
+                return this.contextService.getValue(`options.${path}`);
+            },
+        };
+    }
+    getEventScope() {
+        return {
+            context: (path) => {
+                return this.onContextChanged.pipe(filter((c) => {
+                    // If no path filter specified, pass all events
+                    if (path == null || path === '') {
+                        return true;
+                    }
+                    // Ensure c.path exists
+                    if (!c.path) {
+                        return false;
+                    }
+                    // Pattern: "prefix*" - matches paths that start with prefix
+                    if (path.endsWith('*')) {
+                        const prefix = path.substring(0, path.length - 1);
+                        return c.path.startsWith(prefix);
+                    }
+                    // Pattern: "*suffix" - matches paths that end with suffix
+                    else if (path.startsWith('*')) {
+                        const suffix = path.substring(1);
+                        return c.path.endsWith(suffix);
+                    }
+                    // Exact match
+                    else {
+                        return c.path === path;
+                    }
+                }));
+            },
+            from: (event) => get(this.instance.api(), event),
+            load: () => {
+                return this.onLoadEvent.asObservable();
+            },
+        };
+    }
+    getWidgetScope() {
+        return {
+            /** Resolved options for this renderer's widget instance (not the host / property-viewer target). */
+            options: (path) => {
+                const opts = this.instance && typeof this.instance.options === 'function'
+                    ? this.instance.options()
+                    : this.mergedOptions();
+                if (path == null || path === '') {
+                    return opts;
+                }
+                return getSmart(opts, path);
+            },
+            call: (name, ...args) => {
+                this.instance.call(name, ...args);
+            },
+            setValue: (value) => {
+                this.instance.setValue(value);
+            },
+            clear: () => {
+                this.instance.setValue(undefined);
+            },
+            refresh: () => {
+                const refresh = this.instance?.['refresh'];
+                if (refresh && typeof refresh === 'function') {
+                    refresh.bind(this.instance)();
+                }
+                else {
+                    this.updateOptionsBasedOnContext();
+                    this.applyOptions();
+                }
+            },
+            output: (name) => {
+                this.instance.output(name);
+            },
+            find: (id) => {
+                return this.builderService.getWidget(id);
+            },
+        };
+    }
+    getFunctionScope() {
+        const scope = {
+            sum: (values) => {
+                return sum(values);
+            },
+            translate: (text, options) => {
+                return this.translateService.translateAsync(text, options);
+            },
+            widgetInfo: (name) => {
+                return this.widgetService.resolve(name);
+            },
+        };
+        // Add custom functions from builder service
+        Object.entries(this.builderService.functions).forEach(([key, fn]) => {
+            scope[key] = (...args) => {
+                return fn(...args);
+            };
+        });
+        return scope;
+    }
+    getVariablesScope() {
+        return {
+            eval: (path) => get(this.builderService.variables, path),
+        };
+    }
+    async assignTriggers() {
+        const node = this.node();
+        // Check multiple possible locations for triggers
+        const triggers = node.triggers || node.options?.['triggers'] || this.mergedOptions()?.triggers;
+        if (!triggers) {
+            return;
+        }
+        for (const trigger of triggers) {
+            try {
+                const event = await this.evaluateTrigger(trigger.event);
+                if (event) {
+                    event.pipe(this.unsubscriber.takeUntilDestroy).subscribe(() => {
+                        const exec = async (action) => {
+                            if (!isEmpty(action) && isString(action)) {
+                                await this.evaluateAction(action);
+                            }
+                        };
+                        const actions = Array.isArray(trigger.action) ? trigger.action : [trigger.action];
+                        actions.forEach(async (a) => await exec(a));
+                    });
+                }
+            }
+            catch (error) {
+                // console.error('Error assigning trigger:', error);
+            }
+        }
+    }
+    async evaluateTrigger(templateExpression) {
+        try {
+            const scope = this.buildExpressionScope();
+            const result = await this.expressionEvaluator.evaluate(templateExpression, scope);
+            // Check if result is an Observable
+            if (result && typeof result.subscribe === 'function') {
+                return result;
+            }
+            else {
+                return null;
+            }
+        }
+        catch (error) {
+            // console.error('Error evaluating trigger expression:', error);
+            return null;
+        }
+    }
+    async evaluateAction(templateExpression) {
+        try {
+            const scope = this.buildExpressionScope();
+            await this.expressionEvaluator.evaluate(templateExpression, scope);
+        }
+        catch (error) {
+            // console.error('Error evaluating action expression:', templateExpression, error);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetRendererDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", 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,
+            },
+        ], exportAs: ["widgetRenderer"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetRendererDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axp-widget-renderer]',
+                    exportAs: 'widgetRenderer',
+                    providers: [
+                        {
+                            provide: AXUnsubscriber,
+                        },
+                    ],
+                    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"] }] } });
+
+const COMPONENTS = [AXPWidgetContainerComponent, AXPWidgetColumnRendererComponent, AXPWidgetRendererDirective];
+class AXPWidgetCoreModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetCoreModule, declarations: [AXPWidgetContainerComponent, AXPWidgetColumnRendererComponent, AXPWidgetRendererDirective], imports: [CommonModule, PortalModule, AXSkeletonModule, AXTranslationModule], exports: [AXPWidgetContainerComponent, AXPWidgetColumnRendererComponent, AXPWidgetRendererDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetCoreModule, imports: [CommonModule, PortalModule, AXSkeletonModule, AXTranslationModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWidgetCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, PortalModule, AXSkeletonModule, AXTranslationModule],
+                    exports: [...COMPONENTS],
+                    declarations: [...COMPONENTS],
+                    providers: [],
+                }]
+        }] });
+
+class AXPPropertyEditorHelper {
+    static expandShorthand(values) {
+        switch (values.length) {
+            case 1:
+                return [values[0], values[0], values[0], values[0]];
+            case 2:
+                return [values[0], values[1], values[0], values[1]];
+            case 3:
+                return [values[0], values[1], values[2], values[1]];
+            case 4:
+                return values;
+            default:
+                throw new Error(`Invalid shorthand value count. Input: ${values}`);
+        }
+    }
+    static condenseShorthand(values) {
+        if (values.length !== 4) {
+            throw new Error('Expected 4 values for condensation.');
+        }
+        if (values[0] === values[1] && values[1] === values[2] && values[2] === values[3]) {
+            return `${values[0]}`;
+        }
+        else if (values[0] === values[2] && values[1] === values[3]) {
+            return `${values[0]} ${values[1]}`;
+        }
+        else if (values[1] === values[3]) {
+            return `${values[0]} ${values[1]} ${values[2]}`;
+        }
+        else {
+            return `${values[0]} ${values[1]} ${values[2]} ${values[3]}`;
+        }
+    }
+    static parseSides(input) {
+        const values = this.expandShorthand(input.match(/(?:rgb\([^)]+\)|[^ ]+)/g)?.map((value) => value.trim()) || []);
+        return { top: values[0], right: values[1], bottom: values[2], left: values[3] };
+    }
+    static parseSidesWithUnits(input) {
+        const values = this.expandShorthand(input.match(/(?:rgb\([^)]+\)|[^ ]+)/g)?.map((value) => value.trim()) || []);
+        return {
+            top: AXPPropertyEditorHelper.getValueWithUnit(values[0]).value,
+            right: AXPPropertyEditorHelper.getValueWithUnit(values[1]).value,
+            bottom: AXPPropertyEditorHelper.getValueWithUnit(values[2]).value,
+            left: AXPPropertyEditorHelper.getValueWithUnit(values[3]).value,
+        };
+    }
+    static parseCorners(input) {
+        const values = this.expandShorthand(input.split(' ').map((value) => value.trim()));
+        return {
+            'top-left': AXPPropertyEditorHelper.getValueWithUnit(values[0]).value,
+            'top-right': AXPPropertyEditorHelper.getValueWithUnit(values[1]).value,
+            'bottom-left': AXPPropertyEditorHelper.getValueWithUnit(values[2]).value,
+            'bottom-right': AXPPropertyEditorHelper.getValueWithUnit(values[3]).value,
+        };
+    }
+    static parseSpacingBox(input) {
+        return {
+            margin: this.parseSidesWithUnits(input.margin),
+            padding: this.parseSidesWithUnits(input.padding),
+        };
+    }
+    static parseBorderBox(input) {
+        return {
+            width: this.parseSidesWithUnits(input.width),
+            radius: this.parseCorners(input.radius),
+            color: this.parseSides(input.color),
+            style: this.parseSides(input.style),
+        };
+    }
+    static parseSpacingBoxReverse(input, units) {
+        const format = (value, unit) => `${value}${unit}`;
+        return {
+            margin: AXPPropertyEditorHelper.condenseShorthand([
+                format(input.margin.top, units.margin.top),
+                format(input.margin.right, units.margin.right),
+                format(input.margin.bottom, units.margin.bottom),
+                format(input.margin.left, units.margin.left),
+            ]),
+            padding: AXPPropertyEditorHelper.condenseShorthand([
+                format(input.padding.top, units.padding.top),
+                format(input.padding.right, units.padding.right),
+                format(input.padding.bottom, units.padding.bottom),
+                format(input.padding.left, units.padding.left),
+            ]),
+        };
+    }
+    static parseBorderBoxReverse(input, units) {
+        const format = (value, unit) => `${value}${unit}`;
+        return {
+            width: AXPPropertyEditorHelper.condenseShorthand([
+                format(input.width.top, units.width.top),
+                format(input.width.right, units.width.right),
+                format(input.width.bottom, units.width.bottom),
+                format(input.width.left, units.width.left),
+            ]),
+            radius: AXPPropertyEditorHelper.condenseShorthand([
+                format(input.radius['top-left'], units.radius['top-left']),
+                format(input.radius['top-right'], units.radius['top-right']),
+                format(input.radius['bottom-right'], units.radius['bottom-right']),
+                format(input.radius['bottom-left'], units.radius['bottom-left']),
+            ]),
+            color: AXPPropertyEditorHelper.condenseShorthand([
+                `${input.color.top}${units.color.top}`,
+                `${input.color.right}${units.color.right}`,
+                `${input.color.bottom}${units.color.bottom}`,
+                `${input.color.left}${units.color.left}`,
+            ]),
+            style: AXPPropertyEditorHelper.condenseShorthand([
+                `${input.style.top}${units.style.top}`,
+                `${input.style.right}${units.style.right}`,
+                `${input.style.bottom}${units.style.bottom}`,
+                `${input.style.left}${units.style.left}`,
+            ]),
+        };
+    }
+    static getValueWithUnit(input) {
+        if (typeof input === 'number')
+            return { value: input, unit: 'px' };
+        if (input === 'auto')
+            return { value: 0, unit: 'px' };
+        const match = input.match(/^([0-9.]+)([a-z%]*)$/i);
+        if (!match)
+            throw new Error(`Invalid unit format: ${input}`);
+        return { value: parseFloat(match[1]), unit: match[2] || '' };
+    }
+    static getValueFromUnit(value, unit) {
+        return unit ? `${value}${unit}` : `${value}`;
+    }
+    static parseGap(gap) {
+        const parts = gap.split(/\s+/);
+        const match = parts[0].match(/^(\d+\.?\d*)([a-z%]+)$/);
+        if (!match) {
+            throw new Error('Invalid gap format');
+        }
+        const [, xValue, unit] = match;
+        let yValue = parseFloat(xValue);
+        if (parts.length === 2) {
+            const secondMatch = parts[1].match(/^(\d+\.?\d*)[a-z%]+$/);
+            if (!secondMatch) {
+                throw new Error('Invalid gap format');
+            }
+            yValue = parseFloat(secondMatch[1]);
+        }
+        return {
+            values: {
+                x: parseFloat(xValue),
+                y: yValue,
+            },
+            unit,
+        };
+    }
+    static parseGridTemplate(gridTemplate) {
+        const match = gridTemplate.match(/^repeat\((\d+),\s*(?:1fr|auto|minmax\([^)]*\))\)$/);
+        if (!match) {
+            throw new Error("Invalid grid template format. Expected 'repeat(N, 1fr|auto|minmax(...))'.");
+        }
+        return parseInt(match[1], 10);
+    }
+    static createGridTemplate(repetitionCount) {
+        if (repetitionCount <= 0) {
+            throw new Error('Repetition count must be a positive integer.');
+        }
+        return `repeat(${repetitionCount}, 1fr)`;
+    }
+}
+function findNonEmptyBreakpoints(values) {
+    const breakpoints = ['default', 'sm', 'md', 'lg', 'xl', '2xl', '3xl'];
+    const nonEmptyBreakpoints = [];
+    for (const breakpoint of breakpoints) {
+        if (values[breakpoint] !== undefined) {
+            nonEmptyBreakpoints.push(breakpoint);
+        }
+    }
+    return nonEmptyBreakpoints;
+}
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Helper Class   ----
+/**
+ * Helper class for serializing and deserializing AXPWidgetNode to/from JSON
+ */
+class AXPWidgetSerializationHelper {
+    /**
+     * Removes non-serializable properties from widget node
+     * @param node - The widget node to clean
+     * @param options - Serialization options
+     * @returns Cleaned widget node ready for JSON serialization
+     */
+    static cleanNode(node, options = {}) {
+        const { removeMeta = true, removeFunctions = true } = options;
+        // Deep clone to avoid mutating original
+        const cleaned = cloneDeep(node);
+        // Remove meta property if requested
+        if (removeMeta && 'meta' in cleaned) {
+            delete cleaned.meta;
+        }
+        // Remove functions from options, triggers, and valueTransforms
+        if (removeFunctions) {
+            this.removeFunctions(cleaned);
+        }
+        // Recursively clean children
+        if (cleaned.children && Array.isArray(cleaned.children)) {
+            cleaned.children = cleaned.children.map((child) => this.cleanNode(child, options));
+        }
+        return cleaned;
+    }
+    /**
+     * Recursively removes functions from object properties
+     */
+    static removeFunctions(obj) {
+        if (obj === null || obj === undefined) {
+            return;
+        }
+        if (Array.isArray(obj)) {
+            obj.forEach((item) => this.removeFunctions(item));
+            return;
+        }
+        if (typeof obj === 'object') {
+            for (const key in obj) {
+                if (typeof obj[key] === 'function') {
+                    delete obj[key];
+                }
+                else if (typeof obj[key] === 'object') {
+                    this.removeFunctions(obj[key]);
+                }
+            }
+        }
+    }
+    /**
+     * Converts AXPWidgetNode to JSON string
+     * @param node - The widget node to serialize
+     * @param options - Serialization options
+     * @returns JSON string representation of the widget node
+     */
+    static toJson(node, options = {}) {
+        const { pretty = false, ...cleanOptions } = options;
+        const cleaned = this.cleanNode(node, cleanOptions);
+        if (pretty) {
+            return JSON.stringify(cleaned, null, 2);
+        }
+        return JSON.stringify(cleaned);
+    }
+    /**
+     * Converts JSON string to AXPWidgetNode
+     * @param json - JSON string to deserialize
+     * @returns Parsed AXPWidgetNode object
+     * @throws Error if JSON is invalid or doesn't match AXPWidgetNode structure
+     */
+    static fromJson(json) {
+        try {
+            const parsed = JSON.parse(json);
+            // Basic validation - ensure it has at least a type property
+            if (!parsed || typeof parsed !== 'object') {
+                throw new Error('Invalid JSON: Expected an object');
+            }
+            if (!parsed.type) {
+                throw new Error('Invalid AXPWidgetNode: Missing required property "type"');
+            }
+            // Recursively validate and parse children if they exist
+            if (parsed.children && Array.isArray(parsed.children)) {
+                parsed.children = parsed.children.map((child) => this.fromJson(JSON.stringify(child)));
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`Invalid JSON string: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Removes meta property from widget node (similar to designer service)
+     * @param node - The widget node to process
+     * @returns Widget node without meta property
+     */
+    static removeMeta(node) {
+        return this.cleanNode(node, { removeMeta: true, removeFunctions: false });
+    }
+}
+//#endregion
+
+/** Normalizes widget categories to an array for iteration and serialization. */
+function normalizeWidgetCategories(categories) {
+    if (categories == null) {
+        return [];
+    }
+    return Array.isArray(categories) ? categories : [categories];
+}
+const AXP_WIDGETS_LAYOUT_CATEGORY = {
+    name: 'layout',
+    order: 1,
+    title: 'Layout',
+};
+const AXP_WIDGETS_EDITOR_CATEGORY = {
+    name: 'editor',
+    order: 2,
+    title: 'Editors',
+};
+const AXP_WIDGETS_ACTION_CATEGORY = {
+    name: 'action',
+    order: 3,
+    title: 'Action',
+};
+const AXP_WIDGETS_ADVANCE_CATEGORY = {
+    name: 'advance',
+    order: 4,
+    title: 'Advance',
+};
+/** Widgets exposed to AI assistants for structured rendering (see Widgets:GetForAI). */
+const AXP_WIDGETS_AI_CATEGORY = {
+    name: 'ai',
+    order: 5,
+    title: 'AI',
+};
+const AXP_WIDGETS_CATEGORIES = [
+    AXP_WIDGETS_LAYOUT_CATEGORY,
+    AXP_WIDGETS_EDITOR_CATEGORY,
+    AXP_WIDGETS_ACTION_CATEGORY,
+    AXP_WIDGETS_ADVANCE_CATEGORY,
+    AXP_WIDGETS_AI_CATEGORY,
+];
+
+var AXPWidgetGroupEnum;
+(function (AXPWidgetGroupEnum) {
+    AXPWidgetGroupEnum["FormElement"] = "form-element";
+    AXPWidgetGroupEnum["DashboardWidget"] = "dashboard-widget";
+    AXPWidgetGroupEnum["FormTemplate"] = "form-template";
+    AXPWidgetGroupEnum["PropertyEditor"] = "property-editor";
+    AXPWidgetGroupEnum["MetaData"] = "meta-data";
+    AXPWidgetGroupEnum["SettingWidget"] = "setting-widget";
+    AXPWidgetGroupEnum["EntityWidget"] = "entity-widget";
+    AXPWidgetGroupEnum["UtilityWidget"] = "utility-widget";
+})(AXPWidgetGroupEnum || (AXPWidgetGroupEnum = {}));
+
+//#region ---- Helpers ----
+/**
+ * True when the widget declares the AI category (see {@link AXP_WIDGETS_AI_CATEGORY}).
+ */
+function hasAiWidgetCategory(config) {
+    return normalizeWidgetCategories(config.categories).some((c) => c.name === AXP_WIDGETS_AI_CATEGORY.name);
+}
+//#endregion
+//#region ---- Public API ----
+/**
+ * Resolves AI catalog visibility using {@link AXPWidgetConfig.aiCatalog} and the AI widget category.
+ * - `exclude`: never listed.
+ * - `include`: always listed (override when the widget cannot declare the AI category yet).
+ * - `inherit` / omitted: listed only if {@link hasAiWidgetCategory} is true.
+ */
+function isWidgetAiCatalogIncluded(config) {
+    const mode = config.aiCatalog ?? 'inherit';
+    if (mode === 'exclude') {
+        return false;
+    }
+    if (mode === 'include') {
+        return true;
+    }
+    return hasAiWidgetCategory(config);
+}
+//#endregion
+
+/**
+ * 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, AXPWidgetCoreElement, AXPWidgetCoreModule, AXPWidgetCoreService, AXPWidgetGroupEnum, AXPWidgetRegistryService, AXPWidgetRendererDirective, AXPWidgetSerializationHelper, AXPWidgetStatus, AXPWidgetsCatalog, AXP_WIDGETS_ACTION_CATEGORY, AXP_WIDGETS_ADVANCE_CATEGORY, AXP_WIDGETS_AI_CATEGORY, AXP_WIDGETS_CATEGORIES, AXP_WIDGETS_EDITOR_CATEGORY, AXP_WIDGETS_LAYOUT_CATEGORY, AXP_WIDGET_COLUMN_TOKEN, AXP_WIDGET_DEFINITION_PROVIDER, AXP_WIDGET_TOKEN, buildWidgetRegistryMapFromProviders, cloneProperty, createBooleanProperty, createNumberProperty, createSelectProperty, createStringProperty, findNonEmptyBreakpoints, hasAiWidgetCategory, isWidgetAiCatalogIncluded, normalizeWidgetCategories };
+//# sourceMappingURL=acorex-platform-layout-widget-core.mjs.map