@guiexpert/table 1.1.24 → 1.1.26

package/src/lib/table/data/tablemodel/areamodel/async-area-model-object-array.ts

@@ -1,110 +0,0 @@
-import {AbstractAreaModel} from "./abstract-area-model";
-import {ColumnDefIf} from "../column/column-def.if";
-import {FilterFunction} from "../../common/filter-function";
-import {SorterService} from "../../../service/sorter.service";
-import {SortItem} from "../../common/sort-item";
-import {isTreeRow} from "../../../instanceof-workaround";
-
-
-export class AsyncBodyAreaModelObjectArray<T> extends AbstractAreaModel<T> {
-
-  protected readonly properties: string[];
-  protected sorterService: SorterService = new SorterService();
-
-  protected cachedStartIndex: number = 0;
-  protected cachedRows: T[] = [];
-
-  constructor(
-    protected readonly maxRowCount: number,
-    public override defaultRowHeight: number,
-    protected override columnDefs: ColumnDefIf[] = []
-  ) {
-    super('body', columnDefs, defaultRowHeight);
-    this.cachedRows = [];
-    this.properties = columnDefs.map(def => def.property);
-  }
-
-  setChunk(startIndex: number, chunk: T[]) {
-    this.cachedStartIndex = startIndex;
-    this.cachedRows = chunk;
-  }
-
-  getRowCount(): number {
-    return this.maxRowCount ?? 0;
-  }
-
-  getValueAt(rowIndex: number, columnIndex: number): any {
-    if (rowIndex < this.cachedStartIndex || rowIndex > (this.cachedStartIndex + this.maxRowCount - 1)) {
-      // TODO send -> server
-      return '';
-    }
-    const property = this.properties[columnIndex];
-    let t = this.cachedRows[rowIndex];
-    if (isTreeRow(t)) {
-      // @ts-ignore
-      t = t.data;
-    }
-    if (t) {
-      return this.getValueByT(t, property);
-    }
-    return "";
-  }
-
-  getFilteredRows(): T[] {
-    return this.cachedRows;
-  }
-
-  getAllRows(): T[] {
-    return this.cachedRows;
-  }
-
-  getRowHeight(_rowIndex: number): number {
-    return this.defaultRowHeight;
-  }
-
-  override getRowByIndex(rowIndex: number): any {
-    return this.cachedRows[rowIndex];
-  }
-
-  externalFilterChanged(predictFn: FilterFunction<any>): void {
-    // TODO send -> server
-  }
-
-  override doSort(sortItems: SortItem[]): boolean {
-    // TODO send -> server
-    return false;
-  }
-
-  getValueByT(t: T, property: string) {
-    if (property.includes(".")) {
-      return this.getPropertyValue(t, property.split("."));
-    }
-    // @ts-ignore
-    return t[property];
-  }
-
-  override changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void {
-    this.arrayMove(this.properties, sourceColumnIndex, targetColumnIndex);
-    super.changeColumnOrder(sourceColumnIndex, targetColumnIndex);
-  }
-
-  protected genericFlatTableSortComparator(property: string, f: number) {
-    return (a: T, b: T) => {
-      const va = this.getValueByT(a, property);
-      const vb = this.getValueByT(b, property);
-      return this.sorterService.genericSortComparator(va, vb, f);
-    };
-  }
-
-
-  private getPropertyValue(o: any, props: string[]): any {
-    const prop = props.shift();
-    // @ts-ignore
-    let o2 = o[prop];
-    if (o2 && props.length) {
-      return this.getPropertyValue(o2, props);
-    }
-    return o2;
-  }
-}
-

package/src/lib/table/data/tablemodel/areamodel/col-and-rowspan-model.ts

@@ -1,64 +0,0 @@
-import { CellRange } from "../../common/cell-range";
-import { AreaModelIf } from "./area-model.if";
-import { TableModelIf } from "../table-model.if";
-
-/**
- * Represents a model for handling colspan and rowspan in a table.
- */
-export class ColAndRowspanModel {
-
-  protected colAndRowspanRanges: CellRange[] | undefined = undefined;
-
-  constructor(
-    protected tableModel: TableModelIf,
-    protected areaModel: AreaModelIf
-  ) {
-  }
-
-  init() {
-    if (this.areaModel.getMaxColspan() < 2 && this.areaModel.getMaxRowspan() < 2) {
-      return; // sip
-    }
-    this.colAndRowspanRanges = [];
-    const rowCount = this.areaModel.getRowCount();
-    const colCount = this.tableModel.getColumnCount();
-    for (let r = 0; r < rowCount; r++) {
-      for (let c = 0; c < colCount; c++) {
-        let cs = this.areaModel.getColspanAt(r, c);
-        let rs = this.areaModel.getRowspanAt(r, c);
-        if (cs > 1 || rs > 1) {
-          if (cs === 0) {
-            cs = 1;
-          }
-          if (rs === 0) {
-            rs = 1;
-          }
-
-          const gammaRange = 'gammaCells' in this.areaModel;
-          this.colAndRowspanRanges.push(
-            new CellRange(r, c, r + rs - 1, c + cs - 1, gammaRange)
-          );
-        }
-      }
-    }
-  }
-
-  getRanges(): CellRange[] {
-    if (this.colAndRowspanRanges) {
-      return this.colAndRowspanRanges;
-    }
-    return [];
-  }
-
-  isInRange(rowIndex: number, columnIndex: number): boolean {
-    if (this.colAndRowspanRanges) {
-      for (const range of this.colAndRowspanRanges) {
-        if (range.isInRange(rowIndex, columnIndex)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-}

package/src/lib/table/data/tablemodel/areamodel/has-default-row-height-if.ts

@@ -1,3 +0,0 @@
-export interface HasDefaultRowHeightIf {
-  defaultRowHeight: number;
-}

package/src/lib/table/data/tablemodel/areamodel/object-array-holder.if.ts

@@ -1,8 +0,0 @@
-
-
-export interface ObjectArrayHolderIf<T> {
-
-  getAllRows(): T[];
-  getFilteredRows(): T[];
-
-}

package/src/lib/table/data/tablemodel/cellgroup/cell-group-ext.ts

@@ -1,172 +0,0 @@
-import { CellGroupIf } from "./cell-group.if";
-import { CellGroup } from "./cell-group";
-
-export class CellGroupExt extends CellGroup {
-
-  public override impl = 'CellGroupExt';
-
-  public override children: CellGroupExt[] | undefined = undefined;
-  public leftNeighbour: CellGroupExt | undefined = undefined;
-  public rightNeighbour: CellGroupExt | undefined = undefined;
-
-  constructor(
-    cellGroup: CellGroupIf,
-    public rowIndex: number = 0,
-    public childIndex: number = 0,
-    public parent?: CellGroupExt
-  ) {
-    super(
-      cellGroup.data,
-      cellGroup.property,
-      cellGroup.toggle,
-      cellGroup.closed,
-      cellGroup.visibility,
-      cellGroup.children
-    );
-  }
-
-  ownColumn(): boolean {
-    return !!this.property;
-  }
-
-  override toString(): string {
-    return this.data + "";
-  }
-
-  // TODO hier gehts weiter!!!!!!!!!!!
-  getColumnIndex(): number {
-    if (!this.parent) {
-      // root level (rowIndex=0)
-      if (this.leftNeighbour) {
-        // return this.leftNeighbour.getBiggestChildColumnIndex() + 1;
-      }
-      return 0;
-    }
-    return this.parent.getColumnIndex() + this.childIndex;
-  }
-
-  //
-  // getLeftClaimedSpaces(): number{
-  //   if (this.leftNeighbour) {
-  //
-  //   }
-  //   return 0;
-  // }
-
-  // getSumOfLeafs(cg: CellGroupExt, sum: number = 0): number {
-  //   if (cg.children?.length) {
-  //     for (let i = 0; i < cg.children.length; i++) {
-  //       const child = cg.children[i];
-  //       if (child.children?.length) {
-  //         sum = this.getSumOfLeafs(child, sum);
-  //       } else {
-  //         sum++;
-  //       }
-  //     }
-  //   }
-  //   if (this.ownColumn()) {
-  //     sum++;
-  //   }
-  //   //console.info(cg.data, sum)
-  //   return sum;
-  // }
-  //
-  // getBiggestChildColumnIndex(): number {
-  //   if (this.children?.length) {
-  //     return Math.max(...this.children.map(c => c.getBiggestChildColumnIndex()));
-  //   }
-  //   return this.childIndex;
-  // }
-
-  isVisible(): boolean {
-    if (!this.parent) {
-      return true;
-    }
-    if (this.visibility === "always") {
-      return this.parent.isVisible();
-    }
-    if (this.visibility === "normal" || !this.visibility) {
-      return this.parent.isVisible() && !this.parent.closed;
-    }
-    if (this.visibility === "inverted") {
-      return this.parent.isVisible() && this.parent.closed;
-    }
-    return true;
-  }
-
-  // should be rendered
-  claimsSpace(): boolean {
-    return this.isVisible() && (this.ownColumn() || this.closed);
-  }
-
-
-  getColumnCount(
-    cg: CellGroupExt = this,
-    ret: number = 0
-  ): number {
-    if (cg?.claimsSpace()) {
-      ret++;
-    }
-    if (cg?.children?.length) {
-      for (const child of cg.children) {
-        ret = this.getColumnCount(child, ret);
-      }
-    }
-    return ret;
-  }
-
-  getRowSpan(
-    cg: CellGroupExt = this,
-    maxRowCount: number
-  ): number {
-    if (cg?.claimsSpace()) {
-      return maxRowCount - this.getParentCount(cg, 0);
-    }
-    return 1;
-  }
-
-
-  getParentCount(
-    cg: CellGroupExt = this,
-    ret: number = 0
-  ): number {
-    if (cg.parent) {
-      ret = ret + 1 + this.getParentCount(cg.parent, ret);
-    }
-    return ret;
-  }
-
-
-  log(maxRowCount: number = 10): string {
-    const tabs = "\t\t\t\t\t\t\t\t\t\t\t\t\t".substring(0, 2 * this.rowIndex);
-    const col = `${this.getColumnIndex()}`;
-    // const bcol = `${this.getBiggestChildColumnIndex()}`;
-    const columnCount = `${this.getColumnCount(this)}`;
-    const rowSpan = `${this.getRowSpan(this, maxRowCount)}`;
-    const pc = `${this.getParentCount(this)}`;
-
-    const out = `${tabs + this.data}
-      childIndex:${this.childIndex}
-      row:${this.rowIndex}
-      col:${col}
-      vis:${this.visibility}
-      toggle:${this.toggle}
-      closed:${this.closed}
-      isVisible:${this.isVisible()}
-      ownColumn:${this.ownColumn()}
-      claimsSpace:${this.claimsSpace()}
-      colCount:${columnCount}
-      rowSpan:${rowSpan}
-      pc:${pc}`.replace(/[ \n]+/g, " ");
-
-    //console.info(out);
-    // console.info(`${tabs + this.data}`);
-    if (this.children) {
-      for (const child of this.children) {
-        child.log(maxRowCount);
-      }
-    }
-    return out;
-  }
-
-}

package/src/lib/table/data/tablemodel/cellgroup/cell-group.if.ts

@@ -1,12 +0,0 @@
-export interface CellGroupIf {
-
-  data: any;
-  property?: string; // if a property is set, then this element has its own column
-  toggle?: boolean; // toggle control will be displayed
-  closed?: boolean; // current state
-  visibility?: "always" | "inverted" | "normal" | undefined;
-  children?: CellGroupIf[] | undefined;
-
-  impl?:string;
-
-}

package/src/lib/table/data/tablemodel/cellgroup/cell-group.ts

@@ -1,18 +0,0 @@
-import { CellGroupIf } from "./cell-group.if";
-
-export class CellGroup implements CellGroupIf {
-
-  public impl = 'CellGroup';
-
-  constructor(
-    public data: any,
-    public property?: string,
-    public toggle?: boolean,
-    public closed: boolean = false,
-    public visibility: "always" | "inverted" | "normal" | undefined = "normal",
-    public children: CellGroupIf[] | undefined = undefined
-  ) {
-  }
-
-
-}

package/src/lib/table/data/tablemodel/cellgroup/cellgroup-factory.ts

@@ -1,148 +0,0 @@
-import { CellGroupIf } from "./cell-group.if";
-import { ColumnDefIf } from "../column/column-def.if";
-import { ColumnDef } from "../column/column-def";
-import { CellGroupExt } from "./cell-group-ext";
-
-export class CellgroupFactory {
-
-
-  static buildColumnDefs(
-    cellGroups: CellGroupIf[],
-    ret: ColumnDefIf[] = []
-  ): ColumnDefIf[] {
-
-    for (const cellGroup of cellGroups) {
-      if (cellGroup.property) {
-        ret.push(ColumnDef.create({
-            property: cellGroup.property,
-            headerLabel: cellGroup.data ? cellGroup.data : cellGroup.property,
-            isVisible: () => {
-              // @ts-ignore
-              if (typeof cellGroup["isVisible"] === "function") {
-                const cge = cellGroup as CellGroupExt;
-                return cge.isVisible();
-              }
-              return true;
-            }
-          })
-        );
-      }
-      if (cellGroup.children) {
-        CellgroupFactory.buildColumnDefs(cellGroup.children, ret);
-      }
-    }
-    return ret;
-  }
-/*
-  static buildDeepMap(
-    cellGroups: CellGroupIf[],
-    ret: { [key: string]: number } = {},
-    deep = 0
-  ): { [key: string]: number } {
-
-    for (const cellGroup of cellGroups) {
-      //if (cellGroup.property) {
-      ret[cellGroup.data] = deep;
-      //}
-      if (cellGroup.children) {
-        CellgroupFactory.buildDeepMap(cellGroup.children, ret, deep + 1);
-      }
-    }
-    return ret;
-  }
-*/
-  static buildGroupExts(
-    cellGroups: CellGroupIf[],
-    ret: CellGroupExt[] = [],
-    deep = 0,
-    parent?: CellGroupExt
-  ): CellGroupExt[] {
-
-    let last: CellGroupExt | undefined = undefined;
-    for (let i = 0; i < cellGroups.length; i++) {
-      const cellGroup = cellGroups[i];
-      const cge = new CellGroupExt(cellGroup, deep, i, parent);
-
-      if (last) {
-        cge.leftNeighbour = last;
-        last.rightNeighbour = cge;
-      }
-      ret.push(cge);
-      if (cellGroup.children) {
-        cge.children = CellgroupFactory.buildGroupExts(cellGroup.children, [], deep + 1, cge);
-      }
-      last = cge;
-    }
-    return ret;
-  }
-
-
-  static flattenGroupExts(
-    cellGroups: CellGroupExt[],
-    ret: CellGroupExt[] = []
-  ): CellGroupExt[] {
-
-    for (const cellGroup of cellGroups) {
-      ret.push(cellGroup);
-      if (cellGroup.children) {
-        CellgroupFactory.flattenGroupExts(cellGroup.children, ret);
-      }
-    }
-    return ret;
-  }
-
-  /*
-
-  Gold                                                           Hohenwarte
-  Gold AB                         Gold CD                        HOH AB                                  HOH CD
-  .          Gold A     Gold B    Gold C   Gold D    Gold Sum    .           HOH Loc    HOH A    HOH B   HOH C    HOH D
-
-  */
-
-  static buildArrayOfArrays(
-    flatten: CellGroupExt[],
-    arrs: (CellGroupExt | null | undefined)[][]
-  ): (CellGroupExt | null | undefined)[][] {
-
-    let col = -1;
-    let lastRowIdx = 99999;
-    for (const cellGroup of flatten) {
-      if (cellGroup.rowIndex <= lastRowIdx) {
-        col++;
-        for (let r = 0; r < arrs.length; r++) {
-          arrs[r][col] = null;
-        }
-      }
-
-      arrs[cellGroup.rowIndex][col] = cellGroup;
-      lastRowIdx = cellGroup.rowIndex;
-
-      if (cellGroup.ownColumn() && cellGroup.children?.length) {
-        for (let r = cellGroup.rowIndex + 1; r < arrs.length; r++) {
-          arrs[r][col] = undefined;
-        }
-        col++;
-        for (let r = 0; r < arrs.length; r++) {
-          arrs[r][col] = null;
-        }
-      }
-    }
-    return arrs;
-  }
-
-
-  static iterateThrowColumns(
-    sb: string[] = [],
-    cellGroups: CellGroupExt[]
-  ) {
-
-    for (const cellGroup of cellGroups) {
-      sb.push(cellGroup.data + "    rowIndex:" + cellGroup.rowIndex);
-      if (cellGroup.children?.length) {
-        CellgroupFactory.iterateThrowColumns(sb, cellGroup.children);
-      }
-    }
-  }
-
-}
-

package/src/lib/table/data/tablemodel/column/column-def.if.ts

@@ -1,141 +0,0 @@
-import { SizeIf } from "../../common/size.if";
-import { CellRendererIf } from "../../../renderer/cell-render.if";
-import { AreaObjectMapType } from "../../common/area-map.type";
-import { BooleanFunction } from "../../common/boolean-function";
-import { SortState } from "../../common/sort-state.type";
-import { GetEditRenderer } from "../../../renderer/edit/edit-cell-renderer.type";
-import { editInputPipe } from "../../../renderer/edit/edit-input-pipe.if";
-
-
-/**
- * Represents a column definition of one table column.
- */
-export interface ColumnDefIf {
-  /**
-   * Represents a property name of the table row element.
-   * @typedef {String} VariableProperty
-   */
-  property: string;
-  /**
-   * Represents the label for a header.
-   *
-   * @typedef {string} headerLabel
-   */
-  headerLabel: string;
-  /**
-   * Represents the size of a column along the width dimension.
-   *
-   * @typedef {number} Width
-   */
-  width: SizeIf;
-  /**
-   * Represents the minimum width of a column.
-   *
-   * @typedef {SizeIf} minWidth
-   * @property {number} width - The minimum width value.
-   * @property {string} unit - The unit of measurement for the minimum width value.
-   *                           Default value is 'px' if not specified.
-   */
-  minWidth: SizeIf;
-  /**
-   * Represents the maximum width of a column.
-   *
-   * @typedef {number} SizeIf
-   */
-  maxWidth: SizeIf;
-  /**
-   * @typedef {Object} AreaObjectMapType
-   * @template T
-   * @property {Object.<string, T>} map - A mapping of strings to values of type T
-   */
-  rendererMap: AreaObjectMapType<CellRendererIf>;
-  /**
-   * Represents an object that maps an area to a collection of objects.
-   *
-   * @typedef {Object.<string, string[]>} AreaObjectMapType
-   */
-  classes: AreaObjectMapType<string[]>;
-  /**
-   * Determines whether or not a column can be sorted.
-   *
-   * @param {boolean} sortable - Specifies if an item is sortable.
-   * @returns {boolean} - Indicating whether the item is sortable or not.
-   */
-  sortable?: BooleanFunction,
-  /**
-   * Determines if the sort icon is visible.
-   *
-   * @typedef {BooleanFunction} sortIconVisible
-   * @returns {boolean} Indicates whether the sort icon is visible.
-   */
-  sortIconVisible?: BooleanFunction,
-  /**
-   * Represents a function that compares two values for sorting purposes.
-   * The function takes two arguments of type T, compares them, and returns a number.
-   * If the result is negative, it means 'a' comes before 'b' in the sorted order.
-   * If the result is positive, it means 'b' comes before 'a' in the sorted order.
-   * If the result is zero, it means the two values are considered equal for sorting purposes.
-   *
-   * @typeparam T The type of values being compared.
-   *
-   * @param a The first value to be compared.
-   * @param b The second value to be compared.
-   *
-   * @returns A number indicating the relative order of 'a' and 'b'.
-   */
-  sortComparator?: <T>(a: T, b: T) => number,
-  /**
-   * Represents the state of sorting for a list.
-   *
-   * @typedef {Object} SortState
-   *
-   * @property {string} [sortKey] - The key to sort the list by. If not provided, no sorting will be applied.
-   * @property {boolean} [reverse] - Indicates whether the list should be sorted in reverse order. Defaults to false.
-   */
-  sortState?: SortState,
-  /**
-   * Represents the order of multiple sort states.
-   *
-   * @typedef {SortState[]} SortStatesOrder
-   */
-  sortStatesOrder?: SortState[],
-  /**
-   * Determines if a column is editable or not.
-   *
-   * @param {any} variable - The variable to check.
-   * @returns {boolean} - Returns true if the variable is editable, false otherwise.
-   */
-  editable?: BooleanFunction,
-  /**
-   * Determines if the column is visible or not.
-   *
-   * @typedef {Function} isVisible
-   * @returns {boolean} - If the element is visible, returns true. Otherwise, returns false.
-   */
-  isVisible?: BooleanFunction,
-  /**
-   * Retrieves the edit renderer for the column.
-   *
-   * @name getEditRenderer
-   * @function
-   * @param {HTMLElement} element - The element for which to retrieve the edit renderer.
-   * @returns {EditRenderer | null} - The edit renderer for the specified element, or null if not found.
-   */
-  getEditRenderer?: GetEditRenderer,
-  /**
-   * Represents an edit input pipe.
-   *
-   * @typedef {object} editInputPipe
-   * @property {string} name - The name of the edit input pipe.
-   * @property {number} id - The unique identifier of the edit input pipe.
-   * @property {boolean} isActive - Indicates whether the edit input pipe is active.
-   * @property {function} execute - Executes the edit input pipe operation.
-   * @property {function} addFilter - Adds a filter to the edit input pipe.
-   * @property {function} removeFilter - Removes a filter from the edit input pipe.
-   * @property {function} clearFilters - Clears all filters from the edit input pipe.
-   * @property {function} setPriority - Sets the priority of the edit input pipe.
-   * @property {function} getStatus - Retrieves the current status of the edit input pipe.
-   */
-  editInputPipe?: editInputPipe
-}
-