photon-grid-angular 0.0.1

package/fesm2022/photon-grid-angular.mjs

@@ -0,0 +1,593 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, createComponent, EventEmitter, ElementRef, ChangeDetectionStrategy, Component, Output, Input, ViewChild, NgModule } from '@angular/core';
+import { GridCore, GridEventType } from 'photon-grid-core';
+export { GridEventType } from 'photon-grid-core';
+
+/** Narrowing helpers used by the adapter (and usable by consumers/tests). */
+function isComponentRendererSpec(value) {
+    return !!value && typeof value === 'object' && value.kind === 'component';
+}
+function isTemplateRendererSpec(value) {
+    return !!value && typeof value === 'object' && value.kind === 'template';
+}
+
+/**
+ * Bridges the framework-agnostic `ColumnRendererMap` (plain functions
+ * returning `HTMLElement | string`) to Angular components and templates.
+ *
+ * One instance is owned per `<photon-grid>` and lives for the component's
+ * lifetime: {@link adaptColumns} is called whenever columns are (re)supplied,
+ * and {@link dispose} is called once, in `ngOnDestroy`, to guarantee nothing
+ * outlives the host component.
+ *
+ * ### Why a MutationObserver
+ * The core owns cell/row virtualization and recycling; it has no lifecycle
+ * hook that tells us "this cell's DOM node is gone, destroy whatever you
+ * mounted into it". Since every renderer invocation mounts a *fresh*
+ * component/embedded view (the core's contract is "produce output for these
+ * params", not "patch existing output"), the only reliable place to catch
+ * disposal is watching the DOM itself: when the core removes/replaces a
+ * mounted host element, a MutationObserver on the grid root sees it and we
+ * destroy the corresponding Angular view right then. This is what keeps
+ * scrolling/virtualized grids from leaking components.
+ */
+class RendererAdapter {
+    appRef;
+    environmentInjector;
+    elementInjector;
+    /** Host element -> live Angular view mounted into it. */
+    mounts = new Map();
+    observer;
+    constructor(appRef, environmentInjector, elementInjector) {
+        this.appRef = appRef;
+        this.environmentInjector = environmentInjector;
+        this.elementInjector = elementInjector;
+    }
+    /**
+     * Starts watching `root` for node removals so mounted views can be torn
+     * down as soon as the core discards their host element. Safe to call
+     * repeatedly (e.g. across grid recreation) — any previous observer is
+     * disconnected first, but existing mounts are left untouched.
+     */
+    observe(root) {
+        this.observer?.disconnect();
+        this.observer = new MutationObserver((mutations) => {
+            // Bounded by the number of *currently mounted* renderer views
+            // (i.e. visible custom cells), not by row/data-set size, because
+            // virtualization keeps that number small regardless of grid size.
+            if (this.mounts.size === 0) {
+                return;
+            }
+            for (const mutation of mutations) {
+                mutation.removedNodes.forEach((node) => this.cleanupRemovedNode(node));
+            }
+        });
+        this.observer.observe(root, { childList: true, subtree: true });
+    }
+    /** Recursively converts `GridColumnDef[]` into plain `ColumnDef[]`. */
+    adaptColumns(columns) {
+        return columns.map((column) => this.adaptColumn(column));
+    }
+    /**
+     * Destroys every currently-mounted component/embedded view and stops
+     * observing. Call exactly once, when the owning grid is torn down.
+     * Deliberately unconditional (does not wait on the MutationObserver):
+     * `disconnect()` drops any in-flight mutation records, so relying on it
+     * for final teardown would risk leaking whatever hadn't been flushed yet.
+     */
+    dispose() {
+        this.observer?.disconnect();
+        this.observer = undefined;
+        for (const [element, mount] of this.mounts) {
+            this.destroyMount(mount);
+            this.mounts.delete(element);
+        }
+    }
+    adaptColumn(column) {
+        const { renderer, children, ...rest } = column;
+        const adapted = { ...rest };
+        if (renderer) {
+            // Adapted per-slot (rather than via a generic loop over the
+            // slot names) so each call keeps its own TParams/TOutput pair —
+            // looping over a union of keys would force `adaptRenderer` to
+            // accept the union of every slot's renderer type at once, which
+            // doesn't type-check (an EditorRendererParams renderer isn't
+            // assignable where a TooltipRendererParams renderer is expected).
+            const adaptedRenderer = {
+                display: this.adaptRenderer(renderer.display),
+                editor: this.adaptRenderer(renderer.editor),
+                option: this.adaptRenderer(renderer.option),
+                filter: this.adaptRenderer(renderer.filter),
+                tooltip: this.adaptRenderer(renderer.tooltip),
+                group: this.adaptRenderer(renderer.group),
+                header: this.adaptRenderer(renderer.header),
+                summary: this.adaptRenderer(renderer.summary),
+            };
+            adapted.renderer = adaptedRenderer;
+        }
+        if (children) {
+            adapted.children = children.map((child) => this.adaptColumn(child));
+        }
+        return adapted;
+    }
+    adaptRenderer(renderer) {
+        if (!renderer) {
+            return undefined;
+        }
+        if (isComponentRendererSpec(renderer)) {
+            return (params) => this.mountComponent(renderer, params);
+        }
+        if (isTemplateRendererSpec(renderer)) {
+            return (params) => this.mountTemplate(renderer, params);
+        }
+        if (renderer instanceof TemplateRef) {
+            return (params) => this.mountTemplate({ template: renderer }, params);
+        }
+        if (this.isComponentType(renderer)) {
+            return (params) => this.mountComponent({ component: renderer }, params);
+        }
+        if (typeof renderer === 'function') {
+            return renderer;
+        }
+        return undefined;
+    }
+    isComponentType(value) {
+        return typeof value === 'function' && !!value.ɵcmp;
+    }
+    mountComponent(spec, params) {
+        const componentRef = createComponent(spec.component, {
+            environmentInjector: this.environmentInjector,
+            elementInjector: this.elementInjector,
+        });
+        const normalizedParams = this.normalizeRendererParams(params);
+        const inputs = spec.inputs ? spec.inputs(normalizedParams) : this.inferInputs(componentRef, normalizedParams);
+        for (const [key, value] of Object.entries(inputs)) {
+            this.setComponentInput(componentRef, key, value);
+        }
+        this.setComponentInput(componentRef, 'params', normalizedParams);
+        // Attaching to ApplicationRef is what makes this component
+        // participate in normal change detection (zone triggers, async
+        // pipe, etc.) for as long as it stays mounted — required for any
+        // interactivity inside the component itself (clicks, forms, ...).
+        this.appRef.attachView(componentRef.hostView);
+        componentRef.changeDetectorRef.detectChanges();
+        this.invokeLifecycle(componentRef.instance, 'pgGridInit', normalizedParams);
+        this.invokeLifecycle(componentRef.instance, 'pgGridRefresh', normalizedParams);
+        const element = componentRef.location.nativeElement;
+        this.mounts.set(element, { kind: 'component', ref: componentRef });
+        return element;
+    }
+    setComponentInput(componentRef, key, value) {
+        try {
+            componentRef.setInput(key, value);
+            return;
+        }
+        catch {
+            const instance = componentRef.instance;
+            instance[key] = value;
+        }
+    }
+    normalizeRendererParams(params) {
+        const normalized = { ...params };
+        const option = normalized['option'];
+        if (normalized['value'] === undefined && option && typeof option === 'object') {
+            const optionValue = option.value;
+            normalized['value'] = optionValue;
+            normalized['rawValue'] = optionValue;
+        }
+        return normalized;
+    }
+    inferInputs(componentRef, params) {
+        const instance = componentRef.instance;
+        const inputs = {};
+        const paramBag = params;
+        const row = paramBag['row'] && typeof paramBag['row'] === 'object'
+            ? paramBag['row']
+            : undefined;
+        for (const key of Object.keys(instance)) {
+            if (key === '__ngContext__' || key === 'constructor') {
+                continue;
+            }
+            if (paramBag[key] !== undefined) {
+                inputs[key] = paramBag[key];
+                continue;
+            }
+            if (row && row[key] !== undefined) {
+                inputs[key] = row[key];
+                continue;
+            }
+            if (key === 'seed' && row && row['id'] !== undefined) {
+                inputs[key] = row['id'];
+                continue;
+            }
+            if (key === 'value' && paramBag['value'] !== undefined) {
+                inputs[key] = paramBag['value'];
+            }
+        }
+        return inputs;
+    }
+    invokeLifecycle(instance, lifecycle, params) {
+        const candidate = instance?.[lifecycle];
+        if (typeof candidate === 'function') {
+            candidate.call(instance, params);
+        }
+    }
+    mountTemplate(spec, params) {
+        const normalizedParams = this.normalizeRendererParams(params);
+        const context = {
+            $implicit: normalizedParams,
+            params: normalizedParams,
+            ...(spec.context ? spec.context(normalizedParams) : {}),
+        };
+        const viewRef = spec.template.createEmbeddedView(context);
+        this.appRef.attachView(viewRef);
+        viewRef.detectChanges();
+        const host = this.resolveTemplateHost(viewRef);
+        this.mounts.set(host, { kind: 'template', ref: viewRef });
+        return host;
+    }
+    /**
+     * Uses the template's single root element directly when possible (so
+     * `editor`/`filter` slots that expect the returned element to *be* the
+     * control keep working); falls back to a wrapper `<div>` for templates
+     * with multiple root nodes or text-only content.
+     */
+    resolveTemplateHost(viewRef) {
+        const [singleRoot] = viewRef.rootNodes;
+        if (viewRef.rootNodes.length === 1 && singleRoot instanceof HTMLElement) {
+            return singleRoot;
+        }
+        const host = document.createElement('div');
+        host.classList.add('photon-grid__template-host');
+        host.append(...viewRef.rootNodes);
+        return host;
+    }
+    cleanupRemovedNode(node) {
+        if (!(node instanceof HTMLElement)) {
+            return;
+        }
+        const directMount = this.mounts.get(node);
+        if (directMount) {
+            this.mounts.delete(node);
+            this.destroyMount(directMount);
+        }
+        // The core may remove an ancestor (e.g. an entire recycled row)
+        // rather than the mounted element itself; sweep for any tracked
+        // host contained in the removed subtree.
+        if (node.childElementCount === 0) {
+            return;
+        }
+        for (const [element, mount] of this.mounts) {
+            if (node.contains(element)) {
+                this.mounts.delete(element);
+                this.destroyMount(mount);
+            }
+        }
+    }
+    destroyMount(mount) {
+        if (mount.kind === 'component') {
+            this.invokeLifecycle(mount.ref.instance, 'pgGridDestroy', undefined);
+            const viewRef = mount.ref.hostView;
+            this.appRef.detachView(viewRef);
+            mount.ref.destroy();
+            return;
+        }
+        const viewRef = mount.ref;
+        this.appRef.detachView(viewRef);
+        mount.ref.destroy();
+    }
+}
+
+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 } },
+ * }];
+ * ```
+ */
+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 }); })();
+
+/**
+ * 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.
+ */
+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] }); })();
+
+/*
+ * Public API surface of photon-grid-angular.
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { PhotonGridComponent, PhotonGridModule, isComponentRendererSpec, isTemplateRendererSpec };
+//# sourceMappingURL=photon-grid-angular.mjs.map