@agility-workbench/angular-grid 1.0.0

package/fesm2022/agility-workbench-angular-grid.mjs

@@ -0,0 +1,1028 @@
+import { isClassRenderer, isClassTooltipComponent, isClassActionFrameComponent, isClassSetFilterComponent, createGrid } from '@agility-workbench/grid';
+export * from '@agility-workbench/grid';
+import * as i0 from '@angular/core';
+import { reflectComponentType, createComponent, input, output, inject, ElementRef, NgZone, Injector, ApplicationRef, EnvironmentInjector, afterNextRender, untracked, effect, ChangeDetectionStrategy, Component } from '@angular/core';
+
+/** True when `value` is a compiled Angular component class (vs a core class or plain function). */
+function isNgComponent(value) {
+    return typeof value === "function" && reflectComponentType(value) !== null;
+}
+/**
+ * Push params into a freshly created / refreshing component using whichever contract it implements:
+ * `awbInit(params)` (interface style) or a declared input named `params` (signal-input style).
+ */
+function deliverParams(ref, mirror, params, kind) {
+    const instance = ref.instance;
+    if (typeof instance.awbInit === "function") {
+        instance.awbInit(params);
+        return;
+    }
+    if (mirror.inputs.some((i) => i.templateName === "params" || i.propName === "params")) {
+        ref.setInput("params", params);
+        return;
+    }
+    throw new Error(`[agility-workbench] ${kind} component ${mirror.selector || ref.componentType.name} must either ` +
+        `implement awbInit(params) or declare an input named 'params'.`);
+}
+/**
+ * Per-grid-instance adapter context. Owns the Angular machinery (injector, ApplicationRef, zone)
+ * needed to host arbitrary Angular components inside DOM elements owned by the framework-agnostic
+ * core, plus per-component caches so the same component class always maps to the same adapter class
+ * (core treats the renderer class identity as the "did the renderer change?" key).
+ */
+class NgAdapters {
+    constructor(appRef, envInjector, zone) {
+        this.appRef = appRef;
+        this.envInjector = envInjector;
+        this.zone = zone;
+        this.rendererCache = new WeakMap();
+        this.tooltipCache = new WeakMap();
+        this.actionFrameCache = new WeakMap();
+        this.editorCache = new WeakMap();
+        this.setFilterComponentCache = new WeakMap();
+    }
+    /**
+     * Create `component` with `hostElement` as its host, deliver params, attach it to the app for
+     * change detection, and run the first CD cycle synchronously (the grid may read the DOM / call
+     * imperative methods immediately after init). Runs inside the Angular zone so template event
+     * listeners registered during creation trigger change detection in zone-based apps — the grid
+     * core itself lives outside the zone.
+     */
+    mount(component, params, hostElement, kind) {
+        return this.zone.run(() => {
+            const mirror = reflectComponentType(component);
+            const ref = createComponent(component, {
+                environmentInjector: this.envInjector,
+                hostElement,
+            });
+            deliverParams(ref, mirror, params, kind);
+            this.appRef.attachView(ref.hostView);
+            ref.changeDetectorRef.detectChanges();
+            return {
+                instance: ref.instance,
+                refresh: (p) => {
+                    return this.zone.run(() => {
+                        const instance = ref.instance;
+                        let handled = true;
+                        if (typeof instance.awbRefresh === "function") {
+                            handled = instance.awbRefresh(p) !== false;
+                        }
+                        else {
+                            deliverParams(ref, mirror, p, kind);
+                        }
+                        ref.changeDetectorRef.detectChanges();
+                        return handled;
+                    });
+                },
+                destroy: () => this.zone.run(() => ref.destroy()),
+            };
+        });
+    }
+    // --- cell renderers -------------------------------------------------------------------------
+    adaptCellRenderer(renderer) {
+        if (!renderer)
+            return undefined;
+        if (typeof renderer === "function" && isClassRenderer(renderer)) {
+            return renderer;
+        }
+        if (!isNgComponent(renderer))
+            return renderer;
+        const cached = this.rendererCache.get(renderer);
+        if (cached)
+            return cached;
+        const adapted = this.createRendererClass(renderer);
+        this.rendererCache.set(renderer, adapted);
+        return adapted;
+    }
+    createRendererClass(component) {
+        const adapters = this;
+        return class NgCellRendererAdapter {
+            constructor() {
+                this.el = document.createElement("span");
+                this.mounted = null;
+            }
+            init(params) {
+                this.el.style.display = "inline-flex";
+                this.el.style.alignItems = "center";
+                this.el.style.width = "100%";
+                this.el.style.height = "100%";
+                this.el.style.overflow = "hidden";
+                this.mounted = adapters.mount(component, getRendererProps(params), this.el, "cellRenderer");
+            }
+            getGui() {
+                return this.el;
+            }
+            refresh(params) {
+                return this.mounted?.refresh(getRendererProps(params)) ?? false;
+            }
+            destroy() {
+                this.mounted?.destroy();
+                this.mounted = null;
+            }
+        };
+    }
+    // --- tooltips --------------------------------------------------------------------------------
+    adaptTooltip(comp) {
+        if (!comp)
+            return undefined;
+        if (typeof comp === "function" && isClassTooltipComponent(comp)) {
+            return comp;
+        }
+        if (!isNgComponent(comp))
+            return comp;
+        const cached = this.tooltipCache.get(comp);
+        if (cached)
+            return cached;
+        const adapted = this.createTooltipClass(comp);
+        this.tooltipCache.set(comp, adapted);
+        return adapted;
+    }
+    /** Adapt an Angular tooltip component returned dynamically by `getRowPresentation`. */
+    adaptGetRowPresentation(getter) {
+        if (!getter)
+            return undefined;
+        return (params) => {
+            const presentation = getter(params);
+            if (!presentation || typeof presentation.tooltip !== "object" || presentation.tooltip == null) {
+                return presentation;
+            }
+            return {
+                ...presentation,
+                tooltip: {
+                    ...presentation.tooltip,
+                    component: this.adaptTooltip(presentation.tooltip.component),
+                },
+            };
+        };
+    }
+    /** headerTooltip may be a plain string (pass through) or a component (adapt like a tooltip). */
+    adaptHeaderTooltip(ht) {
+        if (ht == null || typeof ht === "string")
+            return ht;
+        return this.adaptTooltip(ht);
+    }
+    createTooltipClass(component) {
+        const adapters = this;
+        return class NgTooltipAdapter {
+            constructor() {
+                this.el = document.createElement("div");
+                this.mounted = null;
+            }
+            init(params) {
+                // One component instance lives for the life of this tooltip; refresh re-delivers params
+                // rather than recreating, so interactive content keeps its state across repositions.
+                this.mounted = adapters.mount(component, getTooltipProps(params), this.el, "tooltip");
+            }
+            getGui() {
+                return this.el;
+            }
+            refresh(params) {
+                return this.mounted?.refresh(getTooltipProps(params)) ?? false;
+            }
+            destroy() {
+                this.mounted?.destroy();
+                this.mounted = null;
+            }
+        };
+    }
+    // --- ActionFrame -----------------------------------------------------------------------------
+    adaptActionFrame(comp) {
+        if (!comp)
+            return undefined;
+        if (typeof comp === "function" && isClassActionFrameComponent(comp)) {
+            return comp;
+        }
+        if (!isNgComponent(comp))
+            return comp;
+        const cached = this.actionFrameCache.get(comp);
+        if (cached)
+            return cached;
+        const adapted = this.createActionFrameClass(comp);
+        this.actionFrameCache.set(comp, adapted);
+        return adapted;
+    }
+    createActionFrameClass(component) {
+        const adapters = this;
+        return class NgActionFrameAdapter {
+            constructor() {
+                this.el = document.createElement("div");
+                this.mounted = null;
+            }
+            init(params) {
+                // One component instance for the life of the open frame; refresh re-delivers params so the
+                // form keeps its state across repositions (scroll tracking repositions, not remounts).
+                this.mounted = adapters.mount(component, getActionFrameProps(params), this.el, "actionFrame");
+            }
+            getGui() {
+                return this.el;
+            }
+            refresh(params) {
+                return this.mounted?.refresh(getActionFrameProps(params)) ?? false;
+            }
+            destroy() {
+                this.mounted?.destroy();
+                this.mounted = null;
+            }
+        };
+    }
+    // --- cell editors ----------------------------------------------------------------------------
+    adaptCellEditor(editor) {
+        if (editor == null)
+            return undefined;
+        if (typeof editor === "string")
+            return editor; // built-in alias
+        if (isCoreEditorClass(editor))
+            return editor;
+        if (!isNgComponent(editor))
+            return editor;
+        const cached = this.editorCache.get(editor);
+        if (cached)
+            return cached;
+        const adapted = this.createEditorClass(editor);
+        this.editorCache.set(editor, adapted);
+        return adapted;
+    }
+    createEditorClass(component) {
+        const adapters = this;
+        return class NgCellEditorAdapter {
+            constructor() {
+                this.el = document.createElement("div");
+                this.mounted = null;
+            }
+            init(params) {
+                this.el.style.width = "100%";
+                this.el.style.height = "100%";
+                // mount() runs the first change-detection cycle synchronously, so the instance is fully
+                // initialized before the grid calls focus()/getValue().
+                this.mounted = adapters.mount(component, params, this.el, "cellEditor");
+            }
+            getGui() {
+                return this.el;
+            }
+            getValue() {
+                return this.mounted?.instance.getValue?.();
+            }
+            isParsed() {
+                return this.mounted?.instance.isParsed?.() ?? false;
+            }
+            focus() {
+                this.mounted?.instance.focus?.();
+            }
+            isCancelBeforeStart() {
+                return this.mounted?.instance.isCancelBeforeStart?.() ?? false;
+            }
+            destroy() {
+                // Defer teardown out of the current commit/keyboard dispatch: the destroy may be triggered
+                // by an event fired from inside the component's own template.
+                const mounted = this.mounted;
+                this.mounted = null;
+                if (mounted)
+                    queueMicrotask(() => mounted.destroy());
+            }
+        };
+    }
+    // --- set-filter value components ------------------------------------------------------------
+    adaptSetFilterComponent(component) {
+        if (!component)
+            return undefined;
+        if (typeof component === "function" &&
+            isClassSetFilterComponent(component)) {
+            return component;
+        }
+        if (!isNgComponent(component))
+            return component;
+        const cached = this.setFilterComponentCache.get(component);
+        if (cached)
+            return cached;
+        const adapted = this.createSetFilterComponentClass(component);
+        this.setFilterComponentCache.set(component, adapted);
+        return adapted;
+    }
+    createSetFilterComponentClass(component) {
+        const adapters = this;
+        return class NgSetFilterComponentAdapter {
+            constructor() {
+                this.el = document.createElement("span");
+                this.mounted = null;
+            }
+            init(params) {
+                this.mounted = adapters.mount(component, params, this.el, "setFilterValueComponent");
+            }
+            getGui() {
+                return this.el;
+            }
+            refresh(params) {
+                return this.mounted?.refresh(params) ?? false;
+            }
+            destroy() {
+                this.mounted?.destroy();
+                this.mounted = null;
+            }
+        };
+    }
+    adaptFilterParams(filterParams) {
+        if (!filterParams)
+            return undefined;
+        return {
+            ...filterParams,
+            valueComponent: this.adaptSetFilterComponent(filterParams.valueComponent),
+            selectAllComponent: this.adaptSetFilterComponent(filterParams.selectAllComponent),
+            blanksComponent: this.adaptSetFilterComponent(filterParams.blanksComponent),
+        };
+    }
+    // --- column defs -----------------------------------------------------------------------------
+    /**
+     * Adapt the Angular-aware components carried by a single column def into their core equivalents.
+     * Used for real column defs and, via {@link adaptDefaultColDef}, the grid-level `defaultColDef`.
+     */
+    adaptColDef(colDef) {
+        return {
+            ...colDef,
+            cellRenderer: this.adaptCellRenderer(colDef.cellRenderer),
+            cellEditor: this.adaptCellEditor(colDef.cellEditor),
+            tooltipComponent: this.adaptTooltip(colDef.tooltipComponent),
+            headerTooltip: this.adaptHeaderTooltip(colDef.headerTooltip),
+            actionFrameComponent: this.adaptActionFrame(colDef.actionFrameComponent),
+            filterParams: this.adaptFilterParams(colDef.filterParams),
+            children: colDef.children ? (this.adaptColumnDefs(colDef.children) ?? undefined) : undefined,
+        };
+    }
+    adaptColumnDefs(columnDefs) {
+        if (columnDefs == null)
+            return columnDefs;
+        return columnDefs.map((colDef) => this.adaptColDef(colDef));
+    }
+    /**
+     * Adapt a grid-level `defaultColDef`: same per-field component adaptation as a real column def,
+     * but only the fields actually present are adapted (it is a partial), so an omitted field stays
+     * omitted rather than being forced to `undefined`.
+     */
+    adaptDefaultColDef(defaultColDef) {
+        if (defaultColDef == null)
+            return undefined;
+        const next = { ...defaultColDef };
+        if ("cellRenderer" in defaultColDef)
+            next.cellRenderer = this.adaptCellRenderer(defaultColDef.cellRenderer);
+        if ("cellEditor" in defaultColDef)
+            next.cellEditor = this.adaptCellEditor(defaultColDef.cellEditor);
+        if ("tooltipComponent" in defaultColDef)
+            next.tooltipComponent = this.adaptTooltip(defaultColDef.tooltipComponent);
+        if ("headerTooltip" in defaultColDef)
+            next.headerTooltip = this.adaptHeaderTooltip(defaultColDef.headerTooltip);
+        if ("actionFrameComponent" in defaultColDef) {
+            next.actionFrameComponent = this.adaptActionFrame(defaultColDef.actionFrameComponent);
+        }
+        if ("filterParams" in defaultColDef)
+            next.filterParams = this.adaptFilterParams(defaultColDef.filterParams);
+        return next;
+    }
+}
+function isCoreEditorClass(e) {
+    const proto = e?.prototype;
+    return (typeof e === "function" &&
+        !!proto &&
+        typeof proto.init === "function" &&
+        typeof proto.getGui === "function");
+}
+function getRendererProps(params) {
+    const extraParams = params.colDef.cellRendererParams;
+    if (extraParams == null || typeof extraParams !== "object")
+        return params;
+    return { ...params, ...extraParams };
+}
+function getTooltipProps(params) {
+    const extraParams = params.colDef?.tooltipComponentParams;
+    if (extraParams == null || typeof extraParams !== "object")
+        return params;
+    return { ...params, ...extraParams };
+}
+function getActionFrameProps(params) {
+    const extraParams = params.colDef?.actionFrameComponentParams;
+    if (extraParams == null || typeof extraParams !== "object")
+        return params;
+    return { ...params, ...extraParams };
+}
+
+function setIfDefined(options, key, value) {
+    if (value != null)
+        options[key] = value;
+}
+/**
+ * Snapshot the component's inputs into core GridOptions. Mirrors the React wrapper's
+ * `getGridOptions(props)`, reading Angular signal inputs instead of props. Event callbacks are
+ * bridged separately by the component (they become Angular outputs).
+ */
+function getGridOptions(grid, adapters) {
+    const options = {};
+    setIfDefined(options, "headerHeight", grid.headerHeight());
+    setIfDefined(options, "leafHeaderHeight", grid.leafHeaderHeight());
+    setIfDefined(options, "parentHeaderHeight", grid.parentHeaderHeight());
+    setIfDefined(options, "rowHeight", grid.rowHeight());
+    setIfDefined(options, "pinnedTopRowData", grid.pinnedTopRowData());
+    setIfDefined(options, "pinnedBottomRowData", grid.pinnedBottomRowData());
+    setIfDefined(options, "getRowId", grid.getRowId());
+    setIfDefined(options, "rowIdKey", grid.rowIdKey());
+    setIfDefined(options, "rowDataMode", grid.rowDataMode());
+    setIfDefined(options, "asyncTransactionWaitMs", grid.asyncTransactionWaitMs());
+    setIfDefined(options, "overscanRowCount", grid.overscanRowCount());
+    setIfDefined(options, "minResizeWidth", grid.minResizeWidth());
+    setIfDefined(options, "maxColumnWidth", grid.maxColumnWidth());
+    setIfDefined(options, "autosizeColumnsOnDataChange", grid.autosizeColumnsOnDataChange());
+    setIfDefined(options, "allowExportAsCSV", grid.allowExportAsCSV());
+    setIfDefined(options, "allowExportAsExcel", grid.allowExportAsExcel());
+    setIfDefined(options, "pagination", grid.pagination());
+    setIfDefined(options, "paginationControls", grid.paginationControls());
+    setIfDefined(options, "rowNumbers", grid.rowNumbers());
+    setIfDefined(options, "rowHover", grid.rowHover());
+    setIfDefined(options, "columnHover", grid.columnHover());
+    setIfDefined(options, "zebraRows", grid.zebraRows());
+    setIfDefined(options, "getRowClass", grid.getRowClass());
+    setIfDefined(options, "getRowStyle", grid.getRowStyle());
+    setIfDefined(options, "getRowPresentation", adapters.adaptGetRowPresentation(grid.getRowPresentation()));
+    setIfDefined(options, "ariaLabel", grid.ariaLabel());
+    setIfDefined(options, "ariaLabelledBy", grid.ariaLabelledBy());
+    setIfDefined(options, "highlightActiveCell", grid.highlightActiveCell());
+    setIfDefined(options, "rowSelection", grid.rowSelection());
+    setIfDefined(options, "cellSelection", grid.cellSelection());
+    setIfDefined(options, "rangeSelection", grid.rangeSelection());
+    setIfDefined(options, "columnSelection", grid.columnSelection());
+    setIfDefined(options, "headerKeyboardNavigation", grid.headerKeyboardNavigation());
+    setIfDefined(options, "showColumnButtonsOnHover", grid.showColumnButtonsOnHover());
+    setIfDefined(options, "selectAllRowsOnHeaderClick", grid.selectAllRowsOnHeaderClick());
+    setIfDefined(options, "selectAllScope", grid.selectAllScope());
+    setIfDefined(options, "selectionPersistence", grid.selectionPersistence());
+    setIfDefined(options, "clearSelectionOnBodyClick", grid.clearSelectionOnBodyClick());
+    setIfDefined(options, "resetPageOn", grid.resetPageOn());
+    setIfDefined(options, "pageSize", grid.pageSize());
+    setIfDefined(options, "pageSizes", grid.pageSizes());
+    setIfDefined(options, "serverSideBlockSize", grid.serverSideBlockSize());
+    setIfDefined(options, "rowModelType", grid.rowModelType());
+    setIfDefined(options, "getGroupChildCount", grid.getGroupChildCount());
+    setIfDefined(options, "paginationUnknownTotalTooltip", grid.paginationUnknownTotalTooltip());
+    setIfDefined(options, "undoLimit", grid.undoLimit());
+    setIfDefined(options, "editTrigger", grid.editTrigger());
+    setIfDefined(options, "readOnlyEdit", grid.readOnlyEdit());
+    setIfDefined(options, "initialSort", grid.initialSort());
+    setIfDefined(options, "showSortPriority", grid.showSortPriority());
+    setIfDefined(options, "pinnedRowsEditable", grid.pinnedRowsEditable());
+    setIfDefined(options, "rowPinningMenu", grid.rowPinningMenu());
+    setIfDefined(options, "rowInsertionMenu", grid.rowInsertionMenu());
+    setIfDefined(options, "suppressKeyboardEdit", grid.suppressKeyboardEdit());
+    setIfDefined(options, "suppressTypeToEdit", grid.suppressTypeToEdit());
+    setIfDefined(options, "moveAfterEdit", grid.moveAfterEdit());
+    setIfDefined(options, "commitOnBlur", grid.commitOnBlur());
+    setIfDefined(options, "reevaluateOnEdit", grid.reevaluateOnEdit());
+    setIfDefined(options, "groupDisplayType", grid.groupDisplayType());
+    setIfDefined(options, "groupColumnDef", grid.groupColumnDef());
+    setIfDefined(options, "groupDefaultExpanded", grid.groupDefaultExpanded());
+    setIfDefined(options, "groupSortMode", grid.groupSortMode());
+    setIfDefined(options, "treeData", grid.treeData());
+    setIfDefined(options, "groupRowsSelectable", grid.groupRowsSelectable());
+    setIfDefined(options, "isRowSelectable", grid.isRowSelectable());
+    setIfDefined(options, "isRowPinned", grid.isRowPinned());
+    setIfDefined(options, "groupRowsSticky", grid.groupRowsSticky());
+    setIfDefined(options, "isFullWidthRow", grid.isFullWidthRow());
+    setIfDefined(options, "tooltip", grid.tooltip());
+    setIfDefined(options, "quickFilter", grid.quickFilter());
+    setIfDefined(options, "columnPanel", grid.columnPanel());
+    setIfDefined(options, "toolbar", grid.toolbar());
+    setIfDefined(options, "savedViews", grid.savedViews());
+    setIfDefined(options, "loadingMessage", grid.loadingMessage());
+    setIfDefined(options, "noRowsMessage", grid.noRowsMessage());
+    setIfDefined(options, "filterDebounceMs", grid.filterDebounceMs());
+    setIfDefined(options, "cellFlashDuration", grid.cellFlashDuration());
+    setIfDefined(options, "cellFadeDuration", grid.cellFadeDuration());
+    setIfDefined(options, "icons", grid.icons());
+    setIfDefined(options, "theme", grid.theme());
+    setIfDefined(options, "suppressStyleInjection", grid.suppressStyleInjection());
+    setIfDefined(options, "styleNonce", grid.styleNonce());
+    const fullWidthCellRenderer = grid.fullWidthCellRenderer();
+    if (fullWidthCellRenderer != null) {
+        options.fullWidthCellRenderer = adapters.adaptCellRenderer(fullWidthCellRenderer);
+    }
+    const defaultColDef = grid.defaultColDef();
+    if (defaultColDef != null)
+        options.defaultColDef = adapters.adaptDefaultColDef(defaultColDef);
+    // Forward only the boolean intent to core: false disables the menu (native menu shows);
+    // everything else (true / omitted / a function) leaves core at its "show menu" default and lets
+    // the body-menu adapter apply the function arm (so TemplateRef slots are handled). This avoids
+    // running a user callback twice (once in core, once in the adapter).
+    if (grid.bodyContextMenu() === false)
+        options.bodyContextMenu = false;
+    if (grid.rowModelType() === "serverSide") {
+        setIfDefined(options, "serverSideDataSource", grid.serverSideDataSource());
+        setIfDefined(options, "serverSideAggregationSource", grid.serverSideAggregationSource());
+    }
+    return options;
+}
+
+/**
+ * Shared slot normalization for both menu adapters: app-supplied menu items may carry
+ * `TemplateRef` slots; each open menu stamps them into detached spans and destroys the embedded
+ * views on close (the core calls `cleanup` when the menu is dismissed).
+ */
+class NgMenuAdapterBase {
+    constructor(appRef, zone) {
+        this.appRef = appRef;
+        this.zone = zone;
+    }
+    normalizeItems(items, cleanups) {
+        return items.map((it) => {
+            if (it.isSeparator)
+                return { isSeparator: true };
+            const left = this.normalizeSlot(it.left, cleanups);
+            const right = this.normalizeSlot(it.right, cleanups);
+            return {
+                ...it,
+                left,
+                right,
+                subMenu: it.subMenu ? this.normalizeItems(it.subMenu, cleanups) : undefined,
+            };
+        });
+    }
+    normalizeSlot(slot, cleanups) {
+        if (!slot)
+            return undefined;
+        if (typeof slot === "string")
+            return slot;
+        if (slot instanceof HTMLElement)
+            return slot;
+        // Angular's concrete TemplateRef implementations are not guaranteed to preserve
+        // `instanceof TemplateRef` across compilation/runtime boundaries. Treat the public
+        // createEmbeddedView contract as the discriminator instead.
+        if (typeof slot.createEmbeddedView === "function") {
+            const { el, destroy } = this.stampTemplate(slot);
+            cleanups.push(destroy);
+            return el;
+        }
+        return undefined;
+    }
+    stampTemplate(tpl) {
+        return this.zone.run(() => {
+            const el = document.createElement("span");
+            el.style.display = "inline-flex";
+            el.style.alignItems = "center";
+            const view = tpl.createEmbeddedView({});
+            this.appRef.attachView(view);
+            view.detectChanges();
+            for (const node of view.rootNodes)
+                el.appendChild(node);
+            return { el, destroy: () => this.zone.run(() => view.destroy()) };
+        });
+    }
+}
+class NgMenuAdapter extends NgMenuAdapterBase {
+    constructor(appRef, zone, opts) {
+        super(appRef, zone);
+        this.opts = opts;
+    }
+    resolveMenuItems(ctx, defaults) {
+        const cleanups = [];
+        const defaultsNg = defaults;
+        // Read the hook through the getter so the adapter stays reactive to input changes without
+        // recreating the grid instance (the React wrapper's ref-read, in Angular clothing).
+        const hook = this.opts.getColumnMenuItems?.();
+        const appItems = hook ? hook({ ctx, items: defaultsNg }) : defaultsNg;
+        const items = this.normalizeItems(appItems, cleanups);
+        return {
+            items,
+            cleanup: () => {
+                for (const c of cleanups)
+                    c();
+            },
+        };
+    }
+}
+class NgBodyMenuAdapter extends NgMenuAdapterBase {
+    constructor(appRef, zone, opts) {
+        super(appRef, zone);
+        this.opts = opts;
+    }
+    resolveMenuItems(ctx, defaults) {
+        const cleanups = [];
+        const defaultsNg = defaults;
+        const hook = this.opts.getBodyMenuItems?.();
+        const appItems = hook ? hook({ ctx, items: defaultsNg }) : defaultsNg;
+        const items = this.normalizeItems(appItems, cleanups);
+        return {
+            items,
+            cleanup: () => {
+                for (const c of cleanups)
+                    c();
+            },
+        };
+    }
+}
+
+function destroyInstance(instance) {
+    if (instance.destroyed)
+        return;
+    instance.destroyed = true;
+    // createGrid's api.destroy() performs the whole guarded teardown (detach → renderer.destroy →
+    // core.destroy → api cleanup) in that order, exactly once. The flag above keeps this wrapper
+    // idempotent too, since teardown can be reached twice.
+    try {
+        instance.api.destroy();
+    }
+    catch { }
+}
+/**
+ * Angular host for the framework-agnostic grid. The core owns all DOM inside the host element;
+ * Angular's job is lifecycle (create on first render, destroy with the component), forwarding
+ * input changes to core/renderer setters, bridging core events to Angular outputs, and adapting
+ * Angular components (renderers, editors, tooltips, ActionFrames, menu templates) into the core's
+ * class-component contracts.
+ *
+ * The grid is created outside the Angular zone so its internal scroll/pointer listeners never
+ * trigger app-wide change detection; outputs re-enter the zone when they emit.
+ */
+class AwbGrid {
+    /** The imperative grid API; available from `gridReady` onward (null before first render). */
+    get api() {
+        return this.instance?.api ?? null;
+    }
+    constructor() {
+        // --- data ---
+        this.rowData = input(...(ngDevMode ? [undefined, { debugName: "rowData" }] : []));
+        this.columnDefs = input(...(ngDevMode ? [undefined, { debugName: "columnDefs" }] : []));
+        this.defaultColDef = input(...(ngDevMode ? [undefined, { debugName: "defaultColDef" }] : []));
+        // --- layout / sizing ---
+        this.headerHeight = input(...(ngDevMode ? [undefined, { debugName: "headerHeight" }] : []));
+        this.leafHeaderHeight = input(...(ngDevMode ? [undefined, { debugName: "leafHeaderHeight" }] : []));
+        this.parentHeaderHeight = input(...(ngDevMode ? [undefined, { debugName: "parentHeaderHeight" }] : []));
+        this.rowHeight = input(...(ngDevMode ? [undefined, { debugName: "rowHeight" }] : []));
+        this.overscanRowCount = input(...(ngDevMode ? [undefined, { debugName: "overscanRowCount" }] : []));
+        this.minResizeWidth = input(...(ngDevMode ? [undefined, { debugName: "minResizeWidth" }] : []));
+        this.maxColumnWidth = input(...(ngDevMode ? [undefined, { debugName: "maxColumnWidth" }] : []));
+        this.autosizeColumnsOnDataChange = input(...(ngDevMode ? [undefined, { debugName: "autosizeColumnsOnDataChange" }] : []));
+        // --- row identity ---
+        this.getRowId = input(...(ngDevMode ? [undefined, { debugName: "getRowId" }] : []));
+        this.rowIdKey = input(...(ngDevMode ? [undefined, { debugName: "rowIdKey" }] : []));
+        this.rowDataMode = input(...(ngDevMode ? [undefined, { debugName: "rowDataMode" }] : []));
+        this.asyncTransactionWaitMs = input(...(ngDevMode ? [undefined, { debugName: "asyncTransactionWaitMs" }] : []));
+        // --- appearance / interaction ---
+        this.rowHover = input(...(ngDevMode ? [undefined, { debugName: "rowHover" }] : []));
+        this.columnHover = input(...(ngDevMode ? [undefined, { debugName: "columnHover" }] : []));
+        this.zebraRows = input(...(ngDevMode ? [undefined, { debugName: "zebraRows" }] : []));
+        this.getRowClass = input(...(ngDevMode ? [undefined, { debugName: "getRowClass" }] : []));
+        this.getRowStyle = input(...(ngDevMode ? [undefined, { debugName: "getRowStyle" }] : []));
+        this.getRowPresentation = input(...(ngDevMode ? [undefined, { debugName: "getRowPresentation" }] : []));
+        this.ariaLabel = input(...(ngDevMode ? [undefined, { debugName: "ariaLabel" }] : []));
+        this.ariaLabelledBy = input(...(ngDevMode ? [undefined, { debugName: "ariaLabelledBy" }] : []));
+        this.highlightActiveCell = input(...(ngDevMode ? [undefined, { debugName: "highlightActiveCell" }] : []));
+        this.rowNumbers = input(...(ngDevMode ? [undefined, { debugName: "rowNumbers" }] : []));
+        this.showColumnButtonsOnHover = input(...(ngDevMode ? [undefined, { debugName: "showColumnButtonsOnHover" }] : []));
+        this.theme = input(...(ngDevMode ? [undefined, { debugName: "theme" }] : []));
+        this.icons = input(...(ngDevMode ? [undefined, { debugName: "icons" }] : []));
+        // The renderer delivers the base stylesheet on attach, to whichever root the grid lands in.
+        // Suppress it when the application ships the CSS itself; `styleNonce` covers CSP `style-src`.
+        this.suppressStyleInjection = input(...(ngDevMode ? [undefined, { debugName: "suppressStyleInjection" }] : []));
+        this.styleNonce = input(...(ngDevMode ? [undefined, { debugName: "styleNonce" }] : []));
+        // --- selection ---
+        this.rowSelection = input(...(ngDevMode ? [undefined, { debugName: "rowSelection" }] : []));
+        this.isRowSelectable = input(...(ngDevMode ? [undefined, { debugName: "isRowSelectable" }] : []));
+        this.cellSelection = input(...(ngDevMode ? [undefined, { debugName: "cellSelection" }] : []));
+        this.rangeSelection = input(...(ngDevMode ? [undefined, { debugName: "rangeSelection" }] : []));
+        this.columnSelection = input(...(ngDevMode ? [undefined, { debugName: "columnSelection" }] : []));
+        this.headerKeyboardNavigation = input(...(ngDevMode ? [undefined, { debugName: "headerKeyboardNavigation" }] : []));
+        this.selectAllRowsOnHeaderClick = input(...(ngDevMode ? [undefined, { debugName: "selectAllRowsOnHeaderClick" }] : []));
+        this.selectAllScope = input(...(ngDevMode ? [undefined, { debugName: "selectAllScope" }] : []));
+        this.selectionPersistence = input(...(ngDevMode ? [undefined, { debugName: "selectionPersistence" }] : []));
+        this.clearSelectionOnBodyClick = input(...(ngDevMode ? [undefined, { debugName: "clearSelectionOnBodyClick" }] : []));
+        // --- editing ---
+        this.editTrigger = input(...(ngDevMode ? [undefined, { debugName: "editTrigger" }] : []));
+        // Value-returning pre-commit hook (A5). An input rather than an output because outputs cannot
+        // return the veto/transform result to the grid.
+        this.onBeforeCellCommit = input(...(ngDevMode ? [undefined, { debugName: "onBeforeCellCommit" }] : []));
+        this.readOnlyEdit = input(...(ngDevMode ? [undefined, { debugName: "readOnlyEdit" }] : []));
+        this.pinnedRowsEditable = input(...(ngDevMode ? [undefined, { debugName: "pinnedRowsEditable" }] : []));
+        this.suppressKeyboardEdit = input(...(ngDevMode ? [undefined, { debugName: "suppressKeyboardEdit" }] : []));
+        this.suppressTypeToEdit = input(...(ngDevMode ? [undefined, { debugName: "suppressTypeToEdit" }] : []));
+        this.moveAfterEdit = input(...(ngDevMode ? [undefined, { debugName: "moveAfterEdit" }] : []));
+        this.commitOnBlur = input(...(ngDevMode ? [undefined, { debugName: "commitOnBlur" }] : []));
+        this.reevaluateOnEdit = input(...(ngDevMode ? [undefined, { debugName: "reevaluateOnEdit" }] : []));
+        this.undoLimit = input(...(ngDevMode ? [undefined, { debugName: "undoLimit" }] : []));
+        // --- sorting ---
+        this.initialSort = input(...(ngDevMode ? [undefined, { debugName: "initialSort" }] : []));
+        this.showSortPriority = input(...(ngDevMode ? [undefined, { debugName: "showSortPriority" }] : []));
+        // --- filtering ---
+        this.quickFilter = input(...(ngDevMode ? [undefined, { debugName: "quickFilter" }] : []));
+        this.filterDebounceMs = input(...(ngDevMode ? [undefined, { debugName: "filterDebounceMs" }] : []));
+        // --- grouping / tree ---
+        this.groupDisplayType = input(...(ngDevMode ? [undefined, { debugName: "groupDisplayType" }] : []));
+        this.groupColumnDef = input(...(ngDevMode ? [undefined, { debugName: "groupColumnDef" }] : []));
+        this.groupDefaultExpanded = input(...(ngDevMode ? [undefined, { debugName: "groupDefaultExpanded" }] : []));
+        this.groupSortMode = input(...(ngDevMode ? [undefined, { debugName: "groupSortMode" }] : []));
+        this.groupRowsSelectable = input(...(ngDevMode ? [undefined, { debugName: "groupRowsSelectable" }] : []));
+        this.groupRowsSticky = input(...(ngDevMode ? [undefined, { debugName: "groupRowsSticky" }] : []));
+        this.getGroupChildCount = input(...(ngDevMode ? [undefined, { debugName: "getGroupChildCount" }] : []));
+        this.treeData = input(...(ngDevMode ? [undefined, { debugName: "treeData" }] : []));
+        // --- pinned rows ---
+        this.pinnedTopRowData = input(...(ngDevMode ? [undefined, { debugName: "pinnedTopRowData" }] : []));
+        this.pinnedBottomRowData = input(...(ngDevMode ? [undefined, { debugName: "pinnedBottomRowData" }] : []));
+        this.isRowPinned = input(...(ngDevMode ? [undefined, { debugName: "isRowPinned" }] : []));
+        this.rowPinningMenu = input(...(ngDevMode ? [undefined, { debugName: "rowPinningMenu" }] : []));
+        this.rowInsertionMenu = input(...(ngDevMode ? [undefined, { debugName: "rowInsertionMenu" }] : []));
+        // --- full-width rows ---
+        this.isFullWidthRow = input(...(ngDevMode ? [undefined, { debugName: "isFullWidthRow" }] : []));
+        this.fullWidthCellRenderer = input(...(ngDevMode ? [undefined, { debugName: "fullWidthCellRenderer" }] : []));
+        // --- pagination ---
+        this.pagination = input(...(ngDevMode ? [undefined, { debugName: "pagination" }] : []));
+        this.paginationControls = input(...(ngDevMode ? [undefined, { debugName: "paginationControls" }] : []));
+        this.pageSize = input(...(ngDevMode ? [undefined, { debugName: "pageSize" }] : []));
+        this.pageSizes = input(...(ngDevMode ? [undefined, { debugName: "pageSizes" }] : []));
+        this.resetPageOn = input(...(ngDevMode ? [undefined, { debugName: "resetPageOn" }] : []));
+        this.paginationUnknownTotalTooltip = input(...(ngDevMode ? [undefined, { debugName: "paginationUnknownTotalTooltip" }] : []));
+        // --- server-side row model ---
+        this.rowModelType = input(...(ngDevMode ? [undefined, { debugName: "rowModelType" }] : []));
+        this.serverSideDataSource = input(...(ngDevMode ? [undefined, { debugName: "serverSideDataSource" }] : []));
+        this.serverSideAggregationSource = input(...(ngDevMode ? [undefined, { debugName: "serverSideAggregationSource" }] : []));
+        this.serverSideBlockSize = input(...(ngDevMode ? [undefined, { debugName: "serverSideBlockSize" }] : []));
+        // --- widgets / chrome ---
+        this.tooltip = input(...(ngDevMode ? [undefined, { debugName: "tooltip" }] : []));
+        this.columnPanel = input(...(ngDevMode ? [undefined, { debugName: "columnPanel" }] : []));
+        this.toolbar = input(...(ngDevMode ? [undefined, { debugName: "toolbar" }] : []));
+        this.savedViews = input(...(ngDevMode ? [undefined, { debugName: "savedViews" }] : []));
+        this.allowExportAsCSV = input(...(ngDevMode ? [undefined, { debugName: "allowExportAsCSV" }] : []));
+        this.allowExportAsExcel = input(...(ngDevMode ? [undefined, { debugName: "allowExportAsExcel" }] : []));
+        // --- cell change flashing ---
+        this.cellFlashDuration = input(...(ngDevMode ? [undefined, { debugName: "cellFlashDuration" }] : []));
+        this.cellFadeDuration = input(...(ngDevMode ? [undefined, { debugName: "cellFadeDuration" }] : []));
+        // --- overlays ---
+        /** If true, shows the loading overlay. */
+        this.loading = input(...(ngDevMode ? [undefined, { debugName: "loading" }] : []));
+        this.loadingMessage = input(...(ngDevMode ? [undefined, { debugName: "loadingMessage" }] : []));
+        this.noRowsMessage = input(...(ngDevMode ? [undefined, { debugName: "noRowsMessage" }] : []));
+        // --- menus ---
+        /** Hook to customize column menu items (slots may be `TemplateRef`s). */
+        this.getColumnMenuItems = input(...(ngDevMode ? [undefined, { debugName: "getColumnMenuItems" }] : []));
+        /**
+         * Controls the body (right-click) context menu:
+         * - `true` / omitted (default): the grid's default body menu (Copy, Export, …).
+         * - `false`: no grid menu — the browser's native context menu appears instead.
+         * - a function: called with the menu context and the default items; return the items to show
+         *   (slots may be `TemplateRef`s). Return `[]` to show nothing while still suppressing the
+         *   native menu.
+         */
+        this.bodyContextMenu = input(...(ngDevMode ? [undefined, { debugName: "bodyContextMenu" }] : []));
+        // --- outputs ---
+        this.gridReady = output();
+        this.cellClicked = output();
+        this.rowClicked = output();
+        this.cellValueChanged = output();
+        this.selectionChanged = output();
+        this.sortChanged = output();
+        this.filterChanged = output();
+        this.historyChanged = output();
+        this.host = inject(ElementRef);
+        this.zone = inject(NgZone);
+        this.injector = inject(Injector);
+        this.appRef = inject(ApplicationRef);
+        this.adapters = new NgAdapters(this.appRef, inject(EnvironmentInjector), this.zone);
+        this.instance = null;
+        // afterNextRender only runs in the browser, which doubles as the SSR guard: on the server the
+        // grid is never created and the host renders as an empty element.
+        afterNextRender(() => this.create());
+    }
+    ngOnDestroy() {
+        const instance = this.instance;
+        this.instance = null;
+        if (instance)
+            destroyInstance(instance);
+    }
+    create() {
+        const instance = this.zone.runOutsideAngular(() => {
+            const options = getGridOptions(this, this.adapters);
+            // Stable bridges keep the core subscriptions intact while emitting through Angular outputs
+            // (re-entering the zone so listeners see a consistent change-detection world).
+            options.onCellClicked = (ev) => this.zone.run(() => this.cellClicked.emit(ev));
+            options.onRowClicked = (ev) => this.zone.run(() => this.rowClicked.emit(ev));
+            options.onCellValueChanged = (ev) => this.zone.run(() => this.cellValueChanged.emit(ev));
+            options.onSelectionChanged = (ev) => this.zone.run(() => this.selectionChanged.emit(ev));
+            options.onSortChanged = (ev) => this.zone.run(() => this.sortChanged.emit(ev));
+            options.onFilterChanged = (ev) => this.zone.run(() => this.filterChanged.emit(ev));
+            options.onHistoryChanged = (ev) => this.zone.run(() => this.historyChanged.emit(ev));
+            // Value-returning hook, read through the signal so it stays reactive to input changes.
+            // zone.run propagates the return value, so veto/transform results reach the grid.
+            options.onBeforeCellCommit = (params) => {
+                const hook = this.onBeforeCellCommit();
+                return hook ? this.zone.run(() => hook(params)) : undefined;
+            };
+            // createGrid applies columnDefs and rowData right after init, in the same synchronous
+            // sequence this component used to perform by hand (init → columnDefs → rowData). The sync
+            // effects' creation-time snapshots (lastDefs / lastRows) keep them from re-applying these.
+            const api = createGrid(this.host.nativeElement, {
+                ...options,
+                columnDefs: this.adapters.adaptColumnDefs(this.columnDefs()) ?? undefined,
+                // Client-side grids always get an initial rowDataSet (empty included); server-side grids
+                // must not, so their slot stays undefined and createGrid skips it.
+                rowData: this.rowModelType() !== "serverSide" ? this.rowData() ?? [] : undefined,
+                menuAdapter: new NgMenuAdapter(this.appRef, this.zone, {
+                    getColumnMenuItems: () => this.getColumnMenuItems(),
+                }),
+                bodyMenuAdapter: new NgBodyMenuAdapter(this.appRef, this.zone, {
+                    // Only the function arm customizes items here; boolean modes (default / native menu) are
+                    // forwarded to core by getGridOptions. Read through the signal so the callback stays
+                    // reactive to input changes without recreating the grid instance.
+                    getBodyMenuItems: () => {
+                        const opt = this.bodyContextMenu();
+                        return typeof opt === "function" ? opt : undefined;
+                    },
+                }),
+            });
+            const created = { api, destroyed: false };
+            return created;
+        });
+        this.instance = instance;
+        this.startSyncEffects(instance);
+        this.gridReady.emit(instance.api);
+    }
+    /**
+     * One effect per reconcilable option group, mirroring the React wrapper's per-prop layout
+     * effects. Effects are created after the grid instance exists; each one's first run re-applies
+     * the value the instance was just created with, which is harmless for these idempotent setters
+     * (the React wrapper's mount-run effects do the same). The four widget configs that would
+     * rebuild UI on re-application skip their first run via `keyedEffect`.
+     */
+    startSyncEffects(instance) {
+        const { api } = instance;
+        // columnDefs/rowData were already applied synchronously by create(); these effects compare
+        // against that creation-time snapshot so startup applies them exactly once.
+        let lastDefs = untracked(() => this.columnDefs());
+        this.syncEffect(() => {
+            const defs = this.columnDefs();
+            if (defs === lastDefs)
+                return null;
+            lastDefs = defs;
+            // Presence-based: an undefined input still carries the key, releasing caller ownership of
+            // the schema exactly as setColumnDefsFromProps(undefined) did.
+            return () => api.updateGridOptions({ columnDefs: this.adapters.adaptColumnDefs(defs) });
+        });
+        let lastRows = untracked(() => this.rowData());
+        this.syncEffect(() => {
+            const rows = this.rowData();
+            if (rows === lastRows || this.rowModelType() === "serverSide")
+                return null;
+            lastRows = rows;
+            return () => api.setRowData(rows ?? []);
+        });
+        this.syncEffect(() => {
+            const v = this.groupDisplayType();
+            return () => api.updateGridOptions({ groupDisplayType: v });
+        });
+        this.syncEffect(() => {
+            const v = this.groupSortMode();
+            return () => api.updateGridOptions({ groupSortMode: v });
+        });
+        this.syncEffect(() => {
+            const v = this.groupRowsSelectable();
+            return () => api.updateGridOptions({ groupRowsSelectable: v });
+        });
+        this.syncEffect(() => {
+            const v = this.isRowSelectable();
+            return () => api.updateGridOptions({ isRowSelectable: v });
+        });
+        this.keyedEffect(() => this.rowSelection(), (value) => api.updateGridOptions({ rowSelection: value }));
+        this.syncEffect(() => {
+            const treeData = this.treeData();
+            // Both keys are always supplied so each restates its current value rather than being read
+            // back off the core (the API's presence-based contract).
+            return () => api.setTreeDataKeyboardNavigationOptions({
+                keyboardNavigationMode: treeData?.keyboardNavigationMode,
+                enableKeyboardNavigationModeSwitch: treeData?.enableKeyboardNavigationModeSwitch ?? false,
+            });
+        });
+        this.syncEffect(() => {
+            const opts = {
+                pinnedTopRowData: this.pinnedTopRowData(),
+                pinnedBottomRowData: this.pinnedBottomRowData(),
+                isRowPinned: this.isRowPinned(),
+                groupRowsSticky: this.groupRowsSticky(),
+            };
+            return () => api.updateGridOptions(opts);
+        });
+        this.syncEffect(() => {
+            const opts = {
+                rowHover: this.rowHover() ?? true,
+                columnHover: this.columnHover() ?? false,
+                zebraRows: this.zebraRows() ?? false,
+                getRowClass: this.getRowClass(),
+                getRowStyle: this.getRowStyle(),
+                getRowPresentation: this.adapters.adaptGetRowPresentation(this.getRowPresentation()),
+                ariaLabel: this.ariaLabel(),
+                ariaLabelledBy: this.ariaLabelledBy(),
+                highlightActiveCell: this.highlightActiveCell() ?? false,
+                cellSelection: this.cellSelection() ?? true,
+                rangeSelection: this.rangeSelection() ?? true,
+                columnSelection: this.columnSelection() ?? true,
+                headerKeyboardNavigation: this.headerKeyboardNavigation() ?? true,
+                showColumnButtonsOnHover: this.showColumnButtonsOnHover() ?? false,
+                // Function-valued customization is resolved through the body-menu adapter. Core only owns
+                // whether the browser-native mode disables the grid menu entirely.
+                bodyContextMenu: this.bodyContextMenu() === false ? false : true,
+                editTrigger: this.editTrigger() ?? "doubleClick",
+                readOnlyEdit: this.readOnlyEdit() ?? false,
+                pinnedRowsEditable: this.pinnedRowsEditable() ?? false,
+                rowPinningMenu: this.rowPinningMenu() ?? false,
+                rowInsertionMenu: this.rowInsertionMenu(),
+                suppressKeyboardEdit: this.suppressKeyboardEdit() ?? false,
+                suppressTypeToEdit: this.suppressTypeToEdit() ?? false,
+                moveAfterEdit: this.moveAfterEdit() ?? true,
+                commitOnBlur: this.commitOnBlur() ?? true,
+                asyncTransactionWaitMs: this.asyncTransactionWaitMs() ?? 16,
+            };
+            return () => api.updateGridOptions(opts);
+        });
+        this.syncEffect(() => {
+            const source = this.serverSideDataSource();
+            if (this.rowModelType() !== "serverSide" || !source)
+                return null;
+            return () => api.updateGridOptions({ serverSideDataSource: source });
+        });
+        this.syncEffect(() => {
+            const source = this.serverSideAggregationSource();
+            if (this.rowModelType() !== "serverSide" || !source)
+                return null;
+            return () => api.updateGridOptions({ serverSideAggregationSource: source });
+        });
+        this.syncEffect(() => {
+            const loading = this.loading();
+            return () => api.dispatch({ type: "overlayShow", overlayType: loading ? "loading" : "none" });
+        });
+        this.syncEffect(() => {
+            const pagination = this.pagination();
+            return () => api.updateGridOptions({ pagination });
+        });
+        this.keyedEffect(() => this.paginationControls(), (options) => api.updateGridOptions({ paginationControls: options }));
+        // Widget configs reconcile live without remounting the grid, but a rebuild on first run would
+        // be disruptive (the create path already applied them), so these compare serialized contents
+        // and skip the initial application — the Angular translation of the React wrapper's
+        // JSON.stringify keys + mounted refs.
+        this.keyedEffect(() => this.quickFilter(), (v) => api.updateGridOptions({ quickFilter: v }));
+        this.keyedEffect(() => this.tooltip(), (v) => api.updateGridOptions({ tooltip: v }));
+        this.keyedEffect(() => this.columnPanel(), (v) => api.updateGridOptions({ columnPanel: v }));
+        this.keyedEffect(() => this.toolbar(), (v) => api.updateGridOptions({ toolbar: v }));
+        // Saved views are application-owned. Reconcile a new list/callback object in place so a
+        // persistence update immediately refreshes the Views menu without remounting the grid.
+        this.syncEffect(() => {
+            const savedViews = this.savedViews();
+            return () => api.updateGridOptions({ savedViews });
+        });
+        // Theme vars and icons are reconciled together: `icons` overrides any icons carried by
+        // `theme`, so recompute the merged set whenever either changes. The merge is done here (not
+        // left to the API's theme/icon resolution) because that resolution reads creation-time icons
+        // off the core's options, not the current input.
+        this.syncEffect(() => {
+            const theme = this.theme();
+            const icons = this.icons();
+            return () => api.updateGridOptions({ theme, icons: { ...theme?.getIcons(), ...icons } });
+        });
+    }
+    /**
+     * Effect helper: `read` runs tracked (signal reads register dependencies) and returns the core
+     * call to make, or null to skip; the call itself runs outside the Angular zone so core-side
+     * listener churn never schedules change detection.
+     */
+    syncEffect(read) {
+        effect(() => {
+            const apply = read();
+            if (!apply || !this.instance)
+                return;
+            this.zone.runOutsideAngular(apply);
+        }, { injector: this.injector });
+    }
+    /**
+     * Like syncEffect, but compares serialized contents against the value the grid was created with,
+     * so an inline-object input doesn't rebuild the widget unless its contents actually changed —
+     * and the creation-time application is never repeated. (The effect's first run is NOT guaranteed
+     * to happen at mount: with OnPush it can be deferred to the first input change, so "skip the
+     * first run" would swallow a real change — compare values, not run counts.)
+     */
+    keyedEffect(read, apply) {
+        let lastKey = JSON.stringify(untracked(read) ?? null);
+        effect(() => {
+            const value = read();
+            const key = JSON.stringify(value ?? null);
+            if (key === lastKey || !this.instance)
+                return;
+            lastKey = key;
+            this.zone.runOutsideAngular(() => apply(value));
+        }, { injector: this.injector });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.27", ngImport: i0, type: AwbGrid, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.3.27", type: AwbGrid, isStandalone: true, selector: "awb-grid", inputs: { rowData: { classPropertyName: "rowData", publicName: "rowData", isSignal: true, isRequired: false, transformFunction: null }, columnDefs: { classPropertyName: "columnDefs", publicName: "columnDefs", isSignal: true, isRequired: false, transformFunction: null }, defaultColDef: { classPropertyName: "defaultColDef", publicName: "defaultColDef", isSignal: true, isRequired: false, transformFunction: null }, headerHeight: { classPropertyName: "headerHeight", publicName: "headerHeight", isSignal: true, isRequired: false, transformFunction: null }, leafHeaderHeight: { classPropertyName: "leafHeaderHeight", publicName: "leafHeaderHeight", isSignal: true, isRequired: false, transformFunction: null }, parentHeaderHeight: { classPropertyName: "parentHeaderHeight", publicName: "parentHeaderHeight", isSignal: true, isRequired: false, transformFunction: null }, rowHeight: { classPropertyName: "rowHeight", publicName: "rowHeight", isSignal: true, isRequired: false, transformFunction: null }, overscanRowCount: { classPropertyName: "overscanRowCount", publicName: "overscanRowCount", isSignal: true, isRequired: false, transformFunction: null }, minResizeWidth: { classPropertyName: "minResizeWidth", publicName: "minResizeWidth", isSignal: true, isRequired: false, transformFunction: null }, maxColumnWidth: { classPropertyName: "maxColumnWidth", publicName: "maxColumnWidth", isSignal: true, isRequired: false, transformFunction: null }, autosizeColumnsOnDataChange: { classPropertyName: "autosizeColumnsOnDataChange", publicName: "autosizeColumnsOnDataChange", isSignal: true, isRequired: false, transformFunction: null }, getRowId: { classPropertyName: "getRowId", publicName: "getRowId", isSignal: true, isRequired: false, transformFunction: null }, rowIdKey: { classPropertyName: "rowIdKey", publicName: "rowIdKey", isSignal: true, isRequired: false, transformFunction: null }, rowDataMode: { classPropertyName: "rowDataMode", publicName: "rowDataMode", isSignal: true, isRequired: false, transformFunction: null }, asyncTransactionWaitMs: { classPropertyName: "asyncTransactionWaitMs", publicName: "asyncTransactionWaitMs", isSignal: true, isRequired: false, transformFunction: null }, rowHover: { classPropertyName: "rowHover", publicName: "rowHover", isSignal: true, isRequired: false, transformFunction: null }, columnHover: { classPropertyName: "columnHover", publicName: "columnHover", isSignal: true, isRequired: false, transformFunction: null }, zebraRows: { classPropertyName: "zebraRows", publicName: "zebraRows", isSignal: true, isRequired: false, transformFunction: null }, getRowClass: { classPropertyName: "getRowClass", publicName: "getRowClass", isSignal: true, isRequired: false, transformFunction: null }, getRowStyle: { classPropertyName: "getRowStyle", publicName: "getRowStyle", isSignal: true, isRequired: false, transformFunction: null }, getRowPresentation: { classPropertyName: "getRowPresentation", publicName: "getRowPresentation", isSignal: true, isRequired: false, transformFunction: null }, ariaLabel: { classPropertyName: "ariaLabel", publicName: "ariaLabel", isSignal: true, isRequired: false, transformFunction: null }, ariaLabelledBy: { classPropertyName: "ariaLabelledBy", publicName: "ariaLabelledBy", isSignal: true, isRequired: false, transformFunction: null }, highlightActiveCell: { classPropertyName: "highlightActiveCell", publicName: "highlightActiveCell", isSignal: true, isRequired: false, transformFunction: null }, rowNumbers: { classPropertyName: "rowNumbers", publicName: "rowNumbers", isSignal: true, isRequired: false, transformFunction: null }, showColumnButtonsOnHover: { classPropertyName: "showColumnButtonsOnHover", publicName: "showColumnButtonsOnHover", isSignal: true, isRequired: false, transformFunction: null }, theme: { classPropertyName: "theme", publicName: "theme", isSignal: true, isRequired: false, transformFunction: null }, icons: { classPropertyName: "icons", publicName: "icons", isSignal: true, isRequired: false, transformFunction: null }, suppressStyleInjection: { classPropertyName: "suppressStyleInjection", publicName: "suppressStyleInjection", isSignal: true, isRequired: false, transformFunction: null }, styleNonce: { classPropertyName: "styleNonce", publicName: "styleNonce", isSignal: true, isRequired: false, transformFunction: null }, rowSelection: { classPropertyName: "rowSelection", publicName: "rowSelection", isSignal: true, isRequired: false, transformFunction: null }, isRowSelectable: { classPropertyName: "isRowSelectable", publicName: "isRowSelectable", isSignal: true, isRequired: false, transformFunction: null }, cellSelection: { classPropertyName: "cellSelection", publicName: "cellSelection", isSignal: true, isRequired: false, transformFunction: null }, rangeSelection: { classPropertyName: "rangeSelection", publicName: "rangeSelection", isSignal: true, isRequired: false, transformFunction: null }, columnSelection: { classPropertyName: "columnSelection", publicName: "columnSelection", isSignal: true, isRequired: false, transformFunction: null }, headerKeyboardNavigation: { classPropertyName: "headerKeyboardNavigation", publicName: "headerKeyboardNavigation", isSignal: true, isRequired: false, transformFunction: null }, selectAllRowsOnHeaderClick: { classPropertyName: "selectAllRowsOnHeaderClick", publicName: "selectAllRowsOnHeaderClick", isSignal: true, isRequired: false, transformFunction: null }, selectAllScope: { classPropertyName: "selectAllScope", publicName: "selectAllScope", isSignal: true, isRequired: false, transformFunction: null }, selectionPersistence: { classPropertyName: "selectionPersistence", publicName: "selectionPersistence", isSignal: true, isRequired: false, transformFunction: null }, clearSelectionOnBodyClick: { classPropertyName: "clearSelectionOnBodyClick", publicName: "clearSelectionOnBodyClick", isSignal: true, isRequired: false, transformFunction: null }, editTrigger: { classPropertyName: "editTrigger", publicName: "editTrigger", isSignal: true, isRequired: false, transformFunction: null }, onBeforeCellCommit: { classPropertyName: "onBeforeCellCommit", publicName: "onBeforeCellCommit", isSignal: true, isRequired: false, transformFunction: null }, readOnlyEdit: { classPropertyName: "readOnlyEdit", publicName: "readOnlyEdit", isSignal: true, isRequired: false, transformFunction: null }, pinnedRowsEditable: { classPropertyName: "pinnedRowsEditable", publicName: "pinnedRowsEditable", isSignal: true, isRequired: false, transformFunction: null }, suppressKeyboardEdit: { classPropertyName: "suppressKeyboardEdit", publicName: "suppressKeyboardEdit", isSignal: true, isRequired: false, transformFunction: null }, suppressTypeToEdit: { classPropertyName: "suppressTypeToEdit", publicName: "suppressTypeToEdit", isSignal: true, isRequired: false, transformFunction: null }, moveAfterEdit: { classPropertyName: "moveAfterEdit", publicName: "moveAfterEdit", isSignal: true, isRequired: false, transformFunction: null }, commitOnBlur: { classPropertyName: "commitOnBlur", publicName: "commitOnBlur", isSignal: true, isRequired: false, transformFunction: null }, reevaluateOnEdit: { classPropertyName: "reevaluateOnEdit", publicName: "reevaluateOnEdit", isSignal: true, isRequired: false, transformFunction: null }, undoLimit: { classPropertyName: "undoLimit", publicName: "undoLimit", isSignal: true, isRequired: false, transformFunction: null }, initialSort: { classPropertyName: "initialSort", publicName: "initialSort", isSignal: true, isRequired: false, transformFunction: null }, showSortPriority: { classPropertyName: "showSortPriority", publicName: "showSortPriority", isSignal: true, isRequired: false, transformFunction: null }, quickFilter: { classPropertyName: "quickFilter", publicName: "quickFilter", isSignal: true, isRequired: false, transformFunction: null }, filterDebounceMs: { classPropertyName: "filterDebounceMs", publicName: "filterDebounceMs", isSignal: true, isRequired: false, transformFunction: null }, groupDisplayType: { classPropertyName: "groupDisplayType", publicName: "groupDisplayType", isSignal: true, isRequired: false, transformFunction: null }, groupColumnDef: { classPropertyName: "groupColumnDef", publicName: "groupColumnDef", isSignal: true, isRequired: false, transformFunction: null }, groupDefaultExpanded: { classPropertyName: "groupDefaultExpanded", publicName: "groupDefaultExpanded", isSignal: true, isRequired: false, transformFunction: null }, groupSortMode: { classPropertyName: "groupSortMode", publicName: "groupSortMode", isSignal: true, isRequired: false, transformFunction: null }, groupRowsSelectable: { classPropertyName: "groupRowsSelectable", publicName: "groupRowsSelectable", isSignal: true, isRequired: false, transformFunction: null }, groupRowsSticky: { classPropertyName: "groupRowsSticky", publicName: "groupRowsSticky", isSignal: true, isRequired: false, transformFunction: null }, getGroupChildCount: { classPropertyName: "getGroupChildCount", publicName: "getGroupChildCount", isSignal: true, isRequired: false, transformFunction: null }, treeData: { classPropertyName: "treeData", publicName: "treeData", isSignal: true, isRequired: false, transformFunction: null }, pinnedTopRowData: { classPropertyName: "pinnedTopRowData", publicName: "pinnedTopRowData", isSignal: true, isRequired: false, transformFunction: null }, pinnedBottomRowData: { classPropertyName: "pinnedBottomRowData", publicName: "pinnedBottomRowData", isSignal: true, isRequired: false, transformFunction: null }, isRowPinned: { classPropertyName: "isRowPinned", publicName: "isRowPinned", isSignal: true, isRequired: false, transformFunction: null }, rowPinningMenu: { classPropertyName: "rowPinningMenu", publicName: "rowPinningMenu", isSignal: true, isRequired: false, transformFunction: null }, rowInsertionMenu: { classPropertyName: "rowInsertionMenu", publicName: "rowInsertionMenu", isSignal: true, isRequired: false, transformFunction: null }, isFullWidthRow: { classPropertyName: "isFullWidthRow", publicName: "isFullWidthRow", isSignal: true, isRequired: false, transformFunction: null }, fullWidthCellRenderer: { classPropertyName: "fullWidthCellRenderer", publicName: "fullWidthCellRenderer", isSignal: true, isRequired: false, transformFunction: null }, pagination: { classPropertyName: "pagination", publicName: "pagination", isSignal: true, isRequired: false, transformFunction: null }, paginationControls: { classPropertyName: "paginationControls", publicName: "paginationControls", isSignal: true, isRequired: false, transformFunction: null }, pageSize: { classPropertyName: "pageSize", publicName: "pageSize", isSignal: true, isRequired: false, transformFunction: null }, pageSizes: { classPropertyName: "pageSizes", publicName: "pageSizes", isSignal: true, isRequired: false, transformFunction: null }, resetPageOn: { classPropertyName: "resetPageOn", publicName: "resetPageOn", isSignal: true, isRequired: false, transformFunction: null }, paginationUnknownTotalTooltip: { classPropertyName: "paginationUnknownTotalTooltip", publicName: "paginationUnknownTotalTooltip", isSignal: true, isRequired: false, transformFunction: null }, rowModelType: { classPropertyName: "rowModelType", publicName: "rowModelType", isSignal: true, isRequired: false, transformFunction: null }, serverSideDataSource: { classPropertyName: "serverSideDataSource", publicName: "serverSideDataSource", isSignal: true, isRequired: false, transformFunction: null }, serverSideAggregationSource: { classPropertyName: "serverSideAggregationSource", publicName: "serverSideAggregationSource", isSignal: true, isRequired: false, transformFunction: null }, serverSideBlockSize: { classPropertyName: "serverSideBlockSize", publicName: "serverSideBlockSize", isSignal: true, isRequired: false, transformFunction: null }, tooltip: { classPropertyName: "tooltip", publicName: "tooltip", isSignal: true, isRequired: false, transformFunction: null }, columnPanel: { classPropertyName: "columnPanel", publicName: "columnPanel", isSignal: true, isRequired: false, transformFunction: null }, toolbar: { classPropertyName: "toolbar", publicName: "toolbar", isSignal: true, isRequired: false, transformFunction: null }, savedViews: { classPropertyName: "savedViews", publicName: "savedViews", isSignal: true, isRequired: false, transformFunction: null }, allowExportAsCSV: { classPropertyName: "allowExportAsCSV", publicName: "allowExportAsCSV", isSignal: true, isRequired: false, transformFunction: null }, allowExportAsExcel: { classPropertyName: "allowExportAsExcel", publicName: "allowExportAsExcel", isSignal: true, isRequired: false, transformFunction: null }, cellFlashDuration: { classPropertyName: "cellFlashDuration", publicName: "cellFlashDuration", isSignal: true, isRequired: false, transformFunction: null }, cellFadeDuration: { classPropertyName: "cellFadeDuration", publicName: "cellFadeDuration", isSignal: true, isRequired: false, transformFunction: null }, loading: { classPropertyName: "loading", publicName: "loading", isSignal: true, isRequired: false, transformFunction: null }, loadingMessage: { classPropertyName: "loadingMessage", publicName: "loadingMessage", isSignal: true, isRequired: false, transformFunction: null }, noRowsMessage: { classPropertyName: "noRowsMessage", publicName: "noRowsMessage", isSignal: true, isRequired: false, transformFunction: null }, getColumnMenuItems: { classPropertyName: "getColumnMenuItems", publicName: "getColumnMenuItems", isSignal: true, isRequired: false, transformFunction: null }, bodyContextMenu: { classPropertyName: "bodyContextMenu", publicName: "bodyContextMenu", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { gridReady: "gridReady", cellClicked: "cellClicked", rowClicked: "rowClicked", cellValueChanged: "cellValueChanged", selectionChanged: "selectionChanged", sortChanged: "sortChanged", filterChanged: "filterChanged", historyChanged: "historyChanged" }, exportAs: ["awbGrid"], ngImport: i0, template: "", isInline: true, styles: [":host{position:relative;display:block;width:100%;height:100%;overflow:hidden}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.27", ngImport: i0, type: AwbGrid, decorators: [{
+            type: Component,
+            args: [{ selector: "awb-grid", standalone: true, exportAs: "awbGrid", template: "", changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{position:relative;display:block;width:100%;height:100%;overflow:hidden}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { rowData: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowData", required: false }] }], columnDefs: [{ type: i0.Input, args: [{ isSignal: true, alias: "columnDefs", required: false }] }], defaultColDef: [{ type: i0.Input, args: [{ isSignal: true, alias: "defaultColDef", required: false }] }], headerHeight: [{ type: i0.Input, args: [{ isSignal: true, alias: "headerHeight", required: false }] }], leafHeaderHeight: [{ type: i0.Input, args: [{ isSignal: true, alias: "leafHeaderHeight", required: false }] }], parentHeaderHeight: [{ type: i0.Input, args: [{ isSignal: true, alias: "parentHeaderHeight", required: false }] }], rowHeight: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowHeight", required: false }] }], overscanRowCount: [{ type: i0.Input, args: [{ isSignal: true, alias: "overscanRowCount", required: false }] }], minResizeWidth: [{ type: i0.Input, args: [{ isSignal: true, alias: "minResizeWidth", required: false }] }], maxColumnWidth: [{ type: i0.Input, args: [{ isSignal: true, alias: "maxColumnWidth", required: false }] }], autosizeColumnsOnDataChange: [{ type: i0.Input, args: [{ isSignal: true, alias: "autosizeColumnsOnDataChange", required: false }] }], getRowId: [{ type: i0.Input, args: [{ isSignal: true, alias: "getRowId", required: false }] }], rowIdKey: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowIdKey", required: false }] }], rowDataMode: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowDataMode", required: false }] }], asyncTransactionWaitMs: [{ type: i0.Input, args: [{ isSignal: true, alias: "asyncTransactionWaitMs", required: false }] }], rowHover: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowHover", required: false }] }], columnHover: [{ type: i0.Input, args: [{ isSignal: true, alias: "columnHover", required: false }] }], zebraRows: [{ type: i0.Input, args: [{ isSignal: true, alias: "zebraRows", required: false }] }], getRowClass: [{ type: i0.Input, args: [{ isSignal: true, alias: "getRowClass", required: false }] }], getRowStyle: [{ type: i0.Input, args: [{ isSignal: true, alias: "getRowStyle", required: false }] }], getRowPresentation: [{ type: i0.Input, args: [{ isSignal: true, alias: "getRowPresentation", required: false }] }], ariaLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "ariaLabel", required: false }] }], ariaLabelledBy: [{ type: i0.Input, args: [{ isSignal: true, alias: "ariaLabelledBy", required: false }] }], highlightActiveCell: [{ type: i0.Input, args: [{ isSignal: true, alias: "highlightActiveCell", required: false }] }], rowNumbers: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowNumbers", required: false }] }], showColumnButtonsOnHover: [{ type: i0.Input, args: [{ isSignal: true, alias: "showColumnButtonsOnHover", required: false }] }], theme: [{ type: i0.Input, args: [{ isSignal: true, alias: "theme", required: false }] }], icons: [{ type: i0.Input, args: [{ isSignal: true, alias: "icons", required: false }] }], suppressStyleInjection: [{ type: i0.Input, args: [{ isSignal: true, alias: "suppressStyleInjection", required: false }] }], styleNonce: [{ type: i0.Input, args: [{ isSignal: true, alias: "styleNonce", required: false }] }], rowSelection: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowSelection", required: false }] }], isRowSelectable: [{ type: i0.Input, args: [{ isSignal: true, alias: "isRowSelectable", required: false }] }], cellSelection: [{ type: i0.Input, args: [{ isSignal: true, alias: "cellSelection", required: false }] }], rangeSelection: [{ type: i0.Input, args: [{ isSignal: true, alias: "rangeSelection", required: false }] }], columnSelection: [{ type: i0.Input, args: [{ isSignal: true, alias: "columnSelection", required: false }] }], headerKeyboardNavigation: [{ type: i0.Input, args: [{ isSignal: true, alias: "headerKeyboardNavigation", required: false }] }], selectAllRowsOnHeaderClick: [{ type: i0.Input, args: [{ isSignal: true, alias: "selectAllRowsOnHeaderClick", required: false }] }], selectAllScope: [{ type: i0.Input, args: [{ isSignal: true, alias: "selectAllScope", required: false }] }], selectionPersistence: [{ type: i0.Input, args: [{ isSignal: true, alias: "selectionPersistence", required: false }] }], clearSelectionOnBodyClick: [{ type: i0.Input, args: [{ isSignal: true, alias: "clearSelectionOnBodyClick", required: false }] }], editTrigger: [{ type: i0.Input, args: [{ isSignal: true, alias: "editTrigger", required: false }] }], onBeforeCellCommit: [{ type: i0.Input, args: [{ isSignal: true, alias: "onBeforeCellCommit", required: false }] }], readOnlyEdit: [{ type: i0.Input, args: [{ isSignal: true, alias: "readOnlyEdit", required: false }] }], pinnedRowsEditable: [{ type: i0.Input, args: [{ isSignal: true, alias: "pinnedRowsEditable", required: false }] }], suppressKeyboardEdit: [{ type: i0.Input, args: [{ isSignal: true, alias: "suppressKeyboardEdit", required: false }] }], suppressTypeToEdit: [{ type: i0.Input, args: [{ isSignal: true, alias: "suppressTypeToEdit", required: false }] }], moveAfterEdit: [{ type: i0.Input, args: [{ isSignal: true, alias: "moveAfterEdit", required: false }] }], commitOnBlur: [{ type: i0.Input, args: [{ isSignal: true, alias: "commitOnBlur", required: false }] }], reevaluateOnEdit: [{ type: i0.Input, args: [{ isSignal: true, alias: "reevaluateOnEdit", required: false }] }], undoLimit: [{ type: i0.Input, args: [{ isSignal: true, alias: "undoLimit", required: false }] }], initialSort: [{ type: i0.Input, args: [{ isSignal: true, alias: "initialSort", required: false }] }], showSortPriority: [{ type: i0.Input, args: [{ isSignal: true, alias: "showSortPriority", required: false }] }], quickFilter: [{ type: i0.Input, args: [{ isSignal: true, alias: "quickFilter", required: false }] }], filterDebounceMs: [{ type: i0.Input, args: [{ isSignal: true, alias: "filterDebounceMs", required: false }] }], groupDisplayType: [{ type: i0.Input, args: [{ isSignal: true, alias: "groupDisplayType", required: false }] }], groupColumnDef: [{ type: i0.Input, args: [{ isSignal: true, alias: "groupColumnDef", required: false }] }], groupDefaultExpanded: [{ type: i0.Input, args: [{ isSignal: true, alias: "groupDefaultExpanded", required: false }] }], groupSortMode: [{ type: i0.Input, args: [{ isSignal: true, alias: "groupSortMode", required: false }] }], groupRowsSelectable: [{ type: i0.Input, args: [{ isSignal: true, alias: "groupRowsSelectable", required: false }] }], groupRowsSticky: [{ type: i0.Input, args: [{ isSignal: true, alias: "groupRowsSticky", required: false }] }], getGroupChildCount: [{ type: i0.Input, args: [{ isSignal: true, alias: "getGroupChildCount", required: false }] }], treeData: [{ type: i0.Input, args: [{ isSignal: true, alias: "treeData", required: false }] }], pinnedTopRowData: [{ type: i0.Input, args: [{ isSignal: true, alias: "pinnedTopRowData", required: false }] }], pinnedBottomRowData: [{ type: i0.Input, args: [{ isSignal: true, alias: "pinnedBottomRowData", required: false }] }], isRowPinned: [{ type: i0.Input, args: [{ isSignal: true, alias: "isRowPinned", required: false }] }], rowPinningMenu: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowPinningMenu", required: false }] }], rowInsertionMenu: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowInsertionMenu", required: false }] }], isFullWidthRow: [{ type: i0.Input, args: [{ isSignal: true, alias: "isFullWidthRow", required: false }] }], fullWidthCellRenderer: [{ type: i0.Input, args: [{ isSignal: true, alias: "fullWidthCellRenderer", required: false }] }], pagination: [{ type: i0.Input, args: [{ isSignal: true, alias: "pagination", required: false }] }], paginationControls: [{ type: i0.Input, args: [{ isSignal: true, alias: "paginationControls", required: false }] }], pageSize: [{ type: i0.Input, args: [{ isSignal: true, alias: "pageSize", required: false }] }], pageSizes: [{ type: i0.Input, args: [{ isSignal: true, alias: "pageSizes", required: false }] }], resetPageOn: [{ type: i0.Input, args: [{ isSignal: true, alias: "resetPageOn", required: false }] }], paginationUnknownTotalTooltip: [{ type: i0.Input, args: [{ isSignal: true, alias: "paginationUnknownTotalTooltip", required: false }] }], rowModelType: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowModelType", required: false }] }], serverSideDataSource: [{ type: i0.Input, args: [{ isSignal: true, alias: "serverSideDataSource", required: false }] }], serverSideAggregationSource: [{ type: i0.Input, args: [{ isSignal: true, alias: "serverSideAggregationSource", required: false }] }], serverSideBlockSize: [{ type: i0.Input, args: [{ isSignal: true, alias: "serverSideBlockSize", required: false }] }], tooltip: [{ type: i0.Input, args: [{ isSignal: true, alias: "tooltip", required: false }] }], columnPanel: [{ type: i0.Input, args: [{ isSignal: true, alias: "columnPanel", required: false }] }], toolbar: [{ type: i0.Input, args: [{ isSignal: true, alias: "toolbar", required: false }] }], savedViews: [{ type: i0.Input, args: [{ isSignal: true, alias: "savedViews", required: false }] }], allowExportAsCSV: [{ type: i0.Input, args: [{ isSignal: true, alias: "allowExportAsCSV", required: false }] }], allowExportAsExcel: [{ type: i0.Input, args: [{ isSignal: true, alias: "allowExportAsExcel", required: false }] }], cellFlashDuration: [{ type: i0.Input, args: [{ isSignal: true, alias: "cellFlashDuration", required: false }] }], cellFadeDuration: [{ type: i0.Input, args: [{ isSignal: true, alias: "cellFadeDuration", required: false }] }], loading: [{ type: i0.Input, args: [{ isSignal: true, alias: "loading", required: false }] }], loadingMessage: [{ type: i0.Input, args: [{ isSignal: true, alias: "loadingMessage", required: false }] }], noRowsMessage: [{ type: i0.Input, args: [{ isSignal: true, alias: "noRowsMessage", required: false }] }], getColumnMenuItems: [{ type: i0.Input, args: [{ isSignal: true, alias: "getColumnMenuItems", required: false }] }], bodyContextMenu: [{ type: i0.Input, args: [{ isSignal: true, alias: "bodyContextMenu", required: false }] }], gridReady: [{ type: i0.Output, args: ["gridReady"] }], cellClicked: [{ type: i0.Output, args: ["cellClicked"] }], rowClicked: [{ type: i0.Output, args: ["rowClicked"] }], cellValueChanged: [{ type: i0.Output, args: ["cellValueChanged"] }], selectionChanged: [{ type: i0.Output, args: ["selectionChanged"] }], sortChanged: [{ type: i0.Output, args: ["sortChanged"] }], filterChanged: [{ type: i0.Output, args: ["filterChanged"] }], historyChanged: [{ type: i0.Output, args: ["historyChanged"] }] } });
+
+// Re-export the full framework-agnostic core surface so consumers can import everything they need
+// (ColDef, GridOptions, themes, types, …) from the Angular entry alone:
+// `import { AwbGrid, themeDark, type ColDef } from "@agility-workbench/angular-grid"`.
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AwbGrid };