@unshape/grid-angular 0.0.708

package/dist/fesm2022/unshape-grid-angular.mjs

@@ -0,0 +1,1563 @@
+import * as i0 from '@angular/core';
+import { effect, Directive, Injectable, inject, signal, Injector, input, runInInjectionContext, ContentChild, ChangeDetectionStrategy, Component, ContentChildren, ViewChild, HostBinding, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { Grid } from '@unshape/grid';
+
+function effectSkipFirst(fn) {
+    let first = true;
+    return effect(() => {
+        // Always execute fn, so it reads signals and establishes tracking
+        fn(first);
+        first = false;
+    });
+}
+
+function gridIdInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const id = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setGridId(id);
+    });
+}
+
+function dataInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const data = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setData(data);
+    });
+}
+
+function columnInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const columns = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setColumns(columns);
+    });
+}
+
+function loadingInputEffect(value, grid) {
+    return effect(() => {
+        grid.api.setLoading(value());
+    });
+}
+
+function resizableInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const resizable = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setResizable(resizable);
+    });
+}
+
+function resizeModeInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const resizeMode = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setResizeMode(resizeMode);
+    });
+}
+
+function toggleVisibilityInputEffect(key, value, columnService) {
+    return effectSkipFirst((isInitial) => {
+        const visible = value();
+        if (isInitial)
+            return;
+        const grid = columnService.grid();
+        if (!grid)
+            return;
+        const { enableAnimations } = grid._store.getState().view;
+        if (enableAnimations) {
+            visible
+                ? grid.api.showColumnAnimated(key)
+                : grid.api.hideColumnAnimated(key);
+        }
+        else {
+            grid.api.setColumnVisible(key, visible);
+        }
+    });
+}
+
+function enableAnimationsInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const enableAnimations = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setEnableAnimations(enableAnimations);
+    });
+}
+
+function filterableInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const filterable = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setFilterable(filterable);
+    });
+}
+
+function sortSettingsInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const sortSettings = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setSortSettings(sortSettings);
+    });
+}
+
+function showFooterInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const showFooter = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setShowFooter(showFooter);
+    });
+}
+
+function localeInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const locale = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setLocale(locale);
+    });
+}
+
+function groupableInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const groupable = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setGroupable(groupable);
+    });
+}
+
+function animationOptionsInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const animOptions = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setAnimationOptions(animOptions);
+    });
+}
+
+function pageableInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const pageable = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setPageable(pageable);
+    });
+}
+
+function selectableInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const selectable = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setSelectable(selectable);
+    });
+}
+
+function showStatusBarInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const showStatusBar = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setShowStatusBar(showStatusBar);
+    });
+}
+
+function columnMenuInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const columnMenu = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setColumnMenu(columnMenu);
+    });
+}
+
+function allowColumnReorderInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const allowColumnReorder = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setAllowColumnReorder(allowColumnReorder);
+    });
+}
+
+function showToolBarInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const showToolBar = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setShowToolBar(showToolBar);
+    });
+}
+
+function toolBarRendererInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const toolBarRenderer = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setToolBarRenderer(toolBarRenderer);
+    });
+}
+
+function editableInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const editable = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setEditable(editable);
+    });
+}
+
+function editingEventsInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const editingEvents = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setEditingEvents(editingEvents);
+    });
+}
+
+function schemaInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const schema = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setSchema(schema);
+    });
+}
+
+function rowEditingEventsInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const rowEditingEvents = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setRowEditingEvents(rowEditingEvents);
+    });
+}
+
+function rowEventsInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const rowEvents = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setRowEvents(rowEvents);
+    });
+}
+
+function newRowEventsInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const newRowEvents = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setNewRowEvents(newRowEvents);
+    });
+}
+
+function rowFormatInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const rowFormat = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setRowFormat(rowFormat);
+    });
+}
+
+function copyInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const copy = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setCopySettings(copy);
+    });
+}
+
+function pasteInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const paste = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setPasteSettings(paste);
+    });
+}
+
+function clipboardEventsInputEffect(value, grid) {
+    return effectSkipFirst((isInitial) => {
+        const clipboardEvents = value();
+        if (isInitial)
+            return;
+        if (grid)
+            grid.api.setClipboardEvents(clipboardEvents);
+    });
+}
+
+class UnshapeGridNoDataTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridNoDataTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridNoDataTemplateDirective, isStandalone: true, selector: "[unshapeGridNoDataTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridNoDataTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridNoDataTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridLoadingTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridLoadingTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridLoadingTemplateDirective, isStandalone: true, selector: "[unshapeGridLoadingTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridLoadingTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridLoadingTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridGroupColumnTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridGroupColumnTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridGroupColumnTemplateDirective, isStandalone: true, selector: "[unshapeGridGroupColumnTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridGroupColumnTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridGroupColumnTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridGroupHeaderTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridGroupHeaderTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridGroupHeaderTemplateDirective, isStandalone: true, selector: "[unshapeGridGroupHeaderTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridGroupHeaderTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridGroupHeaderTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridStatusBarTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridStatusBarTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridStatusBarTemplateDirective, isStandalone: true, selector: "[unshapeGridStatusBarTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridStatusBarTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridStatusBarTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridToolBarTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridToolBarTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridToolBarTemplateDirective, isStandalone: true, selector: "[unshapeGridToolBarTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridToolBarTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridToolBarTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridErrorTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridErrorTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridErrorTemplateDirective, isStandalone: true, selector: "[unshapeGridErrorTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridErrorTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridErrorTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class TemplateMountService {
+    appRef;
+    constructor(appRef) {
+        this.appRef = appRef;
+    }
+    mount(template, container, context) {
+        const viewRef = template.createEmbeddedView(context);
+        this.appRef.attachView(viewRef);
+        viewRef.detectChanges();
+        const frag = document.createDocumentFragment();
+        for (const node of viewRef.rootNodes)
+            frag.appendChild(node);
+        container.appendChild(frag);
+        return {
+            update: (partial) => {
+                Object.assign(viewRef.context, partial);
+                viewRef.detectChanges();
+            },
+            destroy: () => {
+                this.appRef.detachView(viewRef);
+                viewRef.destroy();
+            },
+            viewRef,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: TemplateMountService, deps: [{ token: i0.ApplicationRef }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: TemplateMountService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: TemplateMountService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i0.ApplicationRef }] });
+
+function renderNoDataTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        context: req.context,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+function renderLoadingTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        context: req.context,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+function renderErrorTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        title: req.context.title,
+        message: req.context.message,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+function renderColumnHeaderTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        field: req.context.field,
+        header: req.context.header,
+        columnKey: req.context.columnKey,
+        columnId: req.context.columnId,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+function renderColumnFooterTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        field: req.context.field,
+        header: req.context.header,
+        columnKey: req.context.columnKey,
+        columnId: req.context.columnId,
+        values: req.context.values,
+        rows: req.context.rows,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+function renderColumnCellTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        row: req.context.row,
+        value: req.context.value,
+        field: req.context.field,
+        header: req.context.header,
+        columnKey: req.context.columnKey,
+        columnId: req.context.columnId,
+        rowIndex: req.context.rowIndex,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+function renderGroupColumnTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        column: req.context.column,
+        group: req.context.group,
+        aggregate: req.context.aggregate,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+function renderGroupHeaderCellTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        column: req.context.column,
+        group: req.context.group,
+        aggregate: req.context.aggregate,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+function renderGroupHeaderTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        column: req.context.column,
+        group: req.context.group,
+        aggregate: req.context.aggregate,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+function renderGroupFooterCellTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        column: req.context.column,
+        group: req.context.group,
+        aggregate: req.context.aggregate,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+function renderStatusBarTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        statusBar: req.context,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+function renderToolBarTemplate(req, template, templateMountService) {
+    if (!template)
+        return null;
+    const ctx = {
+        $implicit: req.context,
+        context: req.context,
+    };
+    return templateMountService.mount(template, req.container, ctx);
+}
+
+class RendererAdapterFactory {
+    templateMountService = inject(TemplateMountService);
+    buildAdapter(templates) {
+        const headerTemplates = new Map();
+        const footerTemplates = new Map();
+        const cellTemplates = new Map();
+        const groupHeaderCellTemplates = new Map();
+        const groupFooterCellTemplates = new Map();
+        return {
+            renderNoDataTemplate: (req) => renderNoDataTemplate(req, templates.noData, this.templateMountService),
+            renderLoadingTemplate: (req) => renderLoadingTemplate(req, templates.loading, this.templateMountService),
+            renderErrorTemplate: (req) => renderErrorTemplate(req, templates.error, this.templateMountService),
+            renderGroupColumnTemplate: (req) => renderGroupColumnTemplate(req, templates.groupColumn, this.templateMountService),
+            renderGroupHeaderTemplate: (req) => renderGroupHeaderTemplate(req, templates.groupHeader, this.templateMountService),
+            renderColumnHeaderTemplate: (req) => {
+                const tpl = headerTemplates.get(req.context.columnKey);
+                return renderColumnHeaderTemplate(req, tpl, this.templateMountService);
+            },
+            registerColumnHeaderTemplate: (key, tpl) => {
+                headerTemplates.set(key, tpl);
+            },
+            renderColumnFooterTemplate: (req) => {
+                const tpl = footerTemplates.get(req.context.columnKey);
+                return renderColumnFooterTemplate(req, tpl, this.templateMountService);
+            },
+            registerColumnFooterTemplate: (key, tpl) => {
+                footerTemplates.set(key, tpl);
+            },
+            renderColumnCellTemplate: (req) => {
+                const tpl = cellTemplates.get(req.context.columnKey);
+                return renderColumnCellTemplate(req, tpl, this.templateMountService);
+            },
+            registerColumnCellTemplate: (key, tpl) => {
+                cellTemplates.set(key, tpl);
+            },
+            renderGroupHeaderCellTemplate: (req) => {
+                const tpl = groupHeaderCellTemplates.get(req.context.columnKey);
+                return renderGroupHeaderCellTemplate(req, tpl, this.templateMountService);
+            },
+            registerGroupHeaderCellTemplate: (key, tpl) => {
+                groupHeaderCellTemplates.set(key, tpl);
+            },
+            renderGroupFooterCellTemplate: (req) => {
+                const tpl = groupFooterCellTemplates.get(req.context.columnKey);
+                return renderGroupFooterCellTemplate(req, tpl, this.templateMountService);
+            },
+            registerGroupFooterCellTemplate: (key, tpl) => {
+                groupFooterCellTemplates.set(key, tpl);
+            },
+            renderStatusBarTemplate: (req) => renderStatusBarTemplate(req, templates.statusBar, this.templateMountService),
+            renderToolBarTemplate: (req) => renderToolBarTemplate(req, templates.toolBar, this.templateMountService),
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: RendererAdapterFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: RendererAdapterFactory, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: RendererAdapterFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }] });
+
+function extractNoDataTemplate(dir) {
+    return dir?.template;
+}
+
+function extractLoadingTemplate(dir) {
+    return dir?.template;
+}
+
+function extractErrorTemplate(dir) {
+    return dir?.template;
+}
+
+function extractGroupColumnTemplate(dir) {
+    return dir?.template;
+}
+
+function extractGroupHeaderTemplate(dir) {
+    return dir?.template;
+}
+
+function extractStatusBarTemplate(dir) {
+    return dir?.template;
+}
+
+function extractToolBarTemplate(dir) {
+    return dir?.template;
+}
+
+class TemplateCollectorService {
+    collect(noDataTplDir, loadingTplDir, errorTplDir, groupColumnTplDir, groupHeaderTplDir, statusBarTplDir, toolBarTplDir) {
+        return {
+            noData: extractNoDataTemplate(noDataTplDir),
+            loading: extractLoadingTemplate(loadingTplDir),
+            error: extractErrorTemplate(errorTplDir),
+            groupColumn: extractGroupColumnTemplate(groupColumnTplDir),
+            groupHeader: extractGroupHeaderTemplate(groupHeaderTplDir),
+            statusBar: extractStatusBarTemplate(statusBarTplDir),
+            toolBar: extractToolBarTemplate(toolBarTplDir),
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: TemplateCollectorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: TemplateCollectorService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: TemplateCollectorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }] });
+
+function collectProjectedColumns(projectedColumns) {
+    const columns = [];
+    for (const projCol of projectedColumns) {
+        const col = {
+            header: projCol.header(),
+            field: projCol.field(),
+            width: projCol.width(),
+            minWidth: projCol.minWidth(),
+            maxWidth: projCol.maxWidth() ?? Infinity,
+            visible: projCol.visible(),
+            sortable: projCol.sortable(),
+            filterEditor: projCol.filterEditor() ?? projCol.filterEditorFromTemplate,
+            pinned: projCol.pinned(),
+            columnMenu: projCol.columnMenu(),
+            cellEditor: projCol.cellEditor() ?? projCol.cellEditorFromTemplate,
+            filterable: projCol.filterable(),
+            isNonData: projCol.isNonData(),
+            align: projCol.align(),
+            numberFormatOptions: projCol.numberFormatOptions(),
+            dateFormatOptions: projCol.dateFormatOptions(),
+            booleanFormatOptions: projCol.booleanFormatOptions(),
+            formatter: projCol.formatter(),
+            cellFormat: projCol.cellFormat?.() ?? undefined,
+            columnStyle: projCol.columnStyle(),
+            copyCellRenderer: projCol.copyCellRenderer(),
+            copyGroupHeaderCellRenderer: projCol.copyGroupHeaderCellRenderer(),
+            copyGroupFooterCellRenderer: projCol.copyGroupFooterCellRenderer(),
+        };
+        columns.push(col);
+    }
+    return columns;
+}
+
+class ColumnService {
+    _grid = signal(null, ...(ngDevMode ? [{ debugName: "_grid" }] : /* istanbul ignore next */ []));
+    grid = this._grid.asReadonly();
+    adapter;
+    pendingHeaderTemplates = new Map();
+    pendingFooterTemplates = new Map();
+    pendingCellTemplates = new Map();
+    pendingGroupHeaderCellTemplates = new Map();
+    pendingGroupFooterCellTemplates = new Map();
+    setGrid(grid) {
+        this._grid.set(grid);
+    }
+    setAdapter(adapter) {
+        this.adapter = adapter;
+        // flush pending templates into the adapter
+        this.pendingHeaderTemplates.forEach((tpl, key) => {
+            this.adapter.registerColumnHeaderTemplate?.(key, tpl);
+        });
+        this.pendingHeaderTemplates.clear();
+        this.pendingFooterTemplates.forEach((tpl, key) => {
+            this.adapter.registerColumnFooterTemplate?.(key, tpl);
+        });
+        this.pendingFooterTemplates.clear();
+        this.pendingCellTemplates.forEach((tpl, key) => {
+            this.adapter.registerColumnCellTemplate?.(key, tpl);
+        });
+        this.pendingCellTemplates.clear();
+        this.pendingGroupHeaderCellTemplates.forEach((tpl, key) => {
+            this.adapter.registerGroupHeaderCellTemplate?.(key, tpl);
+        });
+        this.pendingGroupHeaderCellTemplates.clear();
+        this.pendingGroupFooterCellTemplates.forEach((tpl, key) => {
+            this.adapter.registerGroupFooterCellTemplate?.(key, tpl);
+        });
+        this.pendingGroupFooterCellTemplates.clear();
+    }
+    registerHeaderTemplate(key, tpl) {
+        if (this.adapter) {
+            this.adapter.registerColumnHeaderTemplate?.(key, tpl);
+        }
+        else {
+            this.pendingHeaderTemplates.set(key, tpl);
+        }
+    }
+    registerFooterTemplate(key, tpl) {
+        if (this.adapter) {
+            this.adapter.registerColumnFooterTemplate?.(key, tpl);
+        }
+        else {
+            this.pendingFooterTemplates.set(key, tpl);
+        }
+    }
+    registerCellTemplate(key, tpl) {
+        if (this.adapter) {
+            this.adapter.registerColumnCellTemplate?.(key, tpl);
+        }
+        else {
+            this.pendingCellTemplates.set(key, tpl);
+        }
+    }
+    registerGroupHeaderCellTemplate(key, tpl) {
+        if (this.adapter) {
+            this.adapter.registerGroupHeaderCellTemplate?.(key, tpl);
+        }
+        else {
+            this.pendingGroupHeaderCellTemplates.set(key, tpl);
+        }
+    }
+    registerGroupFooterCellTemplate(key, tpl) {
+        if (this.adapter) {
+            this.adapter.registerGroupFooterCellTemplate?.(key, tpl);
+        }
+        else {
+            this.pendingGroupFooterCellTemplates.set(key, tpl);
+        }
+    }
+    collectProjectedColumns = collectProjectedColumns;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: ColumnService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: ColumnService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: ColumnService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }] });
+
+class UnshapeGridColumnHeaderTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridColumnHeaderTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridColumnHeaderTemplateDirective, isStandalone: true, selector: "[unshapeGridColumnHeaderTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridColumnHeaderTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridColumnHeaderTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridColumnFooterTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridColumnFooterTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridColumnFooterTemplateDirective, isStandalone: true, selector: "[unshapeGridColumnFooterTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridColumnFooterTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridColumnFooterTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridColumnCellTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridColumnCellTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridColumnCellTemplateDirective, isStandalone: true, selector: "[unshapeGridColumnCellTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridColumnCellTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridColumnCellTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridFilterCellTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridFilterCellTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridFilterCellTemplateDirective, isStandalone: true, selector: "[unshapeGridFilterCellTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridFilterCellTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridFilterCellTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridGroupHeaderCellTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridGroupHeaderCellTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridGroupHeaderCellTemplateDirective, isStandalone: true, selector: "[unshapeGridGroupHeaderCellTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridGroupHeaderCellTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridGroupHeaderCellTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridGroupFooterCellTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridGroupFooterCellTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridGroupFooterCellTemplateDirective, isStandalone: true, selector: "[unshapeGridGroupFooterCellTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridGroupFooterCellTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridGroupFooterCellTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class UnshapeGridEditorCellTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridEditorCellTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.23", type: UnshapeGridEditorCellTemplateDirective, isStandalone: true, selector: "[unshapeGridEditorCellTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridEditorCellTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unshapeGridEditorCellTemplate]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+
+class TemplateFilterEditorWrapper {
+    template;
+    mountService;
+    element;
+    controlElement;
+    onChangeCb = null;
+    onClearCb = null;
+    viewRef;
+    constructor(template, mountService) {
+        this.template = template;
+        this.mountService = mountService;
+    }
+    mount(mount) {
+        const ctx = {
+            // static
+            field: mount.context.field,
+            header: mount.context.header,
+            columnKey: mount.context.columnKey,
+            columnId: mount.context.columnId,
+            // dynamic
+            value: signal(mount.context.value),
+            disabled: signal(mount.context.disabled),
+            operator: signal(mount.context.operator),
+            // callbacks
+            update: (v) => this.onChangeCb?.(v),
+            clear: () => this.onClearCb?.(),
+        };
+        const handle = this.mountService.mount(this.template, mount.container, ctx);
+        this.viewRef = handle.viewRef;
+        const host = this.viewRef.rootNodes.find((n) => n instanceof HTMLElement);
+        // The container is the root element
+        this.element = host;
+        // Find the actual editor element inside the template
+        this.controlElement = host.querySelector("[data-editor]");
+        if (!this.controlElement) {
+            // fallback: assume the container itself is the control
+            this.controlElement = this.element;
+        }
+    }
+    // Grid → template
+    setValue(value) {
+        if (!this.viewRef)
+            return;
+        this.viewRef.context.value.set(value);
+        this.viewRef.detectChanges();
+    }
+    setDisabled(disabled) {
+        if (!this.viewRef)
+            return;
+        this.viewRef.context.disabled.set(disabled);
+        this.viewRef.detectChanges();
+    }
+    onValueChange(cb) {
+        this.onChangeCb = cb;
+    }
+    onClear(cb) {
+        this.onClearCb = cb;
+    }
+    destroy() {
+        this.viewRef?.destroy();
+    }
+}
+
+function templateFilterEditorFactory(template, mountService) {
+    return (column, grid) => {
+        // we don’t have FilterCellMount here yet
+        // we just create an editor that knows how to mount itself later
+        return new TemplateFilterEditorWrapper(template, mountService);
+    };
+}
+
+class TemplateCellEditorWrapper {
+    template;
+    mountService;
+    element;
+    controlElement;
+    onChangeCb = null;
+    onCommitCb = null;
+    onCancelCb = null;
+    viewRef;
+    constructor(template, mountService) {
+        this.template = template;
+        this.mountService = mountService;
+    }
+    mount(mount) {
+        const ctx = {
+            // static
+            field: mount.context.field,
+            header: mount.context.header,
+            columnKey: mount.context.columnKey,
+            columnId: mount.context.columnId,
+            rowId: mount.context.rowId,
+            // dynamic
+            value: signal(mount.context.value),
+            disabled: signal(mount.context.disabled),
+            // callbacks
+            update: (v) => this.onChangeCb?.(v),
+            commit: (v) => this.onCommitCb?.(v),
+            cancel: () => this.onCancelCb?.(),
+            onKeydown: (event) => this.onKeydown(event, ctx),
+        };
+        const handle = this.mountService.mount(this.template, mount.container, ctx);
+        this.viewRef = handle.viewRef;
+        const host = this.viewRef.rootNodes.find((n) => n instanceof HTMLElement);
+        // The container is the root element
+        this.element = host;
+        // Find the actual editor element inside the template
+        this.controlElement = host.querySelector("[data-editor]");
+        if (!this.controlElement) {
+            // fallback: assume the container itself is the control
+            this.controlElement = this.element;
+        }
+    }
+    // Grid → template
+    setValue(value) {
+        if (!this.viewRef)
+            return;
+        this.viewRef.context.value.set(value);
+        this.viewRef.detectChanges();
+    }
+    setDisabled(disabled) {
+        if (!this.viewRef)
+            return;
+        this.viewRef.context.disabled.set(disabled);
+        this.viewRef.detectChanges();
+    }
+    onValueChange(cb) {
+        this.onChangeCb = cb;
+    }
+    onCommit(cb) {
+        this.onCommitCb = cb;
+    }
+    onCancel(cb) {
+        this.onCancelCb = cb;
+    }
+    onKeydown(event, ctx) {
+        if (event.key === "Enter") {
+            event.preventDefault();
+            ctx.commit(ctx.value());
+        }
+        if (event.key === "Escape") {
+            event.preventDefault();
+            ctx.cancel();
+        }
+    }
+    destroy() {
+        this.viewRef?.destroy();
+    }
+}
+
+function templateCellEditorFactory(template, mountService) {
+    return (column, rowId, grid, initialValue) => {
+        // we don’t have EditorCellMount here yet
+        // we just create an editor that knows how to mount itself later
+        return new TemplateCellEditorWrapper(template, mountService);
+    };
+}
+
+class UnshapeGridColumnComponent {
+    injector = inject(Injector);
+    columnService = inject(ColumnService);
+    templateMountService = inject(TemplateMountService);
+    filterEditorFromTemplate;
+    cellEditorFromTemplate;
+    header = input.required(...(ngDevMode ? [{ debugName: "header" }] : /* istanbul ignore next */ []));
+    field = input.required(...(ngDevMode ? [{ debugName: "field" }] : /* istanbul ignore next */ []));
+    width = input(...(ngDevMode ? [undefined, { debugName: "width" }] : /* istanbul ignore next */ []));
+    visible = input(true, ...(ngDevMode ? [{ debugName: "visible" }] : /* istanbul ignore next */ []));
+    minWidth = input(...(ngDevMode ? [undefined, { debugName: "minWidth" }] : /* istanbul ignore next */ []));
+    maxWidth = input(...(ngDevMode ? [undefined, { debugName: "maxWidth" }] : /* istanbul ignore next */ []));
+    sortable = input(false, ...(ngDevMode ? [{ debugName: "sortable" }] : /* istanbul ignore next */ []));
+    filterEditor = input(...(ngDevMode ? [undefined, { debugName: "filterEditor" }] : /* istanbul ignore next */ []));
+    pinned = input(...(ngDevMode ? [undefined, { debugName: "pinned" }] : /* istanbul ignore next */ []));
+    columnMenu = input(true, ...(ngDevMode ? [{ debugName: "columnMenu" }] : /* istanbul ignore next */ []));
+    cellEditor = input(...(ngDevMode ? [undefined, { debugName: "cellEditor" }] : /* istanbul ignore next */ []));
+    filterable = input(true, ...(ngDevMode ? [{ debugName: "filterable" }] : /* istanbul ignore next */ []));
+    isNonData = input(false, ...(ngDevMode ? [{ debugName: "isNonData" }] : /* istanbul ignore next */ []));
+    align = input(...(ngDevMode ? [undefined, { debugName: "align" }] : /* istanbul ignore next */ []));
+    numberFormatOptions = input(...(ngDevMode ? [undefined, { debugName: "numberFormatOptions" }] : /* istanbul ignore next */ []));
+    dateFormatOptions = input(...(ngDevMode ? [undefined, { debugName: "dateFormatOptions" }] : /* istanbul ignore next */ []));
+    booleanFormatOptions = input(...(ngDevMode ? [undefined, { debugName: "booleanFormatOptions" }] : /* istanbul ignore next */ []));
+    formatter = input(...(ngDevMode ? [undefined, { debugName: "formatter" }] : /* istanbul ignore next */ []));
+    cellFormat = input(...(ngDevMode ? [undefined, { debugName: "cellFormat" }] : /* istanbul ignore next */ []));
+    columnStyle = input(...(ngDevMode ? [undefined, { debugName: "columnStyle" }] : /* istanbul ignore next */ []));
+    copyCellRenderer = input(...(ngDevMode ? [undefined, { debugName: "copyCellRenderer" }] : /* istanbul ignore next */ []));
+    copyGroupHeaderCellRenderer = input(...(ngDevMode ? [undefined, { debugName: "copyGroupHeaderCellRenderer" }] : /* istanbul ignore next */ []));
+    copyGroupFooterCellRenderer = input(...(ngDevMode ? [undefined, { debugName: "copyGroupFooterCellRenderer" }] : /* istanbul ignore next */ []));
+    toggleVisibilityEffect;
+    headerTemplateDir;
+    footerTemplateDir;
+    cellTemplateDir;
+    filterCellTemplateDir;
+    groupHeaderCellTemplateDir;
+    groupFooterCellTemplateDir;
+    editorCellTemplateDir;
+    ngAfterViewInit() {
+        runInInjectionContext(this.injector, () => {
+            this.toggleVisibilityEffect = toggleVisibilityInputEffect(`${this.field()}::${this.header()}`, this.visible, this.columnService);
+        });
+    }
+    ngAfterContentInit() {
+        if (this.headerTemplateDir) {
+            this.columnService.registerHeaderTemplate(`${this.field()}::${this.header()}`, this.headerTemplateDir.template);
+        }
+        if (this.footerTemplateDir) {
+            this.columnService.registerFooterTemplate(`${this.field()}::${this.header()}`, this.footerTemplateDir.template);
+        }
+        if (this.cellTemplateDir) {
+            this.columnService.registerCellTemplate(`${this.field()}::${this.header()}`, this.cellTemplateDir.template);
+        }
+        if (this.filterCellTemplateDir) {
+            this.filterEditorFromTemplate = templateFilterEditorFactory(this.filterCellTemplateDir.template, this.templateMountService);
+        }
+        if (this.groupHeaderCellTemplateDir) {
+            this.columnService.registerGroupHeaderCellTemplate(`${this.field()}::${this.header()}`, this.groupHeaderCellTemplateDir.template);
+        }
+        if (this.groupFooterCellTemplateDir) {
+            this.columnService.registerGroupFooterCellTemplate(`${this.field()}::${this.header()}`, this.groupFooterCellTemplateDir.template);
+        }
+        if (this.editorCellTemplateDir) {
+            this.cellEditorFromTemplate = templateCellEditorFactory(this.editorCellTemplateDir.template, this.templateMountService);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridColumnComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.23", type: UnshapeGridColumnComponent, isStandalone: true, selector: "ush-grid-column", inputs: { header: { classPropertyName: "header", publicName: "header", isSignal: true, isRequired: true, transformFunction: null }, field: { classPropertyName: "field", publicName: "field", isSignal: true, isRequired: true, transformFunction: null }, width: { classPropertyName: "width", publicName: "width", isSignal: true, isRequired: false, transformFunction: null }, visible: { classPropertyName: "visible", publicName: "visible", isSignal: true, isRequired: false, transformFunction: null }, minWidth: { classPropertyName: "minWidth", publicName: "minWidth", isSignal: true, isRequired: false, transformFunction: null }, maxWidth: { classPropertyName: "maxWidth", publicName: "maxWidth", isSignal: true, isRequired: false, transformFunction: null }, sortable: { classPropertyName: "sortable", publicName: "sortable", isSignal: true, isRequired: false, transformFunction: null }, filterEditor: { classPropertyName: "filterEditor", publicName: "filterEditor", isSignal: true, isRequired: false, transformFunction: null }, pinned: { classPropertyName: "pinned", publicName: "pinned", isSignal: true, isRequired: false, transformFunction: null }, columnMenu: { classPropertyName: "columnMenu", publicName: "columnMenu", isSignal: true, isRequired: false, transformFunction: null }, cellEditor: { classPropertyName: "cellEditor", publicName: "cellEditor", isSignal: true, isRequired: false, transformFunction: null }, filterable: { classPropertyName: "filterable", publicName: "filterable", isSignal: true, isRequired: false, transformFunction: null }, isNonData: { classPropertyName: "isNonData", publicName: "isNonData", isSignal: true, isRequired: false, transformFunction: null }, align: { classPropertyName: "align", publicName: "align", isSignal: true, isRequired: false, transformFunction: null }, numberFormatOptions: { classPropertyName: "numberFormatOptions", publicName: "numberFormatOptions", isSignal: true, isRequired: false, transformFunction: null }, dateFormatOptions: { classPropertyName: "dateFormatOptions", publicName: "dateFormatOptions", isSignal: true, isRequired: false, transformFunction: null }, booleanFormatOptions: { classPropertyName: "booleanFormatOptions", publicName: "booleanFormatOptions", isSignal: true, isRequired: false, transformFunction: null }, formatter: { classPropertyName: "formatter", publicName: "formatter", isSignal: true, isRequired: false, transformFunction: null }, cellFormat: { classPropertyName: "cellFormat", publicName: "cellFormat", isSignal: true, isRequired: false, transformFunction: null }, columnStyle: { classPropertyName: "columnStyle", publicName: "columnStyle", isSignal: true, isRequired: false, transformFunction: null }, copyCellRenderer: { classPropertyName: "copyCellRenderer", publicName: "copyCellRenderer", isSignal: true, isRequired: false, transformFunction: null }, copyGroupHeaderCellRenderer: { classPropertyName: "copyGroupHeaderCellRenderer", publicName: "copyGroupHeaderCellRenderer", isSignal: true, isRequired: false, transformFunction: null }, copyGroupFooterCellRenderer: { classPropertyName: "copyGroupFooterCellRenderer", publicName: "copyGroupFooterCellRenderer", isSignal: true, isRequired: false, transformFunction: null } }, queries: [{ propertyName: "headerTemplateDir", first: true, predicate: UnshapeGridColumnHeaderTemplateDirective, descendants: true }, { propertyName: "footerTemplateDir", first: true, predicate: UnshapeGridColumnFooterTemplateDirective, descendants: true }, { propertyName: "cellTemplateDir", first: true, predicate: UnshapeGridColumnCellTemplateDirective, descendants: true }, { propertyName: "filterCellTemplateDir", first: true, predicate: UnshapeGridFilterCellTemplateDirective, descendants: true }, { propertyName: "groupHeaderCellTemplateDir", first: true, predicate: UnshapeGridGroupHeaderCellTemplateDirective, descendants: true }, { propertyName: "groupFooterCellTemplateDir", first: true, predicate: UnshapeGridGroupFooterCellTemplateDirective, descendants: true }, { propertyName: "editorCellTemplateDir", first: true, predicate: UnshapeGridEditorCellTemplateDirective, descendants: true }], ngImport: i0, template: "", isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "ush-grid-column",
+                    imports: [CommonModule],
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { header: [{ type: i0.Input, args: [{ isSignal: true, alias: "header", required: true }] }], field: [{ type: i0.Input, args: [{ isSignal: true, alias: "field", required: true }] }], width: [{ type: i0.Input, args: [{ isSignal: true, alias: "width", required: false }] }], visible: [{ type: i0.Input, args: [{ isSignal: true, alias: "visible", required: false }] }], minWidth: [{ type: i0.Input, args: [{ isSignal: true, alias: "minWidth", required: false }] }], maxWidth: [{ type: i0.Input, args: [{ isSignal: true, alias: "maxWidth", required: false }] }], sortable: [{ type: i0.Input, args: [{ isSignal: true, alias: "sortable", required: false }] }], filterEditor: [{ type: i0.Input, args: [{ isSignal: true, alias: "filterEditor", required: false }] }], pinned: [{ type: i0.Input, args: [{ isSignal: true, alias: "pinned", required: false }] }], columnMenu: [{ type: i0.Input, args: [{ isSignal: true, alias: "columnMenu", required: false }] }], cellEditor: [{ type: i0.Input, args: [{ isSignal: true, alias: "cellEditor", required: false }] }], filterable: [{ type: i0.Input, args: [{ isSignal: true, alias: "filterable", required: false }] }], isNonData: [{ type: i0.Input, args: [{ isSignal: true, alias: "isNonData", required: false }] }], align: [{ type: i0.Input, args: [{ isSignal: true, alias: "align", required: false }] }], numberFormatOptions: [{ type: i0.Input, args: [{ isSignal: true, alias: "numberFormatOptions", required: false }] }], dateFormatOptions: [{ type: i0.Input, args: [{ isSignal: true, alias: "dateFormatOptions", required: false }] }], booleanFormatOptions: [{ type: i0.Input, args: [{ isSignal: true, alias: "booleanFormatOptions", required: false }] }], formatter: [{ type: i0.Input, args: [{ isSignal: true, alias: "formatter", required: false }] }], cellFormat: [{ type: i0.Input, args: [{ isSignal: true, alias: "cellFormat", required: false }] }], columnStyle: [{ type: i0.Input, args: [{ isSignal: true, alias: "columnStyle", required: false }] }], copyCellRenderer: [{ type: i0.Input, args: [{ isSignal: true, alias: "copyCellRenderer", required: false }] }], copyGroupHeaderCellRenderer: [{ type: i0.Input, args: [{ isSignal: true, alias: "copyGroupHeaderCellRenderer", required: false }] }], copyGroupFooterCellRenderer: [{ type: i0.Input, args: [{ isSignal: true, alias: "copyGroupFooterCellRenderer", required: false }] }], headerTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridColumnHeaderTemplateDirective]
+            }], footerTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridColumnFooterTemplateDirective]
+            }], cellTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridColumnCellTemplateDirective]
+            }], filterCellTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridFilterCellTemplateDirective]
+            }], groupHeaderCellTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridGroupHeaderCellTemplateDirective]
+            }], groupFooterCellTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridGroupFooterCellTemplateDirective]
+            }], editorCellTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridEditorCellTemplateDirective]
+            }] } });
+
+class UnshapeGridComponent {
+    grid = null;
+    injector = inject(Injector);
+    adapterFactory = inject(RendererAdapterFactory);
+    templateCollector = inject(TemplateCollectorService);
+    errorType;
+    columnService = inject(ColumnService);
+    hostRef;
+    noDataTemplateDir;
+    loadingTemplateDir;
+    errorTemplateDir;
+    groupColumnTemplateDir;
+    groupHeaderTemplateDir;
+    statusBarTemplateDir;
+    toolBarTemplateDir;
+    projectedColumns;
+    // inputs
+    id = input.required(...(ngDevMode ? [{ debugName: "id" }] : /* istanbul ignore next */ []));
+    columns = input([], ...(ngDevMode ? [{ debugName: "columns" }] : /* istanbul ignore next */ []));
+    data = input([], ...(ngDevMode ? [{ debugName: "data" }] : /* istanbul ignore next */ []));
+    loading = input(false, ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
+    resizable = input(false, ...(ngDevMode ? [{ debugName: "resizable" }] : /* istanbul ignore next */ []));
+    resizeMode = input("unconstrained", ...(ngDevMode ? [{ debugName: "resizeMode" }] : /* istanbul ignore next */ []));
+    enableAnimations = input(false, ...(ngDevMode ? [{ debugName: "enableAnimations" }] : /* istanbul ignore next */ []));
+    animationOptions = input({
+        sort: false,
+        filter: false,
+        group: true,
+        paging: false,
+    }, ...(ngDevMode ? [{ debugName: "animationOptions" }] : /* istanbul ignore next */ []));
+    filterable = input(false, ...(ngDevMode ? [{ debugName: "filterable" }] : /* istanbul ignore next */ []));
+    sortSettings = input({}, ...(ngDevMode ? [{ debugName: "sortSettings" }] : /* istanbul ignore next */ []));
+    showFooter = input(true, ...(ngDevMode ? [{ debugName: "showFooter" }] : /* istanbul ignore next */ []));
+    locale = input(navigator.language, ...(ngDevMode ? [{ debugName: "locale" }] : /* istanbul ignore next */ []));
+    groupable = input(false, ...(ngDevMode ? [{ debugName: "groupable" }] : /* istanbul ignore next */ []));
+    pageable = input(false, ...(ngDevMode ? [{ debugName: "pageable" }] : /* istanbul ignore next */ []));
+    selectable = input(false, ...(ngDevMode ? [{ debugName: "selectable" }] : /* istanbul ignore next */ []));
+    showStatusBar = input(false, ...(ngDevMode ? [{ debugName: "showStatusBar" }] : /* istanbul ignore next */ []));
+    columnMenu = input(false, ...(ngDevMode ? [{ debugName: "columnMenu" }] : /* istanbul ignore next */ []));
+    allowColumnReorder = input(false, ...(ngDevMode ? [{ debugName: "allowColumnReorder" }] : /* istanbul ignore next */ []));
+    showToolBar = input(false, ...(ngDevMode ? [{ debugName: "showToolBar" }] : /* istanbul ignore next */ []));
+    toolBarRenderer = input(null, ...(ngDevMode ? [{ debugName: "toolBarRenderer" }] : /* istanbul ignore next */ []));
+    editable = input(false, ...(ngDevMode ? [{ debugName: "editable" }] : /* istanbul ignore next */ []));
+    editingEvents = input({}, ...(ngDevMode ? [{ debugName: "editingEvents" }] : /* istanbul ignore next */ []));
+    schema = input({ fields: [] }, ...(ngDevMode ? [{ debugName: "schema" }] : /* istanbul ignore next */ []));
+    rowEditingEvents = input({}, ...(ngDevMode ? [{ debugName: "rowEditingEvents" }] : /* istanbul ignore next */ []));
+    rowEvents = input({}, ...(ngDevMode ? [{ debugName: "rowEvents" }] : /* istanbul ignore next */ []));
+    newRowEvents = input({}, ...(ngDevMode ? [{ debugName: "newRowEvents" }] : /* istanbul ignore next */ []));
+    rowFormat = input(null, ...(ngDevMode ? [{ debugName: "rowFormat" }] : /* istanbul ignore next */ []));
+    copy = input(false, ...(ngDevMode ? [{ debugName: "copy" }] : /* istanbul ignore next */ []));
+    paste = input(false, ...(ngDevMode ? [{ debugName: "paste" }] : /* istanbul ignore next */ []));
+    clipboardEvents = input({}, ...(ngDevMode ? [{ debugName: "clipboardEvents" }] : /* istanbul ignore next */ []));
+    // reactive effects
+    gridIdEffect;
+    dataEffect;
+    columnEffect;
+    loadingEffect;
+    resizableEffect;
+    resizeModeEffect;
+    enableAnimationsEffect;
+    animationOptionsEffect;
+    filterableEffect;
+    sortSettingsEffect;
+    showFooterEffect;
+    localeEffect;
+    groupableEffect;
+    pageableEffect;
+    selectableEffect;
+    showStatusBarEffect;
+    columnMenuEffect;
+    allowColumnReorderEffect;
+    showToolBarEffect;
+    toolBarRendererEffect;
+    editableEffect;
+    editingEventsEffect;
+    schemaEffect;
+    rowEditingEventsEffect;
+    rowEventsEffect;
+    newRowEventsEffect;
+    rowFormatEffect;
+    copyEffect;
+    pasteEffect;
+    clipboardEventsEffect;
+    ngAfterViewInit() {
+        const host = this.hostRef.nativeElement;
+        const registry = this.templateCollector.collect(this.noDataTemplateDir, this.loadingTemplateDir, this.errorTemplateDir, this.groupColumnTemplateDir, this.groupHeaderTemplateDir, this.statusBarTemplateDir, this.toolBarTemplateDir);
+        const adapter = this.adapterFactory.buildAdapter(registry);
+        this.columnService.setAdapter(adapter);
+        const projected = this.columnService.collectProjectedColumns(this.projectedColumns);
+        const inputCols = this.columns();
+        const finalColumns = inputCols !== undefined && inputCols !== null && inputCols.length > 0
+            ? inputCols
+            : projected;
+        if (finalColumns.length === 0)
+            this.errorType = "no-columns";
+        const options = {
+            id: this.id(),
+            columns: finalColumns,
+            data: this.data(),
+            resizable: this.resizable(),
+            resizeMode: this.resizeMode(),
+            enableAnimations: this.enableAnimations(),
+            animationOptions: this.animationOptions(),
+            filterable: this.filterable(),
+            sortSettings: this.sortSettings(),
+            rendererAdapter: adapter,
+            showFooter: this.showFooter(),
+            locale: this.locale(),
+            groupable: this.groupable(),
+            pageable: this.pageable(),
+            selectable: this.selectable(),
+            showStatusBar: this.showStatusBar(),
+            columnMenu: this.columnMenu(),
+            allowColumnReorder: this.allowColumnReorder(),
+            showToolBar: this.showToolBar(),
+            toolBarRenderer: this.toolBarRenderer(),
+            editable: this.editable(),
+            editingEvents: this.editingEvents(),
+            schema: this.schema(),
+            rowEditingEvents: this.rowEditingEvents(),
+            rowEvents: this.rowEvents(),
+            newRowEvents: this.newRowEvents(),
+            rowFormat: this.rowFormat(),
+            copy: this.copy(),
+            paste: this.paste(),
+            clipboardEvents: this.clipboardEvents(),
+        };
+        this.grid = new Grid(host, options);
+        this.columnService.setGrid(this.grid);
+        runInInjectionContext(this.injector, () => {
+            this.gridIdEffect = gridIdInputEffect(this.id, this.grid);
+            this.dataEffect = dataInputEffect(this.data, this.grid);
+            this.columnEffect = columnInputEffect(this.columns, this.grid);
+            this.loadingEffect = loadingInputEffect(this.loading, this.grid);
+            this.resizableEffect = resizableInputEffect(this.resizable, this.grid);
+            this.resizeModeEffect = resizeModeInputEffect(this.resizeMode, this.grid);
+            this.enableAnimationsEffect = enableAnimationsInputEffect(this.enableAnimations, this.grid);
+            this.animationOptionsEffect = animationOptionsInputEffect(this.animationOptions, this.grid);
+            this.filterableEffect = filterableInputEffect(this.filterable, this.grid);
+            this.sortSettingsEffect = sortSettingsInputEffect(this.sortSettings, this.grid);
+            this.showFooterEffect = showFooterInputEffect(this.showFooter, this.grid);
+            this.localeEffect = localeInputEffect(this.locale, this.grid);
+            this.groupableEffect = groupableInputEffect(this.groupable, this.grid);
+            this.pageableEffect = pageableInputEffect(this.pageable, this.grid);
+            this.selectableEffect = selectableInputEffect(this.selectable, this.grid);
+            this.showStatusBarEffect = showStatusBarInputEffect(this.showStatusBar, this.grid);
+            this.columnMenuEffect = columnMenuInputEffect(this.columnMenu, this.grid);
+            this.allowColumnReorderEffect = allowColumnReorderInputEffect(this.allowColumnReorder, this.grid);
+            this.showToolBarEffect = showToolBarInputEffect(this.showToolBar, this.grid);
+            this.toolBarRendererEffect = toolBarRendererInputEffect(this.toolBarRenderer, this.grid);
+            this.editableEffect = editableInputEffect(this.editable, this.grid);
+            this.editingEventsEffect = editingEventsInputEffect(this.editingEvents, this.grid);
+            this.schemaEffect = schemaInputEffect(this.schema, this.grid);
+            this.rowEditingEventsEffect = rowEditingEventsInputEffect(this.rowEditingEvents, this.grid);
+            this.rowEventsEffect = rowEventsInputEffect(this.rowEvents, this.grid);
+            this.newRowEventsEffect = newRowEventsInputEffect(this.newRowEvents, this.grid);
+            this.rowFormatEffect = rowFormatInputEffect(this.rowFormat, this.grid);
+            this.copyEffect = copyInputEffect(this.copy, this.grid);
+            this.pasteEffect = pasteInputEffect(this.paste, this.grid);
+            this.clipboardEventsEffect = clipboardEventsInputEffect(this.clipboardEvents, this.grid);
+        });
+        if (this.errorType)
+            this.grid.api.setError(true, this.errorType);
+    }
+    ngAfterContentInit() {
+        if (this.columns().length > 0 && this.projectedColumns.length > 0)
+            this.errorType = "ambiguous-column-definition";
+    }
+    ngOnDestroy() {
+        this.grid?.destroy();
+        this.grid = null;
+    }
+    collapseAllGroups() {
+        this.grid.api.collapseAllGroups();
+    }
+    expandAllGroups() {
+        this.grid.api.expandAllGroups();
+    }
+    getValidation(rowId, fieldName) {
+        return this.grid.api.getValidation(rowId, fieldName);
+    }
+    getRowValidation(rowId) {
+        return this.grid.api.getRowValidation(rowId);
+    }
+    getAllValidation() {
+        return this.grid.api.getAllValidation();
+    }
+    hasErrors() {
+        return this.grid.api.hasErrors();
+    }
+    startRowEdit(rowId) {
+        this.grid.api.startRowEdit(rowId);
+    }
+    cancelRowEdit() {
+        this.grid.api.cancelRowEdit();
+    }
+    commitRowEdit() {
+        this.grid.api.commitRowEdit();
+    }
+    deleteRow(rowId) {
+        this.grid.api.deleteRow(rowId);
+    }
+    toggleAddNewRow(show) {
+        this.grid.api.setShowAddNewRow(show);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.23", type: UnshapeGridComponent, isStandalone: true, selector: "ush-grid", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: true, transformFunction: null }, columns: { classPropertyName: "columns", publicName: "columns", isSignal: true, isRequired: false, transformFunction: null }, data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: false, transformFunction: null }, loading: { classPropertyName: "loading", publicName: "loading", isSignal: true, isRequired: false, transformFunction: null }, resizable: { classPropertyName: "resizable", publicName: "resizable", isSignal: true, isRequired: false, transformFunction: null }, resizeMode: { classPropertyName: "resizeMode", publicName: "resizeMode", isSignal: true, isRequired: false, transformFunction: null }, enableAnimations: { classPropertyName: "enableAnimations", publicName: "enableAnimations", isSignal: true, isRequired: false, transformFunction: null }, animationOptions: { classPropertyName: "animationOptions", publicName: "animationOptions", isSignal: true, isRequired: false, transformFunction: null }, filterable: { classPropertyName: "filterable", publicName: "filterable", isSignal: true, isRequired: false, transformFunction: null }, sortSettings: { classPropertyName: "sortSettings", publicName: "sortSettings", isSignal: true, isRequired: false, transformFunction: null }, showFooter: { classPropertyName: "showFooter", publicName: "showFooter", isSignal: true, isRequired: false, transformFunction: null }, locale: { classPropertyName: "locale", publicName: "locale", isSignal: true, isRequired: false, transformFunction: null }, groupable: { classPropertyName: "groupable", publicName: "groupable", isSignal: true, isRequired: false, transformFunction: null }, pageable: { classPropertyName: "pageable", publicName: "pageable", isSignal: true, isRequired: false, transformFunction: null }, selectable: { classPropertyName: "selectable", publicName: "selectable", isSignal: true, isRequired: false, transformFunction: null }, showStatusBar: { classPropertyName: "showStatusBar", publicName: "showStatusBar", isSignal: true, isRequired: false, transformFunction: null }, columnMenu: { classPropertyName: "columnMenu", publicName: "columnMenu", isSignal: true, isRequired: false, transformFunction: null }, allowColumnReorder: { classPropertyName: "allowColumnReorder", publicName: "allowColumnReorder", isSignal: true, isRequired: false, transformFunction: null }, showToolBar: { classPropertyName: "showToolBar", publicName: "showToolBar", isSignal: true, isRequired: false, transformFunction: null }, toolBarRenderer: { classPropertyName: "toolBarRenderer", publicName: "toolBarRenderer", isSignal: true, isRequired: false, transformFunction: null }, editable: { classPropertyName: "editable", publicName: "editable", isSignal: true, isRequired: false, transformFunction: null }, editingEvents: { classPropertyName: "editingEvents", publicName: "editingEvents", isSignal: true, isRequired: false, transformFunction: null }, schema: { classPropertyName: "schema", publicName: "schema", isSignal: true, isRequired: false, transformFunction: null }, rowEditingEvents: { classPropertyName: "rowEditingEvents", publicName: "rowEditingEvents", isSignal: true, isRequired: false, transformFunction: null }, rowEvents: { classPropertyName: "rowEvents", publicName: "rowEvents", isSignal: true, isRequired: false, transformFunction: null }, newRowEvents: { classPropertyName: "newRowEvents", publicName: "newRowEvents", isSignal: true, isRequired: false, transformFunction: null }, rowFormat: { classPropertyName: "rowFormat", publicName: "rowFormat", isSignal: true, isRequired: false, transformFunction: null }, copy: { classPropertyName: "copy", publicName: "copy", isSignal: true, isRequired: false, transformFunction: null }, paste: { classPropertyName: "paste", publicName: "paste", isSignal: true, isRequired: false, transformFunction: null }, clipboardEvents: { classPropertyName: "clipboardEvents", publicName: "clipboardEvents", isSignal: true, isRequired: false, transformFunction: null } }, queries: [{ propertyName: "noDataTemplateDir", first: true, predicate: UnshapeGridNoDataTemplateDirective, descendants: true }, { propertyName: "loadingTemplateDir", first: true, predicate: UnshapeGridLoadingTemplateDirective, descendants: true }, { propertyName: "errorTemplateDir", first: true, predicate: UnshapeGridErrorTemplateDirective, descendants: true }, { propertyName: "groupColumnTemplateDir", first: true, predicate: UnshapeGridGroupColumnTemplateDirective, descendants: true }, { propertyName: "groupHeaderTemplateDir", first: true, predicate: UnshapeGridGroupHeaderTemplateDirective, descendants: true }, { propertyName: "statusBarTemplateDir", first: true, predicate: UnshapeGridStatusBarTemplateDirective, descendants: true }, { propertyName: "toolBarTemplateDir", first: true, predicate: UnshapeGridToolBarTemplateDirective, descendants: true }, { propertyName: "projectedColumns", predicate: UnshapeGridColumnComponent }], viewQueries: [{ propertyName: "hostRef", first: true, predicate: ["host"], descendants: true, static: true }], ngImport: i0, template: "<div #host class=\"ush-grid-host\"></div>\r\n", styles: [":host{display:block;width:100%;height:100%}.ush-grid-host{width:100%;height:100%}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UnshapeGridComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "ush-grid", imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div #host class=\"ush-grid-host\"></div>\r\n", styles: [":host{display:block;width:100%;height:100%}.ush-grid-host{width:100%;height:100%}\n"] }]
+        }], propDecorators: { hostRef: [{
+                type: ViewChild,
+                args: ["host", { static: true }]
+            }], noDataTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridNoDataTemplateDirective]
+            }], loadingTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridLoadingTemplateDirective]
+            }], errorTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridErrorTemplateDirective]
+            }], groupColumnTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridGroupColumnTemplateDirective]
+            }], groupHeaderTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridGroupHeaderTemplateDirective]
+            }], statusBarTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridStatusBarTemplateDirective]
+            }], toolBarTemplateDir: [{
+                type: ContentChild,
+                args: [UnshapeGridToolBarTemplateDirective]
+            }], projectedColumns: [{
+                type: ContentChildren,
+                args: [UnshapeGridColumnComponent]
+            }], id: [{ type: i0.Input, args: [{ isSignal: true, alias: "id", required: true }] }], columns: [{ type: i0.Input, args: [{ isSignal: true, alias: "columns", required: false }] }], data: [{ type: i0.Input, args: [{ isSignal: true, alias: "data", required: false }] }], loading: [{ type: i0.Input, args: [{ isSignal: true, alias: "loading", required: false }] }], resizable: [{ type: i0.Input, args: [{ isSignal: true, alias: "resizable", required: false }] }], resizeMode: [{ type: i0.Input, args: [{ isSignal: true, alias: "resizeMode", required: false }] }], enableAnimations: [{ type: i0.Input, args: [{ isSignal: true, alias: "enableAnimations", required: false }] }], animationOptions: [{ type: i0.Input, args: [{ isSignal: true, alias: "animationOptions", required: false }] }], filterable: [{ type: i0.Input, args: [{ isSignal: true, alias: "filterable", required: false }] }], sortSettings: [{ type: i0.Input, args: [{ isSignal: true, alias: "sortSettings", required: false }] }], showFooter: [{ type: i0.Input, args: [{ isSignal: true, alias: "showFooter", required: false }] }], locale: [{ type: i0.Input, args: [{ isSignal: true, alias: "locale", required: false }] }], groupable: [{ type: i0.Input, args: [{ isSignal: true, alias: "groupable", required: false }] }], pageable: [{ type: i0.Input, args: [{ isSignal: true, alias: "pageable", required: false }] }], selectable: [{ type: i0.Input, args: [{ isSignal: true, alias: "selectable", required: false }] }], showStatusBar: [{ type: i0.Input, args: [{ isSignal: true, alias: "showStatusBar", required: false }] }], columnMenu: [{ type: i0.Input, args: [{ isSignal: true, alias: "columnMenu", required: false }] }], allowColumnReorder: [{ type: i0.Input, args: [{ isSignal: true, alias: "allowColumnReorder", required: false }] }], showToolBar: [{ type: i0.Input, args: [{ isSignal: true, alias: "showToolBar", required: false }] }], toolBarRenderer: [{ type: i0.Input, args: [{ isSignal: true, alias: "toolBarRenderer", required: false }] }], editable: [{ type: i0.Input, args: [{ isSignal: true, alias: "editable", required: false }] }], editingEvents: [{ type: i0.Input, args: [{ isSignal: true, alias: "editingEvents", required: false }] }], schema: [{ type: i0.Input, args: [{ isSignal: true, alias: "schema", required: false }] }], rowEditingEvents: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowEditingEvents", required: false }] }], rowEvents: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowEvents", required: false }] }], newRowEvents: [{ type: i0.Input, args: [{ isSignal: true, alias: "newRowEvents", required: false }] }], rowFormat: [{ type: i0.Input, args: [{ isSignal: true, alias: "rowFormat", required: false }] }], copy: [{ type: i0.Input, args: [{ isSignal: true, alias: "copy", required: false }] }], paste: [{ type: i0.Input, args: [{ isSignal: true, alias: "paste", required: false }] }], clipboardEvents: [{ type: i0.Input, args: [{ isSignal: true, alias: "clipboardEvents", required: false }] }] } });
+
+class SpacerComponent {
+    width = input(...(ngDevMode ? [undefined, { debugName: "width" }] : /* istanbul ignore next */ []));
+    get styleWidth() {
+        return this.width();
+    }
+    get hasWidthClass() {
+        return !!this.width();
+    }
+    get defaultClass() {
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: SpacerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.23", type: SpacerComponent, isStandalone: true, selector: "ush-spacer", inputs: { width: { classPropertyName: "width", publicName: "width", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "style.width": "this.styleWidth", "class.ush-spacer-sized": "this.hasWidthClass", "class.ush-spacer": "this.defaultClass" } }, ngImport: i0, template: "", isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: SpacerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "ush-spacer",
+                    imports: [CommonModule],
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { width: [{ type: i0.Input, args: [{ isSignal: true, alias: "width", required: false }] }], styleWidth: [{
+                type: HostBinding,
+                args: ["style.width"]
+            }], hasWidthClass: [{
+                type: HostBinding,
+                args: ["class.ush-spacer-sized"]
+            }], defaultClass: [{
+                type: HostBinding,
+                args: ["class.ush-spacer"]
+            }] } });
+
+class UNSHAPE_GRID {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UNSHAPE_GRID, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.23", ngImport: i0, type: UNSHAPE_GRID, imports: [UnshapeGridComponent,
+            UnshapeGridColumnComponent,
+            UnshapeGridNoDataTemplateDirective,
+            UnshapeGridLoadingTemplateDirective,
+            UnshapeGridErrorTemplateDirective,
+            UnshapeGridColumnHeaderTemplateDirective,
+            UnshapeGridColumnFooterTemplateDirective,
+            UnshapeGridColumnCellTemplateDirective,
+            UnshapeGridFilterCellTemplateDirective,
+            UnshapeGridGroupColumnTemplateDirective,
+            UnshapeGridGroupHeaderCellTemplateDirective,
+            UnshapeGridGroupHeaderTemplateDirective,
+            UnshapeGridGroupFooterCellTemplateDirective,
+            UnshapeGridStatusBarTemplateDirective,
+            UnshapeGridToolBarTemplateDirective,
+            SpacerComponent,
+            UnshapeGridEditorCellTemplateDirective], exports: [UnshapeGridComponent,
+            UnshapeGridColumnComponent,
+            UnshapeGridNoDataTemplateDirective,
+            UnshapeGridLoadingTemplateDirective,
+            UnshapeGridErrorTemplateDirective,
+            UnshapeGridColumnHeaderTemplateDirective,
+            UnshapeGridColumnFooterTemplateDirective,
+            UnshapeGridColumnCellTemplateDirective,
+            UnshapeGridFilterCellTemplateDirective,
+            UnshapeGridGroupColumnTemplateDirective,
+            UnshapeGridGroupHeaderCellTemplateDirective,
+            UnshapeGridGroupHeaderTemplateDirective,
+            UnshapeGridGroupFooterCellTemplateDirective,
+            UnshapeGridStatusBarTemplateDirective,
+            UnshapeGridToolBarTemplateDirective,
+            SpacerComponent,
+            UnshapeGridEditorCellTemplateDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UNSHAPE_GRID, imports: [UnshapeGridComponent,
+            UnshapeGridColumnComponent,
+            SpacerComponent] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.23", ngImport: i0, type: UNSHAPE_GRID, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        UnshapeGridComponent,
+                        UnshapeGridColumnComponent,
+                        UnshapeGridNoDataTemplateDirective,
+                        UnshapeGridLoadingTemplateDirective,
+                        UnshapeGridErrorTemplateDirective,
+                        UnshapeGridColumnHeaderTemplateDirective,
+                        UnshapeGridColumnFooterTemplateDirective,
+                        UnshapeGridColumnCellTemplateDirective,
+                        UnshapeGridFilterCellTemplateDirective,
+                        UnshapeGridGroupColumnTemplateDirective,
+                        UnshapeGridGroupHeaderCellTemplateDirective,
+                        UnshapeGridGroupHeaderTemplateDirective,
+                        UnshapeGridGroupFooterCellTemplateDirective,
+                        UnshapeGridStatusBarTemplateDirective,
+                        UnshapeGridToolBarTemplateDirective,
+                        SpacerComponent,
+                        UnshapeGridEditorCellTemplateDirective,
+                    ],
+                    exports: [
+                        UnshapeGridComponent,
+                        UnshapeGridColumnComponent,
+                        UnshapeGridNoDataTemplateDirective,
+                        UnshapeGridLoadingTemplateDirective,
+                        UnshapeGridErrorTemplateDirective,
+                        UnshapeGridColumnHeaderTemplateDirective,
+                        UnshapeGridColumnFooterTemplateDirective,
+                        UnshapeGridColumnCellTemplateDirective,
+                        UnshapeGridFilterCellTemplateDirective,
+                        UnshapeGridGroupColumnTemplateDirective,
+                        UnshapeGridGroupHeaderCellTemplateDirective,
+                        UnshapeGridGroupHeaderTemplateDirective,
+                        UnshapeGridGroupFooterCellTemplateDirective,
+                        UnshapeGridStatusBarTemplateDirective,
+                        UnshapeGridToolBarTemplateDirective,
+                        SpacerComponent,
+                        UnshapeGridEditorCellTemplateDirective,
+                    ],
+                    providers: [],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { SpacerComponent, UNSHAPE_GRID, UnshapeGridColumnCellTemplateDirective, UnshapeGridColumnComponent, UnshapeGridColumnFooterTemplateDirective, UnshapeGridColumnHeaderTemplateDirective, UnshapeGridComponent, UnshapeGridEditorCellTemplateDirective, UnshapeGridErrorTemplateDirective, UnshapeGridFilterCellTemplateDirective, UnshapeGridGroupColumnTemplateDirective, UnshapeGridGroupFooterCellTemplateDirective, UnshapeGridGroupHeaderCellTemplateDirective, UnshapeGridGroupHeaderTemplateDirective, UnshapeGridLoadingTemplateDirective, UnshapeGridNoDataTemplateDirective, UnshapeGridStatusBarTemplateDirective, UnshapeGridToolBarTemplateDirective };
+//# sourceMappingURL=unshape-grid-angular.mjs.map