ms-data-grid 0.0.59 → 0.0.61

package/src/lib/data-grid/statuses.ts

@@ -1,49 +0,0 @@
-export const STATUSES_BADGE_MAP: { [key: string]: string } = {
-  //  Success – Green
-  'active': 'badge badge-success',
-  'approved': 'badge badge-success',
-  'accepted': 'badge badge-success',
-  'completed': 'badge badge-success',
-  'evaluated': 'badge badge-success',
-  'assigned': 'badge badge-success',
-  'scrap': 'badge badge-success',
-  'move-available': 'badge badge-success',
-  'move-assigned': 'badge badge-success',
-
-  // Warning – Yellow/Amber
-  'contract': 'badge badge-warning',
-  'warranty': 'badge badge-warning',
-  'scheduled': 'badge badge-warning',
-  'leased': 'badge badge-warning',
-  'disposed': 'badge badge-warning',
-  'maintenance': 'badge badge-warning',
-  'assigning start': 'badge badge-warning',
-  'evaluation start': 'badge badge-warning',
-  'to be start assigning': 'badge badge-warning',
-  'pending': 'badge badge-warning',
-  'leave': 'badge badge-warning',
-
-  //  Danger – Red
-  'inactive': 'badge badge-danger',
-  'rejected': 'badge badge-danger',
-  'unassigned': 'badge badge-danger',
-  'trashed': 'badge badge-danger',
-  'onhold': 'badge badge-danger',
-  'assigning stop': 'badge badge-danger',
-  'evaluation stop': 'badge badge-danger',
-  'unavailable': 'badge badge-danger',
-  'move-error': 'badge badge-danger',
-  'failed': 'badge badge-danger',
-  'absent': 'badge badge-danger',
-
-  //  Info – Blue
-  'insurance': 'badge badge-info',
-  'pastdue': 'badge badge-info',
-
-  //  Dark – Neutral/Other
-  'expired': 'badge badge-dark',
-  'draft': 'badge badge-dark',
-  'present': 'badge badge-success',
-
-  'todo': 'badge badge-secondary',
-};

package/src/lib/data-grid.module.ts

@@ -1,21 +0,0 @@
-import { NgModule } from '@angular/core';
-import { DataGridComponent } from './data-grid/data-grid.component';
-import { CommonModule } from '@angular/common';
-import { FormsModule } from '@angular/forms';
-import { FilterPipe } from './pipes/filter.pipe';
-import { DragDropModule } from '@angular/cdk/drag-drop';
-import { InlineSVGModule } from 'ng-inline-svg';
-import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
-import { ScrollingModule } from '@angular/cdk/scrolling'; 
-import { CellHostDirective } from './directives/cellHost.directive'; 
-import { CellRenderInitDirective } from './directives/cell-render-init.directive'; 
-
-
-
-@NgModule({
-  declarations: [DataGridComponent, FilterPipe, CellHostDirective, CellRenderInitDirective  ],
-  imports: [CommonModule, FormsModule, DragDropModule, InlineSVGModule.forRoot(), ScrollingModule],
-  exports: [DataGridComponent],
-  providers: [],
-})
-export class DataGridModule {}

package/src/lib/data-grid.service.spec.ts

@@ -1,16 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-
-import { DataGridService } from './data-grid.service';
-
-describe('DataGridService', () => {
-  let service: DataGridService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({});
-    service = TestBed.inject(DataGridService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-});

package/src/lib/data-grid.service.ts

@@ -1,9 +0,0 @@
-import { Injectable } from '@angular/core';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class DataGridService {
-
-  constructor() { }
-}

package/src/lib/directives/cell-render-init.directive.spec.ts

@@ -1,11 +0,0 @@
-/* tslint:disable:no-unused-variable */
-
-import { TestBed, async } from '@angular/core/testing';
-import { CellRenderInitDirective } from './cell-render-init.directive';
-
-describe('Directive: CellRenderInit', () => {
-  it('should create an instance', () => {
-    const directive = new CellRenderInitDirective();
-    expect(directive).toBeTruthy();
-  });
-});

package/src/lib/directives/cell-render-init.directive.ts

@@ -1,65 +0,0 @@
-import {
-  Directive,
-  Input,
-  OnInit,
-  ViewContainerRef,
-  Injector,
-  ComponentRef,
-  Type,
-  EventEmitter,
-  Output
-} from '@angular/core';
-
-@Directive({
-  selector: '[cellRenderInit]'
-})
-export class CellRenderInitDirective implements OnInit {
-  @Input('cellRenderInit') componentType!: Type<any>;
-  @Input() rowData: any;
-  @Input() colData: any;
-  @Input() cellValue: any;
-
-  @Output() cellEvent = new EventEmitter<{ eventName: string; data: any }>();
-
-  constructor(private vcr: ViewContainerRef, private injector: Injector) { }
-
-  ngOnInit(): void {
-    if (!this.componentType) return;
-
-    // ✅ Dynamically create the component
-    const componentRef: ComponentRef<any> = this.vcr.createComponent(this.componentType, {
-      injector: Injector.create({
-        providers: [
-          { provide: 'rowData', useValue: this.rowData },
-          { provide: 'colData', useValue: this.colData },
-          { provide: 'cellValue', useValue: this.cellValue }
-        ],
-        parent: this.injector
-      })
-    });
-
-    // ✅ Automatically call custom lifecycle hook if present
-    if (typeof componentRef.instance.gridInit === 'function') {
-      componentRef.instance.gridInit({
-        row: this.rowData,
-        col: this.colData,
-        value: this.cellValue
-      });
-    }
-    for (const key of Object.keys(componentRef.instance)) {
-      const property = componentRef.instance[key];
-      if (property instanceof EventEmitter) {
-        property.subscribe((value: any) => {
-          this.cellEvent.emit({
-            eventName: key,
-            data: {
-              row: this.rowData,
-              col: this.colData,
-              value,
-            }
-          });
-        });
-      }
-    }
-  }
-}

package/src/lib/directives/cellHost.directive.spec.ts

@@ -1,11 +0,0 @@
-/* tslint:disable:no-unused-variable */
-
-import { TestBed, async } from '@angular/core/testing';
-import { CellHostDirective } from './cellHost.directive';
-
-describe('Directive: CellHost', () => {
-  it('should create an instance', () => {
-    const directive = new CellHostDirective();
-    expect(directive).toBeTruthy();
-  });
-});

package/src/lib/directives/cellHost.directive.ts

@@ -1,10 +0,0 @@
-import { Directive, ViewContainerRef } from '@angular/core';
-
-@Directive({
-  selector: '[cellHost]'
-})
-export class CellHostDirective  {
-
-  constructor(public viewContainerRef: ViewContainerRef) {}
-
-}

package/src/lib/directives/draggable-header.directive.spec.ts

@@ -1,11 +0,0 @@
-/* tslint:disable:no-unused-variable */
-
-import { TestBed, async } from '@angular/core/testing';
-import { DraggableHeaderDirective } from './draggable-header.directive';
-
-describe('Directive: DraggableHeader', () => {
-  it('should create an instance', () => {
-    const directive = new DraggableHeaderDirective();
-    expect(directive).toBeTruthy();
-  });
-});

package/src/lib/directives/draggable-header.directive.ts

@@ -1,172 +0,0 @@
-import {
-  Directive,
-  ElementRef,
-  EventEmitter,
-  HostListener,
-  Input,
-  Output,
-  Renderer2,
-} from '@angular/core';
-
-export interface DragMoveEvent {
-  event: MouseEvent;
-  data: any;
-}
-
-@Directive({
-  selector: '[appDraggableHeader]',
-})
-export class DraggableHeaderDirective {
-  @Input() column: any;
-  @Input() headerName: string = '';
-
-  @Output() dragStart = new EventEmitter<any>();
-  @Output() dragMove = new EventEmitter<any>();
-  @Output() dragEnd = new EventEmitter<any>();
-
-  private isDragging = false;
-  private placeholderEl: HTMLElement | null = null;
-  private previewEl: HTMLElement | null = null;
-
-  constructor(private el: ElementRef, private renderer: Renderer2) {}
-
-  startX = 0;
-  startY = 0;
-
-  @HostListener('mousedown', ['$event'])
-  onMouseDown(event: MouseEvent) {
-    if (event.button !== 0) return;
-    let target = event.target as HTMLElement;
-    const classes = target.classList;
-    debugger
-    if ((event.target as HTMLElement).classList.contains('three-dots')) return;
-      this.startX = event.clientX;
-    this.startY = event.clientY;
-    this.isDragging = false;
-
-    document.addEventListener('mousemove', this.onMouseMove);
-    document.addEventListener('mouseup', this.onMouseUp);
-  }
-
-  onMouseMove = (event: MouseEvent) => {
-    debugger
-    const moveX = Math.abs(event.clientX - this.startX - 10);
-    const moveY = Math.abs(event.clientY - this.startY - 10);
-    if (!this.isDragging && (moveX > 1 || moveY > 1)) {
-      this.startDragging(event);
-    }
-
-    if (this.isDragging && this.previewEl) {
-      this.renderer.setStyle(this.previewEl, 'top', `${event.pageY + 10}px`);
-      this.renderer.setStyle(this.previewEl, 'left', `${event.pageX + 10}px`);
-
-      // Find the element under cursor (hovered element)
-      const hoveredElement = document.elementFromPoint(
-        event.clientX,
-        event.clientY
-      );
-
-      this.dragMove.emit({
-        event,
-        column: this.column,
-        hoveredElement,
-      });
-    }
-  };
-
-  onMouseUp = (event: MouseEvent) => {
-    if (!this.isDragging) return;
-    this.isDragging = false;
-
-    this.dragEnd.emit({ column: this.column, event });
-
-    if (this.previewEl) {
-      this.renderer.removeChild(document.body, this.previewEl);
-      this.previewEl = null;
-    }
-
-    if (this.placeholderEl) {
-      const parent = this.placeholderEl.parentNode;
-      if (parent) {
-        parent.replaceChild(this.el.nativeElement, this.placeholderEl);
-      }
-      this.placeholderEl = null;
-    }
-
-    // Reset the cursor
-    this.resetCursor();
-
-    document.removeEventListener('mousemove', this.onMouseMove);
-    document.removeEventListener('mouseup', this.onMouseUp);
-  };
-
-  private originalCursor: string | null = null;
-
-  private setCursor(cursorStyle: string) {
-    this.renderer.setStyle(document.body, 'cursor', cursorStyle);
-  }
-
-  private resetCursor() {
-    this.renderer.setStyle(document.body, 'cursor', this.originalCursor || '');
-  }
-
-  private startDragging(event: MouseEvent) {
-    this.isDragging = true;
-
-    // Store original cursor (optional fallback)
-    this.originalCursor = getComputedStyle(document.body).cursor;
-
-    // Set cursor to grabbing
-    this.setCursor('move');
-
-    // --- Clone the element as a placeholder ---
-    this.placeholderEl = this.el.nativeElement.cloneNode(true) as HTMLElement;
-    this.renderer.setStyle(this.placeholderEl, 'opacity', '0.5');
-    this.renderer.setStyle(this.placeholderEl, 'pointer-events', 'none');
-    this.renderer.addClass(this.placeholderEl, 'drag-placeholder');
-
-    const parent = this.el.nativeElement.parentNode;
-    parent.replaceChild(this.placeholderEl, this.el.nativeElement);
-
-    // --- Create floating preview ---
-    this.previewEl = this.renderer.createElement('div');
-    this.renderer.setStyle(this.previewEl, 'position', 'absolute');
-    this.renderer.setStyle(this.previewEl, 'top', `${event.pageY + 10}px`);
-    this.renderer.setStyle(this.previewEl, 'left', `${event.pageX + 10}px`);
-    this.renderer.setStyle(this.previewEl, 'pointer-events', 'none');
-    this.renderer.setStyle(this.previewEl, 'z-index', '1000');
-    this.renderer.setStyle(this.previewEl, 'max-width', '200px');
-    this.renderer.setStyle(this.previewEl, 'padding', '8px');
-    this.renderer.setStyle(this.previewEl, 'border', '1px solid #ccc');
-    this.renderer.setStyle(this.previewEl, 'background-color', '#fff');
-    this.renderer.setStyle(
-      this.previewEl,
-      'box-shadow',
-      '0 2px 6px rgba(0,0,0,0.2)'
-    );
-    this.renderer.setStyle(this.previewEl, 'border-radius', '4px');
-    this.renderer.setStyle(this.previewEl, 'display', 'flex');
-    this.renderer.setStyle(this.previewEl, 'align-items', 'center');
-    this.renderer.setStyle(this.previewEl, 'gap', '8px');
-    this.renderer.setStyle(this.previewEl, 'font-weight', '500');
-    this.renderer.setStyle(this.previewEl, 'white-space', 'nowrap');
-
-    const icon = this.renderer.createElement('span');
-    this.renderer.setStyle(icon, 'font-size', '16px');
-    this.renderer.setStyle(icon, 'user-select', 'none');
-    this.renderer.setProperty(icon, 'innerText', '≡');
-
-    const text = this.renderer.createElement('span');
-    this.renderer.setProperty(text, 'innerText', this.headerName || 'Dragging');
-
-    this.renderer.appendChild(this.previewEl, icon);
-    this.renderer.appendChild(this.previewEl, text);
-    this.renderer.appendChild(document.body, this.previewEl);
-
-    this.dragStart.emit({ column: this.column, event });
-  }
-
-  public overrideCursor(style: string) {
-    this.setCursor(style);
-  }
-}

package/src/lib/pipes/filter.pipe.spec.ts

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

package/src/lib/pipes/filter.pipe.ts

@@ -1,22 +0,0 @@
-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/src/lib/services/cell-selection.service.spec.ts

@@ -1,16 +0,0 @@
-// /* 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/src/lib/services/cell-selection.service.ts

@@ -1,205 +0,0 @@
-// 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 [];
-  }
-}

package/src/lib/services/common.service.spec.ts

@@ -1,16 +0,0 @@
-/* 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();
-  }));
-});