cax-design-system 1.0.0

package/esm2022/styleclass/styleclass.mjs

@@ -0,0 +1,316 @@
+import { CommonModule } from '@angular/common';
+import { Directive, HostListener, Input, NgModule, booleanAttribute } from '@angular/core';
+import { DomHandler } from 'cax-design-system/dom';
+import * as i0 from "@angular/core";
+/**
+ * StyleClass manages css classes declaratively to during enter/leave animations or just to toggle classes on an element.
+ * @group Components
+ */
+export class StyleClass {
+    el;
+    renderer;
+    zone;
+    constructor(el, renderer, zone) {
+        this.el = el;
+        this.renderer = renderer;
+        this.zone = zone;
+    }
+    /**
+     * Selector to define the target element. Available selectors are '@next', '@prev', '@parent' and '@grandparent'.
+     * @group Props
+     */
+    selector;
+    /**
+     * Style class to add when item begins to get displayed.
+     * @group Props
+     * @deprecated Use enterFromClass instead
+     */
+    set enterClass(value) {
+        this._enterClass = value;
+        console.warn('enterClass is deprecated, use enterFromClass instead');
+    }
+    get enterClass() {
+        return this._enterClass;
+    }
+    /**
+     * Style class to add when item begins to get displayed.
+     * @group Props
+     */
+    enterFromClass;
+    /**
+     * Style class to add during enter animation.
+     * @group Props
+     */
+    enterActiveClass;
+    /**
+     * Style class to add when item begins to get displayed.
+     * @group Props
+     */
+    enterToClass;
+    /**
+     * Style class to add when item begins to get hidden.
+     * @group Props
+     * @deprecated Use leaveFromClass instead
+     */
+    set leaveClass(value) {
+        this._leaveClass = value;
+        console.warn('leaveClass is deprecated, use leaveFromClass instead');
+    }
+    get leaveClass() {
+        return this._leaveClass;
+    }
+    /**
+     * Style class to add when item begins to get hidden.
+     * @group Props
+     */
+    leaveFromClass;
+    /**
+     * Style class to add during leave animation.
+     * @group Props
+     */
+    leaveActiveClass;
+    /**
+     * Style class to add when leave animation is completed.
+     * @group Props
+     */
+    leaveToClass;
+    /**
+     * Whether to trigger leave animation when outside of the element is clicked.
+     * @group Props
+     */
+    hideOnOutsideClick;
+    /**
+     * Adds or removes a class when no enter-leave animation is required.
+     * @group Props
+     */
+    toggleClass;
+    /**
+     * Whether to trigger leave animation when escape key pressed.
+     * @group Props
+     */
+    hideOnEscape;
+    eventListener;
+    documentClickListener;
+    documentKeydownListener;
+    target;
+    enterListener;
+    leaveListener;
+    animating;
+    _enterClass;
+    _leaveClass;
+    clickListener() {
+        this.target = this.resolveTarget();
+        if (this.toggleClass) {
+            this.toggle();
+        }
+        else {
+            if (this.target.offsetParent === null)
+                this.enter();
+            else
+                this.leave();
+        }
+    }
+    toggle() {
+        if (DomHandler.hasClass(this.target, this.toggleClass))
+            DomHandler.removeClass(this.target, this.toggleClass);
+        else
+            DomHandler.addClass(this.target, this.toggleClass);
+    }
+    enter() {
+        if (this.enterActiveClass) {
+            if (!this.animating) {
+                this.animating = true;
+                if (this.enterActiveClass === 'slidedown') {
+                    this.target.style.height = '0px';
+                    DomHandler.removeClass(this.target, 'hidden');
+                    this.target.style.maxHeight = this.target.scrollHeight + 'px';
+                    DomHandler.addClass(this.target, 'hidden');
+                    this.target.style.height = '';
+                }
+                DomHandler.addClass(this.target, this.enterActiveClass);
+                if (this.enterClass || this.enterFromClass) {
+                    DomHandler.removeClass(this.target, this.enterClass || this.enterFromClass);
+                }
+                this.enterListener = this.renderer.listen(this.target, 'animationend', () => {
+                    DomHandler.removeClass(this.target, this.enterActiveClass);
+                    if (this.enterToClass) {
+                        DomHandler.addClass(this.target, this.enterToClass);
+                    }
+                    this.enterListener && this.enterListener();
+                    if (this.enterActiveClass === 'slidedown') {
+                        this.target.style.maxHeight = '';
+                    }
+                    this.animating = false;
+                });
+            }
+        }
+        else {
+            if (this.enterClass || this.enterFromClass) {
+                DomHandler.removeClass(this.target, this.enterClass || this.enterFromClass);
+            }
+            if (this.enterToClass) {
+                DomHandler.addClass(this.target, this.enterToClass);
+            }
+        }
+        if (this.hideOnOutsideClick) {
+            this.bindDocumentClickListener();
+        }
+        if (this.hideOnEscape) {
+            this.bindDocumentKeydownListener();
+        }
+    }
+    leave() {
+        if (this.leaveActiveClass) {
+            if (!this.animating) {
+                this.animating = true;
+                DomHandler.addClass(this.target, this.leaveActiveClass);
+                if (this.leaveClass || this.leaveFromClass) {
+                    DomHandler.removeClass(this.target, this.leaveClass || this.leaveFromClass);
+                }
+                this.leaveListener = this.renderer.listen(this.target, 'animationend', () => {
+                    DomHandler.removeClass(this.target, this.leaveActiveClass);
+                    if (this.leaveToClass) {
+                        DomHandler.addClass(this.target, this.leaveToClass);
+                    }
+                    this.leaveListener && this.leaveListener();
+                    this.animating = false;
+                });
+            }
+        }
+        else {
+            if (this.leaveClass || this.leaveFromClass) {
+                DomHandler.removeClass(this.target, this.leaveClass || this.leaveFromClass);
+            }
+            if (this.leaveToClass) {
+                DomHandler.addClass(this.target, this.leaveToClass);
+            }
+        }
+        if (this.hideOnOutsideClick) {
+            this.unbindDocumentClickListener();
+        }
+        if (this.hideOnEscape) {
+            this.unbindDocumentKeydownListener();
+        }
+    }
+    resolveTarget() {
+        if (this.target) {
+            return this.target;
+        }
+        switch (this.selector) {
+            case '@next':
+                return this.el.nativeElement.nextElementSibling;
+            case '@prev':
+                return this.el.nativeElement.previousElementSibling;
+            case '@parent':
+                return this.el.nativeElement.parentElement;
+            case '@grandparent':
+                return this.el.nativeElement.parentElement.parentElement;
+            default:
+                return document.querySelector(this.selector);
+        }
+    }
+    bindDocumentClickListener() {
+        if (!this.documentClickListener) {
+            this.documentClickListener = this.renderer.listen(this.el.nativeElement.ownerDocument, 'click', (event) => {
+                if (!this.isVisible() || getComputedStyle(this.target).getPropertyValue('position') === 'static')
+                    this.unbindDocumentClickListener();
+                else if (this.isOutsideClick(event))
+                    this.leave();
+            });
+        }
+    }
+    bindDocumentKeydownListener() {
+        if (!this.documentKeydownListener) {
+            this.zone.runOutsideAngular(() => {
+                this.documentKeydownListener = this.renderer.listen(this.el.nativeElement.ownerDocument, 'keydown', (event) => {
+                    const { key, keyCode, which, type } = event;
+                    if (!this.isVisible() || getComputedStyle(this.target).getPropertyValue('position') === 'static')
+                        this.unbindDocumentKeydownListener();
+                    if (this.isVisible() && key === 'Escape' && keyCode === 27 && which === 27)
+                        this.leave();
+                });
+            });
+        }
+    }
+    isVisible() {
+        return this.target.offsetParent !== null;
+    }
+    isOutsideClick(event) {
+        return !this.el.nativeElement.isSameNode(event.target) && !this.el.nativeElement.contains(event.target) && !this.target.contains(event.target);
+    }
+    unbindDocumentClickListener() {
+        if (this.documentClickListener) {
+            this.documentClickListener();
+            this.documentClickListener = null;
+        }
+    }
+    unbindDocumentKeydownListener() {
+        if (this.documentKeydownListener) {
+            this.documentKeydownListener();
+            this.documentKeydownListener = null;
+        }
+    }
+    ngOnDestroy() {
+        this.target = null;
+        if (this.eventListener) {
+            this.eventListener();
+        }
+        this.unbindDocumentClickListener();
+        this.unbindDocumentKeydownListener();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: StyleClass, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.9", type: StyleClass, selector: "[pStyleClass]", inputs: { selector: ["pStyleClass", "selector"], enterClass: "enterClass", enterFromClass: "enterFromClass", enterActiveClass: "enterActiveClass", enterToClass: "enterToClass", leaveClass: "leaveClass", leaveFromClass: "leaveFromClass", leaveActiveClass: "leaveActiveClass", leaveToClass: "leaveToClass", hideOnOutsideClick: ["hideOnOutsideClick", "hideOnOutsideClick", booleanAttribute], toggleClass: "toggleClass", hideOnEscape: ["hideOnEscape", "hideOnEscape", booleanAttribute] }, host: { listeners: { "click": "clickListener($event)" }, classAttribute: "cax-element" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: StyleClass, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[pStyleClass]',
+                    host: {
+                        class: 'cax-element'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }], propDecorators: { selector: [{
+                type: Input,
+                args: ['pStyleClass']
+            }], enterClass: [{
+                type: Input
+            }], enterFromClass: [{
+                type: Input
+            }], enterActiveClass: [{
+                type: Input
+            }], enterToClass: [{
+                type: Input
+            }], leaveClass: [{
+                type: Input
+            }], leaveFromClass: [{
+                type: Input
+            }], leaveActiveClass: [{
+                type: Input
+            }], leaveToClass: [{
+                type: Input
+            }], hideOnOutsideClick: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], toggleClass: [{
+                type: Input
+            }], hideOnEscape: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], clickListener: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+export class StyleClassModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: StyleClassModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: StyleClassModule, declarations: [StyleClass], imports: [CommonModule], exports: [StyleClass] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: StyleClassModule, imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: StyleClassModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    exports: [StyleClass],
+                    declarations: [StyleClass]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styleclass.js","sourceRoot":"","sources":["../../../src/app/components/styleclass/styleclass.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Directive, ElementRef, HostListener, Input, NgModule, NgZone, OnDestroy, Renderer2, booleanAttribute } from '@angular/core';\nimport { DomHandler } from 'cax-design-system/dom';\nimport { VoidListener } from 'cax-design-system/ts-helpers';\n/**\n * StyleClass manages css classes declaratively to during enter/leave animations or just to toggle classes on an element.\n * @group Components\n */\n@Directive({\n    selector: '[pStyleClass]',\n    host: {\n        class: 'cax-element'\n    }\n})\nexport class StyleClass implements OnDestroy {\n    constructor(\n        public el: ElementRef,\n        public renderer: Renderer2,\n        private zone: NgZone\n    ) {}\n    /**\n     * Selector to define the target element. Available selectors are '@next', '@prev', '@parent' and '@grandparent'.\n     * @group Props\n     */\n    @Input('pStyleClass') selector: string | undefined;\n    /**\n     * Style class to add when item begins to get displayed.\n     * @group Props\n     * @deprecated Use enterFromClass instead\n     */\n    @Input() set enterClass(value: string) {\n        this._enterClass = value;\n        console.warn('enterClass is deprecated, use enterFromClass instead');\n    }\n    get enterClass() {\n        return this._enterClass;\n    }\n    /**\n     * Style class to add when item begins to get displayed.\n     * @group Props\n     */\n    @Input() enterFromClass: string | undefined;\n    /**\n     * Style class to add during enter animation.\n     * @group Props\n     */\n    @Input() enterActiveClass: string | undefined;\n    /**\n     * Style class to add when item begins to get displayed.\n     * @group Props\n     */\n    @Input() enterToClass: string | undefined;\n    /**\n     * Style class to add when item begins to get hidden.\n     * @group Props\n     * @deprecated Use leaveFromClass instead\n     */\n    @Input() set leaveClass(value: string) {\n        this._leaveClass = value;\n        console.warn('leaveClass is deprecated, use leaveFromClass instead');\n    }\n    get leaveClass() {\n        return this._leaveClass;\n    }\n    /**\n     * Style class to add when item begins to get hidden.\n     * @group Props\n     */\n    @Input() leaveFromClass: string | undefined;\n    /**\n     * Style class to add during leave animation.\n     * @group Props\n     */\n    @Input() leaveActiveClass: string | undefined;\n    /**\n     * Style class to add when leave animation is completed.\n     * @group Props\n     */\n    @Input() leaveToClass: string | undefined;\n    /**\n     * Whether to trigger leave animation when outside of the element is clicked.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) hideOnOutsideClick: boolean | undefined;\n    /**\n     * Adds or removes a class when no enter-leave animation is required.\n     * @group Props\n     */\n    @Input() toggleClass: string | undefined;\n    /**\n     * Whether to trigger leave animation when escape key pressed.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) hideOnEscape: boolean | undefined;\n\n    eventListener: VoidListener;\n\n    documentClickListener: VoidListener;\n\n    documentKeydownListener: VoidListener;\n\n    target: HTMLElement | null | undefined;\n\n    enterListener: VoidListener;\n\n    leaveListener: VoidListener;\n\n    animating: boolean | undefined;\n\n    _enterClass: string | undefined;\n\n    _leaveClass: string | undefined;\n\n    @HostListener('click', ['$event'])\n    clickListener() {\n        this.target = this.resolveTarget();\n\n        if (this.toggleClass) {\n            this.toggle();\n        } else {\n            if ((this.target as HTMLElement).offsetParent === null) this.enter();\n            else this.leave();\n        }\n    }\n\n    toggle() {\n        if (DomHandler.hasClass(this.target, this.toggleClass as string)) DomHandler.removeClass(this.target, this.toggleClass as string);\n        else DomHandler.addClass(this.target, this.toggleClass as string);\n    }\n\n    enter() {\n        if (this.enterActiveClass) {\n            if (!this.animating) {\n                this.animating = true;\n\n                if (this.enterActiveClass === 'slidedown') {\n                    (this.target as HTMLElement).style.height = '0px';\n                    DomHandler.removeClass(this.target, 'hidden');\n                    (this.target as HTMLElement).style.maxHeight = (this.target as HTMLElement).scrollHeight + 'px';\n                    DomHandler.addClass(this.target, 'hidden');\n                    (this.target as HTMLElement).style.height = '';\n                }\n\n                DomHandler.addClass(this.target, this.enterActiveClass);\n                if (this.enterClass || this.enterFromClass) {\n                    DomHandler.removeClass(this.target, this.enterClass || this.enterFromClass);\n                }\n\n                this.enterListener = this.renderer.listen(this.target, 'animationend', () => {\n                    DomHandler.removeClass(this.target, this.enterActiveClass as string);\n                    if (this.enterToClass) {\n                        DomHandler.addClass(this.target, this.enterToClass);\n                    }\n                    this.enterListener && this.enterListener();\n\n                    if (this.enterActiveClass === 'slidedown') {\n                        (this.target as HTMLElement).style.maxHeight = '';\n                    }\n                    this.animating = false;\n                });\n            }\n        } else {\n            if (this.enterClass || this.enterFromClass) {\n                DomHandler.removeClass(this.target, this.enterClass || this.enterFromClass);\n            }\n\n            if (this.enterToClass) {\n                DomHandler.addClass(this.target, this.enterToClass);\n            }\n        }\n\n        if (this.hideOnOutsideClick) {\n            this.bindDocumentClickListener();\n        }\n\n        if (this.hideOnEscape) {\n            this.bindDocumentKeydownListener();\n        }\n    }\n\n    leave() {\n        if (this.leaveActiveClass) {\n            if (!this.animating) {\n                this.animating = true;\n                DomHandler.addClass(this.target, this.leaveActiveClass);\n                if (this.leaveClass || this.leaveFromClass) {\n                    DomHandler.removeClass(this.target, this.leaveClass || this.leaveFromClass);\n                }\n\n                this.leaveListener = this.renderer.listen(this.target, 'animationend', () => {\n                    DomHandler.removeClass(this.target, this.leaveActiveClass as string);\n                    if (this.leaveToClass) {\n                        DomHandler.addClass(this.target, this.leaveToClass);\n                    }\n                    this.leaveListener && this.leaveListener();\n                    this.animating = false;\n                });\n            }\n        } else {\n            if (this.leaveClass || this.leaveFromClass) {\n                DomHandler.removeClass(this.target, this.leaveClass || this.leaveFromClass);\n            }\n\n            if (this.leaveToClass) {\n                DomHandler.addClass(this.target, this.leaveToClass);\n            }\n        }\n\n        if (this.hideOnOutsideClick) {\n            this.unbindDocumentClickListener();\n        }\n\n        if (this.hideOnEscape) {\n            this.unbindDocumentKeydownListener();\n        }\n    }\n\n    resolveTarget() {\n        if (this.target) {\n            return this.target;\n        }\n\n        switch (this.selector) {\n            case '@next':\n                return this.el.nativeElement.nextElementSibling;\n\n            case '@prev':\n                return this.el.nativeElement.previousElementSibling;\n\n            case '@parent':\n                return this.el.nativeElement.parentElement;\n\n            case '@grandparent':\n                return this.el.nativeElement.parentElement.parentElement;\n\n            default:\n                return document.querySelector(this.selector as string);\n        }\n    }\n\n    bindDocumentClickListener() {\n        if (!this.documentClickListener) {\n            this.documentClickListener = this.renderer.listen(this.el.nativeElement.ownerDocument, 'click', (event) => {\n                if (!this.isVisible() || getComputedStyle(this.target as HTMLElement).getPropertyValue('position') === 'static') this.unbindDocumentClickListener();\n                else if (this.isOutsideClick(event)) this.leave();\n            });\n        }\n    }\n\n    bindDocumentKeydownListener() {\n        if (!this.documentKeydownListener) {\n            this.zone.runOutsideAngular(() => {\n                this.documentKeydownListener = this.renderer.listen(this.el.nativeElement.ownerDocument, 'keydown', (event) => {\n                    const { key, keyCode, which, type } = event;\n                    if (!this.isVisible() || getComputedStyle(this.target as HTMLElement).getPropertyValue('position') === 'static') this.unbindDocumentKeydownListener();\n                    if (this.isVisible() && key === 'Escape' && keyCode === 27 && which === 27) this.leave();\n                });\n            });\n        }\n    }\n\n    isVisible() {\n        return (this.target as HTMLElement).offsetParent !== null;\n    }\n\n    isOutsideClick(event: MouseEvent) {\n        return !this.el.nativeElement.isSameNode(event.target) && !this.el.nativeElement.contains(event.target) && !(this.target as HTMLElement).contains(<HTMLElement>event.target);\n    }\n\n    unbindDocumentClickListener() {\n        if (this.documentClickListener) {\n            this.documentClickListener();\n            this.documentClickListener = null;\n        }\n    }\n\n    unbindDocumentKeydownListener() {\n        if (this.documentKeydownListener) {\n            this.documentKeydownListener();\n            this.documentKeydownListener = null;\n        }\n    }\n\n    ngOnDestroy() {\n        this.target = null;\n        if (this.eventListener) {\n            this.eventListener();\n        }\n        this.unbindDocumentClickListener();\n        this.unbindDocumentKeydownListener();\n    }\n}\n\n@NgModule({\n    imports: [CommonModule],\n    exports: [StyleClass],\n    declarations: [StyleClass]\n})\nexport class StyleClassModule {}\n"]}

package/esm2022/table/cax-design-system-table.mjs

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

package/esm2022/table/columnfilter.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/table/components/cell-editor/cell-editor.mjs

@@ -0,0 +1,52 @@
+import { CommonModule } from '@angular/common';
+import { Component, ViewEncapsulation, ContentChildren, Optional } from '@angular/core';
+import { CaxTemplate } from 'cax-design-system/api';
+import * as i0 from "@angular/core";
+import * as i1 from "../../table";
+import * as i2 from "../../directives/editable-column.directive";
+import * as i3 from "../../directives/editable-row.directive";
+import * as i4 from "@angular/common";
+export class CellEditor {
+    dt;
+    editableColumn;
+    editableRow;
+    templates;
+    inputTemplate;
+    outputTemplate;
+    constructor(dt, editableColumn, editableRow) {
+        this.dt = dt;
+        this.editableColumn = editableColumn;
+        this.editableRow = editableRow;
+    }
+    ngAfterContentInit() {
+        this.templates.forEach((item) => {
+            switch (item.getType()) {
+                case 'input':
+                    this.inputTemplate = item.template;
+                    break;
+                case 'output':
+                    this.outputTemplate = item.template;
+                    break;
+            }
+        });
+    }
+    get editing() {
+        return (this.dt.editingCell && this.editableColumn && this.dt.editingCell === this.editableColumn.el.nativeElement) || (this.editableRow && this.dt.editMode === 'row' && this.dt.isRowEditing(this.editableRow.data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CellEditor, deps: [{ token: i1.Table }, { token: i2.EditableColumn, optional: true }, { token: i3.EditableRow, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: CellEditor, isStandalone: true, selector: "cax-cellEditor", host: { classAttribute: "cax-element" }, queries: [{ propertyName: "templates", predicate: CaxTemplate }], ngImport: i0, template: "<ng-container *ngIf=\"editing\">\r\n    <ng-container *ngTemplateOutlet=\"inputTemplate\"></ng-container>\r\n</ng-container>\r\n<ng-container *ngIf=\"!editing\">\r\n    <ng-container *ngTemplateOutlet=\"outputTemplate\"></ng-container>\r\n</ng-container>\r\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CellEditor, decorators: [{
+            type: Component,
+            args: [{ selector: 'cax-cellEditor', encapsulation: ViewEncapsulation.None, standalone: true, imports: [CommonModule], host: {
+                        class: 'cax-element'
+                    }, template: "<ng-container *ngIf=\"editing\">\r\n    <ng-container *ngTemplateOutlet=\"inputTemplate\"></ng-container>\r\n</ng-container>\r\n<ng-container *ngIf=\"!editing\">\r\n    <ng-container *ngTemplateOutlet=\"outputTemplate\"></ng-container>\r\n</ng-container>\r\n" }]
+        }], ctorParameters: () => [{ type: i1.Table }, { type: i2.EditableColumn, decorators: [{
+                    type: Optional
+                }] }, { type: i3.EditableRow, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { templates: [{
+                type: ContentChildren,
+                args: [CaxTemplate]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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