@guiexpert/table 1.0.3 → 1.0.5

package/src/lib/table/selection/selection-model.ts

@@ -1,109 +0,0 @@
-import { CellRange } from "../data/common/cell-range";
-import { SelectionMode, SelectionType } from "./selection.type";
-import { SelectionModelIf } from "./selection-model.if";
-
-export class SelectionModel implements SelectionModelIf {
-
-  protected ranges: CellRange[] = [];
-  protected negativeRanges: CellRange[] = [];
-  protected allSelected: boolean = false;
-
-  constructor(
-    public selectionType: SelectionType = "none",
-    public selectionMode: SelectionMode = "single"
-  ) {
-  }
-
-  getSelectionCount(rowIndex: number, columnIndex: number): number {
-    let count = 0;
-    for (const range of this.ranges) {
-      if (range.isInRange(rowIndex, columnIndex)) {
-        count++;
-      }
-    }
-    if (this.allSelected) {
-      count++;
-    }
-    if (this.isInNegativeRange(rowIndex, columnIndex)) {
-      count = 0;
-    }
-    return count;
-  }
-
-  isInNegativeRange(rowIndex: number, columnIndex: number): boolean {
-    for (const range of this.negativeRanges) {
-      if (range.isInRange(rowIndex, columnIndex)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  getRanges() {
-    return this.ranges;
-  }
-
-  clear(): void {
-    this.ranges = [];
-    this.negativeRanges = [];
-    this.allSelected = false;
-  }
-
-  hasSelection(): boolean {
-    return !!this.ranges.length;
-  }
-
-  selectAll() {
-    this.allSelected = true;
-  }
-
-  addSelection(range: CellRange): void {
-    this.addRange(range);
-  }
-
-  removeSelection(range: CellRange): void {
-    if (this.selectionType === "none") {
-      return; // skip!
-    }
-    let r = range;
-    if (this.selectionType === "row") {
-      r = CellRange.singleRow(range.r1);
-    } else if (this.selectionType === "column") {
-      r = CellRange.singleColumn(range.c1);
-    }
-    this.negativeRanges.push(r);
-  }
-
-  togglePoint(row: number, col: number): void {
-    if (this.getSelectionCount(row, col) > 0) {
-      this.removeSelection(CellRange.singleCell(row, col));
-    } else {
-      this.addSelection(CellRange.singleCell(row, col));
-    }
-  }
-
-
-  private addRange(range: CellRange) {
-    if (this.selectionType === "none") {
-      return; // skip!
-    }
-    this.allSelected = false;
-    if (this.selectionMode === "single") {
-      this.ranges = [];
-    }
-    if (this.selectionType === "row") {
-      range.c1 = 0;
-      range.c2 = Number.MAX_SAFE_INTEGER;
-    } else if (this.selectionType === "column") {
-      range.r1 = 0;
-      range.r2 = Number.MAX_SAFE_INTEGER;
-    } else if (this.selectionType === "cell") {
-      range.r2 = range.r1;
-      range.c2 = range.c1;
-    } else if (this.selectionType === "range") {
-      //
-    }
-    this.ranges.push(range);
-  }
-
-}

package/src/lib/table/selection/selection-service.ts

@@ -1,120 +0,0 @@
-import { GeMouseEvent } from "../data/common/event/ge-mouse-event";
-import { TableScope } from "../table-scope";
-import { GetT } from "../data/common/get-t";
-import { SelectionModelIf } from "./selection-model.if";
-import { FocusModelIf } from "../focus/focus-model.if";
-import { CellRange } from "../data/common/cell-range";
-import { OnActionTriggeredIf } from "../action/on-action-triggered.if";
-import { ActionId } from "../action/action-id.type";
-
-
-export class SelectionService implements OnActionTriggeredIf {
-
-  protected getSelectionModel?: GetT<SelectionModelIf>;
-  protected getFocusModel?: GetT<FocusModelIf>;
-  protected previousEvt?: GeMouseEvent;
-
-
-  constructor(
-    protected readonly tableScope: TableScope
-  ) {
-    if (this.tableScope.tableOptions?.getSelectionModel) {
-      this.getSelectionModel = this.tableScope.tableOptions.getSelectionModel;
-    }
-    if (this.tableScope.tableOptions?.getFocusModel) {
-      this.getFocusModel = this.tableScope.tableOptions.getFocusModel;
-    }
-  }
-
-
-  onMouseClicked(evt: GeMouseEvent, _previousEvt: GeMouseEvent | undefined): boolean {
-    let dirty = false;
-    let deletePreviousEvent = false;
-
-    if (this.getSelectionModel && this.getFocusModel) {
-      const sm = this.getSelectionModel();
-      const fm = this.getFocusModel();
-      if (sm && fm) {
-
-        // Focus:
-        if (!fm.hasFocus(evt.rowIndex, evt.columnIndex)) {
-          fm.setFocus(evt.rowIndex, evt.columnIndex);
-          dirty = true;
-        }
-
-        // Selection:
-        if (!evt.originalEvent?.shiftKey) {
-          if (sm.hasSelection()) {
-            sm.clear();
-            dirty = true;
-          }
-        }
-        if (evt.originalEvent?.shiftKey && this.previousEvt) {
-          sm.addSelection(this.createRangeByEvents(evt, this.previousEvt));
-          deletePreviousEvent = true;
-          dirty = true;
-
-        } else if (evt.originalEvent?.ctrlKey || evt.originalEvent?.metaKey) {
-          sm.addSelection(CellRange.singleCell(evt.rowIndex, evt.columnIndex));
-          deletePreviousEvent = true;
-          dirty = true;
-
-        } else if (evt.originalEvent?.altKey && (evt.originalEvent?.ctrlKey || evt.originalEvent?.metaKey)) {
-          sm.removeSelection(CellRange.singleCell(evt.rowIndex, evt.columnIndex));
-          deletePreviousEvent = true;
-          dirty = true;
-        }
-      }
-    }
-    if (deletePreviousEvent) {
-      this.previousEvt = undefined;
-    } else {
-      this.previousEvt = evt?.clone();
-    }
-    return dirty;
-  }
-
-  onActionTriggered(actionId: ActionId): boolean {
-    if (this.getSelectionModel && this.getFocusModel) {
-      const sm = this.getSelectionModel();
-      const fm = this.getFocusModel();
-      if (sm && fm) {
-        if (actionId === "SELECT_ALL") {
-          sm.selectAll();
-          this.tableScope.repaint();
-          return true;
-        }
-        if (actionId === "DESELECT_ALL") {
-          sm.clear();
-          this.tableScope.repaint();
-          return true;
-        }
-        if (actionId === "TOGGLE_SELECTION") {
-          const [row, col] = fm.getFocus();
-          sm.togglePoint(row, col);
-          this.tableScope.repaint();
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-
-  private createRangeByEvents(evt: GeMouseEvent, previousEvt?: GeMouseEvent) {
-    if (!previousEvt) {
-      previousEvt = evt;
-    }
-    const r1 = Math.min(evt.rowIndex, previousEvt?.rowIndex);
-    const r2 = Math.max(evt.rowIndex, previousEvt?.rowIndex);
-    const c1 = Math.min(evt.columnIndex, previousEvt?.columnIndex);
-    const c2 = Math.max(evt.columnIndex, previousEvt?.columnIndex);
-    return CellRange.create({
-      rowIndex1: r1,
-      columnIndex1: c1,
-      rowIndex2: r2,
-      columnIndex2: c2
-    });
-  }
-
-}

package/src/lib/table/service/abstract-store-state.service.ts

@@ -1,105 +0,0 @@
-import { GetStorageKeyFn } from "../data/options/auto-restore-options.if";
-
-
-export abstract class AbstractStoreStateService {
-
-
-  protected getStorageKeyFn?: undefined | GetStorageKeyFn;
-
-
-  constructor(fn: GetStorageKeyFn | undefined) {
-    this.getStorageKeyFn = fn;
-  }
-
-  autoConvertMapToObject(item: any) {
-    const obj = {};
-    if (item instanceof Map) {
-      const map = item as Map<string, any>;
-
-      for (const item of [...map]) {
-        const [
-          key,
-          value
-        ] = item;
-        // @ts-ignore
-        obj[key] = value;
-      }
-    }
-    return obj;
-  }
-
-  // abstract getSubKey(): string;
-
-  protected abstract load(): void;
-
-  protected checkAndPersistItem(keySuffix: string, item: any) {
-    const fn = this.getStorageKeyFn;
-    if (fn) {
-      const key = fn();
-      if (key) {
-        const subKey = key + keySuffix;
-        if ((item + "").includes("Map")) {
-          const obj = this.autoConvertMapToObject(item);
-          this.persistItem(subKey, obj);
-        } else {
-          this.persistItem(subKey, item);
-        }
-
-      }
-    }
-  }
-
-  protected persistItem(subKey: string, item: string | object) {
-    if (item) {
-      localStorage.setItem(subKey, JSON.stringify(item));
-    } else {
-      localStorage.removeItem(subKey);
-    }
-  }
-
-  protected loadFromLocalStorage<U>(subKey: string): U | null {
-    const item = localStorage.getItem(subKey);
-    if (item) {
-      return JSON.parse(item) as U;
-    }
-    return null;
-  }
-
-  // private loadItems() {
-  //   const fn = this.getStorageKeyFn;
-  //   if (fn) {
-  //     const key = fn();
-  //     if (key) {
-  //       // A main key is given by function from options
-  //       const subKey = key + this.CHECKED_STATE;
-  //       const arr = this.loadFromLocalStorage<Array<string | number>>(subKey);
-  //       if (arr) {
-  //         this.checkedStateIds.length = 0;
-  //         arr.forEach(a => this.checkedStateIds.push(a));
-  //       }
-  //
-  //       const subKey2 = key + this.COLLAPSED_EXPANDED_STATE;
-  //       const data = this.loadFromLocalStorage<CollapsedExpandedData>(subKey2);
-  //       if (data) {
-  //         this.collapsedExpandedState = data;
-  //       }
-  //
-  //       const subKey3 = key + this.SELECTED_STATE;
-  //       const arr3 = this.loadFromLocalStorage<object>(subKey3);
-  //       if (arr3) {
-  //         const map: Map<string | number, string[]> = new Map(Object.entries(arr3));
-  //         if (map) {
-  //           this.selectedStateIds.clear();
-  //           map.forEach((col, k) => this.selectedStateIds.set(k, col));
-  //         }
-  //       }
-  //
-  //       const subKey4 = key + this.SCROLL_STATE;
-  //       let scrollOffset = this.loadFromLocalStorage<[number, number]>(subKey4);
-  //       this.scrollOffset = scrollOffset ? scrollOffset : [0, 0];
-  //     }
-  //   }
-  // }
-
-
-}