@oracle/oraclejet 14.1.0 → 14.1.2

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

@@ -2157,6 +2157,7 @@ var __oj_table_metadata =
     this._isEditPending = null;
     this._active = null;
     this._isTableTab = null;
+    this._isAddRowRendered = false;
     this._renderedTableHeaderColumns = false;
 
     // clear any pending timeouts
@@ -2456,6 +2457,7 @@ var __oj_table_metadata =
     if (contextMenu != null && contextMenu !== this._getContextMenuElement()) {
       this._createContextMenuContainer();
     }
+    this._isAddRowRendered = false;
     this._clearLayoutManager();
     this._clearCachedDom();
     this._clearCachedStyling();
@@ -2863,13 +2865,7 @@ var __oj_table_metadata =
     this._hideNoDataMessage();
     const tableBodyDocFrag = document.createDocumentFragment();
 
-    if (
-      this._isAddNewRowEnabled() &&
-      (startIndex == null || startIndex === 0) &&
-      this._getPlaceHolderRow() == null
-    ) {
-      this._refreshAddNewRowPlaceholder(tableBodyDocFrag, true);
-    }
+    this._refreshAddNewRowPlaceholder(tableBodyDocFrag, true);
 
     // if no new rows, and no existing rows, show no data message
     if (rows.length === 0 && this._getTableBodyRows().length === 0) {
@@ -3200,125 +3196,129 @@ var __oj_table_metadata =
         this._hasAddRowTemplate = false;
         this._setTableActionableMode(false);
       }
+      this._isAddRowRendered = false;
       return Promise.resolve(false);
     }
 
-    const templateEngine = this._getTemplateEngine();
-    const addRowTemplate = this._getSlotTemplate('addRowTemplate');
-    const addRowCellTemplate = this._getSlotTemplate('addRowCellTemplate');
-    if (templateEngine !== null) {
-      let slotContext;
-      let submitAddRow = function (cancelAdd) {
-        this._handleAddRow(cancelAdd, null);
-      }.bind(this);
-      const componentElement = this._getRootElement();
-      const tableBody = this._getTableBody();
+    if (!this._isAddRowRendered) {
+      const templateEngine = this._getTemplateEngine();
+      const addRowTemplate = this._getSlotTemplate('addRowTemplate');
+      const addRowCellTemplate = this._getSlotTemplate('addRowCellTemplate');
+      if (templateEngine !== null) {
+        let slotContext;
+        let submitAddRow = function (cancelAdd) {
+          this._handleAddRow(cancelAdd, null);
+        }.bind(this);
+        const componentElement = this._getRootElement();
+        const tableBody = this._getTableBody();
 
-      if (placeHolderRow != null) {
-        this._cleanTemplateNodes(placeHolderRow);
-        $(placeHolderRow).empty();
-      }
-      if (placeHolderRow == null) {
-        placeHolderRow = this._createTableBodyRow();
-      }
-      if (docFrag != null) {
-        docFrag.appendChild(placeHolderRow);
-      } else {
-        tableBody.insertBefore(placeHolderRow, tableBody.firstChild);
-      }
-
-      var addRowCell;
-      if (addRowTemplate != null && this._isDefaultAddRowTemplateSlotValid()) {
-        slotContext = this._getRowSlotTemplateContextObject({}, true);
-        slotContext.submitAddRow = submitAddRow;
-        const nodes = templateEngine.execute(
-          componentElement,
-          addRowTemplate,
-          slotContext,
-          this.options.as,
-          tableBody
-        );
-        for (let i = 0; i < nodes.length; i++) {
-          if (nodes[i].tagName === 'TR') {
-            placeHolderRow.parentNode.replaceChild(nodes[i], placeHolderRow);
-            break;
-          } else {
-            placeHolderRow.appendChild(nodes[i]); // @HTMLUpdateOK
-          }
+        if (placeHolderRow != null) {
+          this._cleanTemplateNodes(placeHolderRow);
+          $(placeHolderRow).empty();
         }
-        if (docFrag == null) {
-          placeHolderRow = this._getRawTableBodyRow(-1);
-        } else if (!docFrag.children) {
-          // use jquery children() because documentFragments do not have
-          // good browser support for .children
-          // eslint-disable-next-line no-param-reassign
-          placeHolderRow = $(docFrag).children()[0];
+        if (placeHolderRow == null) {
+          placeHolderRow = this._createTableBodyRow();
+        }
+        if (docFrag != null) {
+          docFrag.appendChild(placeHolderRow);
         } else {
-          // eslint-disable-next-line no-param-reassign
-          placeHolderRow = docFrag.children[0];
-        }
-        // make sure to honor any reordered columns when re-rendering the add row content from a row template
-        if (this._columnsDestMap != null) {
-          var renderedCells = this._getPlaceHolderRowCells(placeHolderRow);
-          for (let i = 0; i < this._columnsDestMap.length; i++) {
-            var moveAddRowCell = renderedCells[this._columnsDestMap[i]];
-            moveAddRowCell.parentNode.appendChild(moveAddRowCell); // @HTMLUpdateOK
-          }
+          tableBody.insertBefore(placeHolderRow, tableBody.firstChild);
         }
-      } else if (addRowCellTemplate !== null && this._isDefaultAddRowCellTemplateSlotValid()) {
-        var columns = this._getColumnDefs();
-        var columnsCount = columns.length;
-        for (var j = 0; j < columnsCount; j++) {
-          addRowCell = this._createTableBodyCell();
-          placeHolderRow.appendChild(addRowCell);
-          slotContext = this._getCellSlotTemplateContextObject({ columnIndex: j }, true);
+
+        var addRowCell;
+        if (addRowTemplate != null && this._isDefaultAddRowTemplateSlotValid()) {
+          slotContext = this._getRowSlotTemplateContextObject({}, true);
           slotContext.submitAddRow = submitAddRow;
-          var cellContent = templateEngine.execute(
+          const nodes = templateEngine.execute(
             componentElement,
-            addRowCellTemplate,
+            addRowTemplate,
             slotContext,
             this.options.as,
             tableBody
           );
-          if (!(cellContent instanceof Array)) {
-            cellContent = [cellContent];
+          for (let i = 0; i < nodes.length; i++) {
+            if (nodes[i].tagName === 'TR') {
+              placeHolderRow.parentNode.replaceChild(nodes[i], placeHolderRow);
+              break;
+            } else {
+              placeHolderRow.appendChild(nodes[i]); // @HTMLUpdateOK
+            }
+          }
+          if (docFrag == null) {
+            placeHolderRow = this._getRawTableBodyRow(-1);
+          } else if (!docFrag.children) {
+            // use jquery children() because documentFragments do not have
+            // good browser support for .children
+            // eslint-disable-next-line no-param-reassign
+            placeHolderRow = $(docFrag).children()[0];
+          } else {
+            // eslint-disable-next-line no-param-reassign
+            placeHolderRow = docFrag.children[0];
           }
-          for (let i = 0; i < cellContent.length; i++) {
-            addRowCell.appendChild(cellContent[i]);
+          // make sure to honor any reordered columns when re-rendering the add row content from a row template
+          if (this._columnsDestMap != null) {
+            var renderedCells = this._getPlaceHolderRowCells(placeHolderRow);
+            for (let i = 0; i < this._columnsDestMap.length; i++) {
+              var moveAddRowCell = renderedCells[this._columnsDestMap[i]];
+              moveAddRowCell.parentNode.appendChild(moveAddRowCell); // @HTMLUpdateOK
+            }
+          }
+        } else if (addRowCellTemplate !== null && this._isDefaultAddRowCellTemplateSlotValid()) {
+          var columns = this._getColumnDefs();
+          var columnsCount = columns.length;
+          for (var j = 0; j < columnsCount; j++) {
+            addRowCell = this._createTableBodyCell();
+            placeHolderRow.appendChild(addRowCell);
+            slotContext = this._getCellSlotTemplateContextObject({ columnIndex: j }, true);
+            slotContext.submitAddRow = submitAddRow;
+            var cellContent = templateEngine.execute(
+              componentElement,
+              addRowCellTemplate,
+              slotContext,
+              this.options.as,
+              tableBody
+            );
+            if (!(cellContent instanceof Array)) {
+              cellContent = [cellContent];
+            }
+            for (let i = 0; i < cellContent.length; i++) {
+              addRowCell.appendChild(cellContent[i]);
+            }
           }
         }
-      }
-      placeHolderRow.classList.add(Table.CSS_CLASSES._TABLE_ADD_ROW_PLACEHOLDER_CLASS);
+        placeHolderRow.classList.add(Table.CSS_CLASSES._TABLE_ADD_ROW_PLACEHOLDER_CLASS);
 
-      // set the cell attributes and styling.
-      var addRowCells = this._getPlaceHolderRowCells(placeHolderRow);
-      for (let i = 0; i < addRowCells.length; i++) {
-        addRowCell = addRowCells[i];
-        this._styleTableAddRowCell(i, addRowCell);
-      }
+        // set the cell attributes and styling.
+        var addRowCells = this._getPlaceHolderRowCells(placeHolderRow);
+        for (let i = 0; i < addRowCells.length; i++) {
+          addRowCell = addRowCells[i];
+          this._styleTableAddRowCell(i, addRowCell);
+        }
 
-      this._hasAddRowTemplate = true;
-      if (this._isDefaultSelectorEnabled()) {
-        // If multiple selection is enabled add placeholder cell in the selector place
-        addRowCell = document.createElement(Table.DOM_ELEMENT._TD); // @HTMLUpdateOK
-        placeHolderRow.insertBefore(addRowCell, placeHolderRow.firstChild); // @HTMLUpdateOK
-        addRowCell.classList.add(Table.CSS_CLASSES._TABLE_FROZEN_START);
-        if (this._isVerticalGridEnabled()) {
-          addRowCell.classList.add(Table.CSS_CLASSES._TABLE_VGRID_LINES_CLASS);
+        this._isAddRowRendered = true;
+        this._hasAddRowTemplate = true;
+        if (this._isDefaultSelectorEnabled()) {
+          // If multiple selection is enabled add placeholder cell in the selector place
+          addRowCell = document.createElement(Table.DOM_ELEMENT._TD); // @HTMLUpdateOK
+          placeHolderRow.insertBefore(addRowCell, placeHolderRow.firstChild); // @HTMLUpdateOK
+          addRowCell.classList.add(Table.CSS_CLASSES._TABLE_FROZEN_START);
+          if (this._isVerticalGridEnabled()) {
+            addRowCell.classList.add(Table.CSS_CLASSES._TABLE_VGRID_LINES_CLASS);
+          }
         }
+        if (this._isGutterStartColumnEnabled()) {
+          let tableGutterStart = this._createTableGutterCell('body', 'start');
+          placeHolderRow.insertBefore(tableGutterStart, placeHolderRow.firstChild); // @HTMLUpdateOK
+        }
+        if (this._isGutterEndColumnEnabled()) {
+          let tableGutterEnd = this._createTableGutterCell('body', 'end');
+          placeHolderRow.appendChild(tableGutterEnd); // @HTMLUpdateOK
+        }
+        if (!skipTopUpdate) {
+          this._getLayoutManager()._updateStickyRowTops();
+        }
+        return this._finalizeNonBodyRowRendering([placeHolderRow]);
       }
-      if (this._isGutterStartColumnEnabled()) {
-        let tableGutterStart = this._createTableGutterCell('body', 'start');
-        placeHolderRow.insertBefore(tableGutterStart, placeHolderRow.firstChild); // @HTMLUpdateOK
-      }
-      if (this._isGutterEndColumnEnabled()) {
-        let tableGutterEnd = this._createTableGutterCell('body', 'end');
-        placeHolderRow.appendChild(tableGutterEnd); // @HTMLUpdateOK
-      }
-      if (!skipTopUpdate) {
-        this._getLayoutManager()._updateStickyRowTops();
-      }
-      return this._finalizeNonBodyRowRendering([placeHolderRow]);
     }
     return Promise.resolve(false);
   };
@@ -5989,6 +5989,7 @@ var __oj_table_metadata =
    * @private
    */
   Table.prototype._refreshAddRowDisplay = function () {
+    this._isAddRowRendered = false;
     return this._refreshAddNewRowPlaceholder().then(
       function (value) {
         this._getLayoutManager().notifyTableUpdate(Table._UPDATE._ADD_ROW_DISPLAY);
@@ -19597,8 +19598,8 @@ var __oj_table_metadata =
         var newEditRowValue;
         var editAcceptPromiseArray = [];
 
-        // save the old editable row index
-        var prevEditableRowIdx = this._getEditableRowIdx();
+        // save the old editable row info
+        var prevEditableRowKey = this._getEditableRowKey();
 
         try {
           if (editable && !this._hasEditableRow()) {
@@ -19681,17 +19682,15 @@ var __oj_table_metadata =
                       function () {
                         this._setCellInRowFocus(rowIdx, columnIdx, forwardSearch);
                         // clear out the old editable row
+                        // make sure the row still exists before we refresh it
+                        var prevEditableRowIdx = this._getRowIdxForRowKey(prevEditableRowKey);
                         if (prevEditableRowIdx != null) {
-                          // make sure the row still exists before we refresh it
-                          var prevEditableTableBodyRow = this._getTableBodyRow(prevEditableRowIdx);
-                          if (prevEditableTableBodyRow != null) {
-                            // re-render the previously editable row, which will be read-only now
-                            return this._refreshRow(prevEditableRowIdx, false).then(
-                              function () {
-                                this._isEditPending = false;
-                              }.bind(this)
-                            );
-                          }
+                          // re-render the previously editable row, which will be read-only now
+                          return this._refreshRow(prevEditableRowIdx, false).then(
+                            function () {
+                              this._isEditPending = false;
+                            }.bind(this)
+                          );
                         }
                         this._isEditPending = false;
                         return Promise.resolve();
@@ -19705,24 +19704,22 @@ var __oj_table_metadata =
                   }
 
                   // clear out the old editable row
+                  // make sure the row still exists before we refresh it
+                  var prevEditableRowIdx = this._getRowIdxForRowKey(prevEditableRowKey);
                   if (prevEditableRowIdx != null) {
-                    // make sure the row still exists before we refresh it
-                    var prevEditableTableBodyRow = this._getTableBodyRow(prevEditableRowIdx);
-                    if (prevEditableTableBodyRow != null) {
-                      // re-render the previously editable row, which will be read-only now
-                      return this._refreshRow(prevEditableRowIdx, false).then(
-                        function () {
-                          this._isEditPending = false;
-                        }.bind(this)
-                      );
-                    }
+                    // re-render the previously editable row, which will be read-only now
+                    return this._refreshRow(prevEditableRowIdx, false).then(
+                      function () {
+                        this._isEditPending = false;
+                      }.bind(this)
+                    );
                   }
                   this._isEditPending = false;
                   return Promise.resolve();
                 }.bind(this),
                 function () {
                   this._removeSkeletonRow(rowIdx);
-                  if (editable && prevEditableRowIdx == null) {
+                  if (editable && prevEditableRowKey == null) {
                     this._syncActiveElement();
                   }
                   this._isEditPending = false;
@@ -19761,19 +19758,18 @@ var __oj_table_metadata =
             this._getTable().focus();
           }
         }
-        // clear out the old editable row
-        if (prevEditableRowIdx != null) {
-          // make sure the row still exists before we refresh it
-          var prevEditableTableBodyRow = this._getTableBodyRow(prevEditableRowIdx);
-          if (prevEditableTableBodyRow != null) {
-            this._queueTask(
-              function () {
-                // re-render the previously editable row, which will be read-only now
-                return this._refreshRow(prevEditableRowIdx, false);
-              }.bind(this)
-            );
-          }
-        }
+        this._queueTask(
+          function () {
+            // clear out the old editable row
+            // make sure the row still exists before we refresh it
+            var prevEditableRowIdx = this._getRowIdxForRowKey(prevEditableRowKey);
+            if (prevEditableRowIdx != null) {
+              // re-render the previously editable row, which will be read-only now
+              return this._refreshRow(prevEditableRowIdx, false);
+            }
+            return Promise.resolve();
+          }.bind(this)
+        );
       }
     }
     return undefined;
@@ -19805,6 +19801,7 @@ var __oj_table_metadata =
           return Promise.all(addRowAcceptPromiseArray).then(
             function () {
               this._removeSkeletonRow(-1);
+              this._isAddRowRendered = false;
               return this._refreshAddNewRowPlaceholder().then(
                 function () {
                   let placeHolderRow = this._getPlaceHolderRow();
@@ -19823,6 +19820,7 @@ var __oj_table_metadata =
         }.bind(this)
       );
     } else {
+      this._isAddRowRendered = false;
       this._refreshAddNewRowPlaceholder().then(
         function () {
           let placeHolderRow = this._getPlaceHolderRow();

package/dist/js/libs/oj/debug/ojtimeline-toolkit.js

@@ -1873,27 +1873,39 @@ define(['exports', 'ojs/ojdvt-toolkit', 'ojs/ojdvt-timecomponent', 'ojs/ojtimeax
       if (discreteNavMode) {
         var navButtonBackgroundWidth = DvtTimelineStyleUtils.getNavButtonBackgroundWidth();
         edgeOffset = navButtonBackgroundWidth - padding;
-        var viewportIndexScroll = Math.floor(
-          (itemStartTime - timeline._viewStartTime) / timeline._initialViewportTimeDuration
+        var viewportDates = timeline.getDiscreteViewportDateOffsetPos(
+          timeline._discreteViewportCurrentIndexOffset
         );
-        var discreteViewportOffsetPos =
-          timeline.getDiscreteViewportDateOffsetPos(viewportIndexScroll);
-        startTime = discreteViewportOffsetPos.startDate;
-        endTime = discreteViewportOffsetPos.endDate;
+        startTime = viewportDates.startDate;
+        endTime = viewportDates.endDate;
       } else {
         edgeOffset = -padding;
         startTime = timeline._start;
         endTime = timeline._end;
       }
+      var availableWidthInside = this.getAvailableContentWidth();
+      // For items outside of visible viewport in discrete nav mode, we don't really care how we render them.
+      // For simplicity and to avoid needing to figure out the discrete nav page index for every item,
+      // return the inside width, so that content remain inside the bubble
+      // and that there's no overflow that may interfere with the stuff in the visible viewport.
+      // Note we can't return 0; it would be logical, but
+      // timeline can't handle 0 width content at the moment.
+      if (discreteNavMode && (itemEndTime < startTime || itemStartTime > endTime)) {
+        return Math.floor(availableWidthInside);
+      }
+
       var startLoc = timeline.getDatePos(startTime);
       var endLoc = timeline.getDatePos(endTime);
-      var availableWidthInside =
-        timeline.getDatePos(itemEndTime) - timeline.getDatePos(itemStartTime);
+
       var contentBubbleSpacing = DvtTimelineStyleUtils.getContentBubbleSpacing();
-      var availableWidthLeft =
-        timeline.getDatePos(itemStartTime) - contentBubbleSpacing - startLoc + edgeOffset;
-      var availableWidthRight =
-        endLoc - timeline.getDatePos(itemEndTime) - contentBubbleSpacing + edgeOffset;
+      var availableWidthLeft = Math.max(
+        0,
+        timeline.getDatePos(itemStartTime) - startLoc - contentBubbleSpacing + edgeOffset
+      );
+      var availableWidthRight = Math.max(
+        0,
+        endLoc - timeline.getDatePos(itemEndTime) - contentBubbleSpacing + edgeOffset
+      );
       return Math.floor(Math.max(availableWidthInside, availableWidthLeft, availableWidthRight));
     }
 
@@ -9027,7 +9039,9 @@ define(['exports', 'ojs/ojdvt-toolkit', 'ojs/ojdvt-timecomponent', 'ojs/ojtimeax
         var endTime = item.getEndTime();
         if (endTime && endTime !== startTime) {
           var span = item._timeline.getDatePos(endTime) - loc;
-          loc = loc + Math.min(DvtTimelineStyleUtils.getDurationFeelerOffset(), span / 2);
+          if (item.getItemType() !== DvtTimelineSeriesNode.DURATION_EVENT) {
+            loc = loc + Math.min(DvtTimelineStyleUtils.getDurationFeelerOffset(), span / 2);
+          }
         }
         item.setLoc(loc);
         if (!series._isRandomItemLayout) item.setSpacing(null);
@@ -11912,13 +11926,34 @@ define(['exports', 'ojs/ojdvt-toolkit', 'ojs/ojdvt-timecomponent', 'ojs/ojtimeax
      * Update the viewport when in discrete viewport navigation mode.
      */
     updateDiscreteViewport() {
-      DvtTimelineRenderer._renderAxis(this, this.getTimeZoomCanvas(), true);
-      DvtTimelineRenderer._renderNavigationArrows(this, this.getTimeZoomCanvas());
+      this.prepareViewportLength();
+      var navButtonBackgroundWidth = DvtTimelineStyleUtils.getNavButtonBackgroundWidth();
+      this._timeAxisRatio = (this._canvasLength - 2 * navButtonBackgroundWidth) / this._canvasLength;
+      this._discreteOffset =
+        (this.getContentLength() - this.getContentLength() * this._timeAxisRatio) / 2;
+      this._discreteContentLength = this.getContentLength() * this._timeAxisRatio;
+
+      this.renderTimeZoomCanvas(this._canvas);
+      this.updateSeries();
+      DvtTimelineRenderer._renderAxis(this, this._timeZoomCanvas);
+      DvtTimelineRenderer._renderNavigationArrows(this, this._timeZoomCanvas);
+      this.doInitialPan();
+
       if (this._hasOverview) {
         DvtTimelineRenderer._renderOverview(this);
+        // Reapply selections to overview region
+        if (this.SelectionHandler) {
+          var selection = this.SelectionHandler.getSelectedIds();
+          if (selection && selection.length !== 0) {
+            for (var i = 0; i < selection.length; i++) {
+              this._overview.selSelectItem(selection[i]);
+            }
+          }
+        }
+      }
+      if (this.isTimeDirScrollbarOn() || this.isContentDirScrollbarOn()) {
+        DvtTimelineRenderer._renderScrollbars(this);
       }
-      this.updateSeries();
-      DvtTimelineRenderer._renderScrollbars(this);
     }
 
     /**

package/dist/js/libs/oj/debug_esm/ojconverterutils-i18n.js

@@ -511,11 +511,6 @@ OraI18nUtils.zeroPad = function (str, count, left) {
  * @method getTimeStringFromOffset
  */
 OraI18nUtils.getTimeStringFromOffset = function (prefix, offset, reverseSign, alwaysMinutes) {
-  // when offset is 0 return 'Z' instead of '+00:00'. This is standard practice and is what Java does as well.
-  // This changed in JET v14.0.0.
-  if (offset === 0) {
-    return 'Z';
-  }
   var isNegative = reverseSign ? offset > 0 : offset < 0;
   var absOffset = Math.abs(offset);
   var hours = Math.floor(absOffset / 60);

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

@@ -37,12 +37,12 @@ const oj = {
    * @global
    * @member {string} version JET version numberr
    */
-  version: '14.1.0',
+  version: '14.1.2',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2023-04-06_12-30-15',
+  revision: '2023-05-18_10-18-28',
 
   // 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/ojdiagram-toolkit.js

@@ -5240,15 +5240,16 @@ class DvtDiagramNode extends Container {
       this._containerButton = null;
     }
     if (this._customNodeContent) {
-      if (this._nodeContext) {
-        this._diagram.getOptions()['_cleanTemplate'](this.getId());
-      }
       // reparent child node pane - it is likely to be attached
       // to an element inside of custom content
       if (this._childNodePane) {
         this._childNodePane.setParent(null);
         this.addChild(this._childNodePane);
       }
+      // JET-57658 Need to reparent the child before cleaning the template
+      if (this._nodeContext) {
+        this._diagram.getOptions()['_cleanTemplate'](this.getId());
+      }
       if (this._customNodeContent.namespaceURI === ToolkitUtils.SVG_NS) {
         this.getContainerElem().removeChild(this._customNodeContent);
         saveContainer &&