@guiexpert/table 0.0.1 → 1.0.1

package/src/lib/table/service/simple-dom-service.ts

@@ -0,0 +1,46 @@
+import { DomServiceIf } from "./dom-service.if";
+
+
+export class SimpleDomService implements DomServiceIf {
+
+
+  setStyle(el: any, style: string, value: any): any {
+    el.style[style] = value;
+    return el;
+  };
+
+
+  appendText(parent: HTMLDivElement, text: string): HTMLDivElement {
+    const div = this.createText(text);
+    this.appendChild(parent, div);
+    return div;
+  }
+
+
+  addClass(div: HTMLDivElement, clazz: string) {
+    if (clazz.includes(" ")) {
+      clazz.split(" ").forEach(c => div.classList.add(c));
+    } else {
+      div.classList.add(clazz);
+    }
+    return div;
+  }
+
+  appendChild(parent: HTMLElement, child: HTMLElement): void {
+    parent.appendChild(child);
+  }
+
+  createElement<T>(name: string): T {
+    return document.createElement(name) as T;
+  }
+
+  createText(value: string): any {
+    return document.createTextNode(value);
+  }
+
+  setAttribute(ele: HTMLElement, key: string, value: string): void {
+    ele.setAttribute(key, value);
+  }
+
+
+}

package/src/lib/table/service/sorter.service.ts

@@ -0,0 +1,30 @@
+export class SorterService {
+
+
+  genericSortComparator(va: any, vb: any, f: number): number {
+    if (typeof va === "number" && typeof vb === "number") {
+      return f * (va - vb);
+    }
+    if (typeof va === "string" && typeof vb === "string") {
+      return f * (va.localeCompare(vb));
+    }
+    if (typeof va === "boolean" && typeof vb === "boolean") {
+      const a = va ? -1 : 1;
+      const b = vb ? -1 : 1;
+      return f * (a - b);
+    }
+    if (va instanceof Date && vb instanceof Date) {
+      return f * (va.getTime() - vb.getTime());
+    }
+    if (va instanceof Array && vb instanceof Array) {
+      const arr1: Array<any> = va;
+      const arr2: Array<any> = vb;
+      if (arr1.length && arr2.length) {
+        return this.genericSortComparator(arr1[0], arr2[0], f);
+      }
+    }
+    return f * ("" + va).localeCompare(("" + vb));
+  }
+
+
+}

package/src/lib/table/service/store-state-collapsed-expand.service.ts

@@ -0,0 +1,76 @@
+import { AbstractStoreStateService } from "./abstract-store-state.service";
+import { CollapsedExpandedData } from "./data/collapsed-expanded.data";
+import { GetStorageKeyFn } from "../data/options/auto-restore-options.if";
+
+
+export class StoreStateCollapsedExpandService extends AbstractStoreStateService {
+
+  private readonly COLLAPSED_EXPANDED_STATE = "collapsedExpandedState";
+  private collapsedExpandedState: CollapsedExpandedData = new CollapsedExpandedData();
+
+
+  constructor(
+    fn: GetStorageKeyFn | undefined) {
+    super(fn);
+    this.load();
+  }
+
+
+  collapsedExpandedStateGet(): CollapsedExpandedData {
+    return this.collapsedExpandedState;
+  }
+
+  collapsedExpandedStateIncludes(rowId: (string | number)): boolean {
+    return this.collapsedExpandedState.rowIds.includes(rowId);
+  }
+
+
+  collapsedStateIdsPush(id: (string | number)) {
+    if (!this.collapsedExpandedState.rowIds.includes(id)) {
+      this.collapsedExpandedState.rowIds.push(id);
+      this.collapsedExpandedState.allCollapsed = false;
+      this.collapsedExpandedState.allExpanded = false;
+      this.persist();
+    }
+  }
+
+  collapsedStateIdsRemove(id: (string | number)) {
+    const idx = this.collapsedExpandedState.rowIds.indexOf(id);
+    if (idx !== -1) {
+      this.collapsedExpandedState.rowIds.splice(idx, 1);
+      this.collapsedExpandedState.allCollapsed = false;
+      this.collapsedExpandedState.allExpanded = false;
+      this.persist();
+    }
+  }
+
+
+  collapsedStateAll(expand: boolean) {
+    this.collapsedExpandedState.rowIds = [];
+    this.collapsedExpandedState.mode = expand ? "collapsed" : "expanded"; // if all expanded, rowids are the collapsed ones
+    this.collapsedExpandedState.allCollapsed = !expand;
+    this.collapsedExpandedState.allExpanded = expand;
+    this.persist();
+  }
+
+
+  protected override load() {
+    const fn = this.getStorageKeyFn;
+    if (fn) {
+      const key = fn();
+      if (key) {
+        const subKey2 = key + this.COLLAPSED_EXPANDED_STATE;
+        const data = this.loadFromLocalStorage<CollapsedExpandedData>(subKey2);
+        if (data) {
+          this.collapsedExpandedState = data;
+        }
+      }
+    }
+  }
+
+  private persist() {
+    this.checkAndPersistItem(this.COLLAPSED_EXPANDED_STATE, this.collapsedExpandedState);
+  }
+
+
+}

package/src/lib/table/service/store-state-scroll-pos.service.ts

@@ -0,0 +1,40 @@
+import { AbstractStoreStateService } from "./abstract-store-state.service";
+import { GetStorageKeyFn } from "../data/options/auto-restore-options.if";
+
+
+export class StoreStateScrollPosService extends AbstractStoreStateService {
+
+  private readonly SCROLL_STATE = "scrollState";
+  private scrollOffset: [number, number] = [0, 0];
+
+
+  constructor(fn: GetStorageKeyFn | undefined) {
+    super(fn);
+    this.load();
+  }
+
+  getScrollOffset(): [number, number] {
+    return this.scrollOffset;
+  }
+
+  updateScrollOffset(xy: [number, number]) {
+    this.scrollOffset = xy;
+    this.checkAndPersistItem(this.SCROLL_STATE, this.scrollOffset);
+  }
+
+
+  protected override load() {
+    const fn = this.getStorageKeyFn;
+    if (fn) {
+      const key = fn();
+      if (key) {
+        // A main key is given by function from options
+        const subKey4 = key + this.SCROLL_STATE;
+        let scrollOffset = this.loadFromLocalStorage<[number, number]>(subKey4);
+        this.scrollOffset = scrollOffset ? scrollOffset : [0, 0];
+      }
+    }
+  }
+
+
+}

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

@@ -0,0 +1,41 @@
+import { AbstractStoreStateService } from "./abstract-store-state.service";
+import { GetStorageKeyFn } from "../data/options/auto-restore-options.if";
+import { SortItem } from "../data/common/sort-item";
+
+
+export class StoreStateSortingService extends AbstractStoreStateService {
+
+  private readonly SORTING_STATE = "sortingState";
+  private sortItems: SortItem[] = [];
+
+
+  constructor(fn: GetStorageKeyFn | undefined) {
+    super(fn);
+    this.load();
+  }
+
+  getSortItems(): SortItem[] {
+    return this.sortItems;
+  }
+
+  setSortItems(sortItems: SortItem[]): void {
+    this.sortItems = sortItems;
+    this.checkAndPersistItem(this.SORTING_STATE, this.sortItems);
+  }
+
+
+  protected override load() {
+    const fn = this.getStorageKeyFn;
+    if (fn) {
+      const key = fn();
+      if (key) {
+        // A main key is given by function from options
+        const subKey = key + this.SORTING_STATE;
+        let sortItems = this.loadFromLocalStorage<SortItem[]>(subKey);
+        this.sortItems = sortItems ? sortItems : [];
+      }
+    }
+  }
+
+
+}

package/src/lib/table/service/tree-row.service.ts

@@ -0,0 +1,31 @@
+import { TreeRow } from "../data/common/tree-row";
+
+export class TreeRowService {
+
+  flattenTree<T>(
+    rows: TreeRow<T>[],
+    ret: TreeRow<T>[] = []
+  ): TreeRow<T>[] {
+
+    for (const row of rows) {
+      if (this.isVisible(row)) {
+        ret.push(row);
+      }
+      if (row.children?.length) {
+        this.flattenTree(row.children, ret);
+      }
+    }
+    return ret;
+  }
+
+  isVisible(row: TreeRow<any>): boolean {
+    if (!row.parent) {
+      return true;
+    }
+    if (!row.parent.expanded) {
+      return false;
+    }
+    return this.isVisible(row.parent);
+  }
+
+}

package/src/lib/table/table-api.ts

@@ -0,0 +1,61 @@
+import { TableScope } from "./table-scope";
+import { ColumnDefIf } from "./data/tablemodel/column/column-def.if";
+import { TableCellUpdateEventIf } from "./data/common/event/input/table-cell-update-event.if";
+
+
+export class TableApi {
+
+  constructor(
+    private readonly tableScope: TableScope
+  ) {
+  }
+
+
+  updateCells(events: TableCellUpdateEventIf[]): void {
+    this.tableScope.updateCells(events);
+  }
+
+
+  externalFilterChanged(): void {
+    this.tableScope.externalFilterChanged();
+  };
+
+  scrollToPixel(_px: number = 0, _py: number = 0) {
+    // TODO scrollToPixel
+  }
+
+
+  scrollToIndex(_indexX: number = 0, _indexY: number = 0) {
+    // TODO scrollToIndex
+  }
+
+  setHeaderVisible(_visible: boolean = true) {
+    // TODO setHeaderVisible
+  }
+
+  setColumnVisible(_column: number | ColumnDefIf, _visible: boolean = true) {
+    // TODO setColumnVisible
+  }
+
+  isColumnVisible(_column: number | ColumnDefIf): boolean {
+    // TODO isColumnVisible
+    return true;
+  }
+
+  isHeaderVisible(): boolean {
+    return true; // TODO isHeaderVisible
+  }
+
+  setFooterVisible(_visible: boolean = true) {
+    // TODO setFooterVisible
+  }
+
+  isFooterVisible(): boolean {
+    return true; // TODO isFooterVisible
+  }
+
+  repaint() {
+    this.tableScope.repaint();
+  }
+
+}