data-grid-workspace 0.0.120

package/projects/data-grid/src/lib/pipes/filter.pipe.ts

@@ -0,0 +1,22 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'filter',
+})
+export class FilterPipe implements PipeTransform {
+transform(items: any[], searchText: string, key?: string): any[] {
+  if (!items || !searchText) return items;
+ 
+  const lowerSearch = searchText.toLowerCase();
+ 
+  return items.filter(item => {
+    if (key && item && typeof item === 'object') {
+      const value = item[key];
+      return value?.toString().toLowerCase().includes(lowerSearch);
+    }
+    if (typeof item === 'string' || typeof item === 'number') {
+      return item.toString().toLowerCase().includes(lowerSearch);
+    }
+    return false;
+  });
+}}

package/projects/data-grid/src/lib/pipes/format-currency.pipe.spec.ts

@@ -0,0 +1,11 @@
+/* tslint:disable:no-unused-variable */
+
+import { TestBed, async } from '@angular/core/testing';
+import { FormatCurrencyPipe } from './format-currency.pipe';
+
+describe('Pipe: FormatCurrencye', () => {
+  it('create an instance', () => {
+    let pipe = new FormatCurrencyPipe();
+    expect(pipe).toBeTruthy();
+  });
+});

package/projects/data-grid/src/lib/pipes/format-currency.pipe.ts

@@ -0,0 +1,59 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'formatCurrencies',
+})
+export class FormatCurrencyPipe implements PipeTransform {
+  transform(value: number | string, currencyFormat: string): string {
+    if (value == null || value === '' || !value) return '';
+
+    const numericValue = typeof value === 'string' ? parseFloat(value) : value;
+    if (isNaN(numericValue)) return '';
+
+
+    let [integerPart, decimalPart] = numericValue.toFixed(2).split('.');
+
+
+    let formattedInteger = integerPart;
+
+    switch (currencyFormat) {
+      case '1,234,567.89':
+        formattedInteger = new Intl.NumberFormat('en-US', {
+          style: 'decimal',
+          minimumFractionDigits: 0,
+          maximumFractionDigits: 0,
+        }).format(Number(integerPart));
+        break;
+
+      case '12,34,567.89':
+        formattedInteger = new Intl.NumberFormat('en-IN', {
+          style: 'decimal',
+          minimumFractionDigits: 0,
+          maximumFractionDigits: 0,
+        }).format(Number(integerPart)).replace(/(\d)(?=(\d{2})+\d)/g, '$1,');
+        break;
+
+      case '1234567,89':
+        formattedInteger = new Intl.NumberFormat('fr-FR', {
+          style: 'decimal',
+          minimumFractionDigits: 0,
+          maximumFractionDigits: 0,
+        }).format(Number(integerPart)).replace(',', '.');
+        break;
+
+      case '1.234.567,89':
+        formattedInteger = new Intl.NumberFormat('de-DE', {
+          style: 'decimal',
+          minimumFractionDigits: 0,
+          maximumFractionDigits: 0,
+        }).format(Number(integerPart)).replace('.', ',');
+        break;
+
+      default:
+        formattedInteger = integerPart;
+    }
+
+    return `${formattedInteger}.${decimalPart}`;
+  }
+
+}

package/projects/data-grid/src/lib/pipes/format-index.pipe.spec.ts

@@ -0,0 +1,11 @@
+/* tslint:disable:no-unused-variable */
+
+import { TestBed, async } from '@angular/core/testing';
+import { FormatIndexPipe } from './format-index.pipe';
+
+describe('Pipe: FormatIndexe', () => {
+  it('create an instance', () => {
+    let pipe = new FormatIndexPipe();
+    expect(pipe).toBeTruthy();
+  });
+});

package/projects/data-grid/src/lib/pipes/format-index.pipe.ts

@@ -0,0 +1,20 @@
+// format-index.pipe.ts
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'formatIndex'
+})
+export class FormatIndexPipe implements PipeTransform {
+
+  transform(value: number): string {
+    if (value === null || value === undefined) return '';
+
+    if (value > 9999) {
+      // divide by 1000 and keep two decimals
+      return (value / 1000).toFixed(2) + 'k';
+    }
+
+    return value.toString();
+  }
+
+}

package/projects/data-grid/src/lib/services/cell-selection.service.spec.ts

@@ -0,0 +1,16 @@
+// /* tslint:disable:no-unused-variable */
+
+// import { TestBed, async, inject } from '@angular/core/testing';
+// import { CellSelectionService } from './cell-selection.service';
+
+// describe('Service: CellSelection', () => {
+//   beforeEach(() => {
+//     TestBed.configureTestingModule({
+//       providers: [CellSelectionService]
+//     });
+//   });
+
+//   it('should ...', inject([CellSelectionService], (service: CellSelectionService) => {
+//     expect(service).toBeTruthy();
+//   }));
+// });

package/projects/data-grid/src/lib/services/cell-selection.service.ts

@@ -0,0 +1,372 @@
+// selection.service.ts
+import { Injectable } from '@angular/core';
+
+export interface SelectionRange {
+  startRow: number;
+  startGroupIndex: number;
+  startSubColIndex: number;
+  startField: string;
+  endRow: number;
+  endGroupIndex: number;
+  endSubColIndex: number;
+  endField: string;
+}
+
+export interface ActiveCell {
+  row: number;
+  groupIndex: number;
+  subColIndex: number;
+  field: string;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CellSelectionService {
+  private selectionRange: SelectionRange | null = null;
+  private activeCell: ActiveCell | null = null;
+  private isSelecting = false;
+  getSelection(): SelectionRange | null {
+    return this.selectionRange;
+  }
+
+  getActiveCell(): ActiveCell | null {
+    return this.activeCell;
+  }
+
+  isSelected(row: number, groupIndex: number, subColIndex: number, field: string): boolean {
+    if (!this.selectionRange) return false;
+
+    const {
+      startRow,
+      startGroupIndex,
+      startSubColIndex,
+      startField,
+      endRow,
+      endGroupIndex,
+      endSubColIndex,
+      endField
+    } = this.selectionRange;
+
+    const minRow = Math.min(startRow, endRow);
+    const maxRow = Math.max(startRow, endRow);
+
+    const isSameGroup = startGroupIndex === endGroupIndex;
+    const isSameField = startField === endField;
+
+    if (isSameGroup && isSameField) {
+      const minSubCol = Math.min(startSubColIndex, endSubColIndex);
+      const maxSubCol = Math.max(startSubColIndex, endSubColIndex);
+
+      return row >= minRow &&
+        row <= maxRow &&
+        groupIndex === startGroupIndex &&
+        field === startField &&
+        subColIndex >= minSubCol &&
+        subColIndex <= maxSubCol;
+    } else if (isSameGroup) {
+
+      const fieldsInGroup = this.getFieldsInGroup(groupIndex);
+      const startFieldIndex = fieldsInGroup.indexOf(startField);
+      const endFieldIndex = fieldsInGroup.indexOf(endField);
+      const minFieldIndex = Math.min(startFieldIndex, endFieldIndex);
+      const maxFieldIndex = Math.max(startFieldIndex, endFieldIndex);
+      const currentFieldIndex = fieldsInGroup.indexOf(field);
+
+      return row >= minRow &&
+        row <= maxRow &&
+        groupIndex === startGroupIndex &&
+        currentFieldIndex >= minFieldIndex &&
+        currentFieldIndex <= maxFieldIndex;
+    } else {
+      const minGroup = Math.min(startGroupIndex, endGroupIndex);
+      const maxGroup = Math.max(startGroupIndex, endGroupIndex);
+
+      if (groupIndex === startGroupIndex) {
+        const fieldsInGroup = this.getFieldsInGroup(groupIndex);
+        const startFieldIndex = fieldsInGroup.indexOf(startField);
+        const currentFieldIndex = fieldsInGroup.indexOf(field);
+
+        return row >= minRow &&
+          row <= maxRow &&
+          currentFieldIndex >= (startGroupIndex === minGroup ? startFieldIndex : 0) &&
+          currentFieldIndex <= (startGroupIndex === maxGroup ? startFieldIndex : fieldsInGroup.length - 1);
+      }
+
+      if (groupIndex === endGroupIndex) {
+        const fieldsInGroup = this.getFieldsInGroup(groupIndex);
+        const endFieldIndex = fieldsInGroup.indexOf(endField);
+        const currentFieldIndex = fieldsInGroup.indexOf(field);
+
+        return row >= minRow &&
+          row <= maxRow &&
+          currentFieldIndex >= (endGroupIndex === minGroup ? endFieldIndex : 0) &&
+          currentFieldIndex <= (endGroupIndex === maxGroup ? endFieldIndex : fieldsInGroup.length - 1);
+      }
+
+      return row >= minRow &&
+        row <= maxRow &&
+        groupIndex > minGroup &&
+        groupIndex < maxGroup;
+    }
+  }
+
+  isActiveCell(row: number, groupIndex: number, subColIndex: number, field: string): boolean {
+    return this.activeCell?.row === row &&
+      this.activeCell?.groupIndex === groupIndex &&
+      this.activeCell?.subColIndex === subColIndex &&
+      this.activeCell?.field === field;
+  }
+
+  // startSelection(row: number, groupIndex: number, subColIndex: number, field: string): void {
+  //   this.isSelecting = true;
+  //   this.selectionRange = {
+  //     startRow: row,
+  //     startGroupIndex: groupIndex,
+  //     startSubColIndex: subColIndex,
+  //     startField: field,
+  //     endRow: row,
+  //     endGroupIndex: groupIndex,
+  //     endSubColIndex: subColIndex,
+  //     endField: field
+  //   };
+  //   this.activeCell = { row, groupIndex, subColIndex, field };
+  // }
+
+  // extendSelection(row: number, groupIndex: number, subColIndex: number, field: string): void {
+  //   if (this.isSelecting && this.selectionRange) {
+  //     this.selectionRange.endRow = row;
+  //     this.selectionRange.endGroupIndex = groupIndex;
+  //     this.selectionRange.endSubColIndex = subColIndex;
+  //     this.selectionRange.endField = field;
+  //   }
+  // }
+
+  // endSelection(): void {
+  //   this.isSelecting = false;
+  // }
+
+  // clearSelection(): void {
+  //   this.selectionRange = null;
+  //   this.activeCell = null;
+  // }
+
+  // moveSelection(direction: 'up' | 'down' | 'left' | 'right', columnStructure: any[]): void {
+  //   if (!this.activeCell) return;
+
+  //   let { row, groupIndex, subColIndex, field } = this.activeCell;
+
+  //   switch (direction) {
+  //     case 'up':
+  //       row--;
+  //       break;
+  //     case 'down':
+  //       row++;
+  //       break;
+  //     case 'left':
+  //       if (subColIndex > 0) {
+  //         subColIndex--;
+  //         field = this.getFieldFromIndices(groupIndex, subColIndex, columnStructure);
+  //       } else if (groupIndex > 0) {
+  //         groupIndex--;
+  //         subColIndex = columnStructure[groupIndex].children.length - 1;
+  //         field = this.getFieldFromIndices(groupIndex, subColIndex, columnStructure);
+  //       }
+  //       break;
+  //     case 'right':
+  //       if (subColIndex < columnStructure[groupIndex].children.length - 1) {
+  //         subColIndex++;
+  //         field = this.getFieldFromIndices(groupIndex, subColIndex, columnStructure);
+  //       } else if (groupIndex < columnStructure.length - 1) {
+  //         groupIndex++;
+  //         subColIndex = 0;
+  //         field = this.getFieldFromIndices(groupIndex, subColIndex, columnStructure);
+  //       }
+  //       break;
+  //   }
+
+  //   this.startSelection(row, groupIndex, subColIndex, field);
+  //   this.endSelection();
+  // }
+
+  // private getFieldFromIndices(groupIndex: number, subColIndex: number, columnStructure: any[]): string {
+  //   if (groupIndex >= 0 &&
+  //     groupIndex < columnStructure.length &&
+  //     subColIndex >= 0 &&
+  //     subColIndex < columnStructure[groupIndex].children.length) {
+  //     return columnStructure[groupIndex].children[subColIndex].field;
+  //   }
+  //   return '';
+  // }
+
+  private getFieldsInGroup(groupIndex: number): string[] {
+    return [];
+  }
+
+
+
+  flatColumns: any[] = [];
+flatIndexMap: Record<string, number> = {}; 
+totalCols = 0;
+
+buildFlatColumns(columnStructure: any[]): void {
+  const left: any[] = [];
+  const center: any[] = [];
+  const right: any[] = [];
+
+  columnStructure.forEach((group, groupIndex) => {
+    group.children.forEach((col: { pinned: any; pin: any; }, subColIndex: any) => {
+      const item = {
+        ...col,
+        groupIndex,
+        subColIndex,
+        pinned: col.pinned || col.pin || null
+      };
+
+      if (item.pinned === 'left') left.push(item);
+      else if (item.pinned === 'right') right.push(item);
+      else center.push(item);
+    });
+  });
+
+  // Store full flat structure
+  this.flatColumns = [...left, ...center, ...right];
+  this.totalCols = this.flatColumns.length;
+
+  // Build O(1) lookup map
+  this.flatIndexMap = {};
+  this.flatColumns.forEach((col, index) => {
+    this.flatIndexMap[col.field] = index;
+  });
+}
+
+
+
+
+
+
+
+  private flattenColumns(columnStructure: any[]): any[] {
+  const left: any[] = [];
+  const center: any[] = [];
+  const right: any[] = [];
+
+  columnStructure.forEach((group, groupIndex) => {
+    group.children.forEach((col: { pinned: any; pin: any; }, subColIndex: any) => {
+      const item = {
+        ...col,
+        groupIndex,
+        subColIndex,
+        pinned: col.pinned || col.pin || null // support multiple names
+      };
+
+      if (item.pinned === 'left') left.push(item);
+      else if (item.pinned === 'right') right.push(item);
+      else center.push(item);
+    });
+  });
+
+  // Build a single continuous sequence for navigation
+  return [
+    ...left,
+    ...center,
+    ...right
+  ];
+}
+
+private findColumn(flat: any[], field: string) {
+  return flat.find(c => c.field === field);
+}
+
+// isSelecting = false;
+// activeCell: any = null;
+// selectionRange: any = null;
+
+
+startSelection(row: number, groupIndex: number, subColIndex: number, field: string): void {
+  this.isSelecting = true;
+
+  this.selectionRange = {
+    startRow: row,
+    startGroupIndex: groupIndex,
+    startSubColIndex: subColIndex,
+    startField: field,
+    endRow: row,
+    endGroupIndex: groupIndex,
+    endSubColIndex: subColIndex,
+    endField: field
+  };
+
+  this.activeCell = { row, groupIndex, subColIndex, field };
+}
+
+extendSelection(row: number, groupIndex: number, subColIndex: number, field: string): void {
+  if (!this.isSelecting || !this.selectionRange) return;
+
+  this.selectionRange.endRow = row;
+  this.selectionRange.endGroupIndex = groupIndex;
+  this.selectionRange.endSubColIndex = subColIndex;
+  this.selectionRange.endField = field;
+}
+
+endSelection(): void {
+  this.isSelecting = false;
+}
+
+clearSelection(): void {
+  this.selectionRange = null;
+  this.activeCell = null;
+}
+
+
+moveSelection(
+  direction: 'up' | 'down' | 'left' | 'right',
+  columnStructure: any[],
+  rowCount: number
+): void {
+  if (!this.activeCell) return;
+
+  let { row, field } = this.activeCell;
+
+  // Fast O(1) lookup
+  let currentIndex = this.flatIndexMap[field];
+  if (currentIndex == null) return;
+
+  let newIndex = currentIndex;
+
+  switch (direction) {
+    case 'up':
+      row = Math.max(0, row - 1);
+      break;
+
+    case 'down':
+      row = Math.min(rowCount - 1, row + 1);
+      break;
+
+    case 'left':
+      newIndex = Math.max(0, currentIndex - 1);
+      break;
+
+    case 'right':
+      newIndex = Math.min(this.totalCols - 1, currentIndex + 1);
+      break;
+  }
+
+  const newCol = this.flatColumns[newIndex];
+  if (!newCol) return;
+
+  const { groupIndex, subColIndex } = newCol;
+
+  this.startSelection(row, groupIndex, subColIndex, newCol.field);
+  this.endSelection();
+}
+
+
+
+getFieldFromIndices(groupIndex: number, subColIndex: number, columnStructure: any[]): string {
+  return columnStructure[groupIndex].children[subColIndex].field;
+}
+
+
+
+}

package/projects/data-grid/src/lib/services/common.service.spec.ts

@@ -0,0 +1,16 @@
+/* tslint:disable:no-unused-variable */
+
+import { TestBed, async, inject } from '@angular/core/testing';
+import { CommonService } from './common.service';
+
+describe('Service: Common', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [CommonService]
+    });
+  });
+
+  it('should ...', inject([CommonService], (service: CommonService) => {
+    expect(service).toBeTruthy();
+  }));
+});