@guiexpert/table 1.0.3 → 1.0.5

package/src/lib/table/data/tablemodel/areamodel/area-model-cell-groups.ts

@@ -1,210 +0,0 @@
-import { AreaIdent } from "../area-ident.type";
-import { ColumnDefIf } from "../column/column-def.if";
-import { AreaModelIf } from "./area-model.if";
-import { CellGroupIf } from "../cellgroup/cell-group.if";
-import { CheckboxModelIf } from "../../../checkbox/checkbox-model.if";
-import { SortItem } from "../../common/sort-item";
-import { FilterFunction } from "../../common/filter-function";
-import { CellRendererIf } from "../../../renderer/cell-render.if";
-import { CheckedType } from "../../common/checked-type";
-import { CellgroupFactory } from "../cellgroup/cellgroup-factory";
-import { CellGroupExt } from "../cellgroup/cell-group-ext";
-import { CellGroupExtCellRenderer } from "../../../renderer/cell-group-ext-cell-renderer";
-
-// TODO next steps:   fix this model
-export class AreaModelCellGroups implements AreaModelIf {
-
-  public gammaCells = true;
-
-  public rowSelectionModel: CheckboxModelIf<any> | undefined;
-  public readonly arr: (CellGroupExt | null | undefined)[][];
-
-  private groupExts: CellGroupExt[] = [];
-  private cellGroupExtCellRenderer = new CellGroupExtCellRenderer();
-
-  constructor(
-    public readonly areaIdent: AreaIdent = "header",
-    public readonly groups: CellGroupIf[],
-    public readonly columnDefs: ColumnDefIf[] = [],
-    public readonly defaultRowHeight: number
-  ) {
-    this.groupExts = CellgroupFactory.buildGroupExts(groups);
-    console.info(this.groupExts);
-    console.info(this.getAllLeafs());
-    console.info(this.getMaxRowCount());
-    for (const g of this.groupExts) {
-      g.log(this.getMaxRowCount());
-      //console.info(g.getAllRowCounts(g));
-    }
-    this.arr = this.buildArray();
-
-    if (!this.columnDefs?.length && areaIdent === "header") {
-      this.columnDefs = CellgroupFactory.buildColumnDefs(groups);
-    }
-    console.info('this.columnDefs', this.columnDefs);
-    console.info('this.arr', this.arr);
-  }
-
-  getAllLeafs(): CellGroupExt[] {
-    const flatten = CellgroupFactory.flattenGroupExts(this.groupExts);
-    return flatten.filter(ge => !ge.children);
-  }
-
-  getMaxRowCount(): number {
-    const allLeafs = this.getAllLeafs();
-    if (allLeafs?.length) {
-      return 1 + Math.max(...allLeafs.map(c => c.getParentCount(c)));
-    }
-    return 0;
-  }
-
-  buildArray(): (CellGroupExt | null | undefined)[][] {
-    console.info("");
-    let flatten = CellgroupFactory.flattenGroupExts(this.groupExts);
-    // console.info("flat", flatten);
-
-    const maxCol = flatten.length;
-    const maxRow = 1 + Math.max(...flatten.map(c => c.rowIndex));
-    console.info("max  row/col:", maxRow + "/" + maxCol);
-
-    const sb: string[] = [];
-    CellgroupFactory.iterateThrowColumns(sb, this.groupExts);
-    console.info(sb);
-
-    const arrs = Array.from(Array(maxRow).keys()).map((_r) => []);
-    let ret = CellgroupFactory.buildArrayOfArrays(flatten, arrs);
-    console.table(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
-
-*/
-    return ret;
-  }
-
-  changeColumnOrder(_sourceColumnIndex: number, _targetColumnIndex: number): void {
-    // skip
-  }
-
-  doSort(_sortItems: SortItem[]): boolean {
-    return false;
-  }
-
-  externalFilterChanged<T>(_predictFn: FilterFunction<T>): void {
-    // skip
-  }
-
-  getCellRenderer(_rowIndex: number, _columnIndex: number): CellRendererIf | undefined {
-    return this.cellGroupExtCellRenderer;
-  }
-
-  getColspanAt(rowIndex: number, columnIndex: number): number {
-    // let ret = 1;
-    //
-    // if (this.getValueAt(rowIndex, columnIndex)){
-    //   const maxCol = this.arr[0].length;
-    //   while (ret< maxCol && this.getValueAt(rowIndex, columnIndex + ret)===null){
-    //     ret++;
-    //   }
-    // }
-    // return ret;
-
-    const val = this.getValueAt(rowIndex, columnIndex);
-    if (val) {
-      return val.getColumnCount();
-    }
-    return 0;
-  }
-
-  getCustomClassesAt(_rowIndex: number, _columnIndex: number): string[] {
-    return [];
-  }
-
-  getCustomStyleAt(_rowIndex: number, _columnIndex: number): { [p: string]: string } | undefined {
-    return undefined;
-  }
-
-  getMaxColspan(): number {
-    return 12;
-  }
-
-  getMaxRowspan(): number {
-    return 12;
-  }
-
-  getRowByIndex(_rowIndex: number): any {
-    return undefined;
-  }
-
-  getRowCount(): number {
-    if (this.arr) {
-      return this.arr.length;
-    }
-    return 0;
-  }
-
-
-  getRowspanAt(rowIndex: number, columnIndex: number): number {
-    // TODO
-    const cge: CellGroupExt | null | undefined = this.getValueAt(rowIndex, columnIndex);
-    if (cge){
-      const maxRowCount = this.getRowCount();
-      return cge.getRowSpan(cge, maxRowCount);
-    }
-    return 0;
-  }
-
-  getTooltipAt(_rowIndex: number, _columnIndex: number): any {
-    // TODO
-    return "";
-  }
-
-  getValueAt(rowIndex: number, columnIndex: number): any {
-    return this.arr[rowIndex][columnIndex];
-  }
-
-  getYPosByRowIndex(_rowIndex: number): number {
-    // TODO
-    return 0;
-  }
-
-
-  init(): void {
-  }
-
-  getRowHeight(_rowIndex: number): number {
-    return this.defaultRowHeight;
-  }
-
-  isEditable(_rowIndex: number, _columnIndex: number): boolean {
-    return false;
-  }
-
-  isFilterable(): boolean {
-    return false;
-  }
-
-  isRowCheckable(_rowIndex: number): boolean {
-    return false;
-  }
-
-  isRowChecked(_rowIndex: number): CheckedType | undefined {
-    return undefined;
-  }
-
-  isSelectable(_rowIndex: number, _columnIndex: number): boolean {
-    return false;
-  }
-
-  setRowChecked(_rowIndex: number, _checked: boolean): void {
-    // skipped
-  }
-
-  setValue(_rowIndex: number, _columnIndex: number, _value: any): boolean {
-    return false;
-  }
-
-}

package/src/lib/table/data/tablemodel/areamodel/area-model-hidden.ts

@@ -1,120 +0,0 @@
-import { AreaModelIf } from "./area-model.if";
-import { CellRendererIf } from "../../../renderer/cell-render.if";
-import { CheckedType } from "../../common/checked-type";
-import { CheckboxModelIf } from "../../../checkbox/checkbox-model.if";
-import { FilterFunction } from "../../common/filter-function";
-import { SortItem } from "../../common/sort-item";
-import { AreaIdent } from "../area-ident.type";
-
-/**
- * An unvisible model, which is used internally for hiding a header.
- */
-export class AreaModelHidden implements AreaModelIf {
-
-  rowSelectionModel: CheckboxModelIf<any> | undefined = undefined;
-
-  constructor(
-    public areaIdent: AreaIdent = "body"
-  ) {
-  }
-
-  getRowCount(): number {
-    return 0;
-  }
-
-  getValueAt(_rowIndex: number, _columnIndex: number): any {
-    return "";
-  }
-
-  getCellRenderer(_rowIndex: number, _columnIndex: number): CellRendererIf | undefined {
-    return undefined;
-  }
-
-  getRowHeight(_rowIndex: number): number {
-    return 0;
-  }
-
-  getColspanAt(_rowIndex: number, _columnIndex: number): number {
-    return 0;
-  }
-
-  getCustomClassesAt(_rowIndex: number, _columnIndex: number): string[] {
-    return [];
-  }
-
-  getCustomStyleAt(_rowIndex: number, _columnIndex: number): { [key: string]: string } | undefined {
-    return undefined;
-  }
-
-  getRowspanAt(_rowIndex: number, _columnIndex: number): number {
-    return 0;
-  }
-
-  getRowByIndex(_idx: number): any {
-    return undefined;
-  }
-
-  isRowCheckable(_rowIndex: number): boolean {
-    return false;
-  }
-
-  isRowChecked(_rowIndex: number): CheckedType | undefined {
-    return undefined;
-  }
-
-  setRowChecked(_rowIndex: number, _checked: boolean): void {
-    // nothing
-  }
-
-  getTooltipAt(_rowIndex: number, _columnIndex: number): any {
-    return "";
-  }
-
-  getMaxColspan(): number {
-    return 0;
-  }
-
-  getMaxRowspan(): number {
-    return 0;
-  }
-
-
-  getYPosByRowIndex(_rowIndex: number): number {
-    return 0;
-  }
-
-  init(): void {
-    // nothing
-  }
-
-  externalFilterChanged(_predictFn: FilterFunction<any>): void {
-    // nothing
-  }
-
-  isFilterable(): boolean {
-    return false;
-  }
-
-  doSort(_sortItems: SortItem[]): boolean {
-    // do nothing
-    return false;
-  }
-
-  isEditable(_rowIndex: number, _columnIndex: number): boolean {
-    return false;
-  }
-
-  setValue(_rowIndex: number, _columnIndex: number, _value: string): boolean {
-    return false;
-  }
-
-  isSelectable(_rowIndex: number, _columnIndex: number): boolean {
-    return false;
-  }
-
-  changeColumnOrder(_sourceColumnIndex: number, _targetColumnIndex: number): void {
-    // skip
-  }
-
-}
-

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

@@ -1,23 +0,0 @@
-import { AreaModelObjectyArray } from "./area-model-object-array";
-import { ColumnDefIf } from "../column/column-def.if";
-import { AreaIdent } from "../area-ident.type";
-
-export class AreaModelObjectArrayWithColumndefs<T> extends AreaModelObjectyArray<T> {
-
-
-  constructor(
-    public override areaIdent: AreaIdent,
-    protected override readonly rows: T[],
-    protected override readonly columnDefs: ColumnDefIf[],
-    public override defaultRowHeight: number
-  ) {
-    super(
-      areaIdent,
-      rows,
-      defaultRowHeight,
-      columnDefs
-    );
-  }
-
-}
-

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

@@ -1,105 +0,0 @@
-import { AbstractAreaModel } from "./abstract-area-model";
-import { TreeRow } from "../../common/tree-row";
-import { ColumnDefIf } from "../column/column-def.if";
-import { AreaIdent } from "../area-ident.type";
-import { FilterFunction } from "../../common/filter-function";
-import { SorterService } from "../../../service/sorter.service";
-import { SortItem } from "../../common/sort-item";
-
-export class AreaModelObjectyArray<T> extends AbstractAreaModel<T> {
-
-  protected readonly properties: string[];
-  protected filteredRows: T[];
-  protected sorterService: SorterService = new SorterService();
-
-  constructor(
-    public override areaIdent: AreaIdent,
-    protected readonly rows: T[],
-    public override defaultRowHeight: number,
-    protected override columnDefs: ColumnDefIf[] = []
-  ) {
-    super(areaIdent, columnDefs, defaultRowHeight);
-    this.filteredRows = [...rows];
-    this.properties = columnDefs.map(def => def.property);
-  }
-
-  getRowCount(): number {
-    return this.filteredRows?.length ?? 0;
-  }
-
-  getValueAt(rowIndex: number, columnIndex: number): any {
-    const property = this.properties[columnIndex];
-    let t = this.filteredRows[rowIndex];
-    if (t instanceof TreeRow) {
-      t = t.data;
-    }
-    if (t) {
-      return this.getValueByT(t, property);
-    }
-    return "";
-  }
-
-  getFilteredRows(): T[] {
-    return this.filteredRows;
-  }
-
-  getAllRows(): T[] {
-    return this.rows;
-  }
-
-  getRowHeight(_rowIndex: number): number {
-    return this.defaultRowHeight;
-  }
-
-  override getRowByIndex(rowIndex: number): any {
-    return this.filteredRows[rowIndex];
-  }
-
-  externalFilterChanged(predictFn: FilterFunction<any>): void {
-    this.filteredRows = (this.rows ? this.rows.filter(predictFn) : []);
-  }
-
-  override doSort(sortItems: SortItem[]): boolean {
-    for (const sortItem of sortItems) {
-      const { columnIndex, sortState } = sortItem;
-      const f = sortState === "asc" ? 1 :
-        sortState === "desc" ? -1 : 0;
-      const property = this.properties[columnIndex];
-      this.filteredRows = this.filteredRows.sort(this.genericFlatTableSortComparator(property, f));
-    }
-    return true;
-  }
-
-  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/area-model-tree.ts

@@ -1,215 +0,0 @@
-import { TreeRow } from "../../common/tree-row";
-import { TreeRowService } from "../../../service/tree-row.service";
-import { AbstractAreaModel } from "./abstract-area-model";
-import { AreaIdent } from "../area-ident.type";
-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";
-
-export class AreaModelTree<S> extends AbstractAreaModel<TreeRow<S>> {
-
-  protected readonly properties: string[];
-  protected sorterService: SorterService = new SorterService();
-
-  private readonly service = new TreeRowService();
-  private filteredFlattenRows: TreeRow<S>[];
-  private flattenRows: TreeRow<S>[];
-  private lastPredictFn?: FilterFunction<any>;
-
-  constructor(
-    public override areaIdent: AreaIdent,
-    public readonly rows: TreeRow<S>[],
-    public override  defaultRowHeight: number,
-    protected override columnDefs: ColumnDefIf[] = []
-  ) {
-    super(areaIdent, columnDefs, defaultRowHeight);
-    this.properties = columnDefs.map(def => def.property);
-    this.flattenRows = this.service.flattenTree(rows);
-    this.filteredFlattenRows = [...this.flattenRows];
-  }
-
-  override changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void {
-    //  not this! this.arrayMove(this.columnDefs...)
-    this.arrayMove(this.properties, sourceColumnIndex, targetColumnIndex);
-    super.changeColumnOrder(sourceColumnIndex, targetColumnIndex);
-  }
-
-  recalcVisibleTreeRows() {
-    this.filteredFlattenRows = this.service.flattenTree(this.rows);
-  }
-
-  getFilteredFlattenRows(): TreeRow<S>[] {
-    return this.filteredFlattenRows;
-  }
-
-  getRowCount(): number {
-    let n = 0;
-    for (const r of this.filteredFlattenRows) {
-      if (this.service.isVisible(r)) {
-        n++;
-      }
-    }
-    return n;
-  }
-
-  getValueAt(rowIndex: number, columnIndex: number): any {
-    const row = this.getRowByIndex(rowIndex);
-    if (row) {
-      const prop = this.properties[columnIndex];
-      if (prop) {
-        if (prop.includes(".")) {
-          return this.getPropertyValue(row.data, prop.split("."));
-        }
-        // @ts-ignore
-        return row.data[prop];
-      }
-    }
-    return "";
-  }
-
-  getRowHeight(_rowIndex: number): number {
-    return this.defaultRowHeight;
-  }
-
-  override getCustomClassesAt(rowIndex: number, _columnIndex: number): string[] {
-    const row = this.filteredFlattenRows[rowIndex];
-    return ["ge-table-tree-cell", "ge-table-tree-deep-" + row.deep];
-  }
-
-  override getRowByIndex(idx: number): TreeRow<S> | undefined {
-    return this.filteredFlattenRows[idx];
-  }
-
-  getValueByT(t: S, property: string) {
-    if (property.includes(".")) {
-      return this.getPropertyValue(t, property.split("."));
-    }
-    // @ts-ignore
-    return t[property];
-  }
-
-  externalFilterChanged<S>(predictFn: FilterFunction<S>): void {
-    this.lastPredictFn = predictFn;
-    this.doFiltering();
-  }
-
-  override doSort(sortItems: SortItem[]): boolean {
-    const { columnIndex, sortState } = sortItems[sortItems.length - 1];
-    const f = sortState === "asc" ? 1 :
-      sortState === "desc" ? -1 : 0;
-
-    const property = this.properties[columnIndex];
-    this.treeSort(this.rows, property, f);
-
-    this.flattenRows = this.service.flattenTree(this.rows);
-    this.filteredFlattenRows = [...this.flattenRows];
-    return true;
-  }
-
-  toggleExpandCollapseAll(expanded: boolean) {
-    this.expandAllRecursive(this.rows, expanded);
-
-    this.flattenRows = this.service.flattenTree(this.rows);
-    this.doFiltering();
-  }
-
-  setAllParentsOk(item: TreeRow<any>) {
-    if (item.parent) {
-      item.parent.keep = true;
-      this.setAllParentsOk(item.parent);
-    }
-    return false;
-  }
-
-  override setValue(rowIndex: number, columnIndex: number, value: any): boolean {
-    const editInputPipe = this.columnDefs[columnIndex]?.editInputPipe;
-    if (editInputPipe) {
-      value = editInputPipe(value, rowIndex, columnIndex);
-    }
-    const treeRow: TreeRow<S> | undefined = this.getRowByIndex(rowIndex);
-    if (treeRow) {
-      const row: S = treeRow.data;
-      const property = this.columnDefs[columnIndex].property;
-      if (property.includes(".")) {
-        return this.setPropertyValue(row, property.split("."), value);
-      }
-      // @ts-ignore
-      row[property] = value;
-      return true;
-    }
-    return false;
-  }
-
-  protected genericTreeTableSortComparator(property: string, f: number) {
-    return (a: TreeRow<S>, b: TreeRow<S>) => {
-      const va = this.getValueByT(a.data, property);
-      const vb = this.getValueByT(b.data, property);
-      return this.sorterService.genericSortComparator(va, vb, f);
-    };
-  }
-
-  private expandAllRecursive(arr: TreeRow<S>[], expanded: boolean) {
-    for (const row of arr) {
-      row.expanded = expanded;
-      if (row.children) {
-        this.expandAllRecursive(row.children, expanded);
-      }
-    }
-  }
-
-  private doFiltering() {
-    if (!this.lastPredictFn) {
-      this.filteredFlattenRows = [...(this.flattenRows ? this.flattenRows : [])];
-    } else {
-
-      if (!this.flattenRows) {
-        this.flattenRows = [];
-      }
-
-      let maxDeep = 0;
-      this.flattenRows.forEach(v => {
-        maxDeep = Math.max(maxDeep, v.deep);
-      });
-
-      const okRows = this.flattenRows.filter(
-        (value, index, array) => {
-          // @ts-ignore
-          return this.lastPredictFn(value, index, array);
-        }
-      );
-      this.flattenRows.forEach(v => v.keep = false);
-      this.flattenRows.forEach(v => {
-        if (okRows.includes(v)) {
-          v.keep = true;
-          this.setAllParentsOk(v);
-        }
-      });
-
-      this.filteredFlattenRows = this.flattenRows.filter(
-        (value, _index, _array) => {
-          return value.keep;
-        }
-      );
-    }
-  }
-
-  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;
-  }
-
-  private treeSort(rows: TreeRow<S>[], property: string, f: number) {
-    rows.sort(this.genericTreeTableSortComparator(property, f));
-    for (const row of rows) {
-      if (row.children) {
-        this.treeSort(row.children, property, f);
-      }
-    }
-  }
-}