@guiexpert/table 1.0.2 → 1.0.5

package/esm2022/lib/table/data/tablemodel/cellgroup/cellgroup-factory.mjs

@@ -0,0 +1,110 @@
+import { ColumnDef } from "../column/column-def";
+import { CellGroupExt } from "./cell-group-ext";
+export class CellgroupFactory {
+    static buildColumnDefs(cellGroups, ret = []) {
+        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;
+                            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, ret = [], deep = 0, parent) {
+        let last = 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, ret = []) {
+        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, arrs) {
+        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 = [], cellGroups) {
+        for (const cellGroup of cellGroups) {
+            sb.push(cellGroup.data + "    rowIndex:" + cellGroup.rowIndex);
+            if (cellGroup.children?.length) {
+                CellgroupFactory.iterateThrowColumns(sb, cellGroup.children);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cellgroup-factory.js","sourceRoot":"","sources":["../../../../../../../../../libs/table/src/lib/table/data/tablemodel/cellgroup/cellgroup-factory.ts"],"names":[],"mappings":"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","sourcesContent":["import { CellGroupIf } from \"./cell-group.if\";\nimport { ColumnDefIf } from \"../column/column-def.if\";\nimport { ColumnDef } from \"../column/column-def\";\nimport { CellGroupExt } from \"./cell-group-ext\";\n\nexport class CellgroupFactory {\n\n\n  static buildColumnDefs(\n    cellGroups: CellGroupIf[],\n    ret: ColumnDefIf[] = []\n  ): ColumnDefIf[] {\n\n    for (const cellGroup of cellGroups) {\n      if (cellGroup.property) {\n        ret.push(ColumnDef.create({\n            property: cellGroup.property,\n            headerLabel: cellGroup.data ? cellGroup.data : cellGroup.property,\n            isVisible: () => {\n              // @ts-ignore\n              if (typeof cellGroup[\"isVisible\"] === \"function\") {\n                const cge = cellGroup as CellGroupExt;\n                return cge.isVisible();\n              }\n              return true;\n            }\n          })\n        );\n      }\n      if (cellGroup.children) {\n        CellgroupFactory.buildColumnDefs(cellGroup.children, ret);\n      }\n    }\n    return ret;\n  }\n/*\n  static buildDeepMap(\n    cellGroups: CellGroupIf[],\n    ret: { [key: string]: number } = {},\n    deep = 0\n  ): { [key: string]: number } {\n\n    for (const cellGroup of cellGroups) {\n      //if (cellGroup.property) {\n      ret[cellGroup.data] = deep;\n      //}\n      if (cellGroup.children) {\n        CellgroupFactory.buildDeepMap(cellGroup.children, ret, deep + 1);\n      }\n    }\n    return ret;\n  }\n*/\n  static buildGroupExts(\n    cellGroups: CellGroupIf[],\n    ret: CellGroupExt[] = [],\n    deep = 0,\n    parent?: CellGroupExt\n  ): CellGroupExt[] {\n\n    let last: CellGroupExt | undefined = undefined;\n    for (let i = 0; i < cellGroups.length; i++) {\n      const cellGroup = cellGroups[i];\n      const cge = new CellGroupExt(cellGroup, deep, i, parent);\n\n      if (last) {\n        cge.leftNeighbour = last;\n        last.rightNeighbour = cge;\n      }\n      ret.push(cge);\n      if (cellGroup.children) {\n        cge.children = CellgroupFactory.buildGroupExts(cellGroup.children, [], deep + 1, cge);\n      }\n      last = cge;\n    }\n    return ret;\n  }\n\n\n  static flattenGroupExts(\n    cellGroups: CellGroupExt[],\n    ret: CellGroupExt[] = []\n  ): CellGroupExt[] {\n\n    for (const cellGroup of cellGroups) {\n      ret.push(cellGroup);\n      if (cellGroup.children) {\n        CellgroupFactory.flattenGroupExts(cellGroup.children, ret);\n      }\n    }\n    return ret;\n  }\n\n  /*\n\n  Gold                                                           Hohenwarte\n  Gold AB                         Gold CD                        HOH AB                                  HOH CD\n  .          Gold A     Gold B    Gold C   Gold D    Gold Sum    .           HOH Loc    HOH A    HOH B   HOH C    HOH D\n\n  */\n\n  static buildArrayOfArrays(\n    flatten: CellGroupExt[],\n    arrs: (CellGroupExt | null | undefined)[][]\n  ): (CellGroupExt | null | undefined)[][] {\n\n    let col = -1;\n    let lastRowIdx = 99999;\n    for (const cellGroup of flatten) {\n      if (cellGroup.rowIndex <= lastRowIdx) {\n        col++;\n        for (let r = 0; r < arrs.length; r++) {\n          arrs[r][col] = null;\n        }\n      }\n\n      arrs[cellGroup.rowIndex][col] = cellGroup;\n      lastRowIdx = cellGroup.rowIndex;\n\n      if (cellGroup.ownColumn() && cellGroup.children?.length) {\n        for (let r = cellGroup.rowIndex + 1; r < arrs.length; r++) {\n          arrs[r][col] = undefined;\n        }\n        col++;\n        for (let r = 0; r < arrs.length; r++) {\n          arrs[r][col] = null;\n        }\n      }\n    }\n    return arrs;\n  }\n\n\n  static iterateThrowColumns(\n    sb: string[] = [],\n    cellGroups: CellGroupExt[]\n  ) {\n\n    for (const cellGroup of cellGroups) {\n      sb.push(cellGroup.data + \"    rowIndex:\" + cellGroup.rowIndex);\n      if (cellGroup.children?.length) {\n        CellgroupFactory.iterateThrowColumns(sb, cellGroup.children);\n      }\n    }\n  }\n\n}\n\n"]}

package/esm2022/lib/table/data/tablemodel/column/column-def.if.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLWRlZi5pZi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvdGFibGUvc3JjL2xpYi90YWJsZS9kYXRhL3RhYmxlbW9kZWwvY29sdW1uL2NvbHVtbi1kZWYuaWYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNpemVJZiB9IGZyb20gXCIuLi8uLi9jb21tb24vc2l6ZS5pZlwiO1xuaW1wb3J0IHsgQ2VsbFJlbmRlcmVySWYgfSBmcm9tIFwiLi4vLi4vLi4vcmVuZGVyZXIvY2VsbC1yZW5kZXIuaWZcIjtcbmltcG9ydCB7IEFyZWFPYmplY3RNYXBUeXBlIH0gZnJvbSBcIi4uLy4uL2NvbW1vbi9hcmVhLW1hcC50eXBlXCI7XG5pbXBvcnQgeyBCb29sZWFuRnVuY3Rpb24gfSBmcm9tIFwiLi4vLi4vY29tbW9uL2Jvb2xlYW4tZnVuY3Rpb25cIjtcbmltcG9ydCB7IFNvcnRTdGF0ZSB9IGZyb20gXCIuLi8uLi9jb21tb24vc29ydC1zdGF0ZS50eXBlXCI7XG5pbXBvcnQgeyBHZXRFZGl0UmVuZGVyZXIgfSBmcm9tIFwiLi4vLi4vLi4vcmVuZGVyZXIvZWRpdC9lZGl0LWNlbGwtcmVuZGVyZXIudHlwZVwiO1xuaW1wb3J0IHsgZWRpdElucHV0UGlwZSB9IGZyb20gXCIuLi8uLi8uLi9yZW5kZXJlci9lZGl0L2VkaXQtaW5wdXQtcGlwZS5pZlwiO1xuXG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29sdW1uRGVmSWYge1xuICBwcm9wZXJ0eTogc3RyaW5nO1xuICBoZWFkZXJMYWJlbDogc3RyaW5nO1xuICB3aWR0aDogU2l6ZUlmO1xuICBtaW5XaWR0aDogU2l6ZUlmO1xuICBtYXhXaWR0aDogU2l6ZUlmO1xuICByZW5kZXJlck1hcDogQXJlYU9iamVjdE1hcFR5cGU8Q2VsbFJlbmRlcmVySWY+O1xuICBjbGFzc2VzOiBBcmVhT2JqZWN0TWFwVHlwZTxzdHJpbmdbXT47XG4gIHNvcnRhYmxlPzogQm9vbGVhbkZ1bmN0aW9uLFxuICBzb3J0SWNvblZpc2libGU/OiBCb29sZWFuRnVuY3Rpb24sXG4gIHNvcnRDb21wYXJhdG9yPzogPFQ+KGE6IFQsIGI6IFQpID0+IG51bWJlcixcbiAgc29ydFN0YXRlPzogU29ydFN0YXRlLFxuICBzb3J0U3RhdGVzT3JkZXI/OiBTb3J0U3RhdGVbXSxcbiAgZWRpdGFibGU/OiBCb29sZWFuRnVuY3Rpb24sXG4gIGlzVmlzaWJsZT86IEJvb2xlYW5GdW5jdGlvbixcbiAgZ2V0RWRpdFJlbmRlcmVyPzogR2V0RWRpdFJlbmRlcmVyLFxuICBlZGl0SW5wdXRQaXBlPzogZWRpdElucHV0UGlwZVxufVxuXG4iXX0=

package/esm2022/lib/table/data/tablemodel/column/column-def.mjs

@@ -0,0 +1,52 @@
+import { Size } from "../../common/size";
+import { AreaObjectMap } from "../../common/area-map";
+import { FalseFn, TrueFn } from "../../common/boolean-function";
+export class ColumnDef {
+    property;
+    headerLabel;
+    width;
+    classes;
+    rendererMap;
+    minWidth;
+    maxWidth;
+    sortable;
+    sortComparator;
+    sortState;
+    sortStatesOrder;
+    sortIconVisible;
+    editable;
+    getEditRenderer;
+    editInputPipe;
+    isVisible;
+    visible = true;
+    constructor(property, headerLabel, width = new Size(100, "px"), classes = new AreaObjectMap(), rendererMap = new AreaObjectMap(), minWidth = new Size(100, "px"), maxWidth = new Size(100, "px"), sortable, sortComparator, sortState, sortStatesOrder, sortIconVisible, editable, getEditRenderer, editInputPipe, isVisible = () => this.visible) {
+        this.property = property;
+        this.headerLabel = headerLabel;
+        this.width = width;
+        this.classes = classes;
+        this.rendererMap = rendererMap;
+        this.minWidth = minWidth;
+        this.maxWidth = maxWidth;
+        this.sortable = sortable;
+        this.sortComparator = sortComparator;
+        this.sortState = sortState;
+        this.sortStatesOrder = sortStatesOrder;
+        this.sortIconVisible = sortIconVisible;
+        this.editable = editable;
+        this.getEditRenderer = getEditRenderer;
+        this.editInputPipe = editInputPipe;
+        this.isVisible = isVisible;
+    }
+    static bodyRenderer(bodyRenderer) {
+        return new AreaObjectMap(undefined, bodyRenderer, undefined);
+    }
+    static create(param) {
+        const am = new AreaObjectMap(param.headerRenderer, param.bodyRenderer, param.footerRenderer);
+        const cm = new AreaObjectMap(param.headerClasses, param.bodyClasses, param.footerClasses);
+        const sortIconVisible = param.sortIconVisible ?? param.sortable ?? FalseFn;
+        const editable = param.editable ?? param.editable ?? FalseFn;
+        const isVisible = param.isVisible ?? param.isVisible ?? TrueFn;
+        return new ColumnDef(param.property ?? "", param.headerLabel ?? "", param.width ?? new Size(100, "px"), cm, am, param.minWidth ?? new Size(100, "px"), param.maxWidth ?? new Size(100, "px"), param.sortable, param.sortComparator, param.sortState, param.sortStatesOrder, sortIconVisible, editable, param.getEditRenderer, param.editInputPipe, isVisible);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLWRlZi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvdGFibGUvc3JjL2xpYi90YWJsZS9kYXRhL3RhYmxlbW9kZWwvY29sdW1uL2NvbHVtbi1kZWYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBS3pDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN0RCxPQUFPLEVBQW1CLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQU1qRixNQUFNLE9BQU8sU0FBUztJQUtYO0lBQ0E7SUFDQTtJQUNBO0lBQ0E7SUFDQTtJQUNBO0lBQ0E7SUFDQTtJQUNBO0lBQ0E7SUFDQTtJQUNBO0lBQ0E7SUFDQTtJQUNBO0lBbEJGLE9BQU8sR0FBRyxJQUFJLENBQUM7SUFFdEIsWUFDUyxRQUFnQixFQUNoQixXQUFtQixFQUNuQixRQUFnQixJQUFJLElBQUksQ0FBQyxHQUFHLEVBQUUsSUFBSSxDQUFDLEVBQ25DLFVBQXVDLElBQUksYUFBYSxFQUFZLEVBQ3BFLGNBQWlELElBQUksYUFBYSxFQUFrQixFQUNwRixXQUFtQixJQUFJLElBQUksQ0FBQyxHQUFHLEVBQUUsSUFBSSxDQUFDLEVBQ3RDLFdBQW1CLElBQUksSUFBSSxDQUFDLEdBQUcsRUFBRSxJQUFJLENBQUMsRUFDdEMsUUFBMEIsRUFDMUIsY0FBMEMsRUFDMUMsU0FBcUIsRUFDckIsZUFBNkIsRUFDN0IsZUFBaUMsRUFDakMsUUFBMEIsRUFDMUIsZUFBaUMsRUFDakMsYUFBNkIsRUFDN0IsWUFBNkIsR0FBRSxFQUFFLENBQUEsSUFBSSxDQUFDLE9BQU87UUFmN0MsYUFBUSxHQUFSLFFBQVEsQ0FBUTtRQUNoQixnQkFBVyxHQUFYLFdBQVcsQ0FBUTtRQUNuQixVQUFLLEdBQUwsS0FBSyxDQUE4QjtRQUNuQyxZQUFPLEdBQVAsT0FBTyxDQUE2RDtRQUNwRSxnQkFBVyxHQUFYLFdBQVcsQ0FBeUU7UUFDcEYsYUFBUSxHQUFSLFFBQVEsQ0FBOEI7UUFDdEMsYUFBUSxHQUFSLFFBQVEsQ0FBOEI7UUFDdEMsYUFBUSxHQUFSLFFBQVEsQ0FBa0I7UUFDMUIsbUJBQWMsR0FBZCxjQUFjLENBQTRCO1FBQzFDLGNBQVMsR0FBVCxTQUFTLENBQVk7UUFDckIsb0JBQWUsR0FBZixlQUFlLENBQWM7UUFDN0Isb0JBQWUsR0FBZixlQUFlLENBQWtCO1FBQ2pDLGFBQVEsR0FBUixRQUFRLENBQWtCO1FBQzFCLG9CQUFlLEdBQWYsZUFBZSxDQUFrQjtRQUNqQyxrQkFBYSxHQUFiLGFBQWEsQ0FBZ0I7UUFDN0IsY0FBUyxHQUFULFNBQVMsQ0FBb0M7SUFFdEQsQ0FBQztJQUVELE1BQU0sQ0FBQyxZQUFZLENBQUMsWUFBNEI7UUFDOUMsT0FBTyxJQUFJLGFBQWEsQ0FDdEIsU0FBUyxFQUNULFlBQVksRUFDWixTQUFTLENBQ1YsQ0FBQztJQUNKLENBQUM7SUFFRCxNQUFNLENBQUMsTUFBTSxDQUFDLEtBcUJiO1FBRUMsTUFBTSxFQUFFLEdBQUcsSUFBSSxhQUFhLENBQzFCLEtBQUssQ0FBQyxjQUFjLEVBQ3BCLEtBQUssQ0FBQyxZQUFZLEVBQ2xCLEtBQUssQ0FBQyxjQUFjLENBQ3JCLENBQUM7UUFFRixNQUFNLEVBQUUsR0FBRyxJQUFJLGFBQWEsQ0FDMUIsS0FBSyxDQUFDLGFBQWEsRUFDbkIsS0FBSyxDQUFDLFdBQVcsRUFDakIsS0FBSyxDQUFDLGFBQWEsQ0FDcEIsQ0FBQztRQUVGLE1BQU0sZUFBZSxHQUFHLEtBQUssQ0FBQyxlQUFlLElBQUksS0FBSyxDQUFDLFFBQVEsSUFBSSxPQUFPLENBQUM7UUFDM0UsTUFBTSxRQUFRLEdBQUcsS0FBSyxDQUFDLFFBQVEsSUFBSSxLQUFLLENBQUMsUUFBUSxJQUFJLE9BQU8sQ0FBQztRQUM3RCxNQUFNLFNBQVMsR0FBRyxLQUFLLENBQUMsU0FBUyxJQUFJLEtBQUssQ0FBQyxTQUFTLElBQUksTUFBTSxDQUFDO1FBRS9ELE9BQU8sSUFBSSxTQUFTLENBQ2xCLEtBQUssQ0FBQyxRQUFRLElBQUksRUFBRSxFQUNwQixLQUFLLENBQUMsV0FBVyxJQUFJLEVBQUUsRUFDdkIsS0FBSyxDQUFDLEtBQUssSUFBSSxJQUFJLElBQUksQ0FBQyxHQUFHLEVBQUUsSUFBSSxDQUFDLEVBQ2xDLEVBQUUsRUFDRixFQUFFLEVBQ0YsS0FBSyxDQUFDLFFBQVEsSUFBSSxJQUFJLElBQUksQ0FBQyxHQUFHLEVBQUUsSUFBSSxDQUFDLEVBQ3JDLEtBQUssQ0FBQyxRQUFRLElBQUksSUFBSSxJQUFJLENBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxFQUNyQyxLQUFLLENBQUMsUUFBUSxFQUNkLEtBQUssQ0FBQyxjQUFjLEVBQ3BCLEtBQUssQ0FBQyxTQUFTLEVBQ2YsS0FBSyxDQUFDLGVBQWUsRUFDckIsZUFBZSxFQUNmLFFBQVEsRUFDUixLQUFLLENBQUMsZUFBZSxFQUNyQixLQUFLLENBQUMsYUFBYSxFQUNuQixTQUFTLENBQ1YsQ0FBQztJQUNKLENBQUM7Q0FFRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNpemUgfSBmcm9tIFwiLi4vLi4vY29tbW9uL3NpemVcIjtcbmltcG9ydCB7IFNpemVJZiB9IGZyb20gXCIuLi8uLi9jb21tb24vc2l6ZS5pZlwiO1xuaW1wb3J0IHsgQ29sdW1uRGVmSWYgfSBmcm9tIFwiLi9jb2x1bW4tZGVmLmlmXCI7XG5pbXBvcnQgeyBDZWxsUmVuZGVyZXJJZiB9IGZyb20gXCIuLi8uLi8uLi9yZW5kZXJlci9jZWxsLXJlbmRlci5pZlwiO1xuaW1wb3J0IHsgQXJlYU9iamVjdE1hcFR5cGUgfSBmcm9tIFwiLi4vLi4vY29tbW9uL2FyZWEtbWFwLnR5cGVcIjtcbmltcG9ydCB7IEFyZWFPYmplY3RNYXAgfSBmcm9tIFwiLi4vLi4vY29tbW9uL2FyZWEtbWFwXCI7XG5pbXBvcnQgeyBCb29sZWFuRnVuY3Rpb24sIEZhbHNlRm4sIFRydWVGbiB9IGZyb20gXCIuLi8uLi9jb21tb24vYm9vbGVhbi1mdW5jdGlvblwiO1xuaW1wb3J0IHsgU29ydFN0YXRlIH0gZnJvbSBcIi4uLy4uL2NvbW1vbi9zb3J0LXN0YXRlLnR5cGVcIjtcbmltcG9ydCB7IEdldEVkaXRSZW5kZXJlciB9IGZyb20gXCIuLi8uLi8uLi9yZW5kZXJlci9lZGl0L2VkaXQtY2VsbC1yZW5kZXJlci50eXBlXCI7XG5pbXBvcnQgeyBlZGl0SW5wdXRQaXBlIH0gZnJvbSBcIi4uLy4uLy4uL3JlbmRlcmVyL2VkaXQvZWRpdC1pbnB1dC1waXBlLmlmXCI7XG5cblxuZXhwb3J0IGNsYXNzIENvbHVtbkRlZiBpbXBsZW1lbnRzIENvbHVtbkRlZklmIHtcblxuICBwdWJsaWMgdmlzaWJsZSA9IHRydWU7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIHByb3BlcnR5OiBzdHJpbmcsXG4gICAgcHVibGljIGhlYWRlckxhYmVsOiBzdHJpbmcsXG4gICAgcHVibGljIHdpZHRoOiBTaXplSWYgPSBuZXcgU2l6ZSgxMDAsIFwicHhcIiksXG4gICAgcHVibGljIGNsYXNzZXM6IEFyZWFPYmplY3RNYXBUeXBlPHN0cmluZ1tdPiA9IG5ldyBBcmVhT2JqZWN0TWFwPHN0cmluZ1tdPigpLFxuICAgIHB1YmxpYyByZW5kZXJlck1hcDogQXJlYU9iamVjdE1hcFR5cGU8Q2VsbFJlbmRlcmVySWY+ID0gbmV3IEFyZWFPYmplY3RNYXA8Q2VsbFJlbmRlcmVySWY+KCksXG4gICAgcHVibGljIG1pbldpZHRoOiBTaXplSWYgPSBuZXcgU2l6ZSgxMDAsIFwicHhcIiksXG4gICAgcHVibGljIG1heFdpZHRoOiBTaXplSWYgPSBuZXcgU2l6ZSgxMDAsIFwicHhcIiksXG4gICAgcHVibGljIHNvcnRhYmxlPzogQm9vbGVhbkZ1bmN0aW9uLFxuICAgIHB1YmxpYyBzb3J0Q29tcGFyYXRvcj86IDxUPihhOiBULCBiOiBUKSA9PiBudW1iZXIsXG4gICAgcHVibGljIHNvcnRTdGF0ZT86IFNvcnRTdGF0ZSxcbiAgICBwdWJsaWMgc29ydFN0YXRlc09yZGVyPzogU29ydFN0YXRlW10sXG4gICAgcHVibGljIHNvcnRJY29uVmlzaWJsZT86IEJvb2xlYW5GdW5jdGlvbixcbiAgICBwdWJsaWMgZWRpdGFibGU/OiBCb29sZWFuRnVuY3Rpb24sXG4gICAgcHVibGljIGdldEVkaXRSZW5kZXJlcj86IEdldEVkaXRSZW5kZXJlcixcbiAgICBwdWJsaWMgZWRpdElucHV0UGlwZT86IGVkaXRJbnB1dFBpcGUsXG4gICAgcHVibGljIGlzVmlzaWJsZTogQm9vbGVhbkZ1bmN0aW9uID0gKCk9PnRoaXMudmlzaWJsZVxuICApIHtcbiAgfVxuXG4gIHN0YXRpYyBib2R5UmVuZGVyZXIoYm9keVJlbmRlcmVyOiBDZWxsUmVuZGVyZXJJZikge1xuICAgIHJldHVybiBuZXcgQXJlYU9iamVjdE1hcDxDZWxsUmVuZGVyZXJJZj4oXG4gICAgICB1bmRlZmluZWQsXG4gICAgICBib2R5UmVuZGVyZXIsXG4gICAgICB1bmRlZmluZWRcbiAgICApO1xuICB9XG5cbiAgc3RhdGljIGNyZWF0ZShwYXJhbToge1xuICAgIHByb3BlcnR5Pzogc3RyaW5nLFxuICAgIGhlYWRlckxhYmVsPzogc3RyaW5nLFxuICAgIHdpZHRoPzogU2l6ZUlmLFxuICAgIG1pbldpZHRoPzogU2l6ZUlmLFxuICAgIG1heFdpZHRoPzogU2l6ZUlmLFxuICAgIGhlYWRlclJlbmRlcmVyPzogQ2VsbFJlbmRlcmVySWYsXG4gICAgYm9keVJlbmRlcmVyPzogQ2VsbFJlbmRlcmVySWYsXG4gICAgZm9vdGVyUmVuZGVyZXI/OiBDZWxsUmVuZGVyZXJJZixcbiAgICBoZWFkZXJDbGFzc2VzPzogc3RyaW5nW11cbiAgICBib2R5Q2xhc3Nlcz86IHN0cmluZ1tdXG4gICAgZm9vdGVyQ2xhc3Nlcz86IHN0cmluZ1tdLFxuICAgIHNvcnRhYmxlPzogQm9vbGVhbkZ1bmN0aW9uLFxuICAgIHNvcnRJY29uVmlzaWJsZT86IEJvb2xlYW5GdW5jdGlvbixcbiAgICBzb3J0Q29tcGFyYXRvcj86IDxUPihhOiBULCBiOiBUKSA9PiBudW1iZXIsXG4gICAgc29ydFN0YXRlPzogU29ydFN0YXRlLFxuICAgIHNvcnRTdGF0ZXNPcmRlcj86IFNvcnRTdGF0ZVtdLFxuICAgIGVkaXRhYmxlPzogQm9vbGVhbkZ1bmN0aW9uLFxuICAgIGlzVmlzaWJsZT86IEJvb2xlYW5GdW5jdGlvbixcbiAgICBnZXRFZGl0UmVuZGVyZXI/OiBHZXRFZGl0UmVuZGVyZXIsXG4gICAgZWRpdElucHV0UGlwZT86IGVkaXRJbnB1dFBpcGUsXG4gIH0pOiBDb2x1bW5EZWZJZiB7XG5cbiAgICBjb25zdCBhbSA9IG5ldyBBcmVhT2JqZWN0TWFwPENlbGxSZW5kZXJlcklmPihcbiAgICAgIHBhcmFtLmhlYWRlclJlbmRlcmVyLFxuICAgICAgcGFyYW0uYm9keVJlbmRlcmVyLFxuICAgICAgcGFyYW0uZm9vdGVyUmVuZGVyZXJcbiAgICApO1xuXG4gICAgY29uc3QgY20gPSBuZXcgQXJlYU9iamVjdE1hcDxzdHJpbmdbXT4oXG4gICAgICBwYXJhbS5oZWFkZXJDbGFzc2VzLFxuICAgICAgcGFyYW0uYm9keUNsYXNzZXMsXG4gICAgICBwYXJhbS5mb290ZXJDbGFzc2VzXG4gICAgKTtcblxuICAgIGNvbnN0IHNvcnRJY29uVmlzaWJsZSA9IHBhcmFtLnNvcnRJY29uVmlzaWJsZSA/PyBwYXJhbS5zb3J0YWJsZSA/PyBGYWxzZUZuO1xuICAgIGNvbnN0IGVkaXRhYmxlID0gcGFyYW0uZWRpdGFibGUgPz8gcGFyYW0uZWRpdGFibGUgPz8gRmFsc2VGbjtcbiAgICBjb25zdCBpc1Zpc2libGUgPSBwYXJhbS5pc1Zpc2libGUgPz8gcGFyYW0uaXNWaXNpYmxlID8/IFRydWVGbjtcblxuICAgIHJldHVybiBuZXcgQ29sdW1uRGVmKFxuICAgICAgcGFyYW0ucHJvcGVydHkgPz8gXCJcIixcbiAgICAgIHBhcmFtLmhlYWRlckxhYmVsID8/IFwiXCIsXG4gICAgICBwYXJhbS53aWR0aCA/PyBuZXcgU2l6ZSgxMDAsIFwicHhcIiksXG4gICAgICBjbSxcbiAgICAgIGFtLFxuICAgICAgcGFyYW0ubWluV2lkdGggPz8gbmV3IFNpemUoMTAwLCBcInB4XCIpLFxuICAgICAgcGFyYW0ubWF4V2lkdGggPz8gbmV3IFNpemUoMTAwLCBcInB4XCIpLFxuICAgICAgcGFyYW0uc29ydGFibGUsXG4gICAgICBwYXJhbS5zb3J0Q29tcGFyYXRvcixcbiAgICAgIHBhcmFtLnNvcnRTdGF0ZSxcbiAgICAgIHBhcmFtLnNvcnRTdGF0ZXNPcmRlcixcbiAgICAgIHNvcnRJY29uVmlzaWJsZSxcbiAgICAgIGVkaXRhYmxlLFxuICAgICAgcGFyYW0uZ2V0RWRpdFJlbmRlcmVyLFxuICAgICAgcGFyYW0uZWRpdElucHV0UGlwZSxcbiAgICAgIGlzVmlzaWJsZSxcbiAgICApO1xuICB9XG5cbn1cbiJdfQ==

package/esm2022/lib/table/data/tablemodel/padding.mjs

@@ -0,0 +1,13 @@
+export class Padding {
+    top;
+    right;
+    bottom;
+    left;
+    constructor(top = 0, right = 0, bottom = 0, left = 0) {
+        this.top = top;
+        this.right = right;
+        this.bottom = bottom;
+        this.left = left;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFkZGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvdGFibGUvc3JjL2xpYi90YWJsZS9kYXRhL3RhYmxlbW9kZWwvcGFkZGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sT0FBTztJQUVUO0lBQ0E7SUFDQTtJQUNBO0lBSlQsWUFDUyxNQUFjLENBQUMsRUFDZixRQUFnQixDQUFDLEVBQ2pCLFNBQWlCLENBQUMsRUFDbEIsT0FBZSxDQUFDO1FBSGhCLFFBQUcsR0FBSCxHQUFHLENBQVk7UUFDZixVQUFLLEdBQUwsS0FBSyxDQUFZO1FBQ2pCLFdBQU0sR0FBTixNQUFNLENBQVk7UUFDbEIsU0FBSSxHQUFKLElBQUksQ0FBWTtJQUV6QixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgUGFkZGluZyB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyB0b3A6IG51bWJlciA9IDAsXG4gICAgcHVibGljIHJpZ2h0OiBudW1iZXIgPSAwLFxuICAgIHB1YmxpYyBib3R0b206IG51bWJlciA9IDAsXG4gICAgcHVibGljIGxlZnQ6IG51bWJlciA9IDBcbiAgKSB7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/table/data/tablemodel/table-model.if.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/table/data/tablemodel/table-model.mjs

@@ -0,0 +1,308 @@
+import { Padding } from "./padding";
+import { DefaultRowHeights } from "../options/default-row-heights";
+import { CheckboxColumnDef } from "../common/checkbox-column-def";
+import { CheckboxModel } from "../../checkbox/checkbox-model";
+/**
+ * This is a default implementation of TableModelIf.
+ * Ths TableModel is on one hand a container for the header, body, and footer models
+ * (see : #getAreaModel, and #AreaModelIf), and on the other hand the master of
+ * the column information (#getColumnCount(), #getColumnWidth(columnIndex: number)).
+ *
+ * If getFixedLeftColumnCount() returns a value greater than 0, a fixed west area will be rendered in the
+ * header, body, and footer. A value greater than 0 for getFixedLeftColumnCount()
+ * will result in the presence of an east area.
+ *
+ * <pre>
+ *  +----------------+-------------------+--------------+
+ *  |  header/west   |  header/center    | header/east  |
+ *  +----------------+-------------------+--------------+
+ *  |  body/west     |  body/center      | body/east    |
+ *  +----------------+-------------------+--------------+
+ *  |  footer/west   |  footer/center    | footer/east  |
+ *  +----------------+-------------------+--------------+ </pre>
+ *
+ */
+export class TableModel {
+    headerAreaModel;
+    bodyAreaModel;
+    footerAreaModel;
+    fixedLeftColumnCount;
+    fixedRightColumnCount;
+    rowCheckboxVisible;
+    defaultRowHeights;
+    columnDefs;
+    columnSizes;
+    overridingColumnWidth;
+    columnCount;
+    parentSize;
+    getSelectionModel;
+    rowCount = 0;
+    contentHeightInPx = 0;
+    contentWidthInPx = 0;
+    // in case of a fixed header, left or right column, footer:
+    padding = new Padding(0, 0, 0, 0); // the dimension of the 'body/center'
+    xPositions = [];
+    constructor(headerAreaModel, bodyAreaModel, footerAreaModel, fixedLeftColumnCount = 0, fixedRightColumnCount = 0, rowCheckboxVisible = false, defaultRowHeights = new DefaultRowHeights(), columnDefs = [], columnSizes = [], overridingColumnWidth = -1, columnCount = 0, parentSize = 400, // can be important when we have percentage widthes,
+    getSelectionModel = () => undefined) {
+        this.headerAreaModel = headerAreaModel;
+        this.bodyAreaModel = bodyAreaModel;
+        this.footerAreaModel = footerAreaModel;
+        this.fixedLeftColumnCount = fixedLeftColumnCount;
+        this.fixedRightColumnCount = fixedRightColumnCount;
+        this.rowCheckboxVisible = rowCheckboxVisible;
+        this.defaultRowHeights = defaultRowHeights;
+        this.columnDefs = columnDefs;
+        this.columnSizes = columnSizes;
+        this.overridingColumnWidth = overridingColumnWidth;
+        this.columnCount = columnCount;
+        this.parentSize = parentSize;
+        this.getSelectionModel = getSelectionModel;
+        headerAreaModel.areaIdent = "header";
+        bodyAreaModel.areaIdent = "body";
+        footerAreaModel.areaIdent = "footer";
+        if (!this.columnCount) {
+            if (this.columnDefs?.length) {
+                this.columnCount = this.columnDefs.length;
+            }
+            else if (this.columnSizes?.length) {
+                this.columnCount = this.columnSizes?.length;
+            }
+        }
+        if (this.columnDefs?.length
+            && this.columnDefs[0] instanceof CheckboxColumnDef
+            && !bodyAreaModel.rowSelectionModel) {
+            bodyAreaModel.rowSelectionModel = new CheckboxModel();
+        }
+    }
+    init() {
+        this.recalcSize(this.parentSize);
+        if (this.overridingColumnWidth === -1) {
+            this.calcXPositions();
+        }
+        if (this.headerAreaModel) {
+            this.headerAreaModel.init();
+        }
+        if (this.bodyAreaModel) {
+            this.bodyAreaModel.init();
+        }
+        if (this.footerAreaModel) {
+            this.footerAreaModel.init();
+        }
+    }
+    getColumnCount() {
+        return this.columnCount;
+    }
+    ;
+    setColumnWidth(columnIndex, width) {
+        width = Math.max(0, width);
+        if (this.overridingColumnWidth !== -1) {
+            this.overridingColumnWidth = width;
+        }
+        if (columnIndex > -1 && columnIndex < this.columnSizes?.length) {
+            this.columnSizes[columnIndex] = width;
+        }
+        this.recalcContentWidthInPx();
+    }
+    getColumnWidth(columnIndex) {
+        const cd = this.getColumnDef(columnIndex);
+        if (cd && cd.isVisible && !cd.isVisible()) {
+            return 0;
+        }
+        if (this.overridingColumnWidth !== -1) {
+            return this.overridingColumnWidth;
+        }
+        if (columnIndex > -1 && columnIndex < this.columnSizes?.length) {
+            return this.columnSizes[columnIndex];
+        }
+        return 0;
+    }
+    ;
+    getXPosByColumnIndex(columnIndex) {
+        if (columnIndex === 0) {
+            return 0;
+        }
+        if (this.overridingColumnWidth > -1) {
+            return this.overridingColumnWidth * columnIndex;
+        }
+        return this.xPositions[columnIndex];
+    }
+    recalcSize(clientWidth) {
+        this.recalcColumnWidthes(clientWidth);
+        this.recalcHeightAndPadding();
+    }
+    recalcHeightAndPadding() {
+        const bodyModel = this.getAreaModel("body");
+        this.rowCount = bodyModel.getRowCount();
+        this.contentHeightInPx = this.getAreaHeight("body");
+        this.recalcContentWidthInPx();
+        this.recalcPadding();
+    }
+    recalcPadding() {
+        const westWidth = this.getSideAreaWidth("west");
+        const eastWidth = this.getSideAreaWidth("east");
+        const headerHeight = this.getAreaHeight("header");
+        const footerHeight = this.getAreaHeight("footer");
+        this.padding = new Padding(headerHeight, eastWidth, footerHeight, westWidth);
+    }
+    getPadding() {
+        return this.padding;
+    }
+    getContentHeightInPixel() {
+        return this.contentHeightInPx;
+    }
+    getContentWidthInPixel() {
+        return this.contentWidthInPx;
+    }
+    getRowHeight(rowAreaIdent, rowIndex) {
+        return this.getAreaModel(rowAreaIdent).getRowHeight(rowIndex);
+    }
+    getModel(rowAreaIdent) {
+        return this.getAreaModel(rowAreaIdent);
+    }
+    getAreaHeight(areaIdent) {
+        const model = this.getModel(areaIdent);
+        const rowCount = model.getRowCount();
+        if (this.defaultRowHeights[areaIdent]) {
+            return rowCount * this.defaultRowHeights[areaIdent];
+        }
+        let ret = 0;
+        for (let i = 0; i < rowCount; i++) {
+            ret = ret + model.getRowHeight(i);
+        }
+        return ret;
+    }
+    getSideAreaWidth(sideIdent) {
+        const [cStart, cEnd] = this.getSideStartAndEndColumnIndex(sideIdent);
+        let ret = 0;
+        for (let i = cStart; i <= cEnd; i++) {
+            ret = ret + this.getColumnWidth(i);
+        }
+        return ret;
+    }
+    getSideStartAndEndColumnIndex(sideIdent) {
+        const c1 = this.getFixedLeftColumnCount();
+        const c2 = this.getFixedRightColumnCount();
+        let cStart = 0;
+        let cEnd = this.columnCount - 1;
+        if (sideIdent === "west") {
+            cEnd = c1 - 1;
+        }
+        else if (sideIdent === "east") {
+            cStart = this.columnCount - c2;
+        }
+        else {
+            // center:
+            cStart = c1;
+            cEnd = this.columnCount - c2 - 1;
+        }
+        return [cStart, cEnd];
+    }
+    getColumnDef(index) {
+        if (index < this.columnDefs.length) {
+            return this.columnDefs[index];
+        }
+        return undefined;
+    }
+    getFixedLeftColumnCount() {
+        return this.fixedLeftColumnCount;
+    }
+    getFixedRightColumnCount() {
+        return this.fixedRightColumnCount;
+    }
+    getAreaModel(area) {
+        if (area === "header") {
+            return this.headerAreaModel;
+        }
+        if (area === "body") {
+            return this.bodyAreaModel;
+        }
+        if (area === "footer") {
+            return this.footerAreaModel;
+        }
+        throw new Error("Wrong ident.");
+    }
+    getBodyModel() {
+        return this.bodyAreaModel;
+    }
+    isFooterVisibe() {
+        return (this.footerAreaModel?.getRowCount() ?? 0) > 0;
+    }
+    isHeaderVisibe() {
+        return (this.headerAreaModel?.getRowCount() ?? 0) > 0;
+    }
+    isRowCheckboxVisible() {
+        return this.rowCheckboxVisible;
+    }
+    externalFilterChanged(predictFn) {
+        this.getAreaModel("body").externalFilterChanged(predictFn);
+    }
+    doSort(sortItems) {
+        return this.getAreaModel("body").doSort(sortItems);
+    }
+    getColumnDefs() {
+        return this.columnDefs;
+    }
+    getColumnProperty(columnIndex) {
+        return this.columnDefs[columnIndex].property;
+    }
+    getBodyRowByIndex(rowIndex) {
+        return this.getBodyModel().getRowByIndex(rowIndex);
+    }
+    isSortable(columnIndex) {
+        if (this.columnDefs
+            && columnIndex < this.columnDefs.length
+            && this.columnDefs[columnIndex].sortable) {
+            // @ts-ignore
+            return this.columnDefs[columnIndex].sortable();
+        }
+        return false;
+    }
+    changeColumnOrder(sourceColumnIndex, targetColumnIndex) {
+        this.arrayMove(this.columnDefs, sourceColumnIndex, targetColumnIndex);
+        this.arrayMove(this.columnSizes, sourceColumnIndex, targetColumnIndex);
+        this.headerAreaModel?.changeColumnOrder(sourceColumnIndex, targetColumnIndex);
+        this.bodyAreaModel?.changeColumnOrder(sourceColumnIndex, targetColumnIndex);
+        this.footerAreaModel?.changeColumnOrder(sourceColumnIndex, targetColumnIndex);
+        this.calcXPositions();
+    }
+    recalcColumnWidthes(clientWidth) {
+        if (!this.columnDefs?.length && !this.columnSizes?.length) {
+            this.columnSizes = new Array(this.getColumnCount()).fill(this.overridingColumnWidth);
+        }
+        if (this.columnDefs?.length) {
+            this.columnSizes = this.columnDefs.map(def => {
+                if (def.width.unit === "%" && clientWidth) {
+                    // only for a % value we have to check min and max:
+                    let px = Math.floor(def.width.value * clientWidth / 100);
+                    if (def.minWidth) {
+                        let pxMin = def.minWidth.unit === "px" ? def.minWidth.value : Math.floor(def.minWidth.value * clientWidth / 100);
+                        px = Math.max(pxMin, px);
+                    }
+                    if (def.maxWidth) {
+                        let pxMax = def.maxWidth.unit === "px" ? def.maxWidth.value : Math.floor(def.maxWidth.value * clientWidth / 100);
+                        px = Math.min(pxMax, px);
+                    }
+                    return px;
+                }
+                return def.width.value;
+            });
+        }
+    }
+    arrayMove(arr, fromIndex, toIndex) {
+        const element = arr.splice(fromIndex, 1)[0];
+        arr.splice(toIndex, 0, element);
+        return arr;
+    }
+    recalcContentWidthInPx() {
+        this.contentWidthInPx = this.getSideAreaWidth("center");
+    }
+    calcXPositions() {
+        const columnCount = this.getColumnCount();
+        this.xPositions = new Array(columnCount + 1);
+        this.xPositions[0] = 0;
+        for (let i = 0; i < columnCount; i++) {
+            this.xPositions[i + 1] = this.getColumnWidth(i) + this.xPositions[i];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-model.js","sourceRoot":"","sources":["../../../../../../../../libs/table/src/lib/table/data/tablemodel/table-model.ts"],"names":[],"mappings":"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","sourcesContent":["import { TableModelIf } from \"./table-model.if\";\nimport { Padding } from \"./padding\";\nimport { AreaIdent } from \"./area-ident.type\";\nimport { AreaModelIf } from \"./areamodel/area-model.if\";\nimport { SideIdent } from \"../side-ident.type\";\nimport { DefaultRowHeightsIf } from \"../options/default-row-heights.if\";\nimport { DefaultRowHeights } from \"../options/default-row-heights\";\nimport { ColumnDefIf } from \"./column/column-def.if\";\nimport { FilterFunction } from \"../common/filter-function\";\nimport { SortItem } from \"../common/sort-item\";\nimport { SelectionModelIf } from \"../../selection/selection-model.if\";\nimport { GetT } from \"../common/get-t\";\nimport { CheckboxColumnDef } from \"../common/checkbox-column-def\";\nimport { CheckboxModel } from \"../../checkbox/checkbox-model\";\n\n\n/**\n * This is a default implementation of TableModelIf.\n * Ths TableModel is on one hand a container for the header, body, and footer models\n * (see : #getAreaModel, and #AreaModelIf), and on the other hand the master of\n * the column information (#getColumnCount(), #getColumnWidth(columnIndex: number)).\n *\n * If getFixedLeftColumnCount() returns a value greater than 0, a fixed west area will be rendered in the\n * header, body, and footer. A value greater than 0 for getFixedLeftColumnCount()\n * will result in the presence of an east area.\n *\n * <pre>\n *  +----------------+-------------------+--------------+\n *  |  header/west   |  header/center    | header/east  |\n *  +----------------+-------------------+--------------+\n *  |  body/west     |  body/center      | body/east    |\n *  +----------------+-------------------+--------------+\n *  |  footer/west   |  footer/center    | footer/east  |\n *  +----------------+-------------------+--------------+ </pre>\n *\n */\nexport class TableModel implements TableModelIf {\n\n  protected rowCount = 0;\n  protected contentHeightInPx = 0;\n  protected contentWidthInPx = 0;\n\n  // in case of a fixed header, left or right column, footer:\n  protected padding = new Padding(0, 0, 0, 0); // the dimension of the 'body/center'\n  protected xPositions: number[] = [];\n\n  constructor(\n    public readonly headerAreaModel: AreaModelIf,\n    public readonly bodyAreaModel: AreaModelIf,\n    public readonly footerAreaModel: AreaModelIf,\n    public readonly fixedLeftColumnCount: number = 0,\n    public readonly fixedRightColumnCount: number = 0,\n    public readonly rowCheckboxVisible: boolean = false,\n    public readonly defaultRowHeights: DefaultRowHeightsIf = new DefaultRowHeights(),\n    public columnDefs: ColumnDefIf[] = [],\n    public columnSizes: number[] = [],\n    protected overridingColumnWidth: number = -1,\n    protected columnCount: number = 0,\n    protected parentSize: number = 400, // can be important when we have percentage widthes,\n    public readonly getSelectionModel: GetT<SelectionModelIf> = () => undefined\n  ) {\n    headerAreaModel.areaIdent = \"header\";\n    bodyAreaModel.areaIdent = \"body\";\n    footerAreaModel.areaIdent = \"footer\";\n    if (!this.columnCount) {\n      if (this.columnDefs?.length) {\n        this.columnCount = this.columnDefs.length;\n      } else if (this.columnSizes?.length) {\n        this.columnCount = this.columnSizes?.length;\n      }\n    }\n    if (this.columnDefs?.length\n      && this.columnDefs[0] instanceof CheckboxColumnDef\n      && !bodyAreaModel.rowSelectionModel) {\n      bodyAreaModel.rowSelectionModel = new CheckboxModel();\n    }\n  }\n\n  init() {\n    this.recalcSize(this.parentSize);\n    if (this.overridingColumnWidth === -1) {\n      this.calcXPositions();\n    }\n    if (this.headerAreaModel) {\n      this.headerAreaModel.init();\n    }\n    if (this.bodyAreaModel) {\n      this.bodyAreaModel.init();\n    }\n    if (this.footerAreaModel) {\n      this.footerAreaModel.init();\n    }\n  }\n\n  getColumnCount(): number {\n    return this.columnCount;\n  };\n\n  setColumnWidth(columnIndex: number, width: number): void {\n    width = Math.max(0, width);\n    if (this.overridingColumnWidth !== -1) {\n      this.overridingColumnWidth = width;\n    }\n    if (columnIndex > -1 && columnIndex < this.columnSizes?.length) {\n      this.columnSizes[columnIndex] = width;\n    }\n    this.recalcContentWidthInPx();\n  }\n\n  getColumnWidth(columnIndex: number): number {\n    const cd = this.getColumnDef(columnIndex);\n    if (cd && cd.isVisible && !cd.isVisible()) {\n      return 0;\n    }\n    if (this.overridingColumnWidth !== -1) {\n      return this.overridingColumnWidth;\n    }\n    if (columnIndex > -1 && columnIndex < this.columnSizes?.length) {\n      return this.columnSizes[columnIndex];\n    }\n    return 0;\n  };\n\n  getXPosByColumnIndex(columnIndex: number): number {\n    if (columnIndex === 0) {\n      return 0;\n    }\n    if (this.overridingColumnWidth > -1) {\n      return this.overridingColumnWidth * columnIndex;\n    }\n    return this.xPositions[columnIndex];\n  }\n\n  recalcSize(clientWidth: number) {\n    this.recalcColumnWidthes(clientWidth);\n    this.recalcHeightAndPadding();\n  }\n\n  recalcHeightAndPadding() {\n    const bodyModel = this.getAreaModel(\"body\");\n    this.rowCount = bodyModel.getRowCount();\n    this.contentHeightInPx = this.getAreaHeight(\"body\");\n    this.recalcContentWidthInPx();\n\n    this.recalcPadding();\n  }\n\n  recalcPadding() {\n    const westWidth = this.getSideAreaWidth(\"west\");\n    const eastWidth = this.getSideAreaWidth(\"east\");\n    const headerHeight = this.getAreaHeight(\"header\");\n    const footerHeight = this.getAreaHeight(\"footer\");\n\n    this.padding = new Padding(\n      headerHeight,\n      eastWidth,\n      footerHeight,\n      westWidth);\n  }\n\n  getPadding(): Padding {\n    return this.padding;\n  }\n\n  getContentHeightInPixel(): number {\n    return this.contentHeightInPx;\n  }\n\n  getContentWidthInPixel(): number {\n    return this.contentWidthInPx;\n  }\n\n  getRowHeight(rowAreaIdent: AreaIdent, rowIndex: number): number {\n    return this.getAreaModel(rowAreaIdent).getRowHeight(rowIndex);\n  }\n\n  getModel(rowAreaIdent: AreaIdent): AreaModelIf {\n    return this.getAreaModel(rowAreaIdent);\n  }\n\n  getAreaHeight(areaIdent: AreaIdent): number {\n    const model = this.getModel(areaIdent);\n    const rowCount = model.getRowCount();\n    if (this.defaultRowHeights[areaIdent]) {\n      return rowCount * this.defaultRowHeights[areaIdent];\n    }\n\n    let ret = 0;\n    for (let i = 0; i < rowCount; i++) {\n      ret = ret + model.getRowHeight(i);\n    }\n    return ret;\n  }\n\n  getSideAreaWidth(sideIdent: SideIdent): number {\n    const [cStart, cEnd] = this.getSideStartAndEndColumnIndex(sideIdent);\n    let ret = 0;\n    for (let i = cStart; i <= cEnd; i++) {\n      ret = ret + this.getColumnWidth(i);\n    }\n    return ret;\n  }\n\n  getSideStartAndEndColumnIndex(sideIdent: SideIdent): [number, number] {\n    const c1 = this.getFixedLeftColumnCount();\n    const c2 = this.getFixedRightColumnCount();\n\n    let cStart = 0;\n    let cEnd = this.columnCount - 1;\n    if (sideIdent === \"west\") {\n      cEnd = c1 - 1;\n    } else if (sideIdent === \"east\") {\n      cStart = this.columnCount - c2;\n    } else {\n      // center:\n      cStart = c1;\n      cEnd = this.columnCount - c2 - 1;\n    }\n    return [cStart, cEnd];\n  }\n\n  getColumnDef(index: number): ColumnDefIf | undefined {\n    if (index < this.columnDefs.length) {\n      return this.columnDefs[index];\n    }\n    return undefined;\n  }\n\n  getFixedLeftColumnCount(): number {\n    return this.fixedLeftColumnCount;\n  }\n\n  getFixedRightColumnCount(): number {\n    return this.fixedRightColumnCount;\n  }\n\n  getAreaModel(area: AreaIdent): AreaModelIf {\n    if (area === \"header\") {\n      return this.headerAreaModel;\n    }\n    if (area === \"body\") {\n      return this.bodyAreaModel;\n    }\n    if (area === \"footer\") {\n      return this.footerAreaModel;\n    }\n    throw new Error(\"Wrong ident.\");\n  }\n\n  getBodyModel(): AreaModelIf {\n    return this.bodyAreaModel;\n  }\n\n  isFooterVisibe(): boolean {\n    return (this.footerAreaModel?.getRowCount() ?? 0) > 0;\n  }\n\n  isHeaderVisibe(): boolean {\n    return (this.headerAreaModel?.getRowCount() ?? 0) > 0;\n  }\n\n  isRowCheckboxVisible(): boolean {\n    return this.rowCheckboxVisible;\n  }\n\n  externalFilterChanged<T>(predictFn: FilterFunction<T>): void {\n    this.getAreaModel(\"body\").externalFilterChanged(predictFn);\n  }\n\n  doSort(sortItems: SortItem[]): boolean {\n    return this.getAreaModel(\"body\").doSort(sortItems);\n  }\n\n  getColumnDefs(): ColumnDefIf[] | undefined {\n    return this.columnDefs;\n  }\n\n  getColumnProperty(columnIndex: number): string {\n    return this.columnDefs[columnIndex].property;\n  }\n\n  getBodyRowByIndex(rowIndex: number): any {\n    return this.getBodyModel().getRowByIndex(rowIndex);\n  }\n\n  isSortable(columnIndex: number): boolean {\n    if (this.columnDefs\n      && columnIndex < this.columnDefs.length\n      && this.columnDefs[columnIndex].sortable) {\n      // @ts-ignore\n      return this.columnDefs[columnIndex].sortable();\n    }\n    return false;\n  }\n\n  changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void {\n    this.arrayMove(this.columnDefs, sourceColumnIndex, targetColumnIndex);\n    this.arrayMove(this.columnSizes, sourceColumnIndex, targetColumnIndex);\n    this.headerAreaModel?.changeColumnOrder(sourceColumnIndex, targetColumnIndex);\n    this.bodyAreaModel?.changeColumnOrder(sourceColumnIndex, targetColumnIndex);\n    this.footerAreaModel?.changeColumnOrder(sourceColumnIndex, targetColumnIndex);\n    this.calcXPositions();\n  }\n\n\n  private recalcColumnWidthes(clientWidth: number) {\n    if (!this.columnDefs?.length && !this.columnSizes?.length) {\n      this.columnSizes = new Array(this.getColumnCount()).fill(this.overridingColumnWidth);\n    }\n    if (this.columnDefs?.length) {\n      this.columnSizes = this.columnDefs.map(def => {\n        if (def.width.unit === \"%\" && clientWidth) {\n          // only for a % value we have to check min and max:\n          let px = Math.floor(def.width.value * clientWidth / 100);\n          if (def.minWidth) {\n            let pxMin = def.minWidth.unit === \"px\" ? def.minWidth.value : Math.floor(def.minWidth.value * clientWidth / 100);\n            px = Math.max(pxMin, px);\n          }\n          if (def.maxWidth) {\n            let pxMax = def.maxWidth.unit === \"px\" ? def.maxWidth.value : Math.floor(def.maxWidth.value * clientWidth / 100);\n            px = Math.min(pxMax, px);\n          }\n          return px;\n        }\n        return def.width.value;\n      });\n    }\n  }\n\n  private arrayMove(arr: any[], fromIndex: number, toIndex: number) {\n    const element = arr.splice(fromIndex, 1)[0];\n    arr.splice(toIndex, 0, element);\n    return arr;\n  }\n\n  private recalcContentWidthInPx() {\n    this.contentWidthInPx = this.getSideAreaWidth(\"center\");\n  }\n\n  private calcXPositions() {\n    const columnCount = this.getColumnCount();\n    this.xPositions = new Array(columnCount + 1);\n    this.xPositions[0] = 0;\n    for (let i = 0; i < columnCount; i++) {\n      this.xPositions[i + 1] = this.getColumnWidth(i) + this.xPositions[i];\n    }\n  }\n\n\n}\n\n\n"]}