k-vtable 1.0.24 → 1.0.25

package/dist/vtable.js

@@ -60950,7 +60950,7 @@
         }
         checkFrozen() {
             let originalFrozenColCount = this.table.options.frozenColCount ??
-                ((this.table.isPivotTable() || (this.table.isListTable() && this.table.internalProps.transpose))
+                (this.table.isPivotTable() || (this.table.isListTable() && this.table.internalProps.transpose)
                     ? (this.table.rowHeaderLevelCount ?? 0) + this.table.internalProps.layoutMap.leftRowSeriesNumberColumnCount
                     : 0);
             if (originalFrozenColCount) {
@@ -69698,7 +69698,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.0.24";
+        version = "1.0.25";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -76253,6 +76253,9 @@
             }
             const editor = this.table.getEditor(col, row);
             if (editor) {
+                if (this.table.internalProps.layoutMap.isSeriesNumber(col, row)) {
+                    return;
+                }
                 if (this.table.internalProps.layoutMap?.isAggregation?.(col, row)) {
                     const isPivotTable = this.table.isPivotTable?.();
                     const updateAggregationOnEditCell = isPivotTable
@@ -87746,6 +87749,65 @@
             }
             return null;
         }
+        matchDimensionPath = (paths, treeNodes, needLowestLevel, checkAxisNode = false, pathIndex = 0) => {
+            if (pathIndex >= paths.length) {
+                return undefined;
+            }
+            const currentPath = paths[pathIndex];
+            for (let j = 0; j < treeNodes.length; j++) {
+                const dimension = treeNodes[j];
+                const isMatch = (!isValid$3(currentPath.indicatorKey) &&
+                    dimension.dimensionKey === currentPath.dimensionKey &&
+                    dimension.value === currentPath.value) ||
+                    (isValid$3(currentPath.indicatorKey) &&
+                        dimension.indicatorKey === currentPath.indicatorKey &&
+                        ((isValid$3(dimension.value) && isValid$3(currentPath.value) && currentPath.value === dimension.value) ||
+                            !isValid$3(dimension.value) ||
+                            !isValid$3(currentPath.value)));
+                if (isMatch) {
+                    const children = dimension.children;
+                    if (pathIndex === paths.length - 1) {
+                        if (needLowestLevel) {
+                            const hasAxisNode = checkAxisNode && children && children.some((row) => row.dimensionKey === 'axis');
+                            if (!children?.length || hasAxisNode) {
+                                return dimension;
+                            }
+                            const findLeafNode = (nodes) => {
+                                for (const node of nodes) {
+                                    const nodeChildren = node.children;
+                                    const nodeHasAxis = checkAxisNode && nodeChildren.some((row) => row.dimensionKey === 'axis');
+                                    if (!nodeChildren?.length || nodeHasAxis) {
+                                        return node;
+                                    }
+                                    const leaf = findLeafNode(nodeChildren);
+                                    if (leaf) {
+                                        return leaf;
+                                    }
+                                }
+                                return undefined;
+                            };
+                            const leafNode = findLeafNode(children);
+                            if (leafNode) {
+                                return leafNode;
+                            }
+                        }
+                        else {
+                            return dimension;
+                        }
+                    }
+                    if (children?.length) {
+                        const result = this.matchDimensionPath(paths, children, needLowestLevel, checkAxisNode, pathIndex + 1);
+                        if (result) {
+                            return result;
+                        }
+                    }
+                    else if (pathIndex === paths.length - 1) {
+                        return dimension;
+                    }
+                }
+            }
+            return undefined;
+        };
         getCellAdressByHeaderPath(dimensionPaths) {
             let colHeaderPaths;
             let rowHeaderPaths;
@@ -87837,34 +87899,10 @@
             let row;
             let defaultCol;
             let defaultRow;
-            let rowArr = this.rowTree;
             let rowDimensionFinded;
-            let colArr = this.columnTree;
             let colDimensionFinded;
             if (colHeaderPaths) {
-                for (let i = 0; i < colHeaderPaths.length; i++) {
-                    const colDimension = colHeaderPaths[i];
-                    for (let j = 0; j < colArr.length; j++) {
-                        const dimension = colArr[j];
-                        if ((!isValid$3(colDimension.indicatorKey) &&
-                            dimension.dimensionKey === colDimension.dimensionKey &&
-                            dimension.value === colDimension.value) ||
-                            (isValid$3(colDimension.indicatorKey) &&
-                                dimension.indicatorKey === colDimension.indicatorKey &&
-                                ((isValid$3(dimension.value) && isValid$3(colDimension.value) && colDimension.value === dimension.value) ||
-                                    !isValid$3(dimension.value) ||
-                                    !isValid$3(colDimension.value)))) {
-                            colArr = dimension.children;
-                            if (needLowestLevel_colPaths && !colArr?.length) {
-                                colDimensionFinded = dimension;
-                            }
-                            else if (!needLowestLevel_colPaths) {
-                                colDimensionFinded = dimension;
-                            }
-                            break;
-                        }
-                    }
-                }
+                colDimensionFinded = this.matchDimensionPath(colHeaderPaths, this.columnTree, needLowestLevel_colPaths);
             }
             if (rowHeaderPaths?.length >= 1) {
                 if (this.rowHierarchyType === 'tree') {
@@ -87893,27 +87931,7 @@
                     row = this._rowHeaderCellIds.indexOf(findedCellIdPath) + this.columnHeaderLevelCount;
                 }
                 else {
-                    for (let i = 0; i < rowHeaderPaths.length; i++) {
-                        const rowDimension = rowHeaderPaths[i];
-                        for (let j = 0; j < rowArr.length; j++) {
-                            const dimension = rowArr[j];
-                            if ((!isValid$3(rowDimension.indicatorKey) &&
-                                dimension.dimensionKey === rowDimension.dimensionKey &&
-                                dimension.value === rowDimension.value) ||
-                                (isValid$3(rowDimension.indicatorKey) &&
-                                    dimension.indicatorKey === rowDimension.indicatorKey &&
-                                    (!isValid$3(rowDimension.value) || dimension.value === rowDimension.value))) {
-                                rowArr = dimension.children;
-                                if (needLowestLevel_rowPaths && (!rowArr?.length || rowArr.some(row => row.dimensionKey === 'axis'))) {
-                                    rowDimensionFinded = dimension;
-                                }
-                                else if (!needLowestLevel_rowPaths) {
-                                    rowDimensionFinded = dimension;
-                                }
-                                break;
-                            }
-                        }
-                    }
+                    rowDimensionFinded = this.matchDimensionPath(rowHeaderPaths, this.rowTree, needLowestLevel_rowPaths, true);
                 }
             }
             if (!forceBody && needLowestLevel_colPaths && needLowestLevel_rowPaths) {
@@ -94283,7 +94301,7 @@
     }
 
     registerForVrender();
-    const version = "1.0.24";
+    const version = "1.0.25";
     function getIcons() {
         return get$2();
     }