@guiexpert/table 0.0.1 → 1.0.1

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

@@ -0,0 +1,120 @@
+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/selection/selection.type.ts

@@ -0,0 +1,5 @@
+export type SelectionType = "none" | "cell" | "row" | "column" | "range";
+export type SelectionMode = "single" | "multi";
+
+
+

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

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