@oracle/oraclejet 16.0.0 → 16.0.1

package/dist/js/libs/oj/debug/ojtable.js

@@ -3188,22 +3188,31 @@ var __oj_table_metadata =
             this._styleTableBodyRow(tableBodyRow, false);
 
             // set the cell attributes and styling.
-            var tableBodyCells = this._getTableElementsByTagName(tableBodyRow, Table.DOM_ELEMENT._TD);
-            var tableBodyCellsCount = tableBodyCells.length;
-            var tableBodyCell;
-            for (let i = 0; i < tableBodyCellsCount; i++) {
-              tableBodyCell = tableBodyCells[i];
-              this._setTableBodyCellAttributes(rowIdx, row[Table._CONST_KEY], i, tableBodyCell);
-              this._styleTableBodyCell(i, tableBodyCell, false);
-            }
+            var tableBodyCells = this._getChildElementsByTagName(tableBodyRow, Table.DOM_ELEMENT._TD);
+            var logicalCellArray = this._getColspanLogicalElements(tableBodyCells);
 
-            // sort the re-ordered columns in place
+            // sort the re-ordered columns in place BEFORE applying column styling
             if (this._columnsDestMap != null) {
               for (let i = 0; i < this._columnsDestMap.length; i++) {
-                var moveTableBodyCell = tableBodyCells[this._columnsDestMap[i]];
+                var moveTableBodyCell = logicalCellArray[this._columnsDestMap[i]];
                 moveTableBodyCell.parentNode.appendChild(moveTableBodyCell); // @HTMLUpdateOK
               }
+              // requery the cells as the ordering now matches the current columns array
+              tableBodyCells = this._getChildElementsByTagName(tableBodyRow, Table.DOM_ELEMENT._TD);
+              logicalCellArray = this._getColspanLogicalElements(tableBodyCells);
+            }
+
+            // track which cells have been updated / styled in cases of colspans
+            var styledCells = [];
+            for (let i = 0; i < logicalCellArray.length; i++) {
+              var tableBodyCell = logicalCellArray[i];
+              if (styledCells.indexOf(tableBodyCell) === -1) {
+                this._setTableBodyCellAttributes(rowIdx, row[Table._CONST_KEY], i, tableBodyCell);
+                this._styleTableBodyCell(i, tableBodyCell, false);
+                styledCells.push(tableBodyCell);
+              }
             }
+
             return this._finalizeTableBodyCellsRefresh(
               tableBodyRow,
               row,
@@ -7470,13 +7479,14 @@ var __oj_table_metadata =
    * @private
    */
   TableLayoutManager.prototype.registerScrollListeners = function () {
-    var scrollEventElement = DataCollectionUtils.getScrollEventElement(this.getScroller());
+    var scroller = this.getScroller();
+    var scrollEventElement = DataCollectionUtils.getScrollEventElement(scroller);
     if (scrollEventElement != null) {
       // if width or height is defined then we can have scrollbars so register scroll event listeners
       if (this._scrollEventListener == null) {
         this._scrollEventListener = function (event) {
-          var newScrollLeft = this._table._getElementScrollLeft(event.target);
-          var newScrollTop = event.target.scrollTop;
+          var newScrollLeft = this._table._getElementScrollLeft(scroller);
+          var newScrollTop = scroller.scrollTop;
           if (newScrollLeft === this._table._scrollLeft && newScrollTop === this._table._scrollTop) {
             // discard bogus scroll event
             return;
@@ -7834,7 +7844,7 @@ var __oj_table_metadata =
     var tableFooterRow = this._table._getTableFooterRow();
     var tableBody = this._table._getTableBody();
     var tableBottomSlot = this._table._getTableBottomSlot();
-    var tableScroller = this.getScroller();
+    var tableScroller = this._table._getTableScroller();
 
     var tableContainer = this._table._getTableContainer();
     tableContainer.classList.remove(Table.CSS_CLASSES._TABLE_SCROLL_VERTICAL_CLASS);
@@ -10007,7 +10017,7 @@ var __oj_table_metadata =
       for (i = 0; i < tableBodyRows.length; i++) {
         var isSticky = false;
         var tableBodyRow = tableBodyRows[i];
-        var rowCells = this._table._getTableElementsByTagName(tableBodyRow, Table.DOM_ELEMENT._TD);
+        var rowCells = this._table._getChildElementsByTagName(tableBodyRow, Table.DOM_ELEMENT._TD);
         if (tableBodyRow.classList.contains(Table.CSS_CLASSES._TABLE_STICKY_ROW_CLASS)) {
           isSticky = true;
         }
@@ -11219,6 +11229,8 @@ var __oj_table_metadata =
           }
         }
       }
+    } else {
+      tableElem.style[Table.CSS_PROP._WIDTH] = '';
     }
     return overallWidth;
   };
@@ -11230,6 +11242,9 @@ var __oj_table_metadata =
     var i;
     var columns = this._table._getColumnDefs();
     var columnsCount = columns.length;
+    if (columnsCount === 0) {
+      return 0;
+    }
 
     var totalPreferredWidth = 0; // total of all data column widths if set to their preferred or forced values
     var totalWorkingWeight = 0; // total weight of all non-forced data columns
@@ -11608,6 +11623,8 @@ var __oj_table_metadata =
     if (overallWidth > 0) {
       tableElem.style[Table.CSS_PROP._WIDTH] = overallWidth + Table.CSS_VAL._PX;
       tableElem.style['table-layout'] = 'fixed';
+    } else {
+      tableElem.style[Table.CSS_PROP._WIDTH] = '';
     }
   };
 
@@ -11618,6 +11635,9 @@ var __oj_table_metadata =
     var i = 0;
     var columns = this._table._getColumnDefs();
     var columnsCount = columns.length;
+    if (columnsCount === 0) {
+      return 0;
+    }
 
     var totalWorkingWeight = 0; // total weight of all non-forced data columns
     var forcedTotalWidth = 0; // total width of all forced data columns
@@ -15502,6 +15522,9 @@ var __oj_table_metadata =
     this._columnDefArray.splice(destColIdx + 1, 0, ...columnDefs);
     this._columnsDestMap.splice(destColIdx + 1, 0, ...columnsDestMapItems);
 
+    // clean up / reapply column selection in case colspans are present
+    this._updateSelectionStylingFromColumnReorder();
+
     // clone the array so we can trigger that it's changed
     this.option('columns', clonedColumnsOption, {
       _context: {
@@ -15750,10 +15773,12 @@ var __oj_table_metadata =
         var tableBodyRowsCount = tableBodyRows.length;
         for (i = 0; i < tableBodyRowsCount; i++) {
           var tableBodyCell = this._getTableBodyCell(i, columnIdx, null);
-          if (!add) {
-            tableBodyCell.classList.remove(styleClass);
-          } else {
-            tableBodyCell.classList.add(styleClass);
+          if (tableBodyCell != null) {
+            if (!add) {
+              tableBodyCell.classList.remove(styleClass);
+            } else {
+              tableBodyCell.classList.add(styleClass);
+            }
           }
         }
       }
@@ -15989,7 +16014,7 @@ var __oj_table_metadata =
       return;
     }
     tableFooter.classList.add(Table.CSS_CLASSES._TABLE_FOOTER_CLASS);
-    var tableFooterRow = this._getTableElementsByTagName(tableFooter, Table.DOM_ELEMENT._TR)[0];
+    var tableFooterRow = this._getChildElementsByTagName(tableFooter, Table.DOM_ELEMENT._TR)[0];
     tableFooterRow.classList.add(Table.CSS_CLASSES._TABLE_FOOTER_ROW_CLASS);
     tableFooterRow.setAttribute(Context._OJ_CONTEXT_ATTRIBUTE, ''); // @HTMLUpdateOK
   };
@@ -16053,7 +16078,7 @@ var __oj_table_metadata =
     tableHeader.classList.add(Table.CSS_CLASSES._TABLE_HEADER_CLASS);
     // eslint-disable-next-line no-param-reassign
     tableHeader.style[Table.CSS_PROP._DISPLAY] = 'table-header-group';
-    var tableHeaderRow = this._getTableElementsByTagName(tableHeader, Table.DOM_ELEMENT._TR)[0];
+    var tableHeaderRow = this._getChildElementsByTagName(tableHeader, Table.DOM_ELEMENT._TR)[0];
     tableHeaderRow.classList.add(Table.CSS_CLASSES._TABLE_HEADER_ROW_CLASS);
     tableHeaderRow.style[Table.CSS_PROP._POSITION] = Table.CSS_VAL._RELATIVE;
     tableHeaderRow.setAttribute(Context._OJ_CONTEXT_ATTRIBUTE, ''); // @HTMLUpdateOK
@@ -16426,6 +16451,26 @@ var __oj_table_metadata =
     return null;
   };
 
+  /**
+   * Get the child DOM elements by tag name
+   * @param {Element} parentElement parent element
+   * @param {string} name tagName name to match on
+   * @return {Array<Element>} returns the child DOM elements
+   * @private
+   */
+  Table.prototype._getChildElementsByTagName = function (parentElement, tagName) {
+    var childElements = [];
+    if (parentElement.childNodes != null && parentElement.childNodes.length > 0) {
+      for (var i = 0; i < parentElement.childNodes.length; i++) {
+        var childTagName = parentElement.childNodes[i].tagName;
+        if (childTagName != null && childTagName.toLowerCase() === tagName) {
+          childElements.push(parentElement.childNodes[i]);
+        }
+      }
+    }
+    return childElements;
+  };
+
   /**
    * Get descendant elements by class name. Only those directly owned by this table (or clone of) is included.
    * @param {Element} parentElement parent element
@@ -21934,6 +21979,23 @@ var __oj_table_metadata =
     }
   };
 
+  /**
+   * @private
+   */
+  Table.prototype._updateSelectionStylingFromColumnReorder = function () {
+    var selected = this.option('selected');
+    var columnKeySet = selected.column;
+
+    var headers = this._getTableHeaderColumns();
+    headers.forEach(function (header, index) {
+      if (columnKeySet.has(this._getColumnKeyForColumnIdx(index))) {
+        this._setColumnState(index, true);
+      } else {
+        this._setColumnState(index, false);
+      }
+    }, this);
+  };
+
   /**
    * @param {boolean=} isOptionUpdate
    * @private

package/dist/js/libs/oj/debug_esm/ojcore-base.js

@@ -37,12 +37,12 @@ const oj = {
    * @global
    * @member {string} version JET version numberr
    */
-  version: '16.0.0',
+  version: '16.0.1',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2024-02-10_08-15-32',
+  revision: '2024-03-20_19-05-18',
 
   // This function is only meant to be used outside the library, so quoting the name
   // to avoid renaming is appropriate

package/dist/js/libs/oj/debug_esm/ojcorerouter.js

@@ -570,11 +570,14 @@ CoreRouter.prototype.sync = function () {
     const transition = pendingTransitions.shift();
     const newRoutes = this._getParentRoutes().concat(this._getPendingState(transition));
     const newPath = urlAdapter.getUrlForRoutes(newRoutes);
-    window.history.replaceState(null, 'path', newPath);
+    if (!this._noHistory) {
+      window.history.replaceState(null, 'path', newPath);
+    }
     route = transition;
   } else {
     route = this._getRouteSegment();
   }
+
   // Transition to the new route, or a default one if no current one exists
   return this._execute(route || { path: '', params: {} })
     .then((state) => {
@@ -583,9 +586,6 @@ CoreRouter.prototype.sync = function () {
       var childRouter = this.childRouter;
       if (childRouter) {
         p = childRouter.sync();
-      } else if (!this._noHistory) {
-        // Cleanup noHistorySegments after navigating any history-tracking routers
-        noHistorySegments = [];
       }
       return p;
     })
@@ -732,10 +732,6 @@ CoreRouter.prototype.go = function (...transitions) {
     // Get the current routes for all active routers, and compare that to the
     // new routes for this transition.
     const currentPath = urlAdapter.getUrlForRoutes(getActiveRoutes());
-    // Insert the new transitions after the current router's route offset
-    const newRoutes = this._getParentRoutes().concat(this._getPendingState(first, true));
-    const newPath = urlAdapter.getUrlForRoutes(newRoutes);
-
     const prevNoHistorySegments = noHistorySegments;
     if (this._noHistory) {
       info(`Navigating non-history tracking router(${this._name}) to ${path}`);
@@ -743,8 +739,15 @@ CoreRouter.prototype.go = function (...transitions) {
       // to store their transitions. Replace the segments after our index with
       // the new transitions
       noHistorySegments = noHistorySegments.slice(0, this._noHistoryOffset).concat(transitions);
-    } else if (currentPath !== newPath) {
-      window.history.pushState(null, 'path', newPath);
+    } else {
+      // Cleanup noHistorySegments when navigating any history-tracking routers
+      noHistorySegments = [];
+      // Insert the new transitions after the current router's route offset
+      const newRoutes = this._getParentRoutes().concat(this._getPendingState(first, true));
+      const newPath = urlAdapter.getUrlForRoutes(newRoutes);
+      if (currentPath !== newPath) {
+        window.history.pushState(null, 'path', newPath);
+      }
     }
     goP = this.sync().catch((ex) => {
       // Clear transitions if transition rejected
@@ -809,7 +812,7 @@ CoreRouter.prototype._prepublish = function (state) {
     if (activeSync !== this._activeSync) {
       // If this isn't the latest sync, then reject the Promise because another
       // sync() is already underway
-      return Promise.reject();
+      return Promise.reject('sync overridden');
     }
     return s;
   });

package/dist/js/libs/oj/debug_esm/ojdatacollection-common.js

@@ -914,7 +914,10 @@ DataCollectionUtils.isRequestIdleCallbackSupported = function () {
  * @private
  */
 DataCollectionUtils.isFetchAborted = function (fetchResult) {
-  var signal = fetchResult.value.fetchParameters.signal;
+  if (fetchResult?.value == null) {
+    return false;
+  }
+  var signal = fetchResult.value.fetchParameters?.signal;
   if (signal == null) {
     warn(
       'Signal is missing from fetch parameters, which is set by collection component and should be present'

package/dist/js/libs/oj/debug_esm/ojdatagrid.js

@@ -5846,8 +5846,8 @@ DvtDataGrid.prototype.resizeGrid = function () {
   this.setElementWidth(colEndHeader, columnHeaderWidth);
 
   [rowHeaderWidth, colHeaderHeight] = this._setFrozenContainerDimension(
-    availableWidth,
-    availableHeight,
+    databodyWidth,
+    databodyHeight,
     rowHeaderWidth,
     rowEndHeaderWidth,
     colHeaderHeight,
@@ -6060,7 +6060,10 @@ DvtDataGrid.prototype._adjustHeaderBorders = function () {
         this.m_utils.removeCSSClassName(this.m_bottomCorner, style);
       }
     }
-    tags = this.m_rowEndHeader.firstChild.childNodes;
+    tags = Array.from(this.m_rowEndHeader.firstChild.childNodes);
+    if (this.m_rowEndHeaderFrozen?.firstChild?.childNodes?.length) {
+      tags.push(...this.m_rowEndHeaderFrozen.firstChild.childNodes);
+    }
     for (i = 0; i < tags.length; i++) {
       if (bw) {
         this.m_utils.addCSSClassName(tags[i], style);
@@ -6127,7 +6130,10 @@ DvtDataGrid.prototype._adjustHeaderBorders = function () {
         this.m_utils.removeCSSClassName(this.m_bottomCorner, style);
       }
     }
-    tags = this.m_colEndHeader.firstChild.childNodes;
+    tags = Array.from(this.m_colEndHeader.firstChild.childNodes);
+    if (this.m_colEndHeaderFrozen?.firstChild?.childNodes?.length) {
+      tags.push(...this.m_colEndHeaderFrozen.firstChild.childNodes);
+    }
     const groupingContainerStyle = this.getMappedStyle('groupingcontainer');
     // Identify if the endHeader is a groupingcontainer and apply style to the first child.
     for (i = 0; i < tags.length; i++) {
@@ -17129,8 +17135,8 @@ DvtDataGrid.prototype._handleInsertRangeCellFetchSuccess = function (
   // are available and insert is done at the end of the frozen section.
   if (this._hasFrozenColumns() || this._hasFrozenRows()) {
     if (
-      (axis === 'column' && offset <= this.m_frozenColIndex + 1) ||
-      (axis === 'row' && offset <= this.m_frozenRowIndex + 1)
+      (axis === 'column' && this._hasFrozenColumns() && offset <= this.m_frozenColIndex + 1) ||
+      (axis === 'row' && this._hasFrozenRows() && offset <= this.m_frozenRowIndex + 1)
     ) {
       frozenDimensions = new Array(count).fill(totalDimension / count);
     } else {
@@ -18206,11 +18212,14 @@ DvtDataGrid.prototype._splitRange = function (cellSet, rowStart, rowEnd, colStar
   let frozenColExists = this.m_frozenColIndex !== null && this.m_frozenColIndex !== -1;
   let frozenRowExists = this.m_frozenRowIndex !== null && this.m_frozenRowIndex !== -1;
 
+  // * If no frozen section, mutate the rest of the databody
+  // * If either of them exists, then check if the row/col End exceeds the frozen region and mutate the rest of the databody
+  // * ensure check for frozenAxisExists as 1 > null alone shall pass
   if (
     (!frozenColExists && !frozenRowExists) ||
     ((frozenColExists || frozenRowExists) &&
-      rowEnd > this.m_frozenRowIndex &&
-      colEnd > this.m_frozenColIndex)
+      (!frozenRowExists || rowEnd > this.m_frozenRowIndex) &&
+      (!frozenColExists || colEnd > this.m_frozenColIndex))
   ) {
     this._fetchAndMutateCellsByRange(cellSet, this.m_databody, rowStart, rowEnd, colStart, colEnd);
   }
@@ -18436,6 +18445,14 @@ DvtDataGrid.prototype._handleDeleteRangeEvent = function (eventDetail) {
         if (endHeaders.length) {
           this._removeAndModifyHeaders(endHeaders, dimension, dimensionToRetrieve, dirToSet, index);
         }
+        if (
+          (axis === 'column' && this._hasFrozenColumns() && index <= this.m_frozenColIndex) ||
+          (axis === 'row' && this._hasFrozenRows() && index <= this.m_frozenRowIndex)
+        ) {
+          frozenSectionDimension += dimension;
+        } else {
+          databodyDimension += dimension;
+        }
       }
       if (
         (axis === 'column' && this._hasFrozenColumns() && index <= this.m_frozenColIndex) ||
@@ -18446,14 +18463,6 @@ DvtDataGrid.prototype._handleDeleteRangeEvent = function (eventDetail) {
         insideDeletedDimension += dimension;
         dimensions.unshift(dimension);
       }
-      if (
-        (axis === 'column' && this._hasFrozenColumns() && index <= this.m_frozenColIndex) ||
-        (axis === 'row' && this._hasFrozenRows() && index <= this.m_frozenRowIndex)
-      ) {
-        frozenSectionDimension += dimension;
-      } else {
-        databodyDimension += dimension;
-      }
     } else if (flag === DvtDataGrid.AFTER && this.m_options.getScrollPolicy() === 'scroll') {
       // only concerned with after rows if virtual scroll
       databodyDimension += dimension;
@@ -18591,6 +18600,9 @@ DvtDataGrid.prototype._handleDeleteRangeEvent = function (eventDetail) {
     }
     var databodyContentHeight = this.getElementHeight(databodyContent) - databodyDimension;
     this.setElementHeight(databodyContent, databodyContentHeight);
+    if (this.m_databodyFrozenCol) {
+      this.setElementHeight(this.m_databodyFrozenCol, databodyContentHeight);
+    }
     if (this.m_databodyFrozenRow) {
       var frozenDatabodyContentHeight =
         this.getElementHeight(this.m_databodyFrozenRow) - frozenSectionDimension;
@@ -18627,6 +18639,9 @@ DvtDataGrid.prototype._handleDeleteRangeEvent = function (eventDetail) {
     }
     var databodyContentWidth = this.getElementWidth(databodyContent) - databodyDimension;
     this.setElementWidth(databodyContent, databodyContentWidth);
+    if (this.m_databodyFrozenRow) {
+      this.setElementWidth(this.m_databodyFrozenRow, databodyContentWidth);
+    }
     if (this.m_databodyFrozenCol) {
       var frozenDatabodyContentWidth =
         this.getElementWidth(this.m_databodyFrozenCol) - frozenSectionDimension;
@@ -19176,31 +19191,21 @@ DvtDataGrid.prototype._findHeaderByKey = function (key, root, className) {
   if (root == null) {
     return null;
   }
+  var sections = [];
+  var headers = [];
+  sections.push(root);
 
-  var headers;
-
-  // identify region based on the frozen indexes.
-  if (
-    this._hasFrozenRows() &&
-    parseInt(key, 10) <= this.m_frozenRowIndex &&
-    (root === this.m_rowHeader || root === this.m_rowEndHeader)
-  ) {
-    // eslint-disable-next-line no-param-reassign
-    root = root === this.m_rowHeader ? this.m_rowHeaderFrozen : this.m_rowEndHeaderFrozen;
+  if (this._hasFrozenRows() && (root === this.m_rowHeader || root === this.m_rowEndHeader)) {
+    let section = root === this.m_rowHeader ? this.m_rowHeaderFrozen : this.m_rowEndHeaderFrozen;
+    sections.push(section);
   }
-  if (
-    this._hasFrozenColumns() &&
-    parseInt(key, 10) <= this.m_frozenColIndex &&
-    (root === this.m_colHeader || root === this.m_colEndHeader)
-  ) {
-    // eslint-disable-next-line no-param-reassign
-    root = root === this.m_colHeader ? this.m_colHeaderFrozen : this.m_colEndHeaderFrozen;
+  if (this._hasFrozenColumns() && (root === this.m_colHeader || root === this.m_colEndHeader)) {
+    let section = root === this.m_colHeader ? this.m_colHeaderFrozen : this.m_colEndHeaderFrozen;
+    sections.push(section);
   }
-  // getElementsByClassName support is IE9 and up
-  if (root.getElementsByClassName) {
-    headers = root.getElementsByClassName(className);
-  } else {
-    headers = root.childNodes;
+
+  for (let i = 0; i < sections.length; i++) {
+    headers.push(...sections[i].getElementsByClassName(className));
   }
   for (var i = 0; i < headers.length; i++) {
     var header = headers[i];
@@ -27108,6 +27113,13 @@ DvtDataGrid.prototype._fireCellResizeEvent = function (
     if ((resizeHeaderMode === 'column' || resizeHeaderMode === 'columnEnd') && !isHeaderLabel) {
       // index based
       dimension = 'columnWidth';
+      details.ui.size = this.getElementWidth(
+        this._getHeaderByIndex(
+          resizingElementIndex + context.extent - 1,
+          'column',
+          this.m_columnHeaderLevelCount - 1
+        )
+      );
     } else if (isHeaderLabel) {
       let isRowEndHeaderLabel = this.m_utils.containsCSSClassName(
         this.m_resizingElement,
@@ -27115,10 +27127,9 @@ DvtDataGrid.prototype._fireCellResizeEvent = function (
       );
       dimension = isRowEndHeaderLabel ? 'rowEndHeaderWidth' : 'rowHeaderWidth';
       details.ui.levels = [
-        resizeHeaderMode.includes('row')
-          ? context.level + context.depth - 1
-          : this.m_rowHeaderLevelCount - 1
+        resizeHeaderMode.includes('row') ? context.level : this.m_rowHeaderLevelCount - 1
       ];
+      details.ui.size = newWidth;
     } else {
       let isRowEndHeader = this.m_utils.containsCSSClassName(
         this.m_resizingElement,
@@ -27126,13 +27137,22 @@ DvtDataGrid.prototype._fireCellResizeEvent = function (
       );
       dimension = isRowEndHeader ? 'rowEndHeaderWidth' : 'rowHeaderWidth';
       details.ui.levels = [context.level + context.depth - 1];
+      details.ui.size = isRowEndHeader
+        ? this.m_rowEndHeaderLevelWidths[context.level + context.depth - 1]
+        : this.m_rowHeaderLevelWidths[context.level + context.depth - 1];
     }
-    details.ui.size = newWidth;
     details.ui.dimension = dimension;
   } else if (newHeight !== oldHeight) {
     if ((resizeHeaderMode === 'row' || resizeHeaderMode === 'rowEnd') && !isHeaderLabel) {
       // index based
       dimension = 'rowHeight';
+      details.ui.size = this.getElementHeight(
+        this._getHeaderByIndex(
+          resizingElementIndex + context.extent - 1,
+          'row',
+          this.m_rowHeaderLevelCount - 1
+        )
+      );
     } else if (isHeaderLabel) {
       let isColumnEndHeaderLabel = this.m_utils.containsCSSClassName(
         this.m_resizingElement,
@@ -27140,10 +27160,9 @@ DvtDataGrid.prototype._fireCellResizeEvent = function (
       );
       dimension = isColumnEndHeaderLabel ? 'columnEndHeaderHeight' : 'columnHeaderHeight';
       details.ui.levels = [
-        resizeHeaderMode.includes('column')
-          ? context.level + context.depth - 1
-          : this.m_columnHeaderLevelCount - 1
+        resizeHeaderMode.includes('column') ? context.level : this.m_columnHeaderLevelCount - 1
       ];
+      details.ui.size = newHeight;
     } else {
       let isColumnEndHeader = this.m_utils.containsCSSClassName(
         this.m_resizingElement,
@@ -27151,8 +27170,10 @@ DvtDataGrid.prototype._fireCellResizeEvent = function (
       );
       dimension = isColumnEndHeader ? 'columnEndHeaderHeight' : 'columnHeaderHeight';
       details.ui.levels = [context.level + context.depth - 1];
+      details.ui.size = isColumnEndHeader
+        ? this.m_columnEndHeaderLevelHeights[context.level + context.depth - 1]
+        : this.m_columnHeaderLevelHeights[context.level + context.depth - 1];
     }
-    details.ui.size = newHeight;
     details.ui.dimension = dimension;
   } else {
     return;
@@ -27416,7 +27437,7 @@ DvtDataGrid.prototype.manageHeaderCursor = function (event, isLabel) {
       if ((!end && bottomEdgeCheck) || (end && topEdgeCheck)) {
         this.m_resizingElement = elem;
         return 'row-resize';
-      } else if ((!end && topEdgeCheck) || (end && bottomEdgeCheck)) {
+      } else if (((!end && topEdgeCheck) || (end && bottomEdgeCheck)) && level !== 0) {
         // can we resize the height of the parent header
         this.m_resizingElement = parent;
         this.m_resizingElementSibling = elem;
@@ -27448,8 +27469,9 @@ DvtDataGrid.prototype.manageHeaderCursor = function (event, isLabel) {
         this.m_resizingElement = elem;
         return 'col-resize';
       } else if (
-        (!end && (rtl ? rightEdgeCheck : leftEdgeCheck)) ||
-        (end && (rtl ? leftEdgeCheck : rightEdgeCheck))
+        ((!end && (rtl ? rightEdgeCheck : leftEdgeCheck)) ||
+          (end && (rtl ? leftEdgeCheck : rightEdgeCheck))) &&
+        level !== 0
       ) {
         this.m_resizingElement = parent;
         this.m_resizingElementSibling = elem;
@@ -28483,8 +28505,8 @@ DvtDataGrid.prototype.manageResizeScrollbars = function () {
   this.setElementWidth(colEndHeader, columnHeaderWidth);
 
   [rowHeaderWidth, colHeaderHeight] = this._setFrozenContainerDimension(
-    availableWidth,
-    availableHeight,
+    databodyWidth,
+    databodyHeight,
     rowHeaderWidth,
     rowEndHeaderWidth,
     colHeaderHeight,
@@ -28829,33 +28851,23 @@ DvtDataGrid.prototype._shiftFrozenCellsAlongAxis = function (
 
     if (!(tempArray[i] && tempArray[i][startAxisChange]) && shiftOnly !== true) {
       this.setElementDir(cell, this.getElementDir(cell, dimension) + dimensionDelta, dimension);
-      if (axis === 'row') {
-        this._updateTempArray(
-          tempArray,
-          true,
-          i,
-          startAxisChange,
-          cellContext.extents.column,
-          axisExtent - extentWithinCellToIgnore
-        );
-      } else {
-        if (forHideShow) {
-          if (this.isHidden(axis, startAxisChange)) {
-            cell.style.display = 'none';
-          } else {
-            cell.style.display = '';
-          }
+      if (forHideShow) {
+        if (this.isHidden(axis, startAxisChange)) {
+          cell.style.display = 'none';
+        } else {
+          cell.style.display = '';
         }
-
-        this._updateTempArray(
-          tempArray,
-          true,
-          i,
-          startAxisChange,
-          cellContext.extents.row,
-          axisExtent - extentWithinCellToIgnore
-        );
       }
+
+      const otherAxis = axis === 'row' ? 'column' : 'row';
+      this._updateTempArray(
+        tempArray,
+        true,
+        i,
+        startAxisChange,
+        cellContext.extents[otherAxis],
+        axisExtent - extentWithinCellToIgnore
+      );
     }
     let axisStartValue = startAxisChange;
     if (shiftOnly !== true) {
@@ -45004,8 +45016,10 @@ DvtDataGrid.prototype._buildFrozenHeaders = function (axis, startResults, endRes
     endHeaderFetchCount: 0
   };
 
+  // null check and -1 check to fully ensure frozenSection doesn't exist.
   if (
     this.m_options._getFreezeIndex(axis) === null ||
+    this.m_options._getFreezeIndex(axis) === -1 ||
     !this._isFreezeFeasible(axis, startResults, endResults, start, 0)
   ) {
     returnObj = {
@@ -50146,7 +50160,7 @@ DvtDataGrid.prototype.shiftAxisForHidability = function (index, hide, axis) {
         undefined,
         true
       );
-      if (this.m_databodyFrozenRow) {
+      if (this.m_databodyFrozenRow || this.m_databodyFrozenCol) {
         this._shiftFrozenCellsAlongAxis(axis, dimensionChange, axisIndex, false, true);
       }
       // eslint-disable-next-line no-unused-expressions
@@ -50154,8 +50168,8 @@ DvtDataGrid.prototype.shiftAxisForHidability = function (index, hide, axis) {
         ? (this.m_endColPixel += dimensionChange)
         : (this.m_endRowPixel += dimensionChange);
     } else if (
-      (axis === 'column' && this.m_databodyFrozenRow) ||
-      (axis === 'row' && this.m_databodyFrozenCol)
+      (axis === 'column' && this.m_databodyFrozenCol) ||
+      (axis === 'row' && this.m_databodyFrozenRow)
     ) {
       corner = true;
       this._shiftCellsAlongAxis(

package/dist/js/libs/oj/debug_esm/ojdrawerpopup.js

@@ -89,6 +89,7 @@ let DrawerPopup = DrawerPopup_1 = class DrawerPopup extends Component {
             const $drawerElement = $(this.rootRef.current);
             const status = ZOrderUtils.getStatus($drawerElement);
             if (status === ZOrderUtils.STATUS.OPEN) {
+                $drawerElement.detach();
                 const psOptions = {};
                 psOptions[PopupService.OPTION.POPUP] = $drawerElement;
                 this.ignoreUpdate = true;