@oracle/oraclejet 14.0.9 → 14.0.11

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

@@ -2145,6 +2145,7 @@ var __oj_table_metadata =
     this._isEditPending = null;
     this._active = null;
     this._isTableTab = null;
+    this._isAddRowRendered = false;
     this._renderedTableHeaderColumns = false;
 
     // clear any pending timeouts
@@ -2442,6 +2443,7 @@ var __oj_table_metadata =
     if (contextMenu != null && contextMenu !== this._getContextMenuElement()) {
       this._createContextMenuContainer();
     }
+    this._isAddRowRendered = false;
     this._clearLayoutManager();
     this._clearCachedDom();
     this._clearCachedStyling();
@@ -2843,13 +2845,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) {
@@ -3180,117 +3176,121 @@ 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];
+          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
+            }
           }
-          for (let i = 0; i < cellContent.length; i++) {
-            addRowCell.appendChild(cellContent[i]);
+          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];
+          }
+        } 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);
   };
@@ -5961,6 +5961,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);
@@ -19544,8 +19545,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()) {
@@ -19628,17 +19629,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();
@@ -19652,24 +19651,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;
@@ -19708,19 +19705,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;
@@ -19752,6 +19748,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();
@@ -19770,6 +19767,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_esm/ojcore-base.js

@@ -37,12 +37,12 @@ const oj = {
    * @global
    * @member {string} version JET version numberr
    */
-  version: '14.0.9',
+  version: '14.0.11',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2023-04-28_10-06-48',
+  revision: '2023-05-19_09-44-29',
 
   // 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/ojdatetimepicker.js

@@ -4240,6 +4240,8 @@ oj.__registerWidget('oj.ojInputDate', $.oj.inputBase, {
     if (value) {
       // need to preserve the time portion when of ojInputDateTime, so update only year, month, and date
       try {
+        // After this method call the value is a local datetime. no offset, no zulu. It will get converted
+        // back in the switchDone method when the user clicks the Done button or closes the picker.
         value = converterUtils._dateTime(value, {
           fullYear: tempDate.getFullYear(),
           month: tempDate.getMonth(),
@@ -6284,6 +6286,13 @@ oj.__registerWidget('oj.ojInputDate', $.oj.inputBase, {
     }
   },
 
+  _createOffsetConverter: function (inputConverter) {
+    var resolvedOptions = inputConverter.resolvedOptions();
+    var options = {};
+    $.extend(options, resolvedOptions, { isoStrFormat: 'offset' });
+    return new IntlDateTimeConverter(options);
+  },
+
   /**
    * TODO: Technically i think should be used for the calendar, but later since late in release
    * @ignore
@@ -6421,7 +6430,22 @@ oj.__registerWidget('oj.ojInputDate', $.oj.inputBase, {
 
     var converter = this._GetConverter();
     if (!(converter instanceof Promise)) {
-      this._switcherPrevValue = converter.parse(this._getDateIso());
+      // switcherPrevValue is used as the base value where the new day, month and/or year is substituted into
+      // when the user selects a new day, month, and/or year. (See the switchDone method for details)
+      // switcherPrevValue can't be zulu, because if it is zulu,
+      // then substituting the day into a zulu date might be a different day in the timezone and then the formatted
+      // date will be a different day than what the user selected. (See JET-54551)
+      // So if it is zulu we change it to offset.
+      // This is what a zulu and offset format looks like
+      // zulu: 2013-12-13T04:00:00Z
+      // offset: 2013-12-01T20:00:00-08:00
+      const dateIso = this.options.value ? this._getDateIso() : '';
+      if (dateIso && IntlConverterUtils._getISOStrFormatType(dateIso) === 'zulu') {
+        const offsetConverter = this._createOffsetConverter(converter);
+        this._switcherPrevValue = offsetConverter.parse(dateIso);
+      } else {
+        this._switcherPrevValue = converter.parse(dateIso);
+      }
     } else {
       this._switcherPrevValue = this._getDateIso();
     }
@@ -12340,10 +12364,12 @@ oj.__registerWidget('oj.ojInputDateTime', $.oj.ojInputDate, {
               ($.ui.keyCode.ENTER === keyCode || $.ui.keyCode.SPACE === keyCode)) ||
             evt.type === 'click'
           ) {
-            var formattedValue = self._GetConverter().format(self._getDateIso());
-            var newVal = self._GetConverter().parse(formattedValue);
+            var newVal;
             if (self._switcherDateValue) {
               newVal = self._switcherDateValue;
+            } else {
+              var formattedValue = self._GetConverter().format(self._getDateIso());
+              newVal = self._GetConverter().parse(formattedValue);
             }
 
             if (self._switcherTimeValue) {
@@ -13074,20 +13100,6 @@ oj.__registerWidget('oj.ojInputDateTime', $.oj.ojInputDate, {
    */
   _ShowHTMLDatePicker: function () {
     var retVal = this._superApply(arguments);
-
-    // if there is a value, save the Iso date version as the default value. Otherwise, set to ""
-    // so that we correctly restore the empty string if there is no value.
-
-    var converter = this._GetConverter();
-    if (!(converter instanceof Promise)) {
-      this._switcherPrevValue = converter.parse(this.options.value ? this._getDateIso() : '');
-    } else {
-      this._switcherPrevValue = this.options.value ? this._getDateIso() : '';
-    }
-    this._switcherPrevDay = this._currentDay;
-    this._switcherPrevMonth = this._currentMonth;
-    this._switcherPrevYear = this._currentYear;
-
     this._updateSwitcherText();
     return retVal;
   },

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 &&