photon-grid-angular 0.0.1

package/esm2022/library/photon-grid.component.mjs

@@ -0,0 +1,287 @@
+import { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { GridCore, GridEventType } from 'photon-grid-core';
+import { RendererAdapter } from './angular-renderer.adapter';
+import * as i0 from "@angular/core";
+const _c0 = ["gridHost"];
+/**
+ * Angular wrapper around the framework-agnostic Photon Grid core.
+ *
+ * The component owns a single {@link GridCore} instance, keeps it in sync
+ * with the `columns`, `dataSet` and `options` inputs, and re-emits the
+ * grid's internal events as strongly-typed Angular `@Output`s.
+ *
+ * Cell/header/editor/etc. renderers may be plain functions (raw
+ * `HTMLElement`/`string`, identical to the core's own API), or declarative
+ * Angular specs — `{ kind: 'component', component: MyBadge }` or
+ * `{ kind: 'template', template: myTemplateRef }` — via {@link GridColumnDef}.
+ * An internal {@link RendererAdapter} mounts/unmounts those for every
+ * renderer invocation and disposes them as soon as the core discards their
+ * host element, so virtualization/recycling never leaks components.
+ *
+ * @example
+ * ```html
+ * <photon-grid
+ *   [columns]="columns"
+ *   [dataSet]="rows"
+ *   [options]="{ theme: 'light', showCheckboxes: true }"
+ *   (gridReady)="onReady($event)"
+ *   (rowClicked)="onRowClicked($event)">
+ * </photon-grid>
+ * ```
+ *
+ * @example Component-based cell renderer
+ * ```ts
+ * columns: GridColumnDef[] = [{
+ *   colId: 'status', field: 'status', header: 'Status', type: 'string',
+ *   renderer: {
+ *     display: {
+ *       kind: 'component',
+ *       component: StatusBadgeComponent,
+ *       inputs: (params) => ({ value: params.value }),
+ *     },
+ *   },
+ * }];
+ * ```
+ *
+ * @example Template-based cell renderer
+ * ```html
+ * <ng-template #statusTpl let-params>
+ *   <span class="badge">{{ params.value }}</span>
+ * </ng-template>
+ * ```
+ * ```ts
+ * @ViewChild('statusTpl') statusTpl!: TemplateRef<RendererContext<DisplayRendererParams>>;
+ * columns: GridColumnDef[] = [{
+ *   colId: 'status', field: 'status', header: 'Status', type: 'string',
+ *   renderer: { display: { kind: 'template', template: this.statusTpl } },
+ * }];
+ * ```
+ */
+export class PhotonGridComponent {
+    /** Container the grid renders into. */
+    gridHost;
+    /**
+     * Column definitions. Bound to {@link GridApi.setColumns} on change.
+     * Provided as a dedicated input rather than through `options.columns`.
+     * Renderer slots accept Angular components/templates in addition to
+     * plain functions — see {@link GridColumnDef}.
+     */
+    columns = [];
+    /**
+     * Row data. Bound to {@link GridApi.setData} on change. Provided as a
+     * dedicated input rather than through `options.data`.
+     */
+    dataSet = [];
+    /**
+     * Remaining grid options (theme, selection, editing, pagination, …).
+     * `columns` and `data` are supplied by the dedicated inputs above and are
+     * merged in automatically. The core has no runtime options setter, so a
+     * change to this input transparently recreates the grid.
+     */
+    options = {};
+    /** Emitted once the grid is constructed, carrying its {@link GridApi}. */
+    gridReady = new EventEmitter();
+    /** Row data changed (count delta). */
+    dataChanged = new EventEmitter();
+    /** A row was clicked. */
+    rowClicked = new EventEmitter();
+    /** A row was double-clicked. */
+    rowDoubleClicked = new EventEmitter();
+    /** Row selection changed. */
+    rowSelected = new EventEmitter();
+    /** A cell was clicked. */
+    cellClicked = new EventEmitter();
+    /** A cell was double-clicked. */
+    cellDoubleClicked = new EventEmitter();
+    /** A cell value was committed. */
+    cellValueChanged = new EventEmitter();
+    /** Range/cell selection changed. */
+    cellSelectionChanged = new EventEmitter();
+    /** A column was resized. */
+    columnResized = new EventEmitter();
+    /** A column was reordered. */
+    columnMoved = new EventEmitter();
+    /** Sort state changed. */
+    sortChanged = new EventEmitter();
+    /** Filter model changed. */
+    filterChanged = new EventEmitter();
+    /** Pagination page or size changed. */
+    pageChanged = new EventEmitter();
+    /** Column state (width/visibility/pin/order) changed. */
+    columnsStateChanged = new EventEmitter();
+    /** Active theme changed. */
+    themeChanged = new EventEmitter();
+    /** An export finished. */
+    exportComplete = new EventEmitter();
+    /** The live core instance, created in {@link ngAfterViewInit}. */
+    grid;
+    /** Unsubscribe callbacks for every wired core event; drained on teardown. */
+    disposers = [];
+    /**
+     * Bridges Angular component/template renderer specs to the core's
+     * plain-function `ColumnRendererMap`. Owned for the lifetime of this
+     * component (not DI-provided) so its mounted-view tracking is scoped
+     * to this grid instance alone.
+     *
+     * Built explicitly in the constructor body (rather than as a field
+     * initializer referencing constructor-parameter properties) so it isn't
+     * subject to field-initializer-vs-parameter-property ordering: at this
+     * point `appRef`/`environmentInjector`/`elementInjector` are plain local
+     * constructor arguments, guaranteed to already be set.
+     */
+    rendererAdapter;
+    constructor(appRef, environmentInjector, elementInjector) {
+        this.rendererAdapter = new RendererAdapter(appRef, environmentInjector, elementInjector);
+    }
+    ngAfterViewInit() {
+        this.createGrid();
+    }
+    ngOnChanges(changes) {
+        // Initial inputs are consumed by createGrid() in ngAfterViewInit.
+        if (!this.grid) {
+            return;
+        }
+        // An options change cannot be applied incrementally (no core setter),
+        // so recreate; this already re-seeds columns and data.
+        if (changes['options'] && !changes['options'].firstChange) {
+            this.recreateGrid();
+            return;
+        }
+        if (changes['columns'] && !changes['columns'].firstChange) {
+            this.grid.api.setColumns(this.rendererAdapter.adaptColumns(this.columns));
+        }
+        if (changes['dataSet'] && !changes['dataSet'].firstChange) {
+            this.grid.api.setData(this.dataSet);
+        }
+    }
+    ngOnDestroy() {
+        this.teardownGrid();
+    }
+    /** Builds the core from the current inputs and wires its events. */
+    createGrid() {
+        // Must be observing *before* the core mounts anything, so every
+        // renderer-produced element is tracked for cleanup from the start.
+        this.rendererAdapter.observe(this.gridHost.nativeElement);
+        const mergedOptions = {
+            ...this.options,
+            columns: this.rendererAdapter.adaptColumns(this.columns),
+            data: this.dataSet,
+        };
+        const grid = new GridCore(this.gridHost.nativeElement, mergedOptions);
+        this.grid = grid;
+        this.wireEvents(grid.api);
+        // GridCore emits READY synchronously during construction (before we can
+        // attach a listener), so surface the ready signal explicitly here.
+        this.gridReady.emit(grid.api);
+    }
+    /** Destroys the current core, drops it, and builds a fresh one. */
+    recreateGrid() {
+        this.teardownGrid();
+        this.createGrid();
+    }
+    /**
+     * Disposes event subscriptions, the renderer adapter (stopping its
+     * observer and destroying every mounted component/embedded view), and
+     * the core instance itself, if any.
+     *
+     * Order matters: the adapter is disposed *after* `grid.destroy()` so
+     * any teardown-time DOM removal is irrelevant (dispose() unconditionally
+     * destroys all remaining mounts rather than depending on the
+     * MutationObserver having flushed).
+     */
+    teardownGrid() {
+        for (const dispose of this.disposers) {
+            dispose();
+        }
+        this.disposers.length = 0;
+        this.grid?.destroy();
+        this.grid = undefined;
+        this.rendererAdapter.dispose();
+    }
+    /** Subscribes every core event to its corresponding `@Output` emitter. */
+    wireEvents(api) {
+        this.subscribe(api, GridEventType.DATA_CHANGED, this.dataChanged);
+        this.subscribe(api, GridEventType.ROW_CLICKED, this.rowClicked);
+        this.subscribe(api, GridEventType.ROW_DOUBLE_CLICKED, this.rowDoubleClicked);
+        this.subscribe(api, GridEventType.ROW_SELECTED, this.rowSelected);
+        this.subscribe(api, GridEventType.CELL_CLICKED, this.cellClicked);
+        this.subscribe(api, GridEventType.CELL_DOUBLE_CLICKED, this.cellDoubleClicked);
+        this.subscribe(api, GridEventType.CELL_VALUE_CHANGED, this.cellValueChanged);
+        this.subscribe(api, GridEventType.CELL_SELECTION_CHANGED, this.cellSelectionChanged);
+        this.subscribe(api, GridEventType.COLUMN_RESIZED, this.columnResized);
+        this.subscribe(api, GridEventType.COLUMN_MOVED, this.columnMoved);
+        this.subscribe(api, GridEventType.SORT_CHANGED, this.sortChanged);
+        this.subscribe(api, GridEventType.FILTER_CHANGED, this.filterChanged);
+        this.subscribe(api, GridEventType.PAGE_CHANGED, this.pageChanged);
+        this.subscribe(api, GridEventType.COLUMNS_STATE_CHANGED, this.columnsStateChanged);
+        this.subscribe(api, GridEventType.THEME_CHANGED, this.themeChanged);
+        this.subscribe(api, GridEventType.EXPORT_COMPLETE, this.exportComplete);
+    }
+    /**
+     * Forwards a single strongly-typed core event to an Angular emitter and
+     * records its unsubscribe callback. The generic constraint guarantees the
+     * emitter's payload type matches the event's payload in {@link GridEventMap}.
+     */
+    subscribe(api, event, emitter) {
+        const dispose = api.on(event, (payload) => emitter.emit(payload));
+        this.disposers.push(dispose);
+    }
+    static ɵfac = function PhotonGridComponent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || PhotonGridComponent)(i0.ɵɵdirectiveInject(i0.ApplicationRef), i0.ɵɵdirectiveInject(i0.EnvironmentInjector), i0.ɵɵdirectiveInject(i0.Injector)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PhotonGridComponent, selectors: [["photon-grid"]], viewQuery: function PhotonGridComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 7, ElementRef);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.gridHost = _t.first);
+        } }, inputs: { columns: "columns", dataSet: "dataSet", options: "options" }, outputs: { gridReady: "gridReady", dataChanged: "dataChanged", rowClicked: "rowClicked", rowDoubleClicked: "rowDoubleClicked", rowSelected: "rowSelected", cellClicked: "cellClicked", cellDoubleClicked: "cellDoubleClicked", cellValueChanged: "cellValueChanged", cellSelectionChanged: "cellSelectionChanged", columnResized: "columnResized", columnMoved: "columnMoved", sortChanged: "sortChanged", filterChanged: "filterChanged", pageChanged: "pageChanged", columnsStateChanged: "columnsStateChanged", themeChanged: "themeChanged", exportComplete: "exportComplete" }, standalone: true, features: [i0.ɵɵNgOnChangesFeature, i0.ɵɵStandaloneFeature], decls: 2, vars: 0, consts: [["gridHost", ""], [1, "photon-grid__host"]], template: function PhotonGridComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelement(0, "div", 1, 0);
+        } }, styles: ["[_nghost-%COMP%]{display:block;width:100%;height:100%}.photon-grid__host[_ngcontent-%COMP%]{width:100%;height:100%}"], changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PhotonGridComponent, [{
+        type: Component,
+        args: [{ selector: 'photon-grid', standalone: true, template: `<div #gridHost class="photon-grid__host"></div>`, changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block;width:100%;height:100%}.photon-grid__host{width:100%;height:100%}\n"] }]
+    }], () => [{ type: i0.ApplicationRef }, { type: i0.EnvironmentInjector }, { type: i0.Injector }], { gridHost: [{
+            type: ViewChild,
+            args: ['gridHost', { static: true, read: ElementRef }]
+        }], columns: [{
+            type: Input
+        }], dataSet: [{
+            type: Input
+        }], options: [{
+            type: Input
+        }], gridReady: [{
+            type: Output
+        }], dataChanged: [{
+            type: Output
+        }], rowClicked: [{
+            type: Output
+        }], rowDoubleClicked: [{
+            type: Output
+        }], rowSelected: [{
+            type: Output
+        }], cellClicked: [{
+            type: Output
+        }], cellDoubleClicked: [{
+            type: Output
+        }], cellValueChanged: [{
+            type: Output
+        }], cellSelectionChanged: [{
+            type: Output
+        }], columnResized: [{
+            type: Output
+        }], columnMoved: [{
+            type: Output
+        }], sortChanged: [{
+            type: Output
+        }], filterChanged: [{
+            type: Output
+        }], pageChanged: [{
+            type: Output
+        }], columnsStateChanged: [{
+            type: Output
+        }], themeChanged: [{
+            type: Output
+        }], exportComplete: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(PhotonGridComponent, { className: "PhotonGridComponent", filePath: "library\\photon-grid.component.ts", lineNumber: 104 }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"photon-grid.component.js","sourceRoot":"","sources":["../../../src/library/photon-grid.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,uBAAuB,EACvB,SAAS,EACT,UAAU,EAEV,YAAY,EAEZ,KAAK,EAGL,MAAM,EAEN,SAAS,GACZ,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAsB3D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;;;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAQH,MAAM,OAAO,mBAAmB;IAE5B,uCAAuC;IAEtB,QAAQ,CAA8B;IAEvD;;;;;OAKG;IAEH,OAAO,GAAoB,EAAE,CAAC;IAE9B;;;OAGG;IAEH,OAAO,GAA8B,EAAE,CAAC;IAExC;;;;;OAKG;IAEH,OAAO,GAAyB,EAAE,CAAC;IAEnC,0EAA0E;IACvD,SAAS,GAAG,IAAI,YAAY,EAAW,CAAC;IAE3D,sCAAsC;IACnB,WAAW,GAAG,IAAI,YAAY,EAAoB,CAAC;IAEtE,yBAAyB;IACN,UAAU,GAAG,IAAI,YAAY,EAAmB,CAAC;IAEpE,gCAAgC;IACb,gBAAgB,GAAG,IAAI,YAAY,EAAmB,CAAC;IAE1E,6BAA6B;IACV,WAAW,GAAG,IAAI,YAAY,EAAoB,CAAC;IAEtE,0BAA0B;IACP,WAAW,GAAG,IAAI,YAAY,EAAoB,CAAC;IAEtE,iCAAiC;IACd,iBAAiB,GAAG,IAAI,YAAY,EAAoB,CAAC;IAE5E,kCAAkC;IACf,gBAAgB,GAAG,IAAI,YAAY,EAAyB,CAAC;IAEhF,oCAAoC;IACjB,oBAAoB,GAAG,IAAI,YAAY,EAA6B,CAAC;IAExF,4BAA4B;IACT,aAAa,GAAG,IAAI,YAAY,EAAsB,CAAC;IAE1E,8BAA8B;IACX,WAAW,GAAG,IAAI,YAAY,EAAoB,CAAC;IAEtE,0BAA0B;IACP,WAAW,GAAG,IAAI,YAAY,EAAqB,CAAC;IAEvE,4BAA4B;IACT,aAAa,GAAG,IAAI,YAAY,EAAsB,CAAC;IAE1E,uCAAuC;IACpB,WAAW,GAAG,IAAI,YAAY,EAAoB,CAAC;IAEtE,yDAAyD;IACtC,mBAAmB,GAAG,IAAI,YAAY,EAA4B,CAAC;IAEtF,4BAA4B;IACT,YAAY,GAAG,IAAI,YAAY,EAAqB,CAAC;IAExE,0BAA0B;IACP,cAAc,GAAG,IAAI,YAAY,EAAe,CAAC;IAEpE,kEAAkE;IAC1D,IAAI,CAAY;IAExB,6EAA6E;IAC5D,SAAS,GAAsB,EAAE,CAAC;IAEnD;;;;;;;;;;;OAWG;IACc,eAAe,CAAkB;IAElD,YACI,MAAsB,EACtB,mBAAwC,EACxC,eAAyB;QAEzB,IAAI,CAAC,eAAe,GAAG,IAAI,eAAe,CAAC,MAAM,EAAE,mBAAmB,EAAE,eAAe,CAAC,CAAC;IAC7F,CAAC;IAED,eAAe;QACX,IAAI,CAAC,UAAU,EAAE,CAAC;IACtB,CAAC;IAED,WAAW,CAAC,OAAsB;QAC9B,kEAAkE;QAClE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACb,OAAO;QACX,CAAC;QAED,sEAAsE;QACtE,uDAAuD;QACvD,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;YACxD,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,OAAO;QACX,CAAC;QAED,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;YACxD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9E,CAAC;QAED,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;YACxD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACxC,CAAC;IACL,CAAC;IAED,WAAW;QACP,IAAI,CAAC,YAAY,EAAE,CAAC;IACxB,CAAC;IAED,oEAAoE;IAC5D,UAAU;QACd,gEAAgE;QAChE,mEAAmE;QACnE,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;QAE1D,MAAM,aAAa,GAAgB;YAC/B,GAAG,IAAI,CAAC,OAAO;YACf,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC;YACxD,IAAI,EAAE,IAAI,CAAC,OAAO;SACrB,CAAC;QAEF,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;QACtE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QAEjB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAE1B,wEAAwE;QACxE,mEAAmE;QACnE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAED,mEAAmE;IAC3D,YAAY;QAChB,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,UAAU,EAAE,CAAC;IACtB,CAAC;IAED;;;;;;;;;OASG;IACK,YAAY;QAChB,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnC,OAAO,EAAE,CAAC;QACd,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;QAE1B,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC;QACrB,IAAI,CAAC,IAAI,GAAG,SAAS,CAAC;QAEtB,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC;IACnC,CAAC;IAED,0EAA0E;IAClE,UAAU,CAAC,GAAY;QAC3B,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAClE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAChE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,kBAAkB,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAC7E,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAClE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAClE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,mBAAmB,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAC/E,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,kBAAkB,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAC7E,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;QACrF,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,cAAc,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACtE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAClE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAClE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,cAAc,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACtE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAClE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,qBAAqB,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACnF,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,aAAa,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QACpE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,aAAa,CAAC,eAAe,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IAC5E,CAAC;IAED;;;;OAIG;IACK,SAAS,CACb,GAAY,EACZ,KAAQ,EACR,OAAsC;QAEtC,MAAM,OAAO,GAAG,GAAG,CAAC,EAAE,CAAkB,KAAK,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QACnF,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;6GA9NQ,mBAAmB;6DAAnB,mBAAmB;mCAGiB,UAAU;;;;;YAP5C,4BAA+C;;;iFAIjD,mBAAmB;cAP/B,SAAS;2BACI,aAAa,cACX,IAAI,YACN,iDAAiD,mBAE1C,uBAAuB,CAAC,MAAM;wGAM9B,QAAQ;kBADxB,SAAS;mBAAC,UAAU,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE;YAUzD,OAAO;kBADN,KAAK;YAQN,OAAO;kBADN,KAAK;YAUN,OAAO;kBADN,KAAK;YAIa,SAAS;kBAA3B,MAAM;YAGY,WAAW;kBAA7B,MAAM;YAGY,UAAU;kBAA5B,MAAM;YAGY,gBAAgB;kBAAlC,MAAM;YAGY,WAAW;kBAA7B,MAAM;YAGY,WAAW;kBAA7B,MAAM;YAGY,iBAAiB;kBAAnC,MAAM;YAGY,gBAAgB;kBAAlC,MAAM;YAGY,oBAAoB;kBAAtC,MAAM;YAGY,aAAa;kBAA/B,MAAM;YAGY,WAAW;kBAA7B,MAAM;YAGY,WAAW;kBAA7B,MAAM;YAGY,aAAa;kBAA/B,MAAM;YAGY,WAAW;kBAA7B,MAAM;YAGY,mBAAmB;kBAArC,MAAM;YAGY,YAAY;kBAA9B,MAAM;YAGY,cAAc;kBAAhC,MAAM;;kFAhFE,mBAAmB","sourcesContent":["import {\n    AfterViewInit,\n    ApplicationRef,\n    ChangeDetectionStrategy,\n    Component,\n    ElementRef,\n    EnvironmentInjector,\n    EventEmitter,\n    Injector,\n    Input,\n    OnChanges,\n    OnDestroy,\n    Output,\n    SimpleChanges,\n    ViewChild,\n} from '@angular/core';\n\nimport { GridCore, GridEventType } from 'photon-grid-core';\n\nimport type {\n    CellClickedEvent,\n    CellSelectionChangedEvent,\n    CellValueChangedEvent,\n    ColumnMovedEvent,\n    ColumnResizedEvent,\n    ColumnsStateChangedEvent,\n    ColumnSortedEvent,\n    DataChangedEvent,\n    ExportEvent,\n    FilterChangedEvent,\n    GridApi,\n    GridEventMap,\n    GridOptions,\n    PageChangedEvent,\n    RowClickPayload,\n    RowSelectedEvent,\n    ThemeChangedEvent,\n} from 'photon-grid-core';\n\nimport { RendererAdapter } from './angular-renderer.adapter';\nimport type {ColumnDef as GridColumnDef } from './angular-renderer.types';\n\n/**\n * Angular wrapper around the framework-agnostic Photon Grid core.\n *\n * The component owns a single {@link GridCore} instance, keeps it in sync\n * with the `columns`, `dataSet` and `options` inputs, and re-emits the\n * grid's internal events as strongly-typed Angular `@Output`s.\n *\n * Cell/header/editor/etc. renderers may be plain functions (raw\n * `HTMLElement`/`string`, identical to the core's own API), or declarative\n * Angular specs — `{ kind: 'component', component: MyBadge }` or\n * `{ kind: 'template', template: myTemplateRef }` — via {@link GridColumnDef}.\n * An internal {@link RendererAdapter} mounts/unmounts those for every\n * renderer invocation and disposes them as soon as the core discards their\n * host element, so virtualization/recycling never leaks components.\n *\n * @example\n * ```html\n * <photon-grid\n *   [columns]=\"columns\"\n *   [dataSet]=\"rows\"\n *   [options]=\"{ theme: 'light', showCheckboxes: true }\"\n *   (gridReady)=\"onReady($event)\"\n *   (rowClicked)=\"onRowClicked($event)\">\n * </photon-grid>\n * ```\n *\n * @example Component-based cell renderer\n * ```ts\n * columns: GridColumnDef[] = [{\n *   colId: 'status', field: 'status', header: 'Status', type: 'string',\n *   renderer: {\n *     display: {\n *       kind: 'component',\n *       component: StatusBadgeComponent,\n *       inputs: (params) => ({ value: params.value }),\n *     },\n *   },\n * }];\n * ```\n *\n * @example Template-based cell renderer\n * ```html\n * <ng-template #statusTpl let-params>\n *   <span class=\"badge\">{{ params.value }}</span>\n * </ng-template>\n * ```\n * ```ts\n * @ViewChild('statusTpl') statusTpl!: TemplateRef<RendererContext<DisplayRendererParams>>;\n * columns: GridColumnDef[] = [{\n *   colId: 'status', field: 'status', header: 'Status', type: 'string',\n *   renderer: { display: { kind: 'template', template: this.statusTpl } },\n * }];\n * ```\n */\n@Component({\n    selector: 'photon-grid',\n    standalone: true,\n    template: `<div #gridHost class=\"photon-grid__host\"></div>`,\n    styleUrl: './photon-grid.component.scss',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class PhotonGridComponent implements AfterViewInit, OnChanges, OnDestroy {\n\n    /** Container the grid renders into. */\n    @ViewChild('gridHost', { static: true, read: ElementRef })\n    private readonly gridHost!: ElementRef<HTMLDivElement>;\n\n    /**\n     * Column definitions. Bound to {@link GridApi.setColumns} on change.\n     * Provided as a dedicated input rather than through `options.columns`.\n     * Renderer slots accept Angular components/templates in addition to\n     * plain functions — see {@link GridColumnDef}.\n     */\n    @Input()\n    columns: GridColumnDef[] = [];\n\n    /**\n     * Row data. Bound to {@link GridApi.setData} on change. Provided as a\n     * dedicated input rather than through `options.data`.\n     */\n    @Input()\n    dataSet: Record<string, unknown>[] = [];\n\n    /**\n     * Remaining grid options (theme, selection, editing, pagination, …).\n     * `columns` and `data` are supplied by the dedicated inputs above and are\n     * merged in automatically. The core has no runtime options setter, so a\n     * change to this input transparently recreates the grid.\n     */\n    @Input()\n    options: Partial<GridOptions> = {};\n\n    /** Emitted once the grid is constructed, carrying its {@link GridApi}. */\n    @Output() readonly gridReady = new EventEmitter<GridApi>();\n\n    /** Row data changed (count delta). */\n    @Output() readonly dataChanged = new EventEmitter<DataChangedEvent>();\n\n    /** A row was clicked. */\n    @Output() readonly rowClicked = new EventEmitter<RowClickPayload>();\n\n    /** A row was double-clicked. */\n    @Output() readonly rowDoubleClicked = new EventEmitter<RowClickPayload>();\n\n    /** Row selection changed. */\n    @Output() readonly rowSelected = new EventEmitter<RowSelectedEvent>();\n\n    /** A cell was clicked. */\n    @Output() readonly cellClicked = new EventEmitter<CellClickedEvent>();\n\n    /** A cell was double-clicked. */\n    @Output() readonly cellDoubleClicked = new EventEmitter<CellClickedEvent>();\n\n    /** A cell value was committed. */\n    @Output() readonly cellValueChanged = new EventEmitter<CellValueChangedEvent>();\n\n    /** Range/cell selection changed. */\n    @Output() readonly cellSelectionChanged = new EventEmitter<CellSelectionChangedEvent>();\n\n    /** A column was resized. */\n    @Output() readonly columnResized = new EventEmitter<ColumnResizedEvent>();\n\n    /** A column was reordered. */\n    @Output() readonly columnMoved = new EventEmitter<ColumnMovedEvent>();\n\n    /** Sort state changed. */\n    @Output() readonly sortChanged = new EventEmitter<ColumnSortedEvent>();\n\n    /** Filter model changed. */\n    @Output() readonly filterChanged = new EventEmitter<FilterChangedEvent>();\n\n    /** Pagination page or size changed. */\n    @Output() readonly pageChanged = new EventEmitter<PageChangedEvent>();\n\n    /** Column state (width/visibility/pin/order) changed. */\n    @Output() readonly columnsStateChanged = new EventEmitter<ColumnsStateChangedEvent>();\n\n    /** Active theme changed. */\n    @Output() readonly themeChanged = new EventEmitter<ThemeChangedEvent>();\n\n    /** An export finished. */\n    @Output() readonly exportComplete = new EventEmitter<ExportEvent>();\n\n    /** The live core instance, created in {@link ngAfterViewInit}. */\n    private grid?: GridCore;\n\n    /** Unsubscribe callbacks for every wired core event; drained on teardown. */\n    private readonly disposers: Array<() => void> = [];\n\n    /**\n     * Bridges Angular component/template renderer specs to the core's\n     * plain-function `ColumnRendererMap`. Owned for the lifetime of this\n     * component (not DI-provided) so its mounted-view tracking is scoped\n     * to this grid instance alone.\n     *\n     * Built explicitly in the constructor body (rather than as a field\n     * initializer referencing constructor-parameter properties) so it isn't\n     * subject to field-initializer-vs-parameter-property ordering: at this\n     * point `appRef`/`environmentInjector`/`elementInjector` are plain local\n     * constructor arguments, guaranteed to already be set.\n     */\n    private readonly rendererAdapter: RendererAdapter;\n\n    constructor(\n        appRef: ApplicationRef,\n        environmentInjector: EnvironmentInjector,\n        elementInjector: Injector,\n    ) {\n        this.rendererAdapter = new RendererAdapter(appRef, environmentInjector, elementInjector);\n    }\n\n    ngAfterViewInit(): void {\n        this.createGrid();\n    }\n\n    ngOnChanges(changes: SimpleChanges): void {\n        // Initial inputs are consumed by createGrid() in ngAfterViewInit.\n        if (!this.grid) {\n            return;\n        }\n\n        // An options change cannot be applied incrementally (no core setter),\n        // so recreate; this already re-seeds columns and data.\n        if (changes['options'] && !changes['options'].firstChange) {\n            this.recreateGrid();\n            return;\n        }\n\n        if (changes['columns'] && !changes['columns'].firstChange) {\n            this.grid.api.setColumns(this.rendererAdapter.adaptColumns(this.columns));\n        }\n\n        if (changes['dataSet'] && !changes['dataSet'].firstChange) {\n            this.grid.api.setData(this.dataSet);\n        }\n    }\n\n    ngOnDestroy(): void {\n        this.teardownGrid();\n    }\n\n    /** Builds the core from the current inputs and wires its events. */\n    private createGrid(): void {\n        // Must be observing *before* the core mounts anything, so every\n        // renderer-produced element is tracked for cleanup from the start.\n        this.rendererAdapter.observe(this.gridHost.nativeElement);\n\n        const mergedOptions: GridOptions = {\n            ...this.options,\n            columns: this.rendererAdapter.adaptColumns(this.columns),\n            data: this.dataSet,\n        };\n\n        const grid = new GridCore(this.gridHost.nativeElement, mergedOptions);\n        this.grid = grid;\n\n        this.wireEvents(grid.api);\n\n        // GridCore emits READY synchronously during construction (before we can\n        // attach a listener), so surface the ready signal explicitly here.\n        this.gridReady.emit(grid.api);\n    }\n\n    /** Destroys the current core, drops it, and builds a fresh one. */\n    private recreateGrid(): void {\n        this.teardownGrid();\n        this.createGrid();\n    }\n\n    /**\n     * Disposes event subscriptions, the renderer adapter (stopping its\n     * observer and destroying every mounted component/embedded view), and\n     * the core instance itself, if any.\n     *\n     * Order matters: the adapter is disposed *after* `grid.destroy()` so\n     * any teardown-time DOM removal is irrelevant (dispose() unconditionally\n     * destroys all remaining mounts rather than depending on the\n     * MutationObserver having flushed).\n     */\n    private teardownGrid(): void {\n        for (const dispose of this.disposers) {\n            dispose();\n        }\n        this.disposers.length = 0;\n\n        this.grid?.destroy();\n        this.grid = undefined;\n\n        this.rendererAdapter.dispose();\n    }\n\n    /** Subscribes every core event to its corresponding `@Output` emitter. */\n    private wireEvents(api: GridApi): void {\n        this.subscribe(api, GridEventType.DATA_CHANGED, this.dataChanged);\n        this.subscribe(api, GridEventType.ROW_CLICKED, this.rowClicked);\n        this.subscribe(api, GridEventType.ROW_DOUBLE_CLICKED, this.rowDoubleClicked);\n        this.subscribe(api, GridEventType.ROW_SELECTED, this.rowSelected);\n        this.subscribe(api, GridEventType.CELL_CLICKED, this.cellClicked);\n        this.subscribe(api, GridEventType.CELL_DOUBLE_CLICKED, this.cellDoubleClicked);\n        this.subscribe(api, GridEventType.CELL_VALUE_CHANGED, this.cellValueChanged);\n        this.subscribe(api, GridEventType.CELL_SELECTION_CHANGED, this.cellSelectionChanged);\n        this.subscribe(api, GridEventType.COLUMN_RESIZED, this.columnResized);\n        this.subscribe(api, GridEventType.COLUMN_MOVED, this.columnMoved);\n        this.subscribe(api, GridEventType.SORT_CHANGED, this.sortChanged);\n        this.subscribe(api, GridEventType.FILTER_CHANGED, this.filterChanged);\n        this.subscribe(api, GridEventType.PAGE_CHANGED, this.pageChanged);\n        this.subscribe(api, GridEventType.COLUMNS_STATE_CHANGED, this.columnsStateChanged);\n        this.subscribe(api, GridEventType.THEME_CHANGED, this.themeChanged);\n        this.subscribe(api, GridEventType.EXPORT_COMPLETE, this.exportComplete);\n    }\n\n    /**\n     * Forwards a single strongly-typed core event to an Angular emitter and\n     * records its unsubscribe callback. The generic constraint guarantees the\n     * emitter's payload type matches the event's payload in {@link GridEventMap}.\n     */\n    private subscribe<E extends keyof GridEventMap>(\n        api: GridApi,\n        event: E,\n        emitter: EventEmitter<GridEventMap[E]>,\n    ): void {\n        const dispose = api.on<GridEventMap[E]>(event, (payload) => emitter.emit(payload));\n        this.disposers.push(dispose);\n    }\n}"]}

package/esm2022/library/photon-grid.module.mjs

@@ -0,0 +1,23 @@
+import { NgModule } from '@angular/core';
+import { PhotonGridComponent } from './photon-grid.component';
+import * as i0 from "@angular/core";
+/**
+ * Convenience NgModule for consumers that are not yet on standalone APIs.
+ * {@link PhotonGridComponent} is itself standalone; this module simply
+ * imports and re-exports it so it can be dropped into an NgModule's
+ * `imports`/`exports` and used in that module's templates.
+ */
+export class PhotonGridModule {
+    static ɵfac = function PhotonGridModule_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || PhotonGridModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: PhotonGridModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PhotonGridModule, [{
+        type: NgModule,
+        args: [{
+                imports: [PhotonGridComponent],
+                exports: [PhotonGridComponent],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(PhotonGridModule, { imports: [PhotonGridComponent], exports: [PhotonGridComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGhvdG9uLWdyaWQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYnJhcnkvcGhvdG9uLWdyaWQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7O0FBRTlEOzs7OztHQUtHO0FBS0gsTUFBTSxPQUFPLGdCQUFnQjswR0FBaEIsZ0JBQWdCOzREQUFoQixnQkFBZ0I7OztpRkFBaEIsZ0JBQWdCO2NBSjVCLFFBQVE7ZUFBQztnQkFDTixPQUFPLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQztnQkFDOUIsT0FBTyxFQUFFLENBQUMsbUJBQW1CLENBQUM7YUFDakM7O3dGQUNZLGdCQUFnQixjQUhmLG1CQUFtQixhQUNuQixtQkFBbUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBQaG90b25HcmlkQ29tcG9uZW50IH0gZnJvbSAnLi9waG90b24tZ3JpZC5jb21wb25lbnQnO1xuXG4vKipcbiAqIENvbnZlbmllbmNlIE5nTW9kdWxlIGZvciBjb25zdW1lcnMgdGhhdCBhcmUgbm90IHlldCBvbiBzdGFuZGFsb25lIEFQSXMuXG4gKiB7QGxpbmsgUGhvdG9uR3JpZENvbXBvbmVudH0gaXMgaXRzZWxmIHN0YW5kYWxvbmU7IHRoaXMgbW9kdWxlIHNpbXBseVxuICogaW1wb3J0cyBhbmQgcmUtZXhwb3J0cyBpdCBzbyBpdCBjYW4gYmUgZHJvcHBlZCBpbnRvIGFuIE5nTW9kdWxlJ3NcbiAqIGBpbXBvcnRzYC9gZXhwb3J0c2AgYW5kIHVzZWQgaW4gdGhhdCBtb2R1bGUncyB0ZW1wbGF0ZXMuXG4gKi9cbkBOZ01vZHVsZSh7XG4gICAgaW1wb3J0czogW1Bob3RvbkdyaWRDb21wb25lbnRdLFxuICAgIGV4cG9ydHM6IFtQaG90b25HcmlkQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgUGhvdG9uR3JpZE1vZHVsZSB7fVxuIl19

package/esm2022/photon-grid-angular.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGhvdG9uLWdyaWQtYW5ndWxhci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9waG90b24tZ3JpZC1hbmd1bGFyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/public-api.mjs

@@ -0,0 +1,8 @@
+/*
+ * Public API surface of photon-grid-angular.
+ */
+export * from './library/photon-grid.component';
+export * from './library/photon-grid.module';
+export * from './library/angular-renderer.types';
+export { GridEventType } from 'photon-grid-core';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsa0NBQWtDLENBQUM7QUFRakQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgc3VyZmFjZSBvZiBwaG90b24tZ3JpZC1hbmd1bGFyLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGlicmFyeS9waG90b24tZ3JpZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWJyYXJ5L3Bob3Rvbi1ncmlkLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYnJhcnkvYW5ndWxhci1yZW5kZXJlci50eXBlcyc7XG5cbi8vIFJlLWV4cG9ydCB0aGUgbW9zdCBjb21tb25seSBuZWVkZWQgY29yZSB0eXBlcyBzbyBjb25zdW1lcnMgY2FuIGJpbmQgdGhlXG4vLyB3cmFwcGVyIHdpdGhvdXQgaW1wb3J0aW5nIHBob3Rvbi1ncmlkLWNvcmUgZGlyZWN0bHkuXG5leHBvcnQgdHlwZSB7XG4gICAgR3JpZEFwaSxcbiAgICBHcmlkT3B0aW9ucyxcbn0gZnJvbSAncGhvdG9uLWdyaWQtY29yZSc7XG5leHBvcnQgeyBHcmlkRXZlbnRUeXBlIH0gZnJvbSAncGhvdG9uLWdyaWQtY29yZSc7XG4iXX0=