cax-design-system 1.0.0

package/esm2022/table/directives/editable-column.directive.mjs

@@ -0,0 +1,344 @@
+import { Directive, Input, booleanAttribute, HostListener } from '@angular/core';
+import { DomHandler } from 'cax-design-system/dom';
+import * as i0 from "@angular/core";
+import * as i1 from "../table";
+export class EditableColumn {
+    dt;
+    el;
+    zone;
+    data;
+    field;
+    rowIndex;
+    caxEditableColumnDisabled;
+    pFocusCellSelector;
+    overlayEventListener;
+    constructor(dt, el, zone) {
+        this.dt = dt;
+        this.el = el;
+        this.zone = zone;
+    }
+    ngOnChanges(changes) {
+        if (changes.caxEditableColumnDisabled?.currentValue === true && DomHandler.hasClass(this.el.nativeElement, 'cax-cell-editing')) {
+            this.closeEditingCell(false, new Event('cancel'));
+        }
+        else if (changes.data?.firstChange === false && this.el.nativeElement) {
+            this.dt.updateEditingCell(this.el.nativeElement, this.data, this.field, this.rowIndex);
+        }
+    }
+    ngAfterViewInit() {
+        if (this.isEnabled()) {
+            DomHandler.addClass(this.el.nativeElement, 'cax-editable-column');
+        }
+    }
+    onClick(event) {
+        if (this.isEnabled()) {
+            this.dt.selfClick = true;
+            if (this.dt.editingCell) {
+                if (this.dt.editingCell !== this.el.nativeElement) {
+                    if (!this.dt.isEditingCellValid()) {
+                        return;
+                    }
+                    this.closeEditingCell(true, event);
+                    this.openCell();
+                }
+            }
+            else {
+                this.openCell();
+            }
+        }
+    }
+    openCell() {
+        this.dt.updateEditingCell(this.el.nativeElement, this.data, this.field, this.rowIndex);
+        DomHandler.addClass(this.el.nativeElement, 'cax-cell-editing');
+        this.dt.onEditInit.emit({ field: this.field, data: this.data, index: this.rowIndex });
+        this.zone.runOutsideAngular(() => {
+            setTimeout(() => {
+                let focusCellSelector = this.pFocusCellSelector || 'input, textarea, select';
+                let focusableElement = DomHandler.findSingle(this.el.nativeElement, focusCellSelector);
+                if (focusableElement) {
+                    focusableElement.focus();
+                }
+            }, 50);
+        });
+        this.overlayEventListener = (e) => {
+            if (this.el && this.el.nativeElement.contains(e.target)) {
+                this.dt.selfClick = true;
+            }
+        };
+        this.dt.overlaySubscription = this.dt.overlayService.clickObservable.subscribe(this.overlayEventListener);
+    }
+    closeEditingCell(completed, event) {
+        const eventData = { field: this.dt.editingCellField, data: this.dt.editingCellData, originalEvent: event, index: this.dt.editingCellRowIndex };
+        if (completed) {
+            this.dt.onEditComplete.emit(eventData);
+        }
+        else {
+            this.dt.onEditCancel.emit(eventData);
+            this.dt.value.forEach((element) => {
+                if (element[this.dt.editingCellField] === this.data) {
+                    element[this.dt.editingCellField] = this.dt.editingCellData;
+                }
+            });
+        }
+        DomHandler.removeClass(this.dt.editingCell, 'cax-cell-editing');
+        this.dt.editingCell = null;
+        this.dt.editingCellData = null;
+        this.dt.editingCellField = null;
+        this.dt.unbindDocumentEditListener();
+        if (this.dt.overlaySubscription) {
+            this.dt.overlaySubscription.unsubscribe();
+        }
+    }
+    onEnterKeyDown(event) {
+        if (this.isEnabled() && !event.shiftKey) {
+            if (this.dt.isEditingCellValid()) {
+                this.closeEditingCell(true, event);
+            }
+            event.preventDefault();
+        }
+    }
+    onTabKeyDown(event) {
+        if (this.isEnabled()) {
+            if (this.dt.isEditingCellValid()) {
+                this.closeEditingCell(true, event);
+            }
+            event.preventDefault();
+        }
+    }
+    onEscapeKeyDown(event) {
+        if (this.isEnabled()) {
+            if (this.dt.isEditingCellValid()) {
+                this.closeEditingCell(false, event);
+            }
+            event.preventDefault();
+        }
+    }
+    onShiftKeyDown(event) {
+        if (this.isEnabled()) {
+            if (event.shiftKey)
+                this.moveToPreviousCell(event);
+            else {
+                this.moveToNextCell(event);
+            }
+        }
+    }
+    onArrowDown(event) {
+        if (this.isEnabled()) {
+            let currentCell = this.findCell(event.target);
+            if (currentCell) {
+                let cellIndex = DomHandler.index(currentCell);
+                let targetCell = this.findNextEditableColumnByIndex(currentCell, cellIndex);
+                if (targetCell) {
+                    if (this.dt.isEditingCellValid()) {
+                        this.closeEditingCell(true, event);
+                    }
+                    DomHandler.invokeElementMethod(event.target, 'blur');
+                    DomHandler.invokeElementMethod(targetCell, 'click');
+                }
+                event.preventDefault();
+            }
+        }
+    }
+    onArrowUp(event) {
+        if (this.isEnabled()) {
+            let currentCell = this.findCell(event.target);
+            if (currentCell) {
+                let cellIndex = DomHandler.index(currentCell);
+                let targetCell = this.findPrevEditableColumnByIndex(currentCell, cellIndex);
+                if (targetCell) {
+                    if (this.dt.isEditingCellValid()) {
+                        this.closeEditingCell(true, event);
+                    }
+                    DomHandler.invokeElementMethod(event.target, 'blur');
+                    DomHandler.invokeElementMethod(targetCell, 'click');
+                }
+                event.preventDefault();
+            }
+        }
+    }
+    onArrowLeft(event) {
+        if (this.isEnabled()) {
+            this.moveToPreviousCell(event);
+        }
+    }
+    onArrowRight(event) {
+        if (this.isEnabled()) {
+            this.moveToNextCell(event);
+        }
+    }
+    findCell(element) {
+        if (element) {
+            let cell = element;
+            while (cell && !DomHandler.hasClass(cell, 'cax-cell-editing')) {
+                cell = cell.parentElement;
+            }
+            return cell;
+        }
+        else {
+            return null;
+        }
+    }
+    moveToPreviousCell(event) {
+        let currentCell = this.findCell(event.target);
+        if (currentCell) {
+            let targetCell = this.findPreviousEditableColumn(currentCell);
+            if (targetCell) {
+                if (this.dt.isEditingCellValid()) {
+                    this.closeEditingCell(true, event);
+                }
+                DomHandler.invokeElementMethod(event.target, 'blur');
+                DomHandler.invokeElementMethod(targetCell, 'click');
+                event.preventDefault();
+            }
+        }
+    }
+    moveToNextCell(event) {
+        let currentCell = this.findCell(event.target);
+        if (currentCell) {
+            let targetCell = this.findNextEditableColumn(currentCell);
+            if (targetCell) {
+                if (this.dt.isEditingCellValid()) {
+                    this.closeEditingCell(true, event);
+                }
+                DomHandler.invokeElementMethod(event.target, 'blur');
+                DomHandler.invokeElementMethod(targetCell, 'click');
+                event.preventDefault();
+            }
+            else {
+                if (this.dt.isEditingCellValid()) {
+                    this.closeEditingCell(true, event);
+                }
+            }
+        }
+    }
+    findPreviousEditableColumn(cell) {
+        let prevCell = cell.previousElementSibling;
+        if (!prevCell) {
+            let previousRow = cell.parentElement?.previousElementSibling;
+            if (previousRow) {
+                prevCell = previousRow.lastElementChild;
+            }
+        }
+        if (prevCell) {
+            if (DomHandler.hasClass(prevCell, 'cax-editable-column'))
+                return prevCell;
+            else
+                return this.findPreviousEditableColumn(prevCell);
+        }
+        else {
+            return null;
+        }
+    }
+    findNextEditableColumn(cell) {
+        let nextCell = cell.nextElementSibling;
+        if (!nextCell) {
+            let nextRow = cell.parentElement?.nextElementSibling;
+            if (nextRow) {
+                nextCell = nextRow.firstElementChild;
+            }
+        }
+        if (nextCell) {
+            if (DomHandler.hasClass(nextCell, 'cax-editable-column'))
+                return nextCell;
+            else
+                return this.findNextEditableColumn(nextCell);
+        }
+        else {
+            return null;
+        }
+    }
+    findNextEditableColumnByIndex(cell, index) {
+        let nextRow = cell.parentElement?.nextElementSibling;
+        if (nextRow) {
+            let nextCell = nextRow.children[index];
+            if (nextCell && DomHandler.hasClass(nextCell, 'cax-editable-column')) {
+                return nextCell;
+            }
+            return null;
+        }
+        else {
+            return null;
+        }
+    }
+    findPrevEditableColumnByIndex(cell, index) {
+        let prevRow = cell.parentElement?.previousElementSibling;
+        if (prevRow) {
+            let prevCell = prevRow.children[index];
+            if (prevCell && DomHandler.hasClass(prevCell, 'cax-editable-column')) {
+                return prevCell;
+            }
+            return null;
+        }
+        else {
+            return null;
+        }
+    }
+    isEnabled() {
+        return this.caxEditableColumnDisabled !== true;
+    }
+    ngOnDestroy() {
+        if (this.dt.overlaySubscription) {
+            this.dt.overlaySubscription.unsubscribe();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: EditableColumn, deps: [{ token: i1.Table }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.9", type: EditableColumn, isStandalone: true, selector: "[caxEditableColumn]", inputs: { data: ["caxEditableColumn", "data"], field: ["caxEditableColumnField", "field"], rowIndex: ["caxEditableColumnRowIndex", "rowIndex"], caxEditableColumnDisabled: ["caxEditableColumnDisabled", "caxEditableColumnDisabled", booleanAttribute], pFocusCellSelector: "pFocusCellSelector" }, host: { listeners: { "click": "onClick($event)", "keydown.enter": "onEnterKeyDown($event)", "keydown.tab": "onShiftKeyDown($event)", "keydown.escape": "onEscapeKeyDown($event)", "keydown.shift.tab": "onShiftKeyDown($event)", "keydown.meta.tab": "onShiftKeyDown($event)", "keydown.arrowdown": "onArrowDown($event)", "keydown.arrowup": "onArrowUp($event)", "keydown.arrowleft": "onArrowLeft($event)", "keydown.arrowright": "onArrowRight($event)" }, classAttribute: "cax-element" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: EditableColumn, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[caxEditableColumn]',
+                    standalone: true,
+                    host: {
+                        class: 'cax-element'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i1.Table }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { data: [{
+                type: Input,
+                args: ['caxEditableColumn']
+            }], field: [{
+                type: Input,
+                args: ['caxEditableColumnField']
+            }], rowIndex: [{
+                type: Input,
+                args: ['caxEditableColumnRowIndex']
+            }], caxEditableColumnDisabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], pFocusCellSelector: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], onEnterKeyDown: [{
+                type: HostListener,
+                args: ['keydown.enter', ['$event']]
+            }], onTabKeyDown: [{
+                type: HostListener,
+                args: ['keydown.tab', ['$event']]
+            }], onEscapeKeyDown: [{
+                type: HostListener,
+                args: ['keydown.escape', ['$event']]
+            }], onShiftKeyDown: [{
+                type: HostListener,
+                args: ['keydown.tab', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keydown.shift.tab', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keydown.meta.tab', ['$event']]
+            }], onArrowDown: [{
+                type: HostListener,
+                args: ['keydown.arrowdown', ['$event']]
+            }], onArrowUp: [{
+                type: HostListener,
+                args: ['keydown.arrowup', ['$event']]
+            }], onArrowLeft: [{
+                type: HostListener,
+                args: ['keydown.arrowleft', ['$event']]
+            }], onArrowRight: [{
+                type: HostListener,
+                args: ['keydown.arrowright', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editable-column.directive.js","sourceRoot":"","sources":["../../../../src/app/components/table/directives/editable-column.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAuC,KAAK,EAAE,gBAAgB,EAAqC,YAAY,EAAE,MAAM,eAAe,CAAC;AACzJ,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;;;AAUnD,MAAM,OAAO,cAAc;IAcZ;IACA;IACA;IAfiB,IAAI,CAAM;IAEL,KAAK,CAAM;IAER,QAAQ,CAAqB;IAEzB,yBAAyB,CAAsB;IAE9E,kBAAkB,CAAqB;IAEhD,oBAAoB,CAAM;IAE1B,YACW,EAAS,EACT,EAAc,EACd,IAAY;QAFZ,OAAE,GAAF,EAAE,CAAO;QACT,OAAE,GAAF,EAAE,CAAY;QACd,SAAI,GAAJ,IAAI,CAAQ;IACpB,CAAC;IAEG,WAAW,CAAC,OAAsB;QACrC,IAAI,OAAO,CAAC,yBAAyB,EAAE,YAAY,KAAK,IAAI,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE,kBAAkB,CAAC,EAAE,CAAC;YAC7H,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;QACtD,CAAC;aAAM,IAAI,OAAO,CAAC,IAAI,EAAE,WAAW,KAAK,KAAK,IAAI,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE,CAAC;YACtE,IAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,EAAU,IAAI,CAAC,QAAQ,CAAC,CAAC;QACnG,CAAC;IACL,CAAC;IAED,eAAe;QACX,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACnB,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE,qBAAqB,CAAC,CAAC;QACtE,CAAC;IACL,CAAC;IAGD,OAAO,CAAC,KAAiB;QACrB,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACnB,IAAI,CAAC,EAAE,CAAC,SAAS,GAAG,IAAI,CAAC;YAEzB,IAAI,IAAI,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC;gBACtB,IAAI,IAAI,CAAC,EAAE,CAAC,WAAW,KAAK,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE,CAAC;oBAChD,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC;wBAChC,OAAO;oBACX,CAAC;oBAED,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;oBACnC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACpB,CAAC;YACL,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,QAAQ,EAAE,CAAC;YACpB,CAAC;QACL,CAAC;IACL,CAAC;IAED,QAAQ;QACJ,IAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,EAAU,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/F,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC;QAC/D,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,KAAK,EAAU,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC9F,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC7B,UAAU,CAAC,GAAG,EAAE;gBACZ,IAAI,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,IAAI,yBAAyB,CAAC;gBAC7E,IAAI,gBAAgB,GAAG,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;gBAEvF,IAAI,gBAAgB,EAAE,CAAC;oBACnB,gBAAgB,CAAC,KAAK,EAAE,CAAC;gBAC7B,CAAC;YACL,CAAC,EAAE,EAAE,CAAC,CAAC;QACX,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,oBAAoB,GAAG,CAAC,CAAM,EAAE,EAAE;YACnC,IAAI,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC;gBACtD,IAAI,CAAC,EAAE,CAAC,SAAS,GAAG,IAAI,CAAC;YAC7B,CAAC;QACL,CAAC,CAAC;QAEF,IAAI,CAAC,EAAE,CAAC,mBAAmB,GAAG,IAAI,CAAC,EAAE,CAAC,cAAc,CAAC,eAAe,CAAC,SAAS,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAC9G,CAAC;IAED,gBAAgB,CAAC,SAAc,EAAE,KAAY;QACzC,MAAM,SAAS,GAAG,EAAE,KAAK,EAAU,IAAI,CAAC,EAAE,CAAC,gBAAgB,EAAE,IAAI,EAAO,IAAI,CAAC,EAAE,CAAC,eAAe,EAAE,aAAa,EAAS,KAAK,EAAE,KAAK,EAAU,IAAI,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC;QAE3K,IAAI,SAAS,EAAE,CAAC;YACZ,IAAI,CAAC,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC3C,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAErC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC9B,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;oBAClD,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,eAAe,CAAC;gBAChE,CAAC;YACL,CAAC,CAAC,CAAC;QACP,CAAC;QAED,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,WAAW,EAAE,kBAAkB,CAAC,CAAC;QAChE,IAAI,CAAC,EAAE,CAAC,WAAW,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,EAAE,CAAC,eAAe,GAAG,IAAI,CAAC;QAC/B,IAAI,CAAC,EAAE,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAChC,IAAI,CAAC,EAAE,CAAC,0BAA0B,EAAE,CAAC;QAErC,IAAI,IAAI,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC;YAC9B,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC;QAC9C,CAAC;IACL,CAAC;IAGD,cAAc,CAAC,KAAoB;QAC/B,IAAI,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;YACtC,IAAI,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC;gBAC/B,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YACvC,CAAC;YAED,KAAK,CAAC,cAAc,EAAE,CAAC;QAC3B,CAAC;IACL,CAAC;IAGD,YAAY,CAAC,KAAoB;QAC7B,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACnB,IAAI,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC;gBAC/B,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YACvC,CAAC;YAED,KAAK,CAAC,cAAc,EAAE,CAAC;QAC3B,CAAC;IACL,CAAC;IAGD,eAAe,CAAC,KAAoB;QAChC,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACnB,IAAI,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC;gBAC/B,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YACxC,CAAC;YAED,KAAK,CAAC,cAAc,EAAE,CAAC;QAC3B,CAAC;IACL,CAAC;IAKD,cAAc,CAAC,KAAoB;QAC/B,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACnB,IAAI,KAAK,CAAC,QAAQ;gBAAE,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;iBAC9C,CAAC;gBACF,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC;QACL,CAAC;IACL,CAAC;IAED,WAAW,CAAC,KAAoB;QAC5B,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACnB,IAAI,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAC9C,IAAI,WAAW,EAAE,CAAC;gBACd,IAAI,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;gBAC9C,IAAI,UAAU,GAAG,IAAI,CAAC,6BAA6B,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;gBAE5E,IAAI,UAAU,EAAE,CAAC;oBACb,IAAI,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC;wBAC/B,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;oBACvC,CAAC;oBAED,UAAU,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;oBACrD,UAAU,CAAC,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBACxD,CAAC;gBAED,KAAK,CAAC,cAAc,EAAE,CAAC;YAC3B,CAAC;QACL,CAAC;IACL,CAAC;IAGD,SAAS,CAAC,KAAoB;QAC1B,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACnB,IAAI,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAC9C,IAAI,WAAW,EAAE,CAAC;gBACd,IAAI,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;gBAC9C,IAAI,UAAU,GAAG,IAAI,CAAC,6BAA6B,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;gBAE5E,IAAI,UAAU,EAAE,CAAC;oBACb,IAAI,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC;wBAC/B,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;oBACvC,CAAC;oBAED,UAAU,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;oBACrD,UAAU,CAAC,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBACxD,CAAC;gBAED,KAAK,CAAC,cAAc,EAAE,CAAC;YAC3B,CAAC;QACL,CAAC;IACL,CAAC;IAGD,WAAW,CAAC,KAAoB;QAC5B,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACnB,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC;IACL,CAAC;IAGD,YAAY,CAAC,KAAoB;QAC7B,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACnB,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;IACL,CAAC;IAED,QAAQ,CAAC,OAAY;QACjB,IAAI,OAAO,EAAE,CAAC;YACV,IAAI,IAAI,GAAG,OAAO,CAAC;YACnB,OAAO,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC,EAAE,CAAC;gBAC5D,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC;YAC9B,CAAC;YAED,OAAO,IAAI,CAAC;QAChB,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;IAED,kBAAkB,CAAC,KAAoB;QACnC,IAAI,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC9C,IAAI,WAAW,EAAE,CAAC;YACd,IAAI,UAAU,GAAG,IAAI,CAAC,0BAA0B,CAAC,WAAW,CAAC,CAAC;YAE9D,IAAI,UAAU,EAAE,CAAC;gBACb,IAAI,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC;oBAC/B,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBACvC,CAAC;gBAED,UAAU,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBACrD,UAAU,CAAC,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBACpD,KAAK,CAAC,cAAc,EAAE,CAAC;YAC3B,CAAC;QACL,CAAC;IACL,CAAC;IAED,cAAc,CAAC,KAAoB;QAC/B,IAAI,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC9C,IAAI,WAAW,EAAE,CAAC;YACd,IAAI,UAAU,GAAG,IAAI,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC;YAE1D,IAAI,UAAU,EAAE,CAAC;gBACb,IAAI,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC;oBAC/B,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBACvC,CAAC;gBAED,UAAU,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBACrD,UAAU,CAAC,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBACpD,KAAK,CAAC,cAAc,EAAE,CAAC;YAC3B,CAAC;iBAAM,CAAC;gBACJ,IAAI,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC;oBAC/B,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBACvC,CAAC;YACL,CAAC;QACL,CAAC;IACL,CAAC;IAED,0BAA0B,CAAC,IAAS;QAChC,IAAI,QAAQ,GAAG,IAAI,CAAC,sBAAsB,CAAC;QAE3C,IAAI,CAAC,QAAQ,EAAE,CAAC;YACZ,IAAI,WAAW,GAAG,IAAI,CAAC,aAAa,EAAE,sBAAsB,CAAC;YAC7D,IAAI,WAAW,EAAE,CAAC;gBACd,QAAQ,GAAG,WAAW,CAAC,gBAAgB,CAAC;YAC5C,CAAC;QACL,CAAC;QAED,IAAI,QAAQ,EAAE,CAAC;YACX,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC;gBAAE,OAAO,QAAQ,CAAC;;gBACrE,OAAO,IAAI,CAAC,0BAA0B,CAAC,QAAQ,CAAC,CAAC;QAC1D,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;IAED,sBAAsB,CAAC,IAAS;QAC5B,IAAI,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC;QAEvC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACZ,IAAI,OAAO,GAAG,IAAI,CAAC,aAAa,EAAE,kBAAkB,CAAC;YACrD,IAAI,OAAO,EAAE,CAAC;gBACV,QAAQ,GAAG,OAAO,CAAC,iBAAiB,CAAC;YACzC,CAAC;QACL,CAAC;QAED,IAAI,QAAQ,EAAE,CAAC;YACX,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC;gBAAE,OAAO,QAAQ,CAAC;;gBACrE,OAAO,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC;QACtD,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;IAED,6BAA6B,CAAC,IAAa,EAAE,KAAa;QACtD,IAAI,OAAO,GAAG,IAAI,CAAC,aAAa,EAAE,kBAAkB,CAAC;QAErD,IAAI,OAAO,EAAE,CAAC;YACV,IAAI,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAEvC,IAAI,QAAQ,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC,EAAE,CAAC;gBACnE,OAAO,QAAQ,CAAC;YACpB,CAAC;YAED,OAAO,IAAI,CAAC;QAChB,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;IAED,6BAA6B,CAAC,IAAa,EAAE,KAAa;QACtD,IAAI,OAAO,GAAG,IAAI,CAAC,aAAa,EAAE,sBAAsB,CAAC;QAEzD,IAAI,OAAO,EAAE,CAAC;YACV,IAAI,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAEvC,IAAI,QAAQ,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC,EAAE,CAAC;gBACnE,OAAO,QAAQ,CAAC;YACpB,CAAC;YAED,OAAO,IAAI,CAAC;QAChB,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;IAED,SAAS;QACL,OAAO,IAAI,CAAC,yBAAyB,KAAK,IAAI,CAAC;IACnD,CAAC;IAED,WAAW;QACP,IAAI,IAAI,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC;YAC9B,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC;QAC9C,CAAC;IACL,CAAC;uGA5UQ,cAAc;2FAAd,cAAc,6RAOH,gBAAgB;;2FAP3B,cAAc;kBAP1B,SAAS;mBAAC;oBACP,QAAQ,EAAE,qBAAqB;oBAC/B,UAAU,EAAE,IAAI;oBAChB,IAAI,EAAE;wBACF,KAAK,EAAE,aAAa;qBACvB;iBACJ;wHAE+B,IAAI;sBAA/B,KAAK;uBAAC,mBAAmB;gBAEO,KAAK;sBAArC,KAAK;uBAAC,wBAAwB;gBAEK,QAAQ;sBAA3C,KAAK;uBAAC,2BAA2B;gBAEM,yBAAyB;sBAAhE,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAE7B,kBAAkB;sBAA1B,KAAK;gBAyBN,OAAO;sBADN,YAAY;uBAAC,OAAO,EAAE,CAAC,QAAQ,CAAC;gBAuEjC,cAAc;sBADb,YAAY;uBAAC,eAAe,EAAE,CAAC,QAAQ,CAAC;gBAYzC,YAAY;sBADX,YAAY;uBAAC,aAAa,EAAE,CAAC,QAAQ,CAAC;gBAYvC,eAAe;sBADd,YAAY;uBAAC,gBAAgB,EAAE,CAAC,QAAQ,CAAC;gBAc1C,cAAc;sBAHb,YAAY;uBAAC,aAAa,EAAE,CAAC,QAAQ,CAAC;;sBACtC,YAAY;uBAAC,mBAAmB,EAAE,CAAC,QAAQ,CAAC;;sBAC5C,YAAY;uBAAC,kBAAkB,EAAE,CAAC,QAAQ,CAAC;gBAU5C,WAAW;sBADV,YAAY;uBAAC,mBAAmB,EAAE,CAAC,QAAQ,CAAC;gBAuB7C,SAAS;sBADR,YAAY;uBAAC,iBAAiB,EAAE,CAAC,QAAQ,CAAC;gBAuB3C,WAAW;sBADV,YAAY;uBAAC,mBAAmB,EAAE,CAAC,QAAQ,CAAC;gBAQ7C,YAAY;sBADX,YAAY;uBAAC,oBAAoB,EAAE,CAAC,QAAQ,CAAC","sourcesContent":["import { Directive, OnChanges, AfterViewInit, OnDestroy, Input, booleanAttribute, ElementRef, NgZone, SimpleChanges, HostListener } from '@angular/core';\nimport { DomHandler } from 'cax-design-system/dom';\nimport { Table } from '../table';\n\n@Directive({\n    selector: '[caxEditableColumn]',\n    standalone: true,\n    host: {\n        class: 'cax-element'\n    }\n})\nexport class EditableColumn implements OnChanges, AfterViewInit, OnDestroy {\n    @Input('caxEditableColumn') data: any;\n\n    @Input('caxEditableColumnField') field: any;\n\n    @Input('caxEditableColumnRowIndex') rowIndex: number | undefined;\n\n    @Input({ transform: booleanAttribute }) caxEditableColumnDisabled: boolean | undefined;\n\n    @Input() pFocusCellSelector: string | undefined;\n\n    overlayEventListener: any;\n\n    constructor(\n        public dt: Table,\n        public el: ElementRef,\n        public zone: NgZone\n    ) {}\n\n    public ngOnChanges(changes: SimpleChanges): void {\n        if (changes.caxEditableColumnDisabled?.currentValue === true && DomHandler.hasClass(this.el.nativeElement, 'cax-cell-editing')) {\n            this.closeEditingCell(false, new Event('cancel'));\n        } else if (changes.data?.firstChange === false && this.el.nativeElement) {\n            this.dt.updateEditingCell(this.el.nativeElement, this.data, this.field, <number>this.rowIndex);\n        }\n    }\n\n    ngAfterViewInit() {\n        if (this.isEnabled()) {\n            DomHandler.addClass(this.el.nativeElement, 'cax-editable-column');\n        }\n    }\n\n    @HostListener('click', ['$event'])\n    onClick(event: MouseEvent) {\n        if (this.isEnabled()) {\n            this.dt.selfClick = true;\n\n            if (this.dt.editingCell) {\n                if (this.dt.editingCell !== this.el.nativeElement) {\n                    if (!this.dt.isEditingCellValid()) {\n                        return;\n                    }\n\n                    this.closeEditingCell(true, event);\n                    this.openCell();\n                }\n            } else {\n                this.openCell();\n            }\n        }\n    }\n\n    openCell() {\n        this.dt.updateEditingCell(this.el.nativeElement, this.data, this.field, <number>this.rowIndex);\n        DomHandler.addClass(this.el.nativeElement, 'cax-cell-editing');\n        this.dt.onEditInit.emit({ field: this.field, data: this.data, index: <number>this.rowIndex });\n        this.zone.runOutsideAngular(() => {\n            setTimeout(() => {\n                let focusCellSelector = this.pFocusCellSelector || 'input, textarea, select';\n                let focusableElement = DomHandler.findSingle(this.el.nativeElement, focusCellSelector);\n\n                if (focusableElement) {\n                    focusableElement.focus();\n                }\n            }, 50);\n        });\n\n        this.overlayEventListener = (e: any) => {\n            if (this.el && this.el.nativeElement.contains(e.target)) {\n                this.dt.selfClick = true;\n            }\n        };\n\n        this.dt.overlaySubscription = this.dt.overlayService.clickObservable.subscribe(this.overlayEventListener);\n    }\n\n    closeEditingCell(completed: any, event: Event) {\n        const eventData = { field: <string>this.dt.editingCellField, data: <any>this.dt.editingCellData, originalEvent: <Event>event, index: <number>this.dt.editingCellRowIndex };\n\n        if (completed) {\n            this.dt.onEditComplete.emit(eventData);\n        } else {\n            this.dt.onEditCancel.emit(eventData);\n\n            this.dt.value.forEach((element) => {\n                if (element[this.dt.editingCellField] === this.data) {\n                    element[this.dt.editingCellField] = this.dt.editingCellData;\n                }\n            });\n        }\n\n        DomHandler.removeClass(this.dt.editingCell, 'cax-cell-editing');\n        this.dt.editingCell = null;\n        this.dt.editingCellData = null;\n        this.dt.editingCellField = null;\n        this.dt.unbindDocumentEditListener();\n\n        if (this.dt.overlaySubscription) {\n            this.dt.overlaySubscription.unsubscribe();\n        }\n    }\n\n    @HostListener('keydown.enter', ['$event'])\n    onEnterKeyDown(event: KeyboardEvent) {\n        if (this.isEnabled() && !event.shiftKey) {\n            if (this.dt.isEditingCellValid()) {\n                this.closeEditingCell(true, event);\n            }\n\n            event.preventDefault();\n        }\n    }\n\n    @HostListener('keydown.tab', ['$event'])\n    onTabKeyDown(event: KeyboardEvent) {\n        if (this.isEnabled()) {\n            if (this.dt.isEditingCellValid()) {\n                this.closeEditingCell(true, event);\n            }\n\n            event.preventDefault();\n        }\n    }\n\n    @HostListener('keydown.escape', ['$event'])\n    onEscapeKeyDown(event: KeyboardEvent) {\n        if (this.isEnabled()) {\n            if (this.dt.isEditingCellValid()) {\n                this.closeEditingCell(false, event);\n            }\n\n            event.preventDefault();\n        }\n    }\n\n    @HostListener('keydown.tab', ['$event'])\n    @HostListener('keydown.shift.tab', ['$event'])\n    @HostListener('keydown.meta.tab', ['$event'])\n    onShiftKeyDown(event: KeyboardEvent) {\n        if (this.isEnabled()) {\n            if (event.shiftKey) this.moveToPreviousCell(event);\n            else {\n                this.moveToNextCell(event);\n            }\n        }\n    }\n    @HostListener('keydown.arrowdown', ['$event'])\n    onArrowDown(event: KeyboardEvent) {\n        if (this.isEnabled()) {\n            let currentCell = this.findCell(event.target);\n            if (currentCell) {\n                let cellIndex = DomHandler.index(currentCell);\n                let targetCell = this.findNextEditableColumnByIndex(currentCell, cellIndex);\n\n                if (targetCell) {\n                    if (this.dt.isEditingCellValid()) {\n                        this.closeEditingCell(true, event);\n                    }\n\n                    DomHandler.invokeElementMethod(event.target, 'blur');\n                    DomHandler.invokeElementMethod(targetCell, 'click');\n                }\n\n                event.preventDefault();\n            }\n        }\n    }\n\n    @HostListener('keydown.arrowup', ['$event'])\n    onArrowUp(event: KeyboardEvent) {\n        if (this.isEnabled()) {\n            let currentCell = this.findCell(event.target);\n            if (currentCell) {\n                let cellIndex = DomHandler.index(currentCell);\n                let targetCell = this.findPrevEditableColumnByIndex(currentCell, cellIndex);\n\n                if (targetCell) {\n                    if (this.dt.isEditingCellValid()) {\n                        this.closeEditingCell(true, event);\n                    }\n\n                    DomHandler.invokeElementMethod(event.target, 'blur');\n                    DomHandler.invokeElementMethod(targetCell, 'click');\n                }\n\n                event.preventDefault();\n            }\n        }\n    }\n\n    @HostListener('keydown.arrowleft', ['$event'])\n    onArrowLeft(event: KeyboardEvent) {\n        if (this.isEnabled()) {\n            this.moveToPreviousCell(event);\n        }\n    }\n\n    @HostListener('keydown.arrowright', ['$event'])\n    onArrowRight(event: KeyboardEvent) {\n        if (this.isEnabled()) {\n            this.moveToNextCell(event);\n        }\n    }\n\n    findCell(element: any) {\n        if (element) {\n            let cell = element;\n            while (cell && !DomHandler.hasClass(cell, 'cax-cell-editing')) {\n                cell = cell.parentElement;\n            }\n\n            return cell;\n        } else {\n            return null;\n        }\n    }\n\n    moveToPreviousCell(event: KeyboardEvent) {\n        let currentCell = this.findCell(event.target);\n        if (currentCell) {\n            let targetCell = this.findPreviousEditableColumn(currentCell);\n\n            if (targetCell) {\n                if (this.dt.isEditingCellValid()) {\n                    this.closeEditingCell(true, event);\n                }\n\n                DomHandler.invokeElementMethod(event.target, 'blur');\n                DomHandler.invokeElementMethod(targetCell, 'click');\n                event.preventDefault();\n            }\n        }\n    }\n\n    moveToNextCell(event: KeyboardEvent) {\n        let currentCell = this.findCell(event.target);\n        if (currentCell) {\n            let targetCell = this.findNextEditableColumn(currentCell);\n\n            if (targetCell) {\n                if (this.dt.isEditingCellValid()) {\n                    this.closeEditingCell(true, event);\n                }\n\n                DomHandler.invokeElementMethod(event.target, 'blur');\n                DomHandler.invokeElementMethod(targetCell, 'click');\n                event.preventDefault();\n            } else {\n                if (this.dt.isEditingCellValid()) {\n                    this.closeEditingCell(true, event);\n                }\n            }\n        }\n    }\n\n    findPreviousEditableColumn(cell: any): HTMLTableCellElement | null {\n        let prevCell = cell.previousElementSibling;\n\n        if (!prevCell) {\n            let previousRow = cell.parentElement?.previousElementSibling;\n            if (previousRow) {\n                prevCell = previousRow.lastElementChild;\n            }\n        }\n\n        if (prevCell) {\n            if (DomHandler.hasClass(prevCell, 'cax-editable-column')) return prevCell;\n            else return this.findPreviousEditableColumn(prevCell);\n        } else {\n            return null;\n        }\n    }\n\n    findNextEditableColumn(cell: any): HTMLTableCellElement | null {\n        let nextCell = cell.nextElementSibling;\n\n        if (!nextCell) {\n            let nextRow = cell.parentElement?.nextElementSibling;\n            if (nextRow) {\n                nextCell = nextRow.firstElementChild;\n            }\n        }\n\n        if (nextCell) {\n            if (DomHandler.hasClass(nextCell, 'cax-editable-column')) return nextCell;\n            else return this.findNextEditableColumn(nextCell);\n        } else {\n            return null;\n        }\n    }\n\n    findNextEditableColumnByIndex(cell: Element, index: number) {\n        let nextRow = cell.parentElement?.nextElementSibling;\n\n        if (nextRow) {\n            let nextCell = nextRow.children[index];\n\n            if (nextCell && DomHandler.hasClass(nextCell, 'cax-editable-column')) {\n                return nextCell;\n            }\n\n            return null;\n        } else {\n            return null;\n        }\n    }\n\n    findPrevEditableColumnByIndex(cell: Element, index: number) {\n        let prevRow = cell.parentElement?.previousElementSibling;\n\n        if (prevRow) {\n            let prevCell = prevRow.children[index];\n\n            if (prevCell && DomHandler.hasClass(prevCell, 'cax-editable-column')) {\n                return prevCell;\n            }\n\n            return null;\n        } else {\n            return null;\n        }\n    }\n\n    isEnabled() {\n        return this.caxEditableColumnDisabled !== true;\n    }\n\n    ngOnDestroy() {\n        if (this.dt.overlaySubscription) {\n            this.dt.overlaySubscription.unsubscribe();\n        }\n    }\n}\n"]}

package/esm2022/table/directives/editable-row.directive.mjs

@@ -0,0 +1,32 @@
+import { Directive, Input, booleanAttribute } from '@angular/core';
+import * as i0 from "@angular/core";
+export class EditableRow {
+    el;
+    data;
+    caxEditableRowDisabled;
+    constructor(el) {
+        this.el = el;
+    }
+    isEnabled() {
+        return this.caxEditableRowDisabled !== true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: EditableRow, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.9", type: EditableRow, isStandalone: true, selector: "[caxEditableRow]", inputs: { data: ["caxEditableRow", "data"], caxEditableRowDisabled: ["caxEditableRowDisabled", "caxEditableRowDisabled", booleanAttribute] }, host: { classAttribute: "cax-element" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: EditableRow, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[caxEditableRow]',
+                    standalone: true,
+                    host: {
+                        class: 'cax-element'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { data: [{
+                type: Input,
+                args: ['caxEditableRow']
+            }], caxEditableRowDisabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWRpdGFibGUtcm93LmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcHAvY29tcG9uZW50cy90YWJsZS9kaXJlY3RpdmVzL2VkaXRhYmxlLXJvdy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsZ0JBQWdCLEVBQWMsTUFBTSxlQUFlLENBQUM7O0FBUy9FLE1BQU0sT0FBTyxXQUFXO0lBS0Q7SUFKTSxJQUFJLENBQU07SUFFSyxzQkFBc0IsQ0FBc0I7SUFFcEYsWUFBbUIsRUFBYztRQUFkLE9BQUUsR0FBRixFQUFFLENBQVk7SUFBRyxDQUFDO0lBRXJDLFNBQVM7UUFDTCxPQUFPLElBQUksQ0FBQyxzQkFBc0IsS0FBSyxJQUFJLENBQUM7SUFDaEQsQ0FBQzt1R0FUUSxXQUFXOzJGQUFYLFdBQVcsNktBR0EsZ0JBQWdCOzsyRkFIM0IsV0FBVztrQkFQdkIsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsa0JBQWtCO29CQUM1QixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsSUFBSSxFQUFFO3dCQUNGLEtBQUssRUFBRSxhQUFhO3FCQUN2QjtpQkFDSjsrRUFFNEIsSUFBSTtzQkFBNUIsS0FBSzt1QkFBQyxnQkFBZ0I7Z0JBRWlCLHNCQUFzQjtzQkFBN0QsS0FBSzt1QkFBQyxFQUFFLFNBQVMsRUFBRSxnQkFBZ0IsRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQsIGJvb2xlYW5BdHRyaWJ1dGUsIEVsZW1lbnRSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICdbY2F4RWRpdGFibGVSb3ddJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIGhvc3Q6IHtcbiAgICAgICAgY2xhc3M6ICdjYXgtZWxlbWVudCdcbiAgICB9XG59KVxuZXhwb3J0IGNsYXNzIEVkaXRhYmxlUm93IHtcbiAgICBASW5wdXQoJ2NheEVkaXRhYmxlUm93JykgZGF0YTogYW55O1xuXG4gICAgQElucHV0KHsgdHJhbnNmb3JtOiBib29sZWFuQXR0cmlidXRlIH0pIGNheEVkaXRhYmxlUm93RGlzYWJsZWQ6IGJvb2xlYW4gfCB1bmRlZmluZWQ7XG5cbiAgICBjb25zdHJ1Y3RvcihwdWJsaWMgZWw6IEVsZW1lbnRSZWYpIHt9XG5cbiAgICBpc0VuYWJsZWQoKSB7XG4gICAgICAgIHJldHVybiB0aGlzLmNheEVkaXRhYmxlUm93RGlzYWJsZWQgIT09IHRydWU7XG4gICAgfVxufVxuIl19

package/esm2022/table/directives/frozen-column.directive.mjs

@@ -0,0 +1,77 @@
+import { Directive, Input, HostListener } from '@angular/core';
+import { DomHandler } from 'cax-design-system/dom';
+import * as i0 from "@angular/core";
+export class FrozenColumn {
+    el;
+    zone;
+    get frozen() {
+        return this._frozen;
+    }
+    set frozen(val) {
+        this._frozen = val;
+        this.updateStickyPosition();
+    }
+    alignFrozen = 'left';
+    constructor(el, zone) {
+        this.el = el;
+        this.zone = zone;
+    }
+    ngAfterViewChecked() {
+        this.zone.runOutsideAngular(() => {
+            this.recalculateColumns();
+        });
+    }
+    recalculateColumns() {
+        this.updateStickyPosition();
+    }
+    _frozen = true;
+    updateStickyPosition() {
+        if (this._frozen) {
+            if (this.alignFrozen === 'right') {
+                let right = 0;
+                let next = this.el.nativeElement.nextElementSibling;
+                if (next) {
+                    right = DomHandler.getOuterWidth(next) + (parseFloat(next.style.right) || 0);
+                }
+                this.el.nativeElement.style.right = right + 'px';
+            }
+            else {
+                let left = 0;
+                let prev = this.el.nativeElement.previousElementSibling;
+                if (prev) {
+                    left = DomHandler.getOuterWidth(prev) + (parseFloat(prev.style.left) || 0);
+                }
+                this.el.nativeElement.style.left = left + 'px';
+            }
+            const filterRow = this.el.nativeElement?.parentElement?.nextElementSibling;
+            if (filterRow) {
+                let index = DomHandler.index(this.el.nativeElement);
+                if (filterRow.children && filterRow.children[index]) {
+                    filterRow.children[index].style.left = this.el.nativeElement.style.left;
+                    filterRow.children[index].style.right = this.el.nativeElement.style.right;
+                }
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: FrozenColumn, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: FrozenColumn, isStandalone: true, selector: "[caxFrozenColumn]", inputs: { frozen: "frozen", alignFrozen: "alignFrozen" }, host: { listeners: { "window:resize": "recalculateColumns($event)" }, properties: { "class.cax-frozen-column": "frozen" }, classAttribute: "cax-element" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: FrozenColumn, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[caxFrozenColumn]',
+                    standalone: true,
+                    host: {
+                        class: 'cax-element',
+                        '[class.cax-frozen-column]': 'frozen'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { frozen: [{
+                type: Input
+            }], alignFrozen: [{
+                type: Input
+            }], recalculateColumns: [{
+                type: HostListener,
+                args: ['window:resize', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/table/directives/init-editable-row.directive.mjs

@@ -0,0 +1,32 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../table";
+import * as i2 from "./editable-row.directive";
+export class InitEditableRow {
+    dt;
+    editableRow;
+    constructor(dt, editableRow) {
+        this.dt = dt;
+        this.editableRow = editableRow;
+    }
+    onClick(event) {
+        this.dt.initRowEdit(this.editableRow.data);
+        event.preventDefault();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: InitEditableRow, deps: [{ token: i1.Table }, { token: i2.EditableRow }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: InitEditableRow, isStandalone: true, selector: "[caxInitEditableRow]", host: { listeners: { "click": "onClick($event)" }, classAttribute: "cax-element" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: InitEditableRow, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[caxInitEditableRow]',
+                    standalone: true,
+                    host: {
+                        class: 'cax-element'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i1.Table }, { type: i2.EditableRow }], propDecorators: { onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5pdC1lZGl0YWJsZS1yb3cuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FwcC9jb21wb25lbnRzL3RhYmxlL2RpcmVjdGl2ZXMvaW5pdC1lZGl0YWJsZS1yb3cuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7O0FBV3hELE1BQU0sT0FBTyxlQUFlO0lBRWI7SUFDQTtJQUZYLFlBQ1csRUFBUyxFQUNULFdBQXdCO1FBRHhCLE9BQUUsR0FBRixFQUFFLENBQU87UUFDVCxnQkFBVyxHQUFYLFdBQVcsQ0FBYTtJQUNoQyxDQUFDO0lBR0osT0FBTyxDQUFDLEtBQVk7UUFDaEIsSUFBSSxDQUFDLEVBQUUsQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUMzQyxLQUFLLENBQUMsY0FBYyxFQUFFLENBQUM7SUFDM0IsQ0FBQzt1R0FWUSxlQUFlOzJGQUFmLGVBQWU7OzJGQUFmLGVBQWU7a0JBUDNCLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLHNCQUFzQjtvQkFDaEMsVUFBVSxFQUFFLElBQUk7b0JBQ2hCLElBQUksRUFBRTt3QkFDRixLQUFLLEVBQUUsYUFBYTtxQkFDdkI7aUJBQ0o7b0dBUUcsT0FBTztzQkFETixZQUFZO3VCQUFDLE9BQU8sRUFBRSxDQUFDLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSG9zdExpc3RlbmVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBUYWJsZSB9IGZyb20gJy4uL3RhYmxlJztcbmltcG9ydCB7IEVkaXRhYmxlUm93IH0gZnJvbSAnLi9lZGl0YWJsZS1yb3cuZGlyZWN0aXZlJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICdbY2F4SW5pdEVkaXRhYmxlUm93XScsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICBob3N0OiB7XG4gICAgICAgIGNsYXNzOiAnY2F4LWVsZW1lbnQnXG4gICAgfVxufSlcbmV4cG9ydCBjbGFzcyBJbml0RWRpdGFibGVSb3cge1xuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBwdWJsaWMgZHQ6IFRhYmxlLFxuICAgICAgICBwdWJsaWMgZWRpdGFibGVSb3c6IEVkaXRhYmxlUm93XG4gICAgKSB7fVxuXG4gICAgQEhvc3RMaXN0ZW5lcignY2xpY2snLCBbJyRldmVudCddKVxuICAgIG9uQ2xpY2soZXZlbnQ6IEV2ZW50KSB7XG4gICAgICAgIHRoaXMuZHQuaW5pdFJvd0VkaXQodGhpcy5lZGl0YWJsZVJvdy5kYXRhKTtcbiAgICAgICAgZXZlbnQucHJldmVudERlZmF1bHQoKTtcbiAgICB9XG59XG4iXX0=