@sumaris-net/ngx-components 18.23.32 → 18.23.34

package/esm2022/src/app/shared/directives/cell-selection/cell-identifier.directive.mjs

@@ -0,0 +1,41 @@
+import { DestroyRef, Directive, inject, input } from '@angular/core';
+import { APP_CELL_SELECTION_SERVICE_TOKEN } from './cell-selection.service';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+export class CellIdentifierDirective {
+    cellId = input.required({ alias: 'appCellId' });
+    isCellSelected = false;
+    isDragging = false;
+    service = inject(APP_CELL_SELECTION_SERVICE_TOKEN);
+    destroyRef = inject(DestroyRef);
+    ngOnInit() {
+        // Listen to service selection changes and emit
+        this.service.selectionChangeSubject
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => (this.isCellSelected = this.service.isCellSelected(this.cellId())));
+    }
+    async handleMouseDown(event) {
+        await this.service.handleCellMouseDown(event, this.cellId());
+    }
+    async handleMouseEnter(event) {
+        await this.service.handleCellMouseEnter(event, this.cellId());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CellIdentifierDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.13", type: CellIdentifierDirective, isStandalone: true, selector: "[appCellId]", inputs: { cellId: { classPropertyName: "cellId", publicName: "appCellId", isSignal: true, isRequired: true, transformFunction: null } }, host: { listeners: { "mousedown": "handleMouseDown($event)", "mouseenter": "handleMouseEnter($event)" }, properties: { "class.cell-selected": "isCellSelected", "class.cell-dragging": "isDragging", "attr.data-row-id": "cellId().rowId", "attr.data-column-name": "cellId().columnName" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CellIdentifierDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appCellId]',
+                    standalone: true,
+                    host: {
+                        '(mousedown)': 'handleMouseDown($event)',
+                        '(mouseenter)': 'handleMouseEnter($event)',
+                        '[class.cell-selected]': 'isCellSelected',
+                        '[class.cell-dragging]': 'isDragging',
+                        '[attr.data-row-id]': 'cellId().rowId',
+                        '[attr.data-column-name]': 'cellId().columnName',
+                    },
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/shared/directives/cell-selection/cell-selection.directive.mjs

@@ -0,0 +1,201 @@
+import { DestroyRef, Directive, ElementRef, inject, input, output, Renderer2 } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { fromEvent } from 'rxjs';
+import { APP_CELL_SELECTION_SERVICE_TOKEN } from './cell-selection.service';
+import { isEmptyArray, isNotEmptyArray } from '../../functions';
+import * as i0 from "@angular/core";
+export class CellSelectionDirective {
+    // Inputs
+    // eslint-disable-next-line @angular-eslint/no-input-rename
+    selectableColumns = input([], { alias: 'appSelectableColumns' });
+    // Outputs
+    // eslint-disable-next-line @angular-eslint/no-output-rename
+    selectionChange = output({ alias: 'appCellSelectionChange' });
+    // eslint-disable-next-line @angular-eslint/no-output-rename
+    rightClick = output({ alias: 'appCellRightClick' });
+    // Inject service by token
+    service = inject(APP_CELL_SELECTION_SERVICE_TOKEN);
+    elementRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    destroyRef = inject(DestroyRef);
+    overlayElements = [];
+    constructor() { }
+    ngOnInit() {
+        // Initialize service with selectable columns
+        this.setupServiceConfiguration();
+        // Setup global mouseup listener
+        this.setupGlobalMouseEvents();
+        // Setup keyboard listener for copy (for test)
+        // this.setupCopyListener();
+    }
+    setupServiceConfiguration() {
+        // Pass selectable columns to service
+        this.service.selectableColumns = this.selectableColumns();
+        // Listen to service selection changes and emit
+        this.service.selectionChangeSubject
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => this.selectionChange.emit(event));
+        // Listen to right-click event
+        this.service.selectionRightClickSubject.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((event) => this.rightClick.emit(event));
+    }
+    setupGlobalMouseEvents() {
+        fromEvent(document, 'mouseup')
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => this.service.endMouseMove());
+    }
+    // For test purpose only (type CTRL+C)
+    setupCopyListener() {
+        fromEvent(document, 'keydown')
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => {
+            if ((event.ctrlKey || event.metaKey) && event.key === 'c') {
+                const cells = this.service.selectedCells;
+                if (isNotEmptyArray(cells)) {
+                    // Show overlay
+                    this.addCellsOverlay(cells);
+                    event.preventDefault();
+                    // Hide overlay after animation completes (1 second)
+                    setTimeout(() => {
+                        this.removeCellsOverlay();
+                    }, 1000);
+                }
+            }
+        });
+    }
+    addCellsOverlay(cells) {
+        // Remove existing overlays
+        this.removeCellsOverlay();
+        // Group cells into contiguous regions
+        const cellGroups = this.groupContiguousCells(cells);
+        // Create and render overlay for each contiguous region
+        cellGroups.forEach((group) => {
+            const bounds = this.calculateSelectionBounds(group);
+            if (bounds) {
+                const overlay = this.createOverlayElement(bounds);
+                this.renderer.appendChild(this.elementRef.nativeElement, overlay);
+                this.overlayElements.push(overlay);
+            }
+        });
+    }
+    removeCellsOverlay() {
+        this.overlayElements.forEach((overlay) => {
+            this.renderer.removeChild(this.elementRef.nativeElement, overlay);
+        });
+        this.overlayElements = [];
+    }
+    groupContiguousCells(cells) {
+        // Create a map for quick lookup
+        const cellMap = new Map();
+        cells.forEach((cell) => {
+            cellMap.set(this.getCellKey(cell), cell);
+        });
+        const visited = new Set();
+        const groups = [];
+        // Process each cell
+        cells.forEach((cell) => {
+            const key = this.getCellKey(cell);
+            if (visited.has(key)) {
+                return;
+            }
+            // Start a new contiguous group with flood-fill
+            const group = [];
+            const queue = [cell];
+            visited.add(key);
+            while (queue.length > 0) {
+                const current = queue.shift();
+                group.push(current);
+                // Check all 4 adjacent cells (up, down, left, right)
+                const neighbors = this.getAdjacentCells(current);
+                neighbors.forEach((neighbor) => {
+                    const neighborKey = this.getCellKey(neighbor);
+                    if (cellMap.has(neighborKey) && !visited.has(neighborKey)) {
+                        visited.add(neighborKey);
+                        queue.push(neighbor);
+                    }
+                });
+            }
+            groups.push(group);
+        });
+        return groups;
+    }
+    getAdjacentCells(cell) {
+        // Returns cells adjacent to the current cell (up, down, left, right)
+        // Note: We need to get column order from the actual table structure
+        // For now, we'll use a simple approach based on rowId adjacency
+        return [
+            { rowId: cell.rowId - 1, columnName: cell.columnName }, // up
+            { rowId: cell.rowId + 1, columnName: cell.columnName }, // down
+            { rowId: cell.rowId, columnName: this.getNextColumnName(cell.columnName, -1) }, // left
+            { rowId: cell.rowId, columnName: this.getNextColumnName(cell.columnName, 1) }, // right
+        ].filter((c) => c.columnName !== null);
+    }
+    getNextColumnName(currentColumnName, offset) {
+        const columns = this.service.selectableColumns;
+        const currentIndex = columns.indexOf(currentColumnName);
+        if (currentIndex === -1) {
+            return null;
+        }
+        const newIndex = currentIndex + offset;
+        if (newIndex < 0 || newIndex >= columns.length) {
+            return null;
+        }
+        return columns[newIndex];
+    }
+    getCellKey(cell) {
+        return `${cell.rowId}-${cell.columnName}`;
+    }
+    calculateSelectionBounds(cells) {
+        const container = this.elementRef.nativeElement;
+        // Find all selected cell elements
+        const cellElements = [];
+        cells.forEach((cell) => {
+            const cellElement = container.querySelector(`[data-row-id="${cell.rowId}"][data-column-name="${cell.columnName}"]`);
+            if (cellElement) {
+                cellElements.push(cellElement);
+            }
+        });
+        if (isEmptyArray(cellElements)) {
+            return null;
+        }
+        // Get container position
+        const containerRect = container.getBoundingClientRect();
+        // Calculate bounding box
+        let minTop = Infinity;
+        let minLeft = Infinity;
+        let maxBottom = -Infinity;
+        let maxRight = -Infinity;
+        cellElements.forEach((element) => {
+            const rect = element.getBoundingClientRect();
+            minTop = Math.min(minTop, rect.top - containerRect.top);
+            minLeft = Math.min(minLeft, rect.left - containerRect.left);
+            maxBottom = Math.max(maxBottom, rect.bottom - containerRect.top);
+            maxRight = Math.max(maxRight, rect.right - containerRect.left);
+        });
+        return {
+            top: minTop,
+            left: minLeft,
+            width: maxRight - minLeft,
+            height: maxBottom - minTop,
+        };
+    }
+    createOverlayElement(bounds) {
+        const overlay = this.renderer.createElement('div');
+        this.renderer.addClass(overlay, 'cell-selection-overlay');
+        // Set position and size
+        this.renderer.setStyle(overlay, 'top', `${bounds.top}px`);
+        this.renderer.setStyle(overlay, 'left', `${bounds.left}px`);
+        this.renderer.setStyle(overlay, 'width', `${bounds.width}px`);
+        this.renderer.setStyle(overlay, 'height', `${bounds.height}px`);
+        return overlay;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CellSelectionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.13", type: CellSelectionDirective, isStandalone: true, selector: "[appCellSelection]", inputs: { selectableColumns: { classPropertyName: "selectableColumns", publicName: "appSelectableColumns", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { selectionChange: "appCellSelectionChange", rightClick: "appCellRightClick" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CellSelectionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appCellSelection]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cell-selection.directive.js","sourceRoot":"","sources":["../../../../../../../src/app/shared/directives/cell-selection/cell-selection.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, Directive, ElementRef, inject, input, OnInit, output, Renderer2 } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { fromEvent } from 'rxjs';\nimport { APP_CELL_SELECTION_SERVICE_TOKEN, CellSelectionEvent, ICellId } from './cell-selection.service';\nimport { isEmptyArray, isNotEmptyArray } from '../../functions';\n\ninterface SelectionBounds {\n  top: number;\n  left: number;\n  width: number;\n  height: number;\n}\n\n@Directive({\n  selector: '[appCellSelection]',\n  standalone: true,\n})\nexport class CellSelectionDirective<C extends ICellId = ICellId> implements OnInit {\n  // Inputs\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  selectableColumns = input<string[]>([], { alias: 'appSelectableColumns' });\n\n  // Outputs\n  // eslint-disable-next-line @angular-eslint/no-output-rename\n  selectionChange = output<CellSelectionEvent<C>>({ alias: 'appCellSelectionChange' });\n  // eslint-disable-next-line @angular-eslint/no-output-rename\n  rightClick = output<MouseEvent>({ alias: 'appCellRightClick' });\n\n  // Inject service by token\n  protected service = inject(APP_CELL_SELECTION_SERVICE_TOKEN);\n\n  private readonly elementRef = inject(ElementRef);\n  private readonly renderer = inject(Renderer2);\n  private readonly destroyRef = inject(DestroyRef);\n  private overlayElements: HTMLElement[] = [];\n\n  constructor() {}\n\n  ngOnInit() {\n    // Initialize service with selectable columns\n    this.setupServiceConfiguration();\n    // Setup global mouseup listener\n    this.setupGlobalMouseEvents();\n    // Setup keyboard listener for copy (for test)\n    // this.setupCopyListener();\n  }\n\n  private setupServiceConfiguration() {\n    // Pass selectable columns to service\n    this.service.selectableColumns = this.selectableColumns();\n\n    // Listen to service selection changes and emit\n    this.service.selectionChangeSubject\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((event) => this.selectionChange.emit(event as CellSelectionEvent<C>));\n\n    // Listen to right-click event\n    this.service.selectionRightClickSubject.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((event) => this.rightClick.emit(event));\n  }\n\n  private setupGlobalMouseEvents() {\n    fromEvent<MouseEvent>(document, 'mouseup')\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe(() => this.service.endMouseMove());\n  }\n\n  // For test purpose only (type CTRL+C)\n  private setupCopyListener() {\n    fromEvent<KeyboardEvent>(document, 'keydown')\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((event) => {\n        if ((event.ctrlKey || event.metaKey) && event.key === 'c') {\n          const cells = this.service.selectedCells as C[];\n          if (isNotEmptyArray(cells)) {\n            // Show overlay\n            this.addCellsOverlay(cells);\n\n            event.preventDefault();\n\n            // Hide overlay after animation completes (1 second)\n            setTimeout(() => {\n              this.removeCellsOverlay();\n            }, 1000);\n          }\n        }\n      });\n  }\n\n  addCellsOverlay(cells: C[]) {\n    // Remove existing overlays\n    this.removeCellsOverlay();\n\n    // Group cells into contiguous regions\n    const cellGroups = this.groupContiguousCells(cells);\n\n    // Create and render overlay for each contiguous region\n    cellGroups.forEach((group) => {\n      const bounds = this.calculateSelectionBounds(group);\n      if (bounds) {\n        const overlay = this.createOverlayElement(bounds);\n        this.renderer.appendChild(this.elementRef.nativeElement, overlay);\n        this.overlayElements.push(overlay);\n      }\n    });\n  }\n\n  removeCellsOverlay() {\n    this.overlayElements.forEach((overlay) => {\n      this.renderer.removeChild(this.elementRef.nativeElement, overlay);\n    });\n    this.overlayElements = [];\n  }\n\n  private groupContiguousCells(cells: C[]): C[][] {\n    // Create a map for quick lookup\n    const cellMap = new Map<string, C>();\n    cells.forEach((cell) => {\n      cellMap.set(this.getCellKey(cell), cell);\n    });\n\n    const visited = new Set<string>();\n    const groups: C[][] = [];\n\n    // Process each cell\n    cells.forEach((cell) => {\n      const key = this.getCellKey(cell);\n      if (visited.has(key)) {\n        return;\n      }\n\n      // Start a new contiguous group with flood-fill\n      const group: C[] = [];\n      const queue: C[] = [cell];\n      visited.add(key);\n\n      while (queue.length > 0) {\n        const current = queue.shift()!;\n        group.push(current);\n\n        // Check all 4 adjacent cells (up, down, left, right)\n        const neighbors = this.getAdjacentCells(current);\n        neighbors.forEach((neighbor) => {\n          const neighborKey = this.getCellKey(neighbor);\n          if (cellMap.has(neighborKey) && !visited.has(neighborKey)) {\n            visited.add(neighborKey);\n            queue.push(neighbor);\n          }\n        });\n      }\n\n      groups.push(group);\n    });\n\n    return groups;\n  }\n\n  private getAdjacentCells(cell: C): C[] {\n    // Returns cells adjacent to the current cell (up, down, left, right)\n    // Note: We need to get column order from the actual table structure\n    // For now, we'll use a simple approach based on rowId adjacency\n    return [\n      { rowId: cell.rowId - 1, columnName: cell.columnName }, // up\n      { rowId: cell.rowId + 1, columnName: cell.columnName }, // down\n      { rowId: cell.rowId, columnName: this.getNextColumnName(cell.columnName, -1) }, // left\n      { rowId: cell.rowId, columnName: this.getNextColumnName(cell.columnName, 1) }, // right\n    ].filter((c) => c.columnName !== null) as C[];\n  }\n\n  private getNextColumnName(currentColumnName: string, offset: number): string | null {\n    const columns = this.service.selectableColumns;\n\n    const currentIndex = columns.indexOf(currentColumnName);\n    if (currentIndex === -1) {\n      return null;\n    }\n\n    const newIndex = currentIndex + offset;\n    if (newIndex < 0 || newIndex >= columns.length) {\n      return null;\n    }\n\n    return columns[newIndex];\n  }\n\n  private getCellKey(cell: C): string {\n    return `${cell.rowId}-${cell.columnName}`;\n  }\n\n  private calculateSelectionBounds(cells: C[]): SelectionBounds | null {\n    const container = this.elementRef.nativeElement as HTMLElement;\n\n    // Find all selected cell elements\n    const cellElements: HTMLElement[] = [];\n    cells.forEach((cell) => {\n      const cellElement = container.querySelector(`[data-row-id=\"${cell.rowId}\"][data-column-name=\"${cell.columnName}\"]`) as HTMLElement;\n      if (cellElement) {\n        cellElements.push(cellElement);\n      }\n    });\n\n    if (isEmptyArray(cellElements)) {\n      return null;\n    }\n\n    // Get container position\n    const containerRect = container.getBoundingClientRect();\n\n    // Calculate bounding box\n    let minTop = Infinity;\n    let minLeft = Infinity;\n    let maxBottom = -Infinity;\n    let maxRight = -Infinity;\n\n    cellElements.forEach((element) => {\n      const rect = element.getBoundingClientRect();\n      minTop = Math.min(minTop, rect.top - containerRect.top);\n      minLeft = Math.min(minLeft, rect.left - containerRect.left);\n      maxBottom = Math.max(maxBottom, rect.bottom - containerRect.top);\n      maxRight = Math.max(maxRight, rect.right - containerRect.left);\n    });\n\n    return {\n      top: minTop,\n      left: minLeft,\n      width: maxRight - minLeft,\n      height: maxBottom - minTop,\n    };\n  }\n\n  private createOverlayElement(bounds: SelectionBounds): HTMLElement {\n    const overlay = this.renderer.createElement('div');\n    this.renderer.addClass(overlay, 'cell-selection-overlay');\n\n    // Set position and size\n    this.renderer.setStyle(overlay, 'top', `${bounds.top}px`);\n    this.renderer.setStyle(overlay, 'left', `${bounds.left}px`);\n    this.renderer.setStyle(overlay, 'width', `${bounds.width}px`);\n    this.renderer.setStyle(overlay, 'height', `${bounds.height}px`);\n\n    return overlay;\n  }\n}\n"]}

package/esm2022/src/app/shared/directives/cell-selection/cell-selection.service.mjs

@@ -0,0 +1,186 @@
+import { inject, Injectable, InjectionToken } from '@angular/core';
+import { Subject } from 'rxjs';
+import { isEmptyArray } from '../../functions';
+import * as i0 from "@angular/core";
+export const APP_CELL_SELECTION_SERVICE_TOKEN = new InjectionToken('CellSelectionService');
+export const APP_CELL_SELECTION_SERVICE_CONFIG_TOKEN = new InjectionToken('CellSelectionServiceConfig');
+/**
+ * Service to manage cell selection state across multiple directive instances.
+ * This service should be provided at the component level (not root) to ensure
+ * proper isolation between different table instances.
+ */
+export class CellSelectionService {
+    // Configuration
+    config = inject(APP_CELL_SELECTION_SERVICE_CONFIG_TOKEN, { optional: true });
+    selectableColumns = [];
+    // Selection state
+    _selectedCells = [];
+    selectionStartCell = null;
+    isSelecting = false;
+    // Drag state
+    draggedCells = [];
+    dragStartCell = null;
+    isDragging = false;
+    // Observables
+    selectionChangeSubject = new Subject();
+    selectionRightClickSubject = new Subject();
+    // Overridable methods
+    _equals;
+    _new;
+    constructor() {
+        this._equals = this.config?.equals;
+        this._new = this.config?.new;
+    }
+    // Override method
+    equals(cell1, cell2) {
+        return this._equals ? this._equals(cell1, cell2) : cell1?.rowId === cell2?.rowId && cell1?.columnName === cell2?.columnName;
+    }
+    // Override method
+    new(cellId) {
+        return this._new ? this._new(cellId) : cellId;
+    }
+    get selectedCells() {
+        return this._selectedCells;
+    }
+    set selectedCells(value) {
+        this.emitSelection(value, false, false);
+    }
+    isCellSelected(cellId) {
+        return this.selectedCells.some((selectedCell) => this.equals(selectedCell, cellId));
+    }
+    isCellDragged(cellId) {
+        return this.draggedCells.some((selectedCell) => this.equals(selectedCell, cellId));
+    }
+    // Core selection logic (moved from CellIdentifierDirective)
+    async handleCellMouseDown(event, cellId) {
+        event.preventDefault();
+        if (event.button === 2) {
+            event.stopPropagation();
+            this.selectionRightClickSubject.next(event);
+            return;
+        }
+        const isCtrlKey = event.ctrlKey || event.metaKey;
+        const isShiftKey = event.shiftKey;
+        if (!isShiftKey && !isCtrlKey) {
+            this.startSelection(cellId);
+            // this.startDragSelection(cellId);
+        }
+        else if (isCtrlKey) {
+            this.toggleCellSelection(cellId);
+        }
+        else if (isShiftKey) {
+            this.selectRange(cellId);
+        }
+    }
+    async handleCellMouseEnter(event, cellId) {
+        // TODO check if next cell can be selected
+        if (this.isSelecting && this.selectionStartCell) {
+            this.updateSelection(cellId);
+        }
+        else if (this.isDragging && this.dragStartCell) {
+            this.updateDraggedCells(cellId);
+        }
+    }
+    endMouseMove() {
+        if (this.isSelecting) {
+            this.resetSelectionState();
+        }
+        else if (this.isDragging) {
+            this.resetDragState();
+        }
+    }
+    // Private helper methods
+    startSelection(cellId) {
+        this.selectionStartCell = cellId;
+        this.isSelecting = true;
+        this.emitSelection([cellId], false, false);
+    }
+    startDragSelection(cellId) {
+        this.dragStartCell = cellId;
+        this.isDragging = true;
+        this.draggedCells = [cellId];
+        // this.emitSelection([cellId], false, false);
+    }
+    toggleCellSelection(cellId) {
+        const currentCells = [...this.selectedCells];
+        const cellIndex = currentCells.findIndex((c) => this.equals(c, cellId));
+        if (cellIndex >= 0) {
+            currentCells.splice(cellIndex, 1);
+        }
+        else {
+            currentCells.push(cellId);
+        }
+        this.emitSelection(currentCells, false, true);
+    }
+    selectRange(endCell) {
+        const rangeCells = this.calculateRangeCells(endCell);
+        this.emitSelection(rangeCells, true, false);
+    }
+    updateSelection(currentCell) {
+        const rangeCells = this.calculateRangeBetweenCells(this.selectionStartCell, currentCell);
+        this.emitSelection(rangeCells, true, false);
+    }
+    updateDraggedCells(currentCell) {
+        // this.draggedCells.set(rangeCells);
+    }
+    emitSelection(cells, isRange, isToggle) {
+        this._selectedCells = cells;
+        this.selectionChangeSubject.next({
+            selectedCells: cells,
+            isRangeSelection: isRange,
+            isToggleSelection: isToggle,
+        });
+    }
+    calculateRangeCells(endCell) {
+        if (isEmptyArray(this.selectedCells)) {
+            return [endCell];
+        }
+        const lastSelectedCell = this.findFirstSelectedCell(this.selectedCells);
+        return this.calculateRangeBetweenCells(lastSelectedCell, endCell);
+    }
+    calculateRangeBetweenCells(startCell, endCell) {
+        // Get first cell coordinates, then add this cell as a range
+        const firstRowId = Math.min(startCell.rowId, endCell.rowId);
+        const lastRowId = Math.max(startCell.rowId, endCell.rowId);
+        const startColumnIndex = this.selectableColumns.indexOf(startCell.columnName);
+        const endColumnIndex = this.selectableColumns.indexOf(endCell.columnName);
+        const firstColumnIndex = Math.min(startColumnIndex, endColumnIndex);
+        const lastColumnIndex = Math.max(startColumnIndex, endColumnIndex);
+        // Iterate columns and rows
+        const rangeCells = [];
+        for (let i = firstColumnIndex; i <= lastColumnIndex; i++) {
+            const columnName = this.selectableColumns[i];
+            for (let rowId = firstRowId; rowId <= lastRowId; rowId++) {
+                rangeCells.push(this.new({ rowId: rowId, columnName: columnName }));
+            }
+        }
+        return rangeCells;
+    }
+    resetSelectionState() {
+        this.selectionStartCell = null;
+        this.isSelecting = false;
+    }
+    resetDragState() {
+        this.dragStartCell = null;
+        this.isDragging = false;
+        this.draggedCells = [];
+    }
+    findFirstSelectedCell(selectedCells) {
+        // Find the cell with the lowest rowId and columnIndex
+        return this.findSelectedCell(selectedCells, Math.min(...selectedCells.map((cell) => cell.rowId)), Math.min(...selectedCells.map((cell) => this.selectableColumns.indexOf(cell.columnName))));
+    }
+    findLastSelectedCell(selectedCells) {
+        // Find the cell with the lowest rowId and columnIndex
+        return this.findSelectedCell(selectedCells, Math.max(...selectedCells.map((cell) => cell.rowId)), Math.max(...selectedCells.map((cell) => this.selectableColumns.indexOf(cell.columnName))));
+    }
+    findSelectedCell(selectedCells, rowId, columnIndex) {
+        // Find the cell with the current indexes
+        return selectedCells.filter((cell) => cell.rowId === rowId && cell.columnName === this.selectableColumns[columnIndex])[0];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CellSelectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CellSelectionService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CellSelectionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cell-selection.service.js","sourceRoot":"","sources":["../../../../../../../src/app/shared/directives/cell-selection/cell-selection.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, InjectionToken } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { isEmptyArray } from '../../functions';\nimport { EqualsFn } from '../../types';\n\nexport const APP_CELL_SELECTION_SERVICE_TOKEN = new InjectionToken<CellSelectionService>('CellSelectionService');\nexport const APP_CELL_SELECTION_SERVICE_CONFIG_TOKEN = new InjectionToken<CellSelectionServiceConfig<any>>('CellSelectionServiceConfig');\n\nexport interface ICellId {\n  rowId: number;\n  columnName: string;\n}\n\nexport interface CellSelectionEvent<C extends ICellId> {\n  selectedCells: C[];\n  isRangeSelection: boolean;\n  isToggleSelection: boolean;\n}\n\nexport interface CellSelectionServiceConfig<C extends ICellId> {\n  equals: EqualsFn<C>;\n  new: (cellId: ICellId) => C;\n}\n\n/**\n * Service to manage cell selection state across multiple directive instances.\n * This service should be provided at the component level (not root) to ensure\n * proper isolation between different table instances.\n */\n@Injectable()\nexport class CellSelectionService<C extends ICellId = ICellId> {\n  // Configuration\n  config = inject(APP_CELL_SELECTION_SERVICE_CONFIG_TOKEN, { optional: true });\n  selectableColumns: string[] = [];\n\n  // Selection state\n  private _selectedCells: C[] = [];\n  private selectionStartCell: C | null = null;\n  private isSelecting = false;\n\n  // Drag state\n  draggedCells: C[] = [];\n  private dragStartCell: C | null = null;\n  private isDragging = false;\n\n  // Observables\n  readonly selectionChangeSubject = new Subject<CellSelectionEvent<C>>();\n  readonly selectionRightClickSubject = new Subject<MouseEvent>();\n\n  // Overridable methods\n  private readonly _equals: EqualsFn<C>;\n  private readonly _new: (cellId: ICellId) => C;\n\n  constructor() {\n    this._equals = this.config?.equals;\n    this._new = this.config?.new;\n  }\n\n  // Override method\n  equals(cell1: C, cell2: C): boolean {\n    return this._equals ? this._equals(cell1, cell2) : cell1?.rowId === cell2?.rowId && cell1?.columnName === cell2?.columnName;\n  }\n\n  // Override method\n  new(cellId: ICellId): C {\n    return this._new ? this._new(cellId) : (cellId as C);\n  }\n\n  get selectedCells(): C[] {\n    return this._selectedCells;\n  }\n\n  set selectedCells(value: C[]) {\n    this.emitSelection(value, false, false);\n  }\n\n  isCellSelected(cellId: C): boolean {\n    return this.selectedCells.some((selectedCell) => this.equals(selectedCell, cellId));\n  }\n\n  isCellDragged(cellId: C): boolean {\n    return this.draggedCells.some((selectedCell) => this.equals(selectedCell, cellId));\n  }\n\n  // Core selection logic (moved from CellIdentifierDirective)\n  async handleCellMouseDown(event: MouseEvent, cellId: C) {\n    event.preventDefault();\n\n    if (event.button === 2) {\n      event.stopPropagation();\n      this.selectionRightClickSubject.next(event);\n      return;\n    }\n\n    const isCtrlKey = event.ctrlKey || event.metaKey;\n    const isShiftKey = event.shiftKey;\n\n    if (!isShiftKey && !isCtrlKey) {\n      this.startSelection(cellId);\n      // this.startDragSelection(cellId);\n    } else if (isCtrlKey) {\n      this.toggleCellSelection(cellId);\n    } else if (isShiftKey) {\n      this.selectRange(cellId);\n    }\n  }\n\n  async handleCellMouseEnter(event: MouseEvent, cellId: C) {\n    // TODO check if next cell can be selected\n\n    if (this.isSelecting && this.selectionStartCell) {\n      this.updateSelection(cellId);\n    } else if (this.isDragging && this.dragStartCell) {\n      this.updateDraggedCells(cellId);\n    }\n  }\n\n  endMouseMove(): void {\n    if (this.isSelecting) {\n      this.resetSelectionState();\n    } else if (this.isDragging) {\n      this.resetDragState();\n    }\n  }\n\n  // Private helper methods\n  private startSelection(cellId: C): void {\n    this.selectionStartCell = cellId;\n    this.isSelecting = true;\n    this.emitSelection([cellId], false, false);\n  }\n\n  private startDragSelection(cellId: C): void {\n    this.dragStartCell = cellId;\n    this.isDragging = true;\n    this.draggedCells = [cellId];\n    // this.emitSelection([cellId], false, false);\n  }\n\n  private toggleCellSelection(cellId: C): void {\n    const currentCells = [...this.selectedCells];\n    const cellIndex = currentCells.findIndex((c) => this.equals(c, cellId));\n\n    if (cellIndex >= 0) {\n      currentCells.splice(cellIndex, 1);\n    } else {\n      currentCells.push(cellId);\n    }\n\n    this.emitSelection(currentCells, false, true);\n  }\n\n  private selectRange(endCell: C): void {\n    const rangeCells = this.calculateRangeCells(endCell);\n    this.emitSelection(rangeCells, true, false);\n  }\n\n  private updateSelection(currentCell: C): void {\n    const rangeCells = this.calculateRangeBetweenCells(this.selectionStartCell, currentCell);\n    this.emitSelection(rangeCells, true, false);\n  }\n\n  private updateDraggedCells(currentCell: C): void {\n    // this.draggedCells.set(rangeCells);\n  }\n\n  private emitSelection(cells: C[], isRange: boolean, isToggle: boolean): void {\n    this._selectedCells = cells;\n    this.selectionChangeSubject.next({\n      selectedCells: cells,\n      isRangeSelection: isRange,\n      isToggleSelection: isToggle,\n    });\n  }\n\n  calculateRangeCells(endCell: C): C[] {\n    if (isEmptyArray(this.selectedCells)) {\n      return [endCell];\n    }\n\n    const lastSelectedCell = this.findFirstSelectedCell(this.selectedCells);\n    return this.calculateRangeBetweenCells(lastSelectedCell, endCell);\n  }\n\n  calculateRangeBetweenCells(startCell: C, endCell: C): C[] {\n    // Get first cell coordinates, then add this cell as a range\n    const firstRowId = Math.min(startCell.rowId, endCell.rowId);\n    const lastRowId = Math.max(startCell.rowId, endCell.rowId);\n    const startColumnIndex = this.selectableColumns.indexOf(startCell.columnName);\n    const endColumnIndex = this.selectableColumns.indexOf(endCell.columnName);\n    const firstColumnIndex = Math.min(startColumnIndex, endColumnIndex);\n    const lastColumnIndex = Math.max(startColumnIndex, endColumnIndex);\n    // Iterate columns and rows\n    const rangeCells: C[] = [];\n    for (let i = firstColumnIndex; i <= lastColumnIndex; i++) {\n      const columnName = this.selectableColumns[i];\n      for (let rowId = firstRowId; rowId <= lastRowId; rowId++) {\n        rangeCells.push(this.new({ rowId: rowId, columnName: columnName }));\n      }\n    }\n\n    return rangeCells;\n  }\n\n  resetSelectionState(): void {\n    this.selectionStartCell = null;\n    this.isSelecting = false;\n  }\n\n  resetDragState(): void {\n    this.dragStartCell = null;\n    this.isDragging = false;\n    this.draggedCells = [];\n  }\n\n  private findFirstSelectedCell(selectedCells: C[]): C {\n    // Find the cell with the lowest rowId and columnIndex\n    return this.findSelectedCell(\n      selectedCells,\n      Math.min(...selectedCells.map((cell) => cell.rowId)),\n      Math.min(...selectedCells.map((cell) => this.selectableColumns.indexOf(cell.columnName)))\n    );\n  }\n\n  private findLastSelectedCell(selectedCells: C[]): C {\n    // Find the cell with the lowest rowId and columnIndex\n    return this.findSelectedCell(\n      selectedCells,\n      Math.max(...selectedCells.map((cell) => cell.rowId)),\n      Math.max(...selectedCells.map((cell) => this.selectableColumns.indexOf(cell.columnName)))\n    );\n  }\n\n  private findSelectedCell(selectedCells: C[], rowId: number, columnIndex: number): C {\n    // Find the cell with the current indexes\n    return selectedCells.filter((cell) => cell.rowId === rowId && cell.columnName === this.selectableColumns[columnIndex])[0];\n  }\n}\n"]}

package/esm2022/src/app/shared/directives/resizable/resizable.component.mjs

@@ -38,11 +38,11 @@ export class ResizableComponent {
         }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResizableComponent, deps: [{ token: i1.MatColumnDef, optional: true }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ResizableComponent, selector: "th[resizable]", inputs: { resizable: "resizable" }, outputs: { sizeChanged: "sizeChanged" }, host: { properties: { "style.width": "this.width", "style.min-width": "this.minWidth", "style.max-width": "this.maxWidth" } }, ngImport: i0, template: "<div class=\"wrapper\">\n  <div class=\"content\">\n    <ng-content></ng-content>\n  </div>\n  <div class=\"bar\" [class.cdk-visually-hidden]=\"!resizable\" (resizable)=\"onResize($event)\" (fit)=\"onFit()\"></div>\n</div>\n", styles: [":host:last-child .bar{display:none}.wrapper{display:flex;justify-content:flex-end;align-items:center}.content{flex:1}.bar{height:var(--app-table-header-height, 55px);width:10px;justify-self:flex-end;border-left:4px solid transparent;border-right:4px solid transparent;background:var(--ion-color-secondary);background-clip:content-box;cursor:ew-resize;opacity:0;transition:opacity .3s}.bar:hover,.bar:active{opacity:1}:host-context(.mat-table-sticky) .bar{width:12px!important}\n"], dependencies: [{ kind: "directive", type: i2.ResizableDirective, selector: "[resizable]", outputs: ["resizable", "fit"] }] });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ResizableComponent, selector: "th[resizable]", inputs: { resizable: "resizable" }, outputs: { sizeChanged: "sizeChanged" }, host: { properties: { "style.width": "this.width", "style.min-width": "this.minWidth", "style.max-width": "this.maxWidth" } }, ngImport: i0, template: "<div class=\"wrapper\">\n  <div class=\"content\">\n    <ng-content></ng-content>\n  </div>\n  <div class=\"bar\" [class.cdk-visually-hidden]=\"!resizable\" (resizable)=\"onResize($event)\" (fit)=\"onFit()\"></div>\n</div>\n", styles: [":host:last-child .bar{display:none}.wrapper{display:flex;justify-content:flex-end;align-items:center;position:relative;height:var(--app-table-header-height, 100%)}.content{flex:1}.bar{position:relative;width:16px;justify-self:flex-end;cursor:ew-resize;opacity:0;transition:opacity .2s ease-in-out}.bar:before{content:\"\";position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:2px;height:24px;background:var(--ion-color-medium, #92949c);border-radius:1px;transition:all .2s ease-in-out}.bar:after{content:\"\";position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:4px;height:16px;background-image:radial-gradient(circle,var(--ion-color-medium-shade, #808289) 1.5px,transparent 1.5px);background-size:4px 5px;background-position:center;opacity:0;transition:opacity .2s ease-in-out}.bar:hover{opacity:1}.bar:hover:before{background:var(--ion-color-primary, #3880ff);height:32px;width:6px;box-shadow:0 0 8px rgba(var(--ion-color-primary-rgb, 56, 128, 255),.4)}.bar:hover:after{opacity:1}.bar:active{opacity:1}.bar:active:before{background:var(--ion-color-primary-shade, #3171e0);height:40px;width:6px;box-shadow:0 0 12px rgba(var(--ion-color-primary-rgb, 56, 128, 255),.6)}.bar:active:after{opacity:0}:host:hover .bar{opacity:.6}:host-context(.mat-table-sticky) .bar{width:18px}:host-context(.dark-theme) .bar:before,:host-context([color-scheme=dark]) .bar:before{background:var(--ion-color-medium-tint, #a2a4ab)}:host-context(.dark-theme) .bar:hover:before,:host-context([color-scheme=dark]) .bar:hover:before{background:var(--ion-color-primary-tint, #4c8dff)}:host-context(.dark-theme) .bar:active:before,:host-context([color-scheme=dark]) .bar:active:before{background:var(--ion-color-primary, #3880ff)}\n"], dependencies: [{ kind: "directive", type: i2.ResizableDirective, selector: "[resizable]", inputs: ["minWidth"], outputs: ["resizable", "fit"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResizableComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'th[resizable]', template: "<div class=\"wrapper\">\n  <div class=\"content\">\n    <ng-content></ng-content>\n  </div>\n  <div class=\"bar\" [class.cdk-visually-hidden]=\"!resizable\" (resizable)=\"onResize($event)\" (fit)=\"onFit()\"></div>\n</div>\n", styles: [":host:last-child .bar{display:none}.wrapper{display:flex;justify-content:flex-end;align-items:center}.content{flex:1}.bar{height:var(--app-table-header-height, 55px);width:10px;justify-self:flex-end;border-left:4px solid transparent;border-right:4px solid transparent;background:var(--ion-color-secondary);background-clip:content-box;cursor:ew-resize;opacity:0;transition:opacity .3s}.bar:hover,.bar:active{opacity:1}:host-context(.mat-table-sticky) .bar{width:12px!important}\n"] }]
+            args: [{ selector: 'th[resizable]', template: "<div class=\"wrapper\">\n  <div class=\"content\">\n    <ng-content></ng-content>\n  </div>\n  <div class=\"bar\" [class.cdk-visually-hidden]=\"!resizable\" (resizable)=\"onResize($event)\" (fit)=\"onFit()\"></div>\n</div>\n", styles: [":host:last-child .bar{display:none}.wrapper{display:flex;justify-content:flex-end;align-items:center;position:relative;height:var(--app-table-header-height, 100%)}.content{flex:1}.bar{position:relative;width:16px;justify-self:flex-end;cursor:ew-resize;opacity:0;transition:opacity .2s ease-in-out}.bar:before{content:\"\";position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:2px;height:24px;background:var(--ion-color-medium, #92949c);border-radius:1px;transition:all .2s ease-in-out}.bar:after{content:\"\";position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:4px;height:16px;background-image:radial-gradient(circle,var(--ion-color-medium-shade, #808289) 1.5px,transparent 1.5px);background-size:4px 5px;background-position:center;opacity:0;transition:opacity .2s ease-in-out}.bar:hover{opacity:1}.bar:hover:before{background:var(--ion-color-primary, #3880ff);height:32px;width:6px;box-shadow:0 0 8px rgba(var(--ion-color-primary-rgb, 56, 128, 255),.4)}.bar:hover:after{opacity:1}.bar:active{opacity:1}.bar:active:before{background:var(--ion-color-primary-shade, #3171e0);height:40px;width:6px;box-shadow:0 0 12px rgba(var(--ion-color-primary-rgb, 56, 128, 255),.6)}.bar:active:after{opacity:0}:host:hover .bar{opacity:.6}:host-context(.mat-table-sticky) .bar{width:18px}:host-context(.dark-theme) .bar:before,:host-context([color-scheme=dark]) .bar:before{background:var(--ion-color-medium-tint, #a2a4ab)}:host-context(.dark-theme) .bar:hover:before,:host-context([color-scheme=dark]) .bar:hover:before{background:var(--ion-color-primary-tint, #4c8dff)}:host-context(.dark-theme) .bar:active:before,:host-context([color-scheme=dark]) .bar:active:before{background:var(--ion-color-primary, #3880ff)}\n"] }]
         }], ctorParameters: () => [{ type: i1.MatColumnDef, decorators: [{
                     type: Optional
                 }] }], propDecorators: { resizable: [{