@one-grid-core/angular 0.1.0-beta.5

package/esm2022/lib/components/one-grid-cell-currency/one-grid-cell-currency.component.mjs

@@ -0,0 +1,90 @@
+import { Component, Input } from '@angular/core';
+import { getCellField } from '../../helpers/one-cell.helper';
+import { CellEditablePipe } from '../../core/pipes/cell-editable.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/services/one-grid-cell.service";
+import * as i2 from "../../core/services/one-grid-event.service";
+import * as i3 from "@angular/forms";
+import * as i4 from "../../core/directives/one-cell-input-validator.directive";
+import * as i5 from "@angular/common";
+export class OneGridCellCurrencyComponent {
+    constructor(cellService, eventService) {
+        this.cellService = cellService;
+        this.eventService = eventService;
+        this.value = '';
+        this.allowedEdit = false;
+        this.getCellField = getCellField;
+        this.cellEditablePipe = new CellEditablePipe();
+    }
+    oneInit(params) {
+        this.params = params;
+        this.value = params.data[params.columnDef.field];
+        this.result = this.value;
+        this.allowedEdit = params.context.componentParent.allowedEdit || false;
+        this.unsubscribe = this.eventService.addEventListener('cellStateChanged', (payload) => {
+            if (this.params.node.rowId === payload.node.rowId) {
+                this.result = this.cellService.generateCellState(this.params.node, this.params.columnDef).value;
+            }
+        });
+    }
+    refresh(params) {
+        // Update params and values when grid data refreshes
+        this.params = params;
+        this.value = params.data[params.columnDef.field];
+        this.result = this.value;
+        this.allowedEdit = params.context.componentParent.allowedEdit || false;
+        return true;
+    }
+    get isEditable() {
+        if (!this.params.node || !this.params.columnDef)
+            return false;
+        return this.cellEditablePipe.transform(this.params.node.cellStates, this.params.columnDef, this.params.node, this.cellService.editableFn, this.cellService.updatableFn, this.allowedEdit);
+    }
+    startEdit(node, column) {
+        if (!this.isEditable) {
+            return;
+        }
+        if (node) {
+            node.editing[column.field] = true;
+            setTimeout(() => {
+                const input = document.querySelector(`[data-cell-id="${getCellField(node.rowIndex, column.field)}"] input`);
+                if (input) {
+                    input.focus();
+                    const value = input.value;
+                    if (value && ["text"].includes(input.type)) {
+                        input.setSelectionRange(value.length, value.length);
+                    }
+                }
+            }, 10);
+        }
+    }
+    stopEdit(node, column, event) {
+        if (node) {
+            node.data[column.field] = event.target.value === '' ? null : event.target.value;
+            node.cellStates = this.cellService.generateCellStates(node);
+            node.editing[column.field] = false;
+            this.eventService.dispatchEvent('cellStateChanged', {
+                data: { ...node.data },
+                node: node,
+                column: column
+            });
+        }
+    }
+    cancelEdit(node, column) {
+        if (node) {
+            node.editing[column.field] = false;
+        }
+    }
+    ngOnDestroy() {
+        this.unsubscribe?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridCellCurrencyComponent, deps: [{ token: i1.OneGridCellService }, { token: i2.OneGridEventService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: OneGridCellCurrencyComponent, selector: "app-one-grid-cell-currency", inputs: { allowedEdit: "allowedEdit" }, ngImport: i0, template: "<div class=\"cell-wrapper\"\n     [class.editable]=\"isEditable\"\n     [attr.data-cell-id]=\"getCellField(params.node?.rowIndex, params.columnDef?.field)\"\n     [style.min-width.px]=\"params.columnDef?.minWidth\"\n     [style.max-width.px]=\"params.columnDef?.maxWidth\">\n\n    @if (params.node?.editing?.[params.columnDef?.field]) {\n      <input class=\"one-cell-input\"\n        name=\"{{ params.node?.rowIndex }}_{{ params.columnDef?.field }}\"\n        oneCellInputValidator\n        validationType=\"number\"\n        [placeholder]=\"params.columnDef?.cellRendererParams?.placeholder || ''\"\n        type=\"text\"\n        [(ngModel)]=\"value\"\n        [maxLength]=\"250\"\n        (blur)=\"stopEdit(params.node, params.columnDef, $event)\"\n        (keydown.enter)=\"stopEdit(params.node, params.columnDef, $event)\"\n        (keydown.esc)=\"cancelEdit(params.node, params.columnDef)\" />\n    }\n    @else {\n      <div class=\"d-flex justify-content-between px-2 pt-1\"\n        [class.one-cell-allowed-edit-active]=\"isEditable\"\n        (dblclick)=\"startEdit(params.node, params.columnDef)\">\n        <span class=\"currency-code\" style=\"font-weight: bold;\">{{ this.params?.data?.currency?.currencyCode || 'USD' }}</span>\n        <span class=\"amount-value\">\n          {{ result | number:(this.params?.field === 'amount' ? '1.3-3' : '1.2-2') }}\n        </span>\n      </div>\n    }\n</div>\n", styles: [".one-cell-input{position:absolute;top:0;left:0;width:calc(100% - 1px);height:100%;padding:0 6px;background-color:var(--one-grid-input-bg, var(--bs-input-bg, #fff));border:1px solid var(--one-grid-success, var(--bs-success, #198754));border-radius:var(--one-grid-action-btn-radius, 4px);z-index:5}.one-cell-input:focus{background:var(--one-grid-input-bg, var(--bs-input-bg, #fff));border:1px solid var(--one-grid-success, var(--bs-success, #198754))}:host{display:block;width:100%;height:100%;position:relative}.cell-wrapper{position:relative;width:100%;height:100%}.cell-wrapper.editable:before{content:\"\";position:absolute;top:4px;right:4px;width:4px;height:4px;background-color:var(--one-grid-success, var(--bs-success, #198754));border-radius:50%;z-index:1;opacity:.5;transition:opacity .2s ease}.cell-wrapper.editable:hover:before{opacity:1}\n"], dependencies: [{ kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i4.OneCellInputValidatorDirective, selector: "[oneCellInputValidator]", inputs: ["validationType", "regex"] }, { kind: "pipe", type: i5.DecimalPipe, name: "number" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridCellCurrencyComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: false, selector: 'app-one-grid-cell-currency', template: "<div class=\"cell-wrapper\"\n     [class.editable]=\"isEditable\"\n     [attr.data-cell-id]=\"getCellField(params.node?.rowIndex, params.columnDef?.field)\"\n     [style.min-width.px]=\"params.columnDef?.minWidth\"\n     [style.max-width.px]=\"params.columnDef?.maxWidth\">\n\n    @if (params.node?.editing?.[params.columnDef?.field]) {\n      <input class=\"one-cell-input\"\n        name=\"{{ params.node?.rowIndex }}_{{ params.columnDef?.field }}\"\n        oneCellInputValidator\n        validationType=\"number\"\n        [placeholder]=\"params.columnDef?.cellRendererParams?.placeholder || ''\"\n        type=\"text\"\n        [(ngModel)]=\"value\"\n        [maxLength]=\"250\"\n        (blur)=\"stopEdit(params.node, params.columnDef, $event)\"\n        (keydown.enter)=\"stopEdit(params.node, params.columnDef, $event)\"\n        (keydown.esc)=\"cancelEdit(params.node, params.columnDef)\" />\n    }\n    @else {\n      <div class=\"d-flex justify-content-between px-2 pt-1\"\n        [class.one-cell-allowed-edit-active]=\"isEditable\"\n        (dblclick)=\"startEdit(params.node, params.columnDef)\">\n        <span class=\"currency-code\" style=\"font-weight: bold;\">{{ this.params?.data?.currency?.currencyCode || 'USD' }}</span>\n        <span class=\"amount-value\">\n          {{ result | number:(this.params?.field === 'amount' ? '1.3-3' : '1.2-2') }}\n        </span>\n      </div>\n    }\n</div>\n", styles: [".one-cell-input{position:absolute;top:0;left:0;width:calc(100% - 1px);height:100%;padding:0 6px;background-color:var(--one-grid-input-bg, var(--bs-input-bg, #fff));border:1px solid var(--one-grid-success, var(--bs-success, #198754));border-radius:var(--one-grid-action-btn-radius, 4px);z-index:5}.one-cell-input:focus{background:var(--one-grid-input-bg, var(--bs-input-bg, #fff));border:1px solid var(--one-grid-success, var(--bs-success, #198754))}:host{display:block;width:100%;height:100%;position:relative}.cell-wrapper{position:relative;width:100%;height:100%}.cell-wrapper.editable:before{content:\"\";position:absolute;top:4px;right:4px;width:4px;height:4px;background-color:var(--one-grid-success, var(--bs-success, #198754));border-radius:50%;z-index:1;opacity:.5;transition:opacity .2s ease}.cell-wrapper.editable:hover:before{opacity:1}\n"] }]
+        }], ctorParameters: () => [{ type: i1.OneGridCellService }, { type: i2.OneGridEventService }], propDecorators: { allowedEdit: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"one-grid-cell-currency.component.js","sourceRoot":"","sources":["../../../../../../projects/one-grid/src/lib/components/one-grid-cell-currency/one-grid-cell-currency.component.ts","../../../../../../projects/one-grid/src/lib/components/one-grid-cell-currency/one-grid-cell-currency.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input } from '@angular/core';\nimport { CellStateChangedEvent } from '../../core/models/one-event-types.model';\nimport { OneCellRendererParams, OneColumnDef } from '../../core/models/one-column-def-types.model';\nimport { OneGridCellService } from '../../core/services/one-grid-cell.service';\nimport { OneGridEventService } from '../../core/services/one-grid-event.service';\nimport { OneRowNode } from '../../core/instants/one-row-node.class';\nimport { getCellField } from '../../helpers/one-cell.helper';\nimport { CellEditablePipe } from '../../core/pipes/cell-editable.pipe';\n\n@Component({\n  standalone: false,\n  selector: 'app-one-grid-cell-currency',\n  templateUrl: './one-grid-cell-currency.component.html',\n  styleUrl: './one-grid-cell-currency.component.scss'\n})\nexport class OneGridCellCurrencyComponent {\n  \n  value: string = '';\n  result: any;\n  params!: OneCellRendererParams;\n  @Input() allowedEdit: boolean = false;\n\n  getCellField = getCellField;\n  private unsubscribe?: () => void;\n  private cellEditablePipe = new CellEditablePipe();\n\n  constructor(\n    private cellService: OneGridCellService,\n    private eventService: OneGridEventService\n  ) { }\n\n  oneInit(params: OneCellRendererParams): void {\n\n    this.params = params;\n    this.value = params.data[params.columnDef.field];\n    this.result = this.value;\n    this.allowedEdit = params.context.componentParent.allowedEdit || false;\n\n    this.unsubscribe = this.eventService.addEventListener('cellStateChanged', (payload: CellStateChangedEvent<any>) => {\n      if (this.params.node.rowId === payload.node.rowId) {\n\n        this.result = this.cellService.generateCellState(this.params.node, this.params.columnDef).value;\n      }\n    });\n  }\n\n  refresh(params: OneCellRendererParams): boolean {\n    // Update params and values when grid data refreshes\n    this.params = params;\n    this.value = params.data[params.columnDef.field];\n    this.result = this.value;\n    this.allowedEdit = params.context.componentParent.allowedEdit || false;\n\n    return true;\n  }\n\n  get isEditable(): boolean {\n    if (!this.params.node || !this.params.columnDef) return false;\n\n    return this.cellEditablePipe.transform(\n      this.params.node.cellStates,\n      this.params.columnDef,\n      this.params.node,\n      this.cellService.editableFn,\n      this.cellService.updatableFn,\n      this.allowedEdit\n    );\n  }\n\n  startEdit(node: OneRowNode<any>, column: OneColumnDef<any>) {\n\n    if (!this.isEditable) {\n      return;\n    }\n\n    if (node) {\n\n      node.editing[column.field] = true;\n\n      setTimeout(() => {\n\n        const input = document.querySelector<HTMLInputElement>(`[data-cell-id=\"${getCellField(node.rowIndex, column.field)}\"] input`);\n\n        if (input) {\n\n          input.focus();\n\n          const value = input.value;\n\n          if (value && [\"text\"].includes(input.type)) {\n\n            input.setSelectionRange(value.length, value.length);\n          }\n        }\n      }, 10);\n    }\n  }\n\n  stopEdit(node: OneRowNode<any>, column: OneColumnDef<any>, event: any) {\n\n    if (node) {\n\n      node.data[column.field] = event.target.value === '' ? null : event.target.value;\n\n      node.cellStates = this.cellService.generateCellStates(node);\n\n      node.editing[column.field] = false;\n\n      this.eventService.dispatchEvent('cellStateChanged', {\n        data: { ...node.data },\n        node: node,\n        column: column\n      });\n    }\n  }\n\n  cancelEdit(node: OneRowNode<any>, column: OneColumnDef<any>) {\n\n    if (node) {\n\n      node.editing[column.field] = false;\n    }\n  }\n\n  ngOnDestroy(): void {\n\n    this.unsubscribe?.();\n  }\n}\n","<div class=\"cell-wrapper\"\n     [class.editable]=\"isEditable\"\n     [attr.data-cell-id]=\"getCellField(params.node?.rowIndex, params.columnDef?.field)\"\n     [style.min-width.px]=\"params.columnDef?.minWidth\"\n     [style.max-width.px]=\"params.columnDef?.maxWidth\">\n\n    @if (params.node?.editing?.[params.columnDef?.field]) {\n      <input class=\"one-cell-input\"\n        name=\"{{ params.node?.rowIndex }}_{{ params.columnDef?.field }}\"\n        oneCellInputValidator\n        validationType=\"number\"\n        [placeholder]=\"params.columnDef?.cellRendererParams?.placeholder || ''\"\n        type=\"text\"\n        [(ngModel)]=\"value\"\n        [maxLength]=\"250\"\n        (blur)=\"stopEdit(params.node, params.columnDef, $event)\"\n        (keydown.enter)=\"stopEdit(params.node, params.columnDef, $event)\"\n        (keydown.esc)=\"cancelEdit(params.node, params.columnDef)\" />\n    }\n    @else {\n      <div class=\"d-flex justify-content-between px-2 pt-1\"\n        [class.one-cell-allowed-edit-active]=\"isEditable\"\n        (dblclick)=\"startEdit(params.node, params.columnDef)\">\n        <span class=\"currency-code\" style=\"font-weight: bold;\">{{ this.params?.data?.currency?.currencyCode || 'USD' }}</span>\n        <span class=\"amount-value\">\n          {{ result | number:(this.params?.field === 'amount' ? '1.3-3' : '1.2-2') }}\n        </span>\n      </div>\n    }\n</div>\n"]}

package/esm2022/lib/components/one-grid-cell-group-renderer/one-grid-cell-group-renderer.component.mjs

@@ -0,0 +1,31 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class OneGridCellGroupRendererComponent {
+    constructor() {
+        this.masterDetail = false;
+        this.expansionChanged = new EventEmitter();
+    }
+    invokeChangedClick() {
+        // if (this.masterDetail && !this.node.expanded) {
+        //   this.detailCellRendererParams.getDetailRowData({ data: this.node.data, node: this.node, successCallback: (rows) => { this.node.setDetailRowData(rows) }});
+        // }
+        this.expansionChanged.emit({ rowIndex: this.node.rowIndex, data: this.node.data, node: this.node });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridCellGroupRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: OneGridCellGroupRendererComponent, selector: "one-grid-cell-group-renderer", inputs: { node: "node", masterDetail: "masterDetail", detailCellRendererParams: "detailCellRendererParams", detailRendererComponent: "detailRendererComponent" }, outputs: { expansionChanged: "expansionChanged" }, ngImport: i0, template: "@if (node.expandable) {\n    <span class=\"cell-group-renderer\" [style.padding-left.px]=\"6\" (click)=\"invokeChangedClick()\">\n        @if (node.children?.length > 0 || masterDetail) {\n            <i [class.node-expanded]=\"node.expanded\" class=\"bi bi-chevron-right expansion-icon\"></i>\n        }\n    </span>\n}\n", styles: [""] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridCellGroupRendererComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: false, selector: 'one-grid-cell-group-renderer', template: "@if (node.expandable) {\n    <span class=\"cell-group-renderer\" [style.padding-left.px]=\"6\" (click)=\"invokeChangedClick()\">\n        @if (node.children?.length > 0 || masterDetail) {\n            <i [class.node-expanded]=\"node.expanded\" class=\"bi bi-chevron-right expansion-icon\"></i>\n        }\n    </span>\n}\n" }]
+        }], propDecorators: { node: [{
+                type: Input
+            }], masterDetail: [{
+                type: Input
+            }], detailCellRendererParams: [{
+                type: Input
+            }], detailRendererComponent: [{
+                type: Input
+            }], expansionChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/one-grid-cell-option-menu/one-grid-cell-option-menu.component.mjs

@@ -0,0 +1,67 @@
+import { Component, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class OneGridCellOptionMenuComponent {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.column = null;
+        this.node = null;
+        this.options = [];
+        this.cellOptionMenuSelect = new EventEmitter();
+        this.cellOptionMenuClose = new EventEmitter();
+    }
+    // Click outside
+    onDocumentClick(event) {
+        const target = event.target;
+        if (!this.elementRef.nativeElement.contains(target)) {
+            this.close();
+        }
+    }
+    // Escape key
+    onEscape() {
+        this.close();
+    }
+    // Scroll closes menu (prevents misalignment)
+    onScroll() {
+        this.close();
+    }
+    // Option selected
+    onOptionSelected(option) {
+        this.cellOptionMenuSelect.emit({
+            column: this.column,
+            node: this.node,
+            option: option
+        });
+        this.close();
+    }
+    // Single close method
+    close() {
+        this.node.cellOptions[this.column.field] = false;
+        this.cellOptionMenuClose.emit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridCellOptionMenuComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: OneGridCellOptionMenuComponent, selector: "one-grid-cell-option-menu", inputs: { column: "column", node: "node", options: "options" }, outputs: { cellOptionMenuSelect: "cellOptionMenuSelect", cellOptionMenuClose: "cellOptionMenuClose" }, host: { listeners: { "document:click": "onDocumentClick($event)", "document:keydown.escape": "onEscape()", "document:scroll": "onScroll()" } }, ngImport: i0, template: "<div class=\"cell-option-menu\" #menuEl>\n    @for (opt of options; track opt.value) {\n        <div class=\"cell-option-menu-item\" (click)=\"onOptionSelected(opt)\">\n            <!-- <span [style.padding-right.px]=\"8\"><lucide-icon name=\"check\" [size]=\"16\" [strokeWidth]=\"2\"></lucide-icon></span> -->\n            <span>{{ opt.text }}</span> \n        </div>\n    }\n</div>", styles: [""] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridCellOptionMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'one-grid-cell-option-menu', standalone: false, template: "<div class=\"cell-option-menu\" #menuEl>\n    @for (opt of options; track opt.value) {\n        <div class=\"cell-option-menu-item\" (click)=\"onOptionSelected(opt)\">\n            <!-- <span [style.padding-right.px]=\"8\"><lucide-icon name=\"check\" [size]=\"16\" [strokeWidth]=\"2\"></lucide-icon></span> -->\n            <span>{{ opt.text }}</span> \n        </div>\n    }\n</div>" }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { column: [{
+                type: Input
+            }], node: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], cellOptionMenuSelect: [{
+                type: Output
+            }], cellOptionMenuClose: [{
+                type: Output
+            }], onDocumentClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }], onEscape: [{
+                type: HostListener,
+                args: ['document:keydown.escape']
+            }], onScroll: [{
+                type: HostListener,
+                args: ['document:scroll']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/one-grid-checkbox/one-grid-checkbox.component.mjs

@@ -0,0 +1,47 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/services/one-grid-selection.service";
+import * as i2 from "../../core/services/one-grid-event.service";
+export class OneGridCheckboxComponent {
+    constructor(selectionService, eventService) {
+        this.selectionService = selectionService;
+        this.eventService = eventService;
+        this.allowedEdit = false;
+        this.onRowSelection = new EventEmitter();
+    }
+    onToggleSelection(event) {
+        const isChecked = event.target.checked;
+        const { rowId, rowIndex, data } = this.node;
+        const selectionMode = this.selectionService.getSelectionMode();
+        if (selectionMode === 'single') {
+            this.api.deselectAll();
+            if (isChecked) {
+                this.node.setSelected(true);
+            }
+            this.api.toggleSelection(rowId, isChecked);
+        }
+        else {
+            // Multi-select mode
+            this.selectionService.toggleSelection(rowId, isChecked);
+            this.node.setSelected(isChecked);
+        }
+        this.node.cellStates = { ...this.node.cellStates };
+        this.eventService.dispatchEvent('selectionChanged', { rowIndex, selected: isChecked, data, node: this.node });
+        this.onRowSelection.emit({ rowIndex, selected: isChecked, data, node: this.node });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridCheckboxComponent, deps: [{ token: i1.OneGridSelectionService }, { token: i2.OneGridEventService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: OneGridCheckboxComponent, selector: "one-grid-checkbox", inputs: { node: "node", allowedEdit: "allowedEdit", api: "api" }, outputs: { onRowSelection: "onRowSelection" }, ngImport: i0, template: "\n<div class=\"one-grid-checkbox\">\n    <input type=\"checkbox\"\n        [name]=\"node.rowId\"\n        [class.disabled]=\"!(allowedEdit)\"\n        [checked]=\"node.selected\"\n        (change)=\"onToggleSelection($event)\"/>\n</div>", styles: [""] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridCheckboxComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: false, selector: 'one-grid-checkbox', template: "\n<div class=\"one-grid-checkbox\">\n    <input type=\"checkbox\"\n        [name]=\"node.rowId\"\n        [class.disabled]=\"!(allowedEdit)\"\n        [checked]=\"node.selected\"\n        (change)=\"onToggleSelection($event)\"/>\n</div>" }]
+        }], ctorParameters: () => [{ type: i1.OneGridSelectionService }, { type: i2.OneGridEventService }], propDecorators: { node: [{
+                type: Input
+            }], allowedEdit: [{
+                type: Input
+            }], api: [{
+                type: Input
+            }], onRowSelection: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/one-grid-checkbox-header/one-grid-checkbox-header.component.mjs

@@ -0,0 +1,62 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/services/one-grid-event.service";
+import * as i2 from "../../core/services/one-grid-selection.service";
+import * as i3 from "../../core/pipes/header-checkbox-disabled.pipe";
+import * as i4 from "../../core/pipes/header-checkbox-checked.pipe";
+import * as i5 from "../../core/pipes/header-checkbox-indeterminate.pipe";
+export class OneGridCheckboxHeaderComponent {
+    constructor(eventService, selectionService) {
+        this.eventService = eventService;
+        this.selectionService = selectionService;
+        this.allowedEdit = false;
+        this.state = 'unchecked';
+        this.rowNodes = [];
+    }
+    ngOnInit() {
+        this.selectionMode = this.api.rowSelection;
+        /**
+         * Listen Row Node Selection Changed Event
+         */
+        this.eventService.addEventListener('selectionChanged', (payload) => {
+            this.rowNodes = this.api.getAllRowNodes();
+            const rowIds = this.rowNodes && this.rowNodes.length > 0 ? this.rowNodes.map((node) => node.rowId) : [];
+            this.state = this.selectionService.getSelectAllState(rowIds);
+        });
+        /**
+         * Listen Row Data Changed Event
+         */
+        this.eventService.addEventListener('rowDataChanged', (payload) => {
+            this.rowNodes = this.api.getAllRowNodes();
+            const rowIds = this.rowNodes && this.rowNodes.length > 0 ? this.rowNodes.map((node) => node.rowId) : [];
+            this.state = this.selectionService.getSelectAllState(rowIds);
+        });
+    }
+    /**
+     * Toggle Selection Action
+     */
+    toggleSelectionAll(event) {
+        if (this.selectionMode === 'single')
+            return;
+        const checked = event.target.checked;
+        if (this.rowNodes && this.rowNodes.length > 0) {
+            if (checked) {
+                this.api.selectAll();
+            }
+            else {
+                this.api.deselectAll();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridCheckboxHeaderComponent, deps: [{ token: i1.OneGridEventService }, { token: i2.OneGridSelectionService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: OneGridCheckboxHeaderComponent, selector: "one-grid-checkbox-header", inputs: { api: "api", allowedEdit: "allowedEdit" }, ngImport: i0, template: "<div class=\"one-grid-checkbox\">\n    <input\n        [id]=\"api.id\"\n        [type]=\"'checkbox'\"\n        [class.disabled]=\"rowNodes | headerCheckboxDisabled:selectionMode:allowedEdit\"\n        [checked]=\"rowNodes | headerCheckboxChecked:selectionMode:state\"\n        [indeterminate]=\"rowNodes | headerCheckboxIndeterminate:selectionMode:state\"\n        (change)=\"toggleSelectionAll($event)\" />\n</div>", styles: [""], dependencies: [{ kind: "pipe", type: i3.HeaderCheckboxDisabledPipe, name: "headerCheckboxDisabled" }, { kind: "pipe", type: i4.HeaderCheckboxCheckedPipe, name: "headerCheckboxChecked" }, { kind: "pipe", type: i5.HeaderCheckboxIndeterminatePipe, name: "headerCheckboxIndeterminate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridCheckboxHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: false, selector: 'one-grid-checkbox-header', template: "<div class=\"one-grid-checkbox\">\n    <input\n        [id]=\"api.id\"\n        [type]=\"'checkbox'\"\n        [class.disabled]=\"rowNodes | headerCheckboxDisabled:selectionMode:allowedEdit\"\n        [checked]=\"rowNodes | headerCheckboxChecked:selectionMode:state\"\n        [indeterminate]=\"rowNodes | headerCheckboxIndeterminate:selectionMode:state\"\n        (change)=\"toggleSelectionAll($event)\" />\n</div>" }]
+        }], ctorParameters: () => [{ type: i1.OneGridEventService }, { type: i2.OneGridSelectionService }], propDecorators: { api: [{
+                type: Input
+            }], allowedEdit: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/one-grid-header/one-grid-header.component.mjs

@@ -0,0 +1,140 @@
+import { Component, Input } from '@angular/core';
+import { Subject, Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/services/one-grid-event.service";
+import * as i2 from "@angular/common";
+import * as i3 from "lucide-angular";
+import * as i4 from "../one-grid-checkbox-header/one-grid-checkbox-header.component";
+import * as i5 from "../../core/pipes/column-sort-state.pipe";
+export class OneGridHeaderComponent {
+    constructor(eventService, cdr) {
+        this.eventService = eventService;
+        this.cdr = cdr;
+        this.scrollLeft = 0;
+        this.allowedEdit = false;
+        this.enableGroupColumnDefs = false;
+        this.groupColumnDefs = [];
+        this.columnDefs = [];
+        this.sortModel = [];
+        this.destroy$ = new Subject();
+        this.subscriptions = new Subscription();
+        this.draggedIndex = null;
+        // Track resize state
+        this.resizing = false;
+        this.resizeColumnIndex = null;
+        this.startX = 0;
+        this.startWidth = 0;
+        // Arrow function to preserve 'this' context
+        this.onResizeMove = (event) => {
+            if (!this.resizing || this.resizeColumnIndex === null)
+                return;
+            // Calculate how far the mouse has moved
+            const deltaX = event.clientX - this.startX;
+            // Calculate new width (with minimum of 50px)
+            const newWidth = Math.max(50, this.startWidth + deltaX);
+            // Update the column width
+            this.api.updateColumn(this.columnDefs[this.resizeColumnIndex].id, { width: newWidth });
+        };
+        this.onResizeEnd = () => {
+            // Clean up
+            this.resizing = false;
+            this.resizeColumnIndex = null;
+            document.body.style.cursor = '';
+            // Remove document listeners
+            document.removeEventListener('mousemove', this.onResizeMove);
+            document.removeEventListener('mouseup', this.onResizeEnd);
+        };
+    }
+    ngOnInit() {
+        // Listen Column Changed Event
+        this.subscriptions.add(this.eventService.addEventListener('columnChanged', (payload) => {
+            const { groups, columns } = payload;
+            if (groups) {
+                this.groupColumnDefs = groups;
+            }
+            if (columns) {
+                this.columnDefs = columns;
+            }
+            // this.cdr.markForCheck();
+        }));
+    }
+    onHeaderMenuOptionClick(columnDef) {
+    }
+    onHeaderMenuSortClick(colId) {
+        const currentSort = this.sortModel.find(sort => sort.colId === colId)?.sort ?? null;
+        const nextSort = this.cycleSort(currentSort);
+        this.sortModel = nextSort ? [{ colId, sort: nextSort }] : [];
+        this.api.onSortChanged(this.sortModel);
+    }
+    // Cycle Sorting Model
+    cycleSort(current) {
+        switch (current) {
+            case null: return 'asc';
+            case 'asc': return 'desc';
+            case 'desc': return null;
+            default: return null;
+        }
+    }
+    onResizeStart(event, columnIndex) {
+        // Prevent text selection and default behavior
+        event.preventDefault();
+        event.stopPropagation();
+        // Store initial values
+        this.resizing = true;
+        this.resizeColumnIndex = columnIndex;
+        this.startX = event.clientX;
+        this.startWidth = this.columnDefs[columnIndex].width;
+        // Add document-level listeners for drag and release
+        document.addEventListener('mousemove', this.onResizeMove);
+        document.addEventListener('mouseup', this.onResizeEnd);
+        // Add a class to body to maintain cursor during drag
+        document.body.style.cursor = 'col-resize';
+    }
+    // Track the dragged column index
+    onDragColumnStart(event, index) {
+        this.draggedIndex = index;
+        // Optional: Set drag image/effect
+        if (event.dataTransfer) {
+            event.dataTransfer.effectAllowed = 'move';
+        }
+    }
+    onDragColumnOver(event, targetIndex) {
+        event.preventDefault();
+        // Skip if dragging over itself or no drag in progress
+        if (this.draggedIndex === null || this.draggedIndex === targetIndex) {
+            return;
+        }
+        // IMMEDIATELY reorder columns
+        this.api.reorderColumnDefs(this.draggedIndex, targetIndex);
+        // Update draggedIndex to the new position
+        this.draggedIndex = targetIndex;
+    }
+    onDragColumnEnd(event) {
+        this.draggedIndex = null;
+    }
+    onDropColumn(event) {
+        event.preventDefault();
+        this.draggedIndex = null;
+    }
+    /**
+     * Clear All Subscriptions
+     */
+    ngOnDestroy() {
+        this.destroy$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridHeaderComponent, deps: [{ token: i1.OneGridEventService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: OneGridHeaderComponent, selector: "one-grid-header", inputs: { scrollLeft: "scrollLeft", allowedEdit: "allowedEdit", enableGroupColumnDefs: "enableGroupColumnDefs", api: "api" }, ngImport: i0, template: "<div class=\"one-grid-header\">\n    @if (enableGroupColumnDefs) {\n        <div class=\"one-group-header-row\" [style.transform]=\"'translateX(-' + scrollLeft + 'px)'\">\n            <ng-container *ngTemplateOutlet=\"groupColumns; context: { groups: groupColumnDefs }\"></ng-container>\n        </div>\n    }\n    <div class=\"one-grid-header-viewport\">\n        <div class=\"one-header-row\" [style.transform]=\"'translateX(-' + scrollLeft + 'px)'\">\n            <ng-container *ngTemplateOutlet=\"headerColumns; context: { columns: columnDefs }\"></ng-container>\n        </div>\n    </div>\n</div>\n\n<!-- Group Header Cell Template -->\n<ng-template #groupColumns let-groups=\"groups\">\n    @for(group of groups; track group.id) {\n        <div class=\"one-group-header-cell\"\n            [style.width.px]=\"group.width\"\n            [ngClass]=\"group._resolvedGroupClass\"\n            [ngStyle]=\"group._resolvedGroupStyle\">\n            <div class=\"one-group-header-cell-text\">\n                {{ group.headerName }}\n            </div>\n        </div>\n    }\n</ng-template>\n\n<!-- Header Cell Template -->\n<ng-template #headerColumns let-columns=\"columns\">\n    @for (col of columns; let colIndex = $index; track col.id) {\n        <div class=\"one-grid-header-column\"\n            [attr.data-index]=\"colIndex\"\n            [style.width.px]=\"col.width\"\n            [style.min-width.px]=\"col.minWidth\"\n            [style.max-width.px]=\"col.maxWidth\"\n            [draggable]=\"col?.dragable\"\n            (dragstart)=\"onDragColumnStart($event, colIndex)\"\n            (dragover)=\"onDragColumnOver($event, colIndex)\"\n            (dragend)=\"onDragColumnEnd($event)\"\n            (drop)=\"onDropColumn($event)\">\n            <div class=\"one-grid-header-cell\"\n                [ngClass]=\"col._resolvedHeaderClass\"\n                [ngStyle]=\"col._resolvedHeaderStyle\"\n                >\n                <span class=\"one-grid-header-cell-group\">\n                    @if (col?.headerCheckboxSelection) {\n                        <one-grid-checkbox-header\n                            [api]=\"api\"\n                            [allowedEdit]=\"allowedEdit\"\n                        />\n                    }\n\n                    {{ col?.headerName ?? '' }}\n                </span>\n\n                <!-- Og Resize Handler -->\n                @if (col?.resizable) {\n                    <div class=\"og-resize-handle\" (mousedown)=\"onResizeStart($event, colIndex)\">\n                        <i class=\"bi bi-grip-vertical\"></i>\n                    </div>\n                }\n\n                <div class=\"one-grid-header-cell-group\">\n\n                    <!-- Sort Menu Button -->\n                    @if (col?.sortable) {\n                        <div class=\"one-grid-header-menu-button\" (click)=\"onHeaderMenuSortClick(col.field)\">\n\n                            @if ((col.field | columnSortState:api.sortModel) === 'asc') {\n                                <lucide-icon name=\"arrow-up-a-z\" [size]=\"16\" [strokeWidth]=\"2\"></lucide-icon>\n                            }\n                            @else if ((col.field | columnSortState:api.sortModel) === 'desc') {\n                                <lucide-icon name=\"arrow-down-z-a\" [size]=\"16\" [strokeWidth]=\"2\"></lucide-icon>\n                            }\n                            @else {\n                                <lucide-icon name=\"arrow-down-up\" [size]=\"16\" [strokeWidth]=\"2\"></lucide-icon>\n                            }\n                        </div>\n                    }\n\n                    <!-- Og Option Menu Button -->\n                    @if (col && !col.suppressHeaderMenuButton) {\n                        <div class=\"one-grid-header-menu-button\" (click)=\"onHeaderMenuOptionClick(col)\">\n                            <i class=\"bi bi-three-dots-vertical\"></i>\n                        </div>\n                    }\n                </div>\n            </div>\n        </div>\n    }\n</ng-template>\n", styles: [""], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: i3.LucideAngularComponent, selector: "lucide-angular, lucide-icon, i-lucide, span-lucide", inputs: ["class", "name", "img", "color", "absoluteStrokeWidth", "size", "strokeWidth"] }, { kind: "component", type: i4.OneGridCheckboxHeaderComponent, selector: "one-grid-checkbox-header", inputs: ["api", "allowedEdit"] }, { kind: "pipe", type: i5.ColumnSortStatePipe, name: "columnSortState" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: false, selector: 'one-grid-header', template: "<div class=\"one-grid-header\">\n    @if (enableGroupColumnDefs) {\n        <div class=\"one-group-header-row\" [style.transform]=\"'translateX(-' + scrollLeft + 'px)'\">\n            <ng-container *ngTemplateOutlet=\"groupColumns; context: { groups: groupColumnDefs }\"></ng-container>\n        </div>\n    }\n    <div class=\"one-grid-header-viewport\">\n        <div class=\"one-header-row\" [style.transform]=\"'translateX(-' + scrollLeft + 'px)'\">\n            <ng-container *ngTemplateOutlet=\"headerColumns; context: { columns: columnDefs }\"></ng-container>\n        </div>\n    </div>\n</div>\n\n<!-- Group Header Cell Template -->\n<ng-template #groupColumns let-groups=\"groups\">\n    @for(group of groups; track group.id) {\n        <div class=\"one-group-header-cell\"\n            [style.width.px]=\"group.width\"\n            [ngClass]=\"group._resolvedGroupClass\"\n            [ngStyle]=\"group._resolvedGroupStyle\">\n            <div class=\"one-group-header-cell-text\">\n                {{ group.headerName }}\n            </div>\n        </div>\n    }\n</ng-template>\n\n<!-- Header Cell Template -->\n<ng-template #headerColumns let-columns=\"columns\">\n    @for (col of columns; let colIndex = $index; track col.id) {\n        <div class=\"one-grid-header-column\"\n            [attr.data-index]=\"colIndex\"\n            [style.width.px]=\"col.width\"\n            [style.min-width.px]=\"col.minWidth\"\n            [style.max-width.px]=\"col.maxWidth\"\n            [draggable]=\"col?.dragable\"\n            (dragstart)=\"onDragColumnStart($event, colIndex)\"\n            (dragover)=\"onDragColumnOver($event, colIndex)\"\n            (dragend)=\"onDragColumnEnd($event)\"\n            (drop)=\"onDropColumn($event)\">\n            <div class=\"one-grid-header-cell\"\n                [ngClass]=\"col._resolvedHeaderClass\"\n                [ngStyle]=\"col._resolvedHeaderStyle\"\n                >\n                <span class=\"one-grid-header-cell-group\">\n                    @if (col?.headerCheckboxSelection) {\n                        <one-grid-checkbox-header\n                            [api]=\"api\"\n                            [allowedEdit]=\"allowedEdit\"\n                        />\n                    }\n\n                    {{ col?.headerName ?? '' }}\n                </span>\n\n                <!-- Og Resize Handler -->\n                @if (col?.resizable) {\n                    <div class=\"og-resize-handle\" (mousedown)=\"onResizeStart($event, colIndex)\">\n                        <i class=\"bi bi-grip-vertical\"></i>\n                    </div>\n                }\n\n                <div class=\"one-grid-header-cell-group\">\n\n                    <!-- Sort Menu Button -->\n                    @if (col?.sortable) {\n                        <div class=\"one-grid-header-menu-button\" (click)=\"onHeaderMenuSortClick(col.field)\">\n\n                            @if ((col.field | columnSortState:api.sortModel) === 'asc') {\n                                <lucide-icon name=\"arrow-up-a-z\" [size]=\"16\" [strokeWidth]=\"2\"></lucide-icon>\n                            }\n                            @else if ((col.field | columnSortState:api.sortModel) === 'desc') {\n                                <lucide-icon name=\"arrow-down-z-a\" [size]=\"16\" [strokeWidth]=\"2\"></lucide-icon>\n                            }\n                            @else {\n                                <lucide-icon name=\"arrow-down-up\" [size]=\"16\" [strokeWidth]=\"2\"></lucide-icon>\n                            }\n                        </div>\n                    }\n\n                    <!-- Og Option Menu Button -->\n                    @if (col && !col.suppressHeaderMenuButton) {\n                        <div class=\"one-grid-header-menu-button\" (click)=\"onHeaderMenuOptionClick(col)\">\n                            <i class=\"bi bi-three-dots-vertical\"></i>\n                        </div>\n                    }\n                </div>\n            </div>\n        </div>\n    }\n</ng-template>\n" }]
+        }], ctorParameters: () => [{ type: i1.OneGridEventService }, { type: i0.ChangeDetectorRef }], propDecorators: { scrollLeft: [{
+                type: Input
+            }], allowedEdit: [{
+                type: Input
+            }], enableGroupColumnDefs: [{
+                type: Input
+            }], api: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"one-grid-header.component.js","sourceRoot":"","sources":["../../../../../../projects/one-grid/src/lib/components/one-grid-header/one-grid-header.component.ts","../../../../../../projects/one-grid/src/lib/components/one-grid-header/one-grid-header.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, Input, OnDestroy, OnInit } from '@angular/core';\nimport { OneColumnDef, OneGroupColumnDef } from '../../core/models/one-column-def-types.model';\nimport { Subject, Subscription } from 'rxjs';\nimport { OneGridApi } from '../../core/instants/one-grid-api.class';\nimport { OneSortModel } from '../../core/models/one-grid-types.model';\nimport { ColumnChangedEvent } from '../../core/models/one-event-types.model';\nimport { OneGridEventService } from '../../core/services/one-grid-event.service';\n\n@Component({\n  standalone: false,\n  selector: 'one-grid-header',\n  templateUrl: './one-grid-header.component.html',\n  styleUrl: './one-grid-header.component.scss'\n})\nexport class OneGridHeaderComponent<T> implements OnInit, OnDestroy {\n\n  @Input() scrollLeft = 0;\n  @Input() allowedEdit: boolean = false;\n  @Input() enableGroupColumnDefs: boolean = false;\n  @Input() api!: OneGridApi<T>;\n\n  protected groupColumnDefs: OneGroupColumnDef[] = [];\n  protected columnDefs: OneColumnDef<T>[] = [];\n\n  private sortModel: OneSortModel<T>[] = [];\n  private destroy$ = new Subject<void>();\n  private subscriptions = new Subscription();\n  private draggedIndex: number | null = null;\n\n  // Track resize state\n  private resizing = false;\n  private resizeColumnIndex: number | null = null;\n  private startX = 0;\n  private startWidth = 0;\n\n  constructor(\n    private eventService: OneGridEventService,\n    private cdr: ChangeDetectorRef\n   ) {}\n\n  ngOnInit(): void {\n\n    // Listen Column Changed Event\n    this.subscriptions.add(this.eventService.addEventListener('columnChanged', (payload: ColumnChangedEvent) => {\n\n      const { groups, columns } = payload;\n\n      if (groups) {\n\n        this.groupColumnDefs = groups as OneGroupColumnDef[];\n      }\n\n      if (columns) {\n\n        this.columnDefs = columns as OneColumnDef[];\n      }\n\n      // this.cdr.markForCheck();\n    }));\n  }\n\n  onHeaderMenuOptionClick(columnDef: OneColumnDef<T>) {\n\n  }\n\n  onHeaderMenuSortClick(colId: keyof T) {\n\n    const currentSort = this.sortModel.find(sort => sort.colId === colId)?.sort ?? null;\n\n    const nextSort = this.cycleSort(currentSort);\n\n    this.sortModel = nextSort ? [{ colId, sort: nextSort }] : [];\n\n    this.api.onSortChanged(this.sortModel);\n  }\n\n  // Cycle Sorting Model\n  private cycleSort(current: 'asc' | 'desc' | null): 'asc' | 'desc' | null {\n\n    switch (current) {\n\n      case null: return 'asc';\n\n      case 'asc': return 'desc';\n\n      case 'desc': return null;\n\n      default: return null;\n    }\n  }\n\n  onResizeStart(event: MouseEvent, columnIndex: number): void {\n\n    // Prevent text selection and default behavior\n    event.preventDefault();\n    event.stopPropagation();\n\n    // Store initial values\n    this.resizing = true;\n    this.resizeColumnIndex = columnIndex;\n    this.startX = event.clientX;\n    this.startWidth = this.columnDefs[columnIndex].width;\n\n    // Add document-level listeners for drag and release\n    document.addEventListener('mousemove', this.onResizeMove);\n    document.addEventListener('mouseup', this.onResizeEnd);\n\n    // Add a class to body to maintain cursor during drag\n    document.body.style.cursor = 'col-resize';\n  }\n\n  // Arrow function to preserve 'this' context\n  private onResizeMove = (event: MouseEvent): void => {\n\n    if (!this.resizing || this.resizeColumnIndex === null) return;\n\n    // Calculate how far the mouse has moved\n    const deltaX = event.clientX - this.startX;\n\n    // Calculate new width (with minimum of 50px)\n    const newWidth = Math.max(50, this.startWidth + deltaX);\n\n    // Update the column width\n    this.api.updateColumn(this.columnDefs[this.resizeColumnIndex].id, { width: newWidth });\n  }\n\n  private onResizeEnd = (): void => {\n\n    // Clean up\n    this.resizing = false;\n    this.resizeColumnIndex = null;\n    document.body.style.cursor = '';\n\n    // Remove document listeners\n    document.removeEventListener('mousemove', this.onResizeMove);\n    document.removeEventListener('mouseup', this.onResizeEnd);\n  }\n\n  // Track the dragged column index\n  onDragColumnStart(event: DragEvent, index: number): void {\n\n    this.draggedIndex = index;\n\n    // Optional: Set drag image/effect\n    if (event.dataTransfer) {\n\n      event.dataTransfer.effectAllowed = 'move';\n    }\n  }\n\n  onDragColumnOver(event: DragEvent, targetIndex: number): void {\n\n    event.preventDefault();\n\n    // Skip if dragging over itself or no drag in progress\n    if (this.draggedIndex === null || this.draggedIndex === targetIndex) {\n\n      return;\n    }\n\n    // IMMEDIATELY reorder columns\n    this.api.reorderColumnDefs(this.draggedIndex, targetIndex);\n\n    // Update draggedIndex to the new position\n    this.draggedIndex = targetIndex;\n  }\n\n  onDragColumnEnd(event: DragEvent): void {\n\n    this.draggedIndex = null;\n  }\n\n  onDropColumn(event: DragEvent): void {\n\n    event.preventDefault();\n\n    this.draggedIndex = null;\n  }\n\n  /**\n   * Clear All Subscriptions\n   */\n  ngOnDestroy(): void {\n\n    this.destroy$.complete();\n  }\n}\n","<div class=\"one-grid-header\">\n    @if (enableGroupColumnDefs) {\n        <div class=\"one-group-header-row\" [style.transform]=\"'translateX(-' + scrollLeft + 'px)'\">\n            <ng-container *ngTemplateOutlet=\"groupColumns; context: { groups: groupColumnDefs }\"></ng-container>\n        </div>\n    }\n    <div class=\"one-grid-header-viewport\">\n        <div class=\"one-header-row\" [style.transform]=\"'translateX(-' + scrollLeft + 'px)'\">\n            <ng-container *ngTemplateOutlet=\"headerColumns; context: { columns: columnDefs }\"></ng-container>\n        </div>\n    </div>\n</div>\n\n<!-- Group Header Cell Template -->\n<ng-template #groupColumns let-groups=\"groups\">\n    @for(group of groups; track group.id) {\n        <div class=\"one-group-header-cell\"\n            [style.width.px]=\"group.width\"\n            [ngClass]=\"group._resolvedGroupClass\"\n            [ngStyle]=\"group._resolvedGroupStyle\">\n            <div class=\"one-group-header-cell-text\">\n                {{ group.headerName }}\n            </div>\n        </div>\n    }\n</ng-template>\n\n<!-- Header Cell Template -->\n<ng-template #headerColumns let-columns=\"columns\">\n    @for (col of columns; let colIndex = $index; track col.id) {\n        <div class=\"one-grid-header-column\"\n            [attr.data-index]=\"colIndex\"\n            [style.width.px]=\"col.width\"\n            [style.min-width.px]=\"col.minWidth\"\n            [style.max-width.px]=\"col.maxWidth\"\n            [draggable]=\"col?.dragable\"\n            (dragstart)=\"onDragColumnStart($event, colIndex)\"\n            (dragover)=\"onDragColumnOver($event, colIndex)\"\n            (dragend)=\"onDragColumnEnd($event)\"\n            (drop)=\"onDropColumn($event)\">\n            <div class=\"one-grid-header-cell\"\n                [ngClass]=\"col._resolvedHeaderClass\"\n                [ngStyle]=\"col._resolvedHeaderStyle\"\n                >\n                <span class=\"one-grid-header-cell-group\">\n                    @if (col?.headerCheckboxSelection) {\n                        <one-grid-checkbox-header\n                            [api]=\"api\"\n                            [allowedEdit]=\"allowedEdit\"\n                        />\n                    }\n\n                    {{ col?.headerName ?? '' }}\n                </span>\n\n                <!-- Og Resize Handler -->\n                @if (col?.resizable) {\n                    <div class=\"og-resize-handle\" (mousedown)=\"onResizeStart($event, colIndex)\">\n                        <i class=\"bi bi-grip-vertical\"></i>\n                    </div>\n                }\n\n                <div class=\"one-grid-header-cell-group\">\n\n                    <!-- Sort Menu Button -->\n                    @if (col?.sortable) {\n                        <div class=\"one-grid-header-menu-button\" (click)=\"onHeaderMenuSortClick(col.field)\">\n\n                            @if ((col.field | columnSortState:api.sortModel) === 'asc') {\n                                <lucide-icon name=\"arrow-up-a-z\" [size]=\"16\" [strokeWidth]=\"2\"></lucide-icon>\n                            }\n                            @else if ((col.field | columnSortState:api.sortModel) === 'desc') {\n                                <lucide-icon name=\"arrow-down-z-a\" [size]=\"16\" [strokeWidth]=\"2\"></lucide-icon>\n                            }\n                            @else {\n                                <lucide-icon name=\"arrow-down-up\" [size]=\"16\" [strokeWidth]=\"2\"></lucide-icon>\n                            }\n                        </div>\n                    }\n\n                    <!-- Og Option Menu Button -->\n                    @if (col && !col.suppressHeaderMenuButton) {\n                        <div class=\"one-grid-header-menu-button\" (click)=\"onHeaderMenuOptionClick(col)\">\n                            <i class=\"bi bi-three-dots-vertical\"></i>\n                        </div>\n                    }\n                </div>\n            </div>\n        </div>\n    }\n</ng-template>\n"]}