@simple-table/angular 4.1.1 → 4.1.2

package/dist/fesm2022/simple-table-angular.mjs

@@ -0,0 +1,659 @@
+import * as i0 from '@angular/core';
+import { createComponent, EventEmitter, inject, ElementRef, ApplicationRef, EnvironmentInjector, Output, Input, Component, makeEnvironmentProviders } from '@angular/core';
+import { collectHeaderAccessors, asRows, SimpleTableVanilla, headersStructurallyEqual, rowsShallowUnchanged } from 'simple-table-core';
+export { PIVOT_ACCESSOR_PREFIX, PIVOT_BLANK_LABEL, PIVOT_CHILDREN_KEY, PIVOT_IS_TOTAL_KEY, asRows, buildPivotAccessor, buildPivotRowTotalAccessor, pivotRows } from 'simple-table-core';
+
+/**
+ * Wraps an Angular standalone component into a function that returns an
+ * HTMLElement, matching the vanilla renderer contract expected by
+ * simple-table-core.
+ *
+ * Requires references to the running Angular ApplicationRef and
+ * EnvironmentInjector so it can attach the dynamically-created component
+ * to the change detection tree and trigger a synchronous flush before
+ * returning the element to the vanilla rendering pipeline.
+ *
+ * Pass an optional {@link MountRegistry} so core's `onRendererHostDiscard` can
+ * destroy the ComponentRef (including any CDK Overlay / floating UI) when the
+ * host is discarded. The table adapter always supplies a registry; the public
+ * helper used for one-shot static slots (e.g. `tableEmptyStateRenderer`) may omit it.
+ *
+ * These are injected automatically when the consumer uses
+ * `provideSimpleTable()` in their application providers.
+ */
+function wrapAngularRenderer(component, appRef, injector, registry) {
+    return (props) => {
+        const el = document.createElement("div");
+        const componentRef = createComponent(component, {
+            environmentInjector: injector,
+            hostElement: el,
+        });
+        // Assign input props to the component instance.
+        Object.assign(componentRef.instance, props);
+        // Attach to the application's view tree so Angular tracks it.
+        appRef.attachView(componentRef.hostView);
+        // Synchronous change detection flush — ensures the rendered output is
+        // in the DOM before we return the element to the vanilla pipeline.
+        componentRef.changeDetectorRef.detectChanges();
+        registry?.register(el, () => {
+            appRef.detachView(componentRef.hostView);
+            componentRef.destroy();
+        });
+        return el;
+    };
+}
+/**
+ * Like {@link wrapAngularRenderer}, but reuses one wrapper per accessor so
+ * unstable column rebuilds keep a stable function identity on ColumnDef.
+ */
+function wrapCachedAngularRenderer(component, appRef, injector, registry, accessor, kind) {
+    const cache = kind === "cell" ? registry.cellRendererCache : registry.headerRendererCache;
+    const existing = cache.get(accessor);
+    if (existing) {
+        existing.component = component;
+        return existing.wrapped;
+    }
+    const slot = {
+        component,
+        wrapped: null,
+    };
+    const wrapped = (props) => {
+        const el = document.createElement("div");
+        const componentRef = createComponent(slot.component, {
+            environmentInjector: injector,
+            hostElement: el,
+        });
+        Object.assign(componentRef.instance, props);
+        appRef.attachView(componentRef.hostView);
+        componentRef.changeDetectorRef.detectChanges();
+        registry.register(el, () => {
+            appRef.detachView(componentRef.hostView);
+            componentRef.destroy();
+        });
+        return el;
+    };
+    slot.wrapped = wrapped;
+    cache.set(accessor, slot);
+    return wrapped;
+}
+
+/** Resolve column definitions. */
+function resolveAngularColumns(config) {
+    const headers = config.columns;
+    if (!headers) {
+        throw new Error("SimpleTable requires `columns`");
+    }
+    return headers;
+}
+function buildVanillaConfig(config, registry, appRef, injector) {
+    const { columns: _columns, rows, footerRenderer, emptyStateRenderer, errorStateRenderer, loadingStateRenderer, tableEmptyStateRenderer, headerDropdown, columnEditorConfig, icons, rowButtons, onColumnOrderChange, onColumnWidthChange, onHeaderEdit, onColumnSelect, enableColumnEditor, enableColumnEditorInitOpen, enablePagination, onTableReady, hoverRowBackground, oddColumnBackground, oddEvenRowBackground, ...rest } = config;
+    const wrap = (component) => wrapAngularRenderer(component, appRef, injector, registry);
+    function transformIcons(iconsConfig) {
+        const result = {};
+        for (const [key, value] of Object.entries(iconsConfig)) {
+            if (value == null)
+                continue;
+            if (typeof value === "string" ||
+                value instanceof HTMLElement ||
+                value instanceof SVGSVGElement) {
+                result[key] = value;
+            }
+            else if (value.ɵcmp) {
+                result[key] = wrap(value)({});
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    function transformColumnEditorConfig(cfg) {
+        const { rowRenderer, customRenderer, ...cfgRest } = cfg;
+        return {
+            ...cfgRest,
+            ...(rowRenderer ? { rowRenderer: wrap(rowRenderer) } : {}),
+            ...(customRenderer ? { customRenderer: wrap(customRenderer) } : {}),
+        };
+    }
+    function transformHeader(header) {
+        const { cellRenderer, headerRenderer, children, nestedTable, ...headerRest } = header;
+        const accessor = String(header.accessor);
+        const transformed = { ...headerRest };
+        if (cellRenderer) {
+            if (cellRenderer.ɵcmp) {
+                transformed.cellRenderer = wrapCachedAngularRenderer(cellRenderer, appRef, injector, registry, accessor, "cell");
+            }
+            else {
+                transformed.cellRenderer = cellRenderer;
+            }
+        }
+        if (headerRenderer) {
+            if (headerRenderer.ɵcmp) {
+                transformed.headerRenderer = wrapCachedAngularRenderer(headerRenderer, appRef, injector, registry, accessor, "header");
+            }
+            else {
+                transformed.headerRenderer = headerRenderer;
+            }
+        }
+        if (children)
+            transformed.children = children.map(transformHeader);
+        if (nestedTable) {
+            const nestedFull = { ...nestedTable, rows: [] };
+            transformed.nestedTable = buildVanillaConfig(nestedFull, registry, appRef, injector);
+        }
+        return transformed;
+    }
+    const columns = resolveAngularColumns(config);
+    registry.pruneRendererCaches(collectHeaderAccessors(columns));
+    // `rest` still carries TData-bound callbacks (getRowId, onCellEdit, …).
+    // Widen once here — the vanilla runtime is Row-shaped.
+    const shared = rest;
+    const vanillaConfig = {
+        ...shared,
+        rows: asRows(rows),
+        columns: columns.map(transformHeader),
+        enableColumnEditor,
+        enableColumnEditorInitOpen,
+        enablePagination,
+        onTableReady,
+        hoverRowBackground,
+        oddColumnBackground,
+        oddEvenRowBackground,
+        // Authoritative mount teardown: core calls this before it permanently
+        // discards any host element, so the registry destroys exactly the affected
+        // Angular ComponentRefs (including CDK Overlay / floating UI).
+        onRendererHostDiscard: registry.disposeHost,
+    };
+    if (onColumnOrderChange) {
+        vanillaConfig.onColumnOrderChange = (headers) => onColumnOrderChange(headers);
+    }
+    if (onColumnWidthChange) {
+        vanillaConfig.onColumnWidthChange = (headers) => onColumnWidthChange(headers);
+    }
+    if (onHeaderEdit) {
+        vanillaConfig.onHeaderEdit = (header, newLabel) => onHeaderEdit(header, newLabel);
+    }
+    if (onColumnSelect) {
+        vanillaConfig.onColumnSelect = (header) => onColumnSelect(header);
+    }
+    if (footerRenderer !== undefined) {
+        if (footerRenderer.ɵcmp) {
+            vanillaConfig.footerRenderer = wrap(footerRenderer);
+        }
+        else {
+            vanillaConfig.footerRenderer = footerRenderer;
+        }
+    }
+    if (emptyStateRenderer !== undefined) {
+        if (emptyStateRenderer.ɵcmp) {
+            vanillaConfig.emptyStateRenderer = wrap(emptyStateRenderer);
+        }
+        else {
+            vanillaConfig.emptyStateRenderer = emptyStateRenderer;
+        }
+    }
+    if (errorStateRenderer !== undefined) {
+        if (errorStateRenderer.ɵcmp) {
+            vanillaConfig.errorStateRenderer = wrap(errorStateRenderer);
+        }
+        else {
+            vanillaConfig.errorStateRenderer = errorStateRenderer;
+        }
+    }
+    if (loadingStateRenderer !== undefined) {
+        if (loadingStateRenderer.ɵcmp) {
+            vanillaConfig.loadingStateRenderer = wrap(loadingStateRenderer);
+        }
+        else {
+            vanillaConfig.loadingStateRenderer = loadingStateRenderer;
+        }
+    }
+    if (tableEmptyStateRenderer !== undefined) {
+        vanillaConfig.tableEmptyStateRenderer = tableEmptyStateRenderer;
+    }
+    if (headerDropdown !== undefined) {
+        vanillaConfig.headerDropdown = wrap(headerDropdown);
+    }
+    if (columnEditorConfig !== undefined) {
+        vanillaConfig.columnEditorConfig = transformColumnEditorConfig(columnEditorConfig);
+    }
+    if (icons !== undefined) {
+        vanillaConfig.icons = transformIcons(icons);
+    }
+    if (rowButtons !== undefined) {
+        vanillaConfig.rowButtons = rowButtons.map((button) => wrap(button));
+    }
+    return vanillaConfig;
+}
+
+/**
+ * Tracks imperative Angular mounts and caches wrapped cell/header renderers per
+ * accessor so unstable column rebuilds keep stable wrapper identity.
+ */
+const MOUNT_ID_ATTR = "data-st-mount-id";
+class MountRegistry {
+    constructor() {
+        this.entries = new Map();
+        this.nextId = 0;
+        this.cellRendererCache = new Map();
+        this.headerRendererCache = new Map();
+        this.disposeHost = (host) => {
+            if (typeof host.getAttribute !== "function")
+                return;
+            const ids = [];
+            const selfId = host.getAttribute(MOUNT_ID_ATTR);
+            if (selfId !== null)
+                ids.push(selfId);
+            const tagged = host.querySelectorAll(`[${MOUNT_ID_ATTR}]`);
+            tagged.forEach((el) => {
+                const id = el.getAttribute(MOUNT_ID_ATTR);
+                if (id !== null)
+                    ids.push(id);
+            });
+            for (const id of ids) {
+                const dispose = this.entries.get(id);
+                if (!dispose)
+                    continue;
+                this.entries.delete(id);
+                dispose();
+            }
+        };
+    }
+    register(container, dispose) {
+        const id = `st-mount-${this.nextId++}`;
+        container.setAttribute(MOUNT_ID_ATTR, id);
+        this.entries.set(id, dispose);
+    }
+    clear() {
+        this.cellRendererCache.clear();
+        this.headerRendererCache.clear();
+        for (const dispose of this.entries.values()) {
+            dispose();
+        }
+        this.entries.clear();
+    }
+    pruneRendererCaches(liveAccessors) {
+        for (const key of this.cellRendererCache.keys()) {
+            if (!liveAccessors.has(key))
+                this.cellRendererCache.delete(key);
+        }
+        for (const key of this.headerRendererCache.keys()) {
+            if (!liveAccessors.has(key))
+                this.headerRendererCache.delete(key);
+        }
+    }
+    get size() {
+        return this.entries.size;
+    }
+}
+
+/**
+ * SimpleTable — Angular adapter for simple-table-core.
+ *
+ * Accepts the same props as SimpleTableProps (the vanilla user-facing API) but
+ * with Angular component types for all renderer props.
+ *
+ * Prefer typed `rows` / `columns` (`AngularColumnDef<MyRow>`). For a typed
+ * imperative handle, use `@ViewChild(SimpleTableComponent) table!: SimpleTableComponent<MyRow>`
+ * or listen to `(tableReady)`.
+ */
+class SimpleTableComponent {
+    constructor() {
+        /** Emits the TableAPI once the table has mounted. */
+        this.tableReady = new EventEmitter();
+        this.instance = null;
+        this.registry = new MountRegistry();
+        this.hostEl = inject((ElementRef));
+        this.appRef = inject(ApplicationRef);
+        this.envInjector = inject(EnvironmentInjector);
+    }
+    ngOnInit() {
+        const container = this.hostEl.nativeElement.querySelector("div");
+        if (!container)
+            return;
+        const props = this.getProps();
+        this.instance = new SimpleTableVanilla(container, buildVanillaConfig(props, this.registry, this.appRef, this.envInjector));
+        this.instance.mount();
+        this.syncedDefaultHeaders = resolveAngularColumns(props);
+        this.syncedRows = props.rows;
+        this.tableReady.emit(this.instance.getAPI());
+    }
+    ngOnChanges() {
+        if (!this.instance)
+            return;
+        const props = this.getProps();
+        const fullConfig = buildVanillaConfig(props, this.registry, this.appRef, this.envInjector);
+        const patch = { ...fullConfig };
+        const resolvedColumns = resolveAngularColumns(props);
+        const headersUnchanged = headersStructurallyEqual(this.syncedDefaultHeaders, resolvedColumns);
+        this.syncedDefaultHeaders = resolvedColumns;
+        if (headersUnchanged) {
+            delete patch.columns;
+        }
+        const rowsUnchanged = rowsShallowUnchanged(this.syncedRows, props.rows, props.getRowId);
+        this.syncedRows = props.rows;
+        if (rowsUnchanged) {
+            delete patch.rows;
+        }
+        this.instance.update(patch);
+    }
+    ngOnDestroy() {
+        this.instance?.destroy();
+        this.instance = null;
+        this.syncedDefaultHeaders = undefined;
+        this.syncedRows = undefined;
+        this.registry.clear();
+    }
+    /** Returns the full imperative TableAPI. Use via @ViewChild or (tableReady) output. */
+    getAPI() {
+        return this.instance?.getAPI() ?? null;
+    }
+    getProps() {
+        const props = {
+            rows: this.rows,
+        };
+        if (this.columns !== undefined)
+            props.columns = this.columns;
+        if (this.footerRenderer !== undefined)
+            props.footerRenderer = this.footerRenderer;
+        if (this.loadingStateRenderer !== undefined)
+            props.loadingStateRenderer = this.loadingStateRenderer;
+        if (this.errorStateRenderer !== undefined)
+            props.errorStateRenderer = this.errorStateRenderer;
+        if (this.emptyStateRenderer !== undefined)
+            props.emptyStateRenderer = this.emptyStateRenderer;
+        if (this.tableEmptyStateRenderer !== undefined)
+            props.tableEmptyStateRenderer = this.tableEmptyStateRenderer;
+        if (this.headerDropdown !== undefined)
+            props.headerDropdown = this.headerDropdown;
+        if (this.columnEditorConfig !== undefined)
+            props.columnEditorConfig = this.columnEditorConfig;
+        if (this.onCellClick !== undefined)
+            props.onCellClick = this.onCellClick;
+        if (this.onCellEdit !== undefined)
+            props.onCellEdit = this.onCellEdit;
+        if (this.onSortChange !== undefined)
+            props.onSortChange = this.onSortChange;
+        if (this.onFilterChange !== undefined)
+            props.onFilterChange = this.onFilterChange;
+        if (this.onRowSelectionChange !== undefined)
+            props.onRowSelectionChange = this.onRowSelectionChange;
+        if (this.onRowGroupExpand !== undefined)
+            props.onRowGroupExpand = this.onRowGroupExpand;
+        if (this.onColumnOrderChange !== undefined)
+            props.onColumnOrderChange = this.onColumnOrderChange;
+        if (this.onColumnVisibilityChange !== undefined)
+            props.onColumnVisibilityChange = this.onColumnVisibilityChange;
+        if (this.onColumnWidthChange !== undefined)
+            props.onColumnWidthChange = this.onColumnWidthChange;
+        if (this.onPageChange !== undefined)
+            props.onPageChange = this.onPageChange;
+        if (this.onLoadMore !== undefined)
+            props.onLoadMore = this.onLoadMore;
+        if (this.onTableReady !== undefined)
+            props.onTableReady = this.onTableReady;
+        if (this.rowGrouping !== undefined)
+            props.rowGrouping = this.rowGrouping;
+        if (this.pivot !== undefined)
+            props.pivot = this.pivot;
+        if (this.onPivotChange !== undefined)
+            props.onPivotChange = this.onPivotChange;
+        if (this.enableRowSelection !== undefined)
+            props.enableRowSelection = this.enableRowSelection;
+        if (this.theme !== undefined)
+            props.theme = this.theme;
+        if (this.quickFilter !== undefined)
+            props.quickFilter = this.quickFilter;
+        if (this.isLoading !== undefined)
+            props.isLoading = this.isLoading;
+        if (this.getRowId !== undefined)
+            props.getRowId = this.getRowId;
+        if (this.enablePagination !== undefined)
+            props.enablePagination = this.enablePagination;
+        if (this.rowsPerPage !== undefined)
+            props.rowsPerPage = this.rowsPerPage;
+        if (this.serverSidePagination !== undefined)
+            props.serverSidePagination = this.serverSidePagination;
+        if (this.totalRowCount !== undefined)
+            props.totalRowCount = this.totalRowCount;
+        if (this.height !== undefined)
+            props.height = this.height;
+        if (this.maxHeight !== undefined)
+            props.maxHeight = this.maxHeight;
+        if (this.scrollParent !== undefined)
+            props.scrollParent = this.scrollParent;
+        if (this.infiniteScrollThreshold !== undefined)
+            props.infiniteScrollThreshold = this.infiniteScrollThreshold;
+        if (this.columnResizing !== undefined)
+            props.columnResizing = this.columnResizing;
+        if (this.columnReordering !== undefined)
+            props.columnReordering = this.columnReordering;
+        if (this.enableColumnEditor !== undefined)
+            props.enableColumnEditor = this.enableColumnEditor;
+        if (this.enableColumnEditorInitOpen !== undefined)
+            props.enableColumnEditorInitOpen = this.enableColumnEditorInitOpen;
+        if (this.enableColumnEditorInitOpen !== undefined)
+            props.enableColumnEditorInitOpen = this.enableColumnEditorInitOpen;
+        if (this.selectableCells !== undefined)
+            props.selectableCells = this.selectableCells;
+        if (this.selectableColumns !== undefined)
+            props.selectableColumns = this.selectableColumns;
+        if (this.enableHeaderEditing !== undefined)
+            props.enableHeaderEditing = this.enableHeaderEditing;
+        if (this.onHeaderEdit !== undefined)
+            props.onHeaderEdit = this.onHeaderEdit;
+        if (this.customTheme !== undefined)
+            props.customTheme = this.customTheme;
+        if (this.icons !== undefined)
+            props.icons = this.icons;
+        if (this.externalFilterHandling !== undefined)
+            props.externalFilterHandling = this.externalFilterHandling;
+        if (this.externalSortHandling !== undefined)
+            props.externalSortHandling = this.externalSortHandling;
+        if (this.columnBorders !== undefined)
+            props.columnBorders = this.columnBorders;
+        if (this.rowButtons !== undefined)
+            props.rowButtons = this.rowButtons;
+        if (this.hideFooter !== undefined)
+            props.hideFooter = this.hideFooter;
+        if (this.footerPosition !== undefined)
+            props.footerPosition = this.footerPosition;
+        if (this.initialSortColumn !== undefined)
+            props.initialSortColumn = this.initialSortColumn;
+        if (this.initialSortDirection !== undefined)
+            props.initialSortDirection = this.initialSortDirection;
+        if (this.expandAll !== undefined)
+            props.expandAll = this.expandAll;
+        if (this.autoExpandColumns !== undefined)
+            props.autoExpandColumns = this.autoExpandColumns;
+        if (this.animations !== undefined)
+            props.animations = this.animations;
+        if (this.enableVirtualization !== undefined)
+            props.enableVirtualization = this.enableVirtualization;
+        if (this.hoverRowBackground !== undefined)
+            props.hoverRowBackground = this.hoverRowBackground;
+        if (this.hoverRowBackground !== undefined)
+            props.hoverRowBackground = this.hoverRowBackground;
+        if (this.oddColumnBackground !== undefined)
+            props.oddColumnBackground = this.oddColumnBackground;
+        if (this.oddColumnBackground !== undefined)
+            props.oddColumnBackground = this.oddColumnBackground;
+        if (this.oddEvenRowBackground !== undefined)
+            props.oddEvenRowBackground = this.oddEvenRowBackground;
+        if (this.oddEvenRowBackground !== undefined)
+            props.oddEvenRowBackground = this.oddEvenRowBackground;
+        return props;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.27", ngImport: i0, type: SimpleTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.27", type: SimpleTableComponent, isStandalone: true, selector: "simple-table", inputs: { rows: "rows", columns: "columns", footerRenderer: "footerRenderer", loadingStateRenderer: "loadingStateRenderer", errorStateRenderer: "errorStateRenderer", emptyStateRenderer: "emptyStateRenderer", tableEmptyStateRenderer: "tableEmptyStateRenderer", headerDropdown: "headerDropdown", columnEditorConfig: "columnEditorConfig", onCellClick: "onCellClick", onCellEdit: "onCellEdit", onSortChange: "onSortChange", onFilterChange: "onFilterChange", onRowSelectionChange: "onRowSelectionChange", onRowGroupExpand: "onRowGroupExpand", onColumnOrderChange: "onColumnOrderChange", onColumnVisibilityChange: "onColumnVisibilityChange", onColumnWidthChange: "onColumnWidthChange", onPageChange: "onPageChange", onLoadMore: "onLoadMore", onTableReady: "onTableReady", rowGrouping: "rowGrouping", pivot: "pivot", onPivotChange: "onPivotChange", enableRowSelection: "enableRowSelection", theme: "theme", quickFilter: "quickFilter", isLoading: "isLoading", getRowId: "getRowId", enablePagination: "enablePagination", rowsPerPage: "rowsPerPage", serverSidePagination: "serverSidePagination", totalRowCount: "totalRowCount", height: "height", maxHeight: "maxHeight", scrollParent: "scrollParent", infiniteScrollThreshold: "infiniteScrollThreshold", columnResizing: "columnResizing", columnReordering: "columnReordering", enableColumnEditor: "enableColumnEditor", enableColumnEditorInitOpen: "enableColumnEditorInitOpen", selectableCells: "selectableCells", selectableColumns: "selectableColumns", enableHeaderEditing: "enableHeaderEditing", onHeaderEdit: "onHeaderEdit", customTheme: "customTheme", icons: "icons", externalFilterHandling: "externalFilterHandling", externalSortHandling: "externalSortHandling", columnBorders: "columnBorders", rowButtons: "rowButtons", hideFooter: "hideFooter", footerPosition: "footerPosition", initialSortColumn: "initialSortColumn", initialSortDirection: "initialSortDirection", expandAll: "expandAll", autoExpandColumns: "autoExpandColumns", animations: "animations", enableVirtualization: "enableVirtualization", hoverRowBackground: "hoverRowBackground", oddColumnBackground: "oddColumnBackground", oddEvenRowBackground: "oddEvenRowBackground" }, outputs: { tableReady: "tableReady" }, usesOnChanges: true, ngImport: i0, template: `<div #host></div>`, isInline: true, styles: [":host{display:block}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.27", ngImport: i0, type: SimpleTableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "simple-table", standalone: true, template: `<div #host></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { rows: [{
+                type: Input,
+                args: [{ required: true }]
+            }], columns: [{
+                type: Input
+            }], footerRenderer: [{
+                type: Input
+            }], loadingStateRenderer: [{
+                type: Input
+            }], errorStateRenderer: [{
+                type: Input
+            }], emptyStateRenderer: [{
+                type: Input
+            }], tableEmptyStateRenderer: [{
+                type: Input
+            }], headerDropdown: [{
+                type: Input
+            }], columnEditorConfig: [{
+                type: Input
+            }], onCellClick: [{
+                type: Input
+            }], onCellEdit: [{
+                type: Input
+            }], onSortChange: [{
+                type: Input
+            }], onFilterChange: [{
+                type: Input
+            }], onRowSelectionChange: [{
+                type: Input
+            }], onRowGroupExpand: [{
+                type: Input
+            }], onColumnOrderChange: [{
+                type: Input
+            }], onColumnVisibilityChange: [{
+                type: Input
+            }], onColumnWidthChange: [{
+                type: Input
+            }], onPageChange: [{
+                type: Input
+            }], onLoadMore: [{
+                type: Input
+            }], onTableReady: [{
+                type: Input
+            }], rowGrouping: [{
+                type: Input
+            }], pivot: [{
+                type: Input
+            }], onPivotChange: [{
+                type: Input
+            }], enableRowSelection: [{
+                type: Input
+            }], theme: [{
+                type: Input
+            }], quickFilter: [{
+                type: Input
+            }], isLoading: [{
+                type: Input
+            }], getRowId: [{
+                type: Input
+            }], enablePagination: [{
+                type: Input
+            }], rowsPerPage: [{
+                type: Input
+            }], serverSidePagination: [{
+                type: Input
+            }], totalRowCount: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], maxHeight: [{
+                type: Input
+            }], scrollParent: [{
+                type: Input
+            }], infiniteScrollThreshold: [{
+                type: Input
+            }], columnResizing: [{
+                type: Input
+            }], columnReordering: [{
+                type: Input
+            }], enableColumnEditor: [{
+                type: Input
+            }], enableColumnEditorInitOpen: [{
+                type: Input
+            }], selectableCells: [{
+                type: Input
+            }], selectableColumns: [{
+                type: Input
+            }], enableHeaderEditing: [{
+                type: Input
+            }], onHeaderEdit: [{
+                type: Input
+            }], customTheme: [{
+                type: Input
+            }], icons: [{
+                type: Input
+            }], externalFilterHandling: [{
+                type: Input
+            }], externalSortHandling: [{
+                type: Input
+            }], columnBorders: [{
+                type: Input
+            }], rowButtons: [{
+                type: Input
+            }], hideFooter: [{
+                type: Input
+            }], footerPosition: [{
+                type: Input
+            }], initialSortColumn: [{
+                type: Input
+            }], initialSortDirection: [{
+                type: Input
+            }], expandAll: [{
+                type: Input
+            }], autoExpandColumns: [{
+                type: Input
+            }], animations: [{
+                type: Input
+            }], enableVirtualization: [{
+                type: Input
+            }], hoverRowBackground: [{
+                type: Input
+            }], oddColumnBackground: [{
+                type: Input
+            }], oddEvenRowBackground: [{
+                type: Input
+            }], tableReady: [{
+                type: Output
+            }] } });
+
+/**
+ * Call this in your application's `providers` array (or `bootstrapApplication`
+ * providers) to register the dependencies that simple-table-angular's renderer
+ * bridge needs — specifically `ApplicationRef` and `EnvironmentInjector`.
+ *
+ * These are already provided by Angular's platform by default, so in practice
+ * this function is a no-op placeholder that serves as a clear signal to
+ * consumers that the adapter has been correctly wired up. If future versions
+ * need custom providers they will be added here without breaking the call site.
+ *
+ * @example
+ * // main.ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideSimpleTable()],
+ * });
+ *
+ * @example
+ * // app.module.ts
+ * @NgModule({ providers: [provideSimpleTable()] })
+ * export class AppModule {}
+ */
+function provideSimpleTable() {
+    return makeEnvironmentProviders([
+    // ApplicationRef and EnvironmentInjector are part of Angular's core platform
+    // and are available without any additional registration.
+    // This factory is intentionally empty — it exists for API symmetry with
+    // other Angular ecosystem libraries and to allow non-breaking additions later.
+    ]);
+}
+
+// Component
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { SimpleTableComponent, provideSimpleTable, wrapAngularRenderer };
+//# sourceMappingURL=simple-table-angular.mjs.map