@guiexpert/table 1.1.23 → 1.1.25

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

@@ -1,379 +0,0 @@
-import { AreaModelIf } from "../data/tablemodel/areamodel/area-model.if";
-import { DefaultRowHeightsIf } from "../data/options/default-row-heights.if";
-import { ColumnDefIf } from "../data/tablemodel/column/column-def.if";
-import { GetT } from "../data/common/get-t";
-import { TableOptionsIf } from "../data/options/table-options.if";
-import { TableModelIf } from "../data/tablemodel/table-model.if";
-import { DefaultRowHeights } from "../data/options/default-row-heights";
-import { ColumnDef } from "../data/tablemodel/column/column-def";
-import { px200 } from "../data/common/sizes";
-import { AreaModelArrayOfArrays } from "../data/tablemodel/areamodel/area-model-array-of-arrays";
-import { AreaModelHidden } from "../data/tablemodel/areamodel/area-model-hidden";
-import { TreeRow } from "../data/common/tree-row";
-import { AreaModelTree } from "../data/tablemodel/areamodel/area-model-tree";
-import { TreeCheckboxModel } from "../checkbox/tree-checkbox-model";
-import { TableModel } from "../data/tablemodel/table-model";
-import { SelectionModelIf } from "../selection/selection-model.if";
-import {
-  AreaModelObjectArrayWithColumndefs
-} from "../data/tablemodel/areamodel/area-model-object-array-with-columndefs";
-import { TableOptions } from "../data/options/table-options";
-import {isTreeRow} from "../instanceof-workaround";
-
-
-export class TableFactory {
-
-  public static createTableModel(p: Partial<{
-    headerAreaModel: AreaModelIf,
-    bodyAreaModel: AreaModelIf,
-    footerAreaModel: AreaModelIf,
-    fixedLeftColumnCount: number,
-    fixedRightColumnCount: number,
-    rowCheckboxVisible: boolean,
-    defaultRowHeights: DefaultRowHeightsIf,
-    columnDefs: ColumnDefIf[],
-    columnSizes: number[],
-    overridingColumnWidth: number,
-    columnCount: number,
-    parentSize: number,
-    getSelectionModel: GetT<SelectionModelIf>,
-    rows: any[],
-    properties: string[],
-    bodyData: any[][],
-    headerData: string[][], // multi-line header
-    footerData: string[][], // multi-line footerData
-    tableOptions: TableOptionsIf
-
-  }>): TableModelIf {
-
-    if (p.defaultRowHeights === undefined) {
-      if (p.tableOptions?.defaultRowHeights) {
-        p.defaultRowHeights = p.tableOptions.defaultRowHeights;
-      } else {
-        p.defaultRowHeights = new DefaultRowHeights();
-
-        if (p.headerAreaModel && "defaultRowHeight" in p.headerAreaModel) {
-          const dh = p.headerAreaModel.defaultRowHeight as number;
-          if (dh > -1) {
-            p.defaultRowHeights.header = dh;
-          }
-        }
-
-        if (p.bodyAreaModel && "defaultRowHeight" in p.bodyAreaModel) {
-          const dh = p.bodyAreaModel.defaultRowHeight as number;
-          if (dh > -1) {
-            p.defaultRowHeights.body = dh;
-          }
-        }
-
-        if (p.footerAreaModel && "defaultRowHeight" in p.footerAreaModel) {
-          const dh = p.footerAreaModel.defaultRowHeight as number;
-          if (dh > -1) {
-            p.defaultRowHeights.footer = dh;
-          }
-        }
-      }
-    }
-
-    if (p.columnDefs === undefined) {
-      if (p.properties?.length) {
-        p.columnDefs = p.properties.map(p => new ColumnDef(p, p.toUpperCase(), px200));
-      } else if (p.rows?.length) {
-        p.columnDefs = Object.keys(p.rows[0]).map(p => new ColumnDef(p, p.toUpperCase(), px200));
-      } else {
-        p.columnDefs = [];
-      }
-    }
-
-    if (p.columnCount === undefined) {
-      if (p.columnDefs?.length) {
-        p.columnCount = p.columnDefs.length;
-      } else if (p.headerData?.length) {
-        p.columnCount = p.headerData[0].length;
-      } else if (p.columnSizes?.length) {
-        p.columnCount = p.columnSizes?.length;
-      } else {
-        console.warn("Property \"columnCount\" is missing and cannot be derived from other properties.");
-      }
-    }
-
-
-    if (!p.headerAreaModel) {
-      if (p.headerData?.length) {
-        p.headerAreaModel = new AreaModelArrayOfArrays<string>(
-          "header",
-          p.headerData,
-          p.defaultRowHeights.header,
-          p.columnDefs
-        );
-      } else if (p.columnDefs?.length) {
-        p.headerAreaModel = new AreaModelArrayOfArrays<string>(
-          "header",
-          [p.columnDefs.map(def => def.headerLabel)],
-          p.defaultRowHeights.header,
-          p.columnDefs
-        );
-      } else {
-        p.headerAreaModel = new AreaModelHidden("header");
-      }
-    }
-    if (!p.footerAreaModel) {
-      if (p.footerData?.length) {
-        p.footerAreaModel = new AreaModelArrayOfArrays<string>(
-          "footer",
-          p.footerData,
-          p.defaultRowHeights.footer,
-          p.columnDefs
-        );
-      } else {
-        p.footerAreaModel = new AreaModelHidden("footer");
-      }
-    }
-    if (!p.bodyAreaModel) {
-      if (p.rows) {
-
-        if (p.rows?.length && isTreeRow(p.rows[0])) {
-          // Tree:
-          const treeRows = p.rows as TreeRow<any>[];
-          p.bodyAreaModel = new AreaModelTree(
-            "body",
-            treeRows,
-            p.defaultRowHeights.body,
-            p.columnDefs
-          );
-          const checkboxExtraColumnVisible = p.columnDefs[0].property === "CheckboxColumn";
-          if (checkboxExtraColumnVisible || p.tableOptions?.showCheckboxWihoutExtraColumn) {
-            p.bodyAreaModel.rowSelectionModel = new TreeCheckboxModel(treeRows);
-          }
-        } else {
-          p.bodyAreaModel = new AreaModelObjectArrayWithColumndefs<any>(
-            "body", p.rows, p.columnDefs, p.defaultRowHeights.body
-          );
-        }
-
-      } else if (p.bodyData) {
-        p.bodyAreaModel = new AreaModelArrayOfArrays<any>(
-          "body", p.bodyData, p.defaultRowHeights.body
-        );
-      } else {
-        p.bodyAreaModel = new AreaModelHidden("body");
-      }
-    }
-
-    if (p.fixedLeftColumnCount === undefined) {
-      p.fixedLeftColumnCount = 0;
-    }
-    if (p.fixedRightColumnCount === undefined) {
-      p.fixedRightColumnCount = 0;
-    }
-    if (p.rowCheckboxVisible === undefined) {
-      p.rowCheckboxVisible = false;
-    }
-    if (p.overridingColumnWidth === undefined) {
-      p.overridingColumnWidth = -1;
-    }
-
-    if (!p.getSelectionModel && p.tableOptions?.getSelectionModel) {
-      p.getSelectionModel = p.tableOptions?.getSelectionModel;
-    }
-
-    // Flat table:
-    return new TableModel(
-      p.headerAreaModel,
-      p.bodyAreaModel,
-      p.footerAreaModel,
-      p.fixedLeftColumnCount,
-      p.fixedRightColumnCount,
-      p.rowCheckboxVisible,
-      p.defaultRowHeights,
-      p.columnDefs,
-      p.columnSizes,
-      p.overridingColumnWidth,
-      p.columnCount,
-      p.parentSize,
-      p.getSelectionModel
-    );
-  }
-
-  static buildByTypedRowsParam<T>(param: {
-    rows: T[],
-    columnDefs: ColumnDefIf[],
-    tableOptions?: TableOptionsIf,
-    fixedLeftColumnCount?: number,
-    fixedRightColumnCount?: number
-  }): TableModelIf {
-
-    return TableFactory.buildByTypedRows<T>(
-      param.rows ?? [],
-      param.columnDefs,
-      param.tableOptions ?? new TableOptions(),
-      param.fixedLeftColumnCount ?? 0,
-      param.fixedRightColumnCount ?? 0
-    );
-  }
-
-  static buildByTypedRows<T>(
-    rows: T[],
-    columnDefs: ColumnDefIf[],
-    tableOptions: TableOptionsIf = new TableOptions(),
-    fixedLeftColumnCount: number = 0,
-    fixedRightColumnCount: number = 0
-  ): TableModelIf {
-
-    const defaultRowHeights = tableOptions.defaultRowHeights;
-    const checkboxExtraColumnVisible = columnDefs[0].property === "CheckboxColumn";
-
-    if (rows?.length && isTreeRow(rows[0])) {
-      // Tree:
-      const treeRows = rows as TreeRow<T>[];
-      const bodyareaModel = new AreaModelTree(
-        "body",
-        treeRows,
-        defaultRowHeights.body,
-        columnDefs
-      );
-      if (checkboxExtraColumnVisible || tableOptions.showCheckboxWihoutExtraColumn) {
-        bodyareaModel.rowSelectionModel = new TreeCheckboxModel(treeRows);
-      }
-      return TableFactory.createByAreaModelsParam({
-        headerAreaModel: new AreaModelArrayOfArrays<string>("header", [columnDefs.map(def => def.headerLabel)], defaultRowHeights.header),
-        bodyAreaModel: bodyareaModel,
-        footerAreaModel: new AreaModelArrayOfArrays<string>("footer", [], defaultRowHeights.footer),
-        columnDefs,
-        fixedLeftColumnCount,
-        fixedRightColumnCount,
-        defaultRowHeights: tableOptions.defaultRowHeights,
-        rowCheckboxVisible: false,
-        columnSizes: [],
-        columnCount: columnDefs.length,
-        overridingColumnWidth: -1
-      });
-    }
-
-    // Flat table:
-    return TableFactory.createByObjectArrayParam({
-      rows,
-      columnDefs,
-      fixedLeftColumnCount,
-      fixedRightColumnCount,
-      defaultRowHeights: tableOptions.defaultRowHeights
-    });
-
-  }
-
-  public static createByObjectArrayParam<T>(param: {
-    rows: T[],
-    header?: string[][],
-    footer?: string[][],
-    fixedLeftColumnCount?: number,
-    fixedRightColumnCount?: number,
-    rowCheckboxVisible?: boolean,
-    defaultRowHeights?: DefaultRowHeightsIf,
-    columnDefs?: ColumnDefIf[],
-    columnSizes?: number[]
-  }) {
-    const rowCheckboxVisible = param.rowCheckboxVisible !== undefined ? param.rowCheckboxVisible : false;
-    return TableFactory.createByObjectArray<T>(
-      param.rows,
-      param.header ?? [],
-      param.footer ?? [],
-      param.fixedLeftColumnCount ?? 0,
-      param.fixedRightColumnCount ?? 0,
-      rowCheckboxVisible,
-      param.defaultRowHeights ?? new DefaultRowHeights(),
-      param.columnDefs ?? [],
-      param.columnSizes ?? []
-    );
-  }
-
-  public static createByAreaModels(
-    headerAreaModel: AreaModelIf = new AreaModelHidden(),
-    bodyAreaModel: AreaModelIf,
-    footerAreaModel: AreaModelIf = new AreaModelHidden(),
-    fixedLeftColumnCount: number = 0,
-    fixedRightColumnCount: number = 0,
-    rowCheckboxVisible: boolean = false,
-    defaultRowHeights: DefaultRowHeightsIf = new DefaultRowHeights(),
-    columnDefs: ColumnDefIf[],
-    columnSizes: number[] = [],
-    overridingColumnWidth: number = -1,
-    columnCount: number
-  ) {
-    return new TableModel(
-      headerAreaModel,
-      bodyAreaModel,
-      footerAreaModel,
-      fixedLeftColumnCount,
-      fixedRightColumnCount,
-      rowCheckboxVisible,
-      defaultRowHeights,
-      columnDefs,
-      columnSizes,
-      overridingColumnWidth,
-      columnCount
-    );
-  }
-
-  public static createByAreaModelsParam(param: {
-    headerAreaModel?: AreaModelIf,
-    bodyAreaModel: AreaModelIf,
-    footerAreaModel?: AreaModelIf,
-    fixedLeftColumnCount?: number,
-    fixedRightColumnCount?: number,
-    rowCheckboxVisible?: boolean,
-    defaultRowHeights?: DefaultRowHeightsIf,
-    columnDefs?: ColumnDefIf[],
-    columnSizes?: number[],
-    overridingColumnWidth?: number,
-    columnCount?: number
-  }) {
-    return TableFactory.createByAreaModels(
-      param.headerAreaModel ?? new AreaModelHidden(),
-      param.bodyAreaModel,
-      param.footerAreaModel ?? new AreaModelHidden(),
-      param.fixedLeftColumnCount ?? 0,
-      param.fixedRightColumnCount ?? 0,
-      param.rowCheckboxVisible === undefined ? false : param.rowCheckboxVisible,
-      param.defaultRowHeights,
-      param.columnDefs ?? [],
-      param.columnSizes ?? [],
-      param.overridingColumnWidth ?? -1,
-      param.columnCount ?? 0
-    );
-  }
-
-  public static createByObjectArray<T>(
-    rows: T[],
-    header: string[][] = [],
-    footer: string[][] = [],
-    fixedLeftColumnCount: number = 0,
-    fixedRightColumnCount: number = 0,
-    rowCheckboxVisible: boolean = false,
-    defaultRowHeights: DefaultRowHeightsIf = new DefaultRowHeights(),
-    columnDefs: ColumnDefIf[],
-    columnSizes: number[] = []
-  ) {
-    let headerAreaModel: AreaModelIf;
-    if (header?.length) {
-      headerAreaModel = new AreaModelArrayOfArrays<string>("header", header, defaultRowHeights.header, columnDefs);
-    } else if (columnDefs?.length) {
-      headerAreaModel = new AreaModelArrayOfArrays<string>("header", [columnDefs.map(def => def.headerLabel)], defaultRowHeights.header, columnDefs);
-    } else {
-      headerAreaModel = new AreaModelHidden();
-    }
-    const footerAreaModel = footer ? new AreaModelArrayOfArrays<string>("footer", footer, defaultRowHeights.footer, columnDefs) : new AreaModelHidden();
-    const bodyAreaModel = new AreaModelObjectArrayWithColumndefs<T>("body", rows, columnDefs, defaultRowHeights.body);
-
-    return new TableModel(
-      headerAreaModel,
-      bodyAreaModel,
-      footerAreaModel,
-      fixedLeftColumnCount,
-      fixedRightColumnCount,
-      rowCheckboxVisible,
-      defaultRowHeights,
-      columnDefs,
-      columnSizes
-    );
-  }
-}

package/src/lib/table/factory/tree-factory.ts

@@ -1,52 +0,0 @@
-import { TreeRow } from "../data/common/tree-row";
-import {TreeRowIf} from "../data/common/tree-row-if";
-
-export class TreeFactory {
-
-
-  static buildTreeRows<T>(
-    data: T[],
-    childrenProperty: string = "children",
-    deepMaxLimit: number = 12): TreeRowIf<T>[] {
-
-    const ret: TreeRowIf<T>[] = [];
-    for (const r of data) {
-      ret.push(TreeFactory.buildTreeRow<T>(r, childrenProperty, undefined, 0, deepMaxLimit));
-    }
-    return ret;
-  }
-
-
-  static buildTreeRow<T>(
-    data: T,
-    childrenProperty: string = "children",
-    parent: TreeRowIf<T> = new TreeRow<T>(data, true, [], undefined, 0), //, false , '0', '0'),
-    deep: number = 0,
-    deepMaxLimit: number = 12): TreeRowIf<T> {
-
-    if (deep > deepMaxLimit) {
-      console.warn("Max deep limit reached: ", deep);
-      return parent;
-    }
-    // @ts-ignore
-    const children: T[] | undefined = data[childrenProperty];
-    if (children) {
-      for (const r of children) {
-        const tr = new TreeRow<T>(r, true, [], parent, deep + 1);
-        parent.children?.push(tr);
-        TreeFactory.buildTreeRow(
-          r,
-          childrenProperty,
-          tr,
-          deep + 1
-        );
-        if (deep > deepMaxLimit) {
-          console.warn("Max deep limit reached: ", deep);
-          return parent;
-        }
-      }
-    }
-    return parent;
-  }
-}
-

package/src/lib/table/focus/event-focus-changed-listener.if.ts

@@ -1,8 +0,0 @@
-import { FocusModelIf } from './focus-model.if';
-
-
-export interface EventFocusChangedListenerIf {
-
-  onFocusChanged(model: FocusModelIf): void;
-
-}

package/src/lib/table/focus/focus-model.if.ts

@@ -1,20 +0,0 @@
-import { EventFocusChangedListenerIf } from './event-focus-changed-listener.if';
-
-export interface FocusModelIf {
-
-  getEventFocusChangedListeners(): EventFocusChangedListenerIf[];
-  addEventFocusChangedListener(listener: EventFocusChangedListenerIf): void;
-  removeEventFocusChangedListener(listener: EventFocusChangedListenerIf): void;
-
-  clear(): void;
-
-  setFocus(rowIndex: number, columnIndex: number): void;
-
-  hasFocus(rowIndex: number, columnIndex: number): boolean;
-
-  getFocus(): [number, number];
-
-  hasChanged(): boolean;
-
-  clearChanged(): void;
-}

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

@@ -1,76 +0,0 @@
-import { FocusType } from "./focus.type";
-import { FocusModelIf } from "./focus-model.if";
-import { EventFocusChangedListenerIf } from './event-focus-changed-listener.if';
-import { AvoidDoubleExecution } from '../../common/decorator/avoid-double-execution.decorator';
-
-export class FocusModel implements FocusModelIf {
-
-  protected rowIndex: number = -1;
-  protected columnIndex: number = -1;
-  protected changed = false;
-
-  private listenerArr: EventFocusChangedListenerIf[] = [];
-
-  constructor(
-    public selectionType: FocusType = "none"
-  ) {
-  }
-
-  getEventFocusChangedListeners(): EventFocusChangedListenerIf[]{
-    return this.listenerArr;
-  }
-
-  addEventFocusChangedListener(listener: EventFocusChangedListenerIf): void {
-    if (!this.listenerArr.includes(listener)) {
-      this.listenerArr.push(listener);
-    }
-  }
-
-  removeEventFocusChangedListener(listener: EventFocusChangedListenerIf): void {
-    const index = this.listenerArr.indexOf(listener, 0);
-    if (index > -1) {
-      this.listenerArr.splice(index, 1);
-    }
-  }
-
-  //@AvoidDoubleExecution(100)
-  fireChangeEvent() {
-    this.listenerArr.forEach(l => l.onFocusChanged(this));
-  }
-
-  clearChanged(): void {
-    this.changed = false;
-  }
-
-  hasChanged(): boolean {
-    return this.changed;
-  }
-
-  clear(): void {
-    this.rowIndex = -1;
-    this.columnIndex = -1;
-    this.fireChangeEvent();
-  }
-
-
-  setFocus(
-    rowIndex: number,
-    columnIndex: number
-  ): void {
-    if (this.rowIndex !== rowIndex || this.columnIndex !== columnIndex) {
-      this.rowIndex = rowIndex;
-      this.columnIndex = columnIndex;
-      this.changed = true;
-      this.fireChangeEvent();
-    }
-  }
-
-  hasFocus(rowIndex: number, columnIndex: number): boolean {
-    return this.rowIndex === rowIndex && this.columnIndex === columnIndex;
-  }
-
-  getFocus(): [number, number] {
-    return [this.rowIndex, this.columnIndex];
-  }
-
-}

package/src/lib/table/focus/focus.type.ts

@@ -1,4 +0,0 @@
-export type FocusType = "none" | "cell" | "row";
-
-
-

package/src/lib/table/input-handler.ts

@@ -1,48 +0,0 @@
-import { TableScope } from "./table-scope";
-import { AreaIdent, getAreaIdentByString } from "./data/tablemodel/area-ident.type";
-
-/**
- * Class representing an input handler for table input fields (HTMLSelectElement, HTMLTextAreaElement, HTMLInputElement).
- *
- * @class
- * @memberOf module:input
- */
-export class InputHandler {
-
-
-  constructor(
-    protected tableScope: TableScope
-  ) {
-    this.tableScope.hostElement.addEventListener("change", this.onHostElementChanged.bind(this));
-  }
-
-
-  /**
-   * Handles the onHostElementChanged event.
-   * In case that the element is an input field, the tableScope.updateModelValueAfterEdit() method is triggered.
-   *
-   * @param {Event} event - The event object.
-   *
-   * @return {void}
-   */
-  private onHostElementChanged(event: Event) {
-    if (event.target instanceof HTMLInputElement
-      || event.target instanceof HTMLSelectElement
-      || event.target instanceof HTMLTextAreaElement
-    ) {
-      const htmpInputEle = event.target;
-      const areaIdentStr = htmpInputEle.getAttribute("data-area");
-      const rowIndexStr = htmpInputEle.getAttribute("data-row-index");
-      const columnIndexStr = htmpInputEle.getAttribute("data-col-index");
-
-      if (areaIdentStr && rowIndexStr && columnIndexStr) {
-        const area: AreaIdent = getAreaIdentByString(areaIdentStr);
-        const rowIndex = Number(rowIndexStr);
-        const columnIndex = Number(columnIndexStr);
-        this.tableScope.updateModelValueAfterEdit(area, rowIndex, columnIndex, htmpInputEle.value);
-      }
-    }
-  }
-
-
-}

package/src/lib/table/instanceof-workaround.ts

@@ -1,41 +0,0 @@
-
-
-/*
- * necessary because of es5 (Svelte, Astro,...)
- */
-
-/**
- * Checks if the given row is a tree row.
- *
- * @param {any} row - The row to be checked.
- *
- * @return {boolean} - true if the row is a tree row, false otherwise.
- */
-export function isTreeRow(row: any): boolean {
-  return row && row['type'] === 'TreeRow';
-}
-
-
-
-/**
- * Determines if the given model is an AreaModelTree.
- *
- * @param {any} model - The model object to check.
- * @return {boolean} - True if the model is an AreaModelTree, false otherwise.
- */
-export function isAreaModelTree(model: any): boolean {
-  return model && model['type'] === 'AreaModelTree';
-}
-
-
-/**
- * Checks if the given object is a CheckboxColumnDef.
- *
- * @param {any} o - The object to be checked.
- * @returns {boolean} - True if the object is a CheckboxColumnDef, false otherwise.
- */
-export function isCheckboxColumnDef(o: any): boolean {
-  return o && o['type'] === 'CheckboxColumnDef';
-}
-
-

package/src/lib/table/license-manager.ts

@@ -1,47 +0,0 @@
-/**
- * LicenseManager class responsible for managing license keys.
- * As it's a singleton class, it only allows one instance of itself to exist.
- *
- * Usage: LicenseManager.getInstance().setLicenseKey('Your API key');
- */
-export class LicenseManager {
-
-  private static instance: LicenseManager;
-  private alreadySet = false;
-
-  // The constructor is private to prevent direct construction calls
-  // with the `new` operator
-  private constructor() {
-  }
-
-
-  public static getInstance(): LicenseManager {
-    if (!LicenseManager.instance) {
-      LicenseManager.instance = new LicenseManager();
-    }
-
-    return LicenseManager.instance;
-  }
-
-  /**
-   * Method to set the license key for the application.
-   * A 'meta' element is created with content as 'guiexperttable=<license key>'
-   * and appended into the head section of the document
-   *
-   * @param {string} key - The license key to set for the application.
-   *
-   * @return {void} - This method does not return anything
-   */
-  public setLicenseKey(key: string | undefined) {
-    if (key && !this.alreadySet) {
-
-      const meta = document.createElement('meta');
-      meta.content = 'license=' + key;
-      meta.name = 'guiexperttable';
-      document.getElementsByTagName('head')[0].appendChild(meta);
-
-      this.alreadySet = true;
-    }
-  }
-
-}