@oracle/oraclejet 14.0.8 → 14.0.10

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/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.0.8',
+  version: '14.0.10',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2023-04-17_09-28-22',
+  revision: '2023-05-08_10-47-40',
 
   // 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 &&

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

@@ -465,64 +465,50 @@ class FlattenedTreeDataProviderView {
     }
     _calculateItemIndex(parentKey, addEvent, index) {
         var _a, _b;
-        let newIndex;
         if (this._currentSortCriteria) {
             const children = this._getChildrenFromCacheByParentKey(parentKey);
             const sortComparator = SortUtils.getNaturalSortCriteriaComparator(this._currentSortCriteria);
-            const lastChildItem = children[children.length - 1];
-            if (children.length > 0) {
-                if (sortComparator(lastChildItem.data, addEvent.data[index]) >= 0) {
-                    for (let i = 0; i < children.length; i++) {
-                        if (sortComparator(addEvent.data[index], children[i].data) < 0) {
-                            newIndex = this._getItemIndexByKey(children[i].metadata.key) - 1;
-                            break;
-                        }
-                    }
+            for (let i = 0; i < children.length; i++) {
+                if (sortComparator(addEvent.data[index], children[i].data) < 0) {
+                    return this._getItemIndexByKey(children[i].metadata.key);
                 }
-                else {
-                    newIndex =
-                        this._getItemIndexByKey(lastChildItem.metadata.key) +
-                            this._getLocalDescendentCount(lastChildItem.metadata.key) +
-                            1;
-                }
-            }
-            else {
-                newIndex = this._getItemIndexByKey(parentKey);
             }
+            return this._getOOBInsertIndex(parentKey);
         }
         else {
             if (((_a = addEvent === null || addEvent === void 0 ? void 0 : addEvent.addBeforeKeys) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-                if (parentKey === null) {
-                    const beforeKey = addEvent.addBeforeKeys[index];
-                    if (beforeKey !== null) {
-                        let beforeIndex = this._getItemIndexByKey(addEvent.addBeforeKeys[index]);
-                        newIndex = beforeIndex - 1;
-                    }
-                    else {
-                        newIndex = this._cache.length;
-                    }
-                }
-                else {
-                    const parentIndex = this._getItemIndexByKey(parentKey);
-                    newIndex = parentIndex + this._getLocalDescendentCount(parentKey);
-                    if (newIndex === this._cache.length - 1) {
-                        newIndex += 1;
-                    }
+                const beforeKey = addEvent.addBeforeKeys[index];
+                const beforeKeyItemIndex = beforeKey === null ? -1 : this._getItemIndexByKey(beforeKey);
+                if (beforeKeyItemIndex === -1) {
+                    return this._getOOBInsertIndex(parentKey);
                 }
+                return beforeKeyItemIndex;
             }
             else if (((_b = addEvent === null || addEvent === void 0 ? void 0 : addEvent.indexes) === null || _b === void 0 ? void 0 : _b.length) > 0) {
-                const parentIndex = this._getItemIndexByKey(parentKey);
-                newIndex =
-                    parentIndex === -1
-                        ? addEvent.indexes[index] + 1
-                        : parentIndex + this._getLocalDescendentCount(parentKey) + 1;
+                const indexFromParent = addEvent.indexes[index];
+                const children = this._getChildrenFromCacheByParentKey(parentKey);
+                if (indexFromParent === null || indexFromParent > children.length) {
+                    return this._getOOBInsertIndex(parentKey);
+                }
+                if (indexFromParent === 0) {
+                    return this._getItemIndexByKey(parentKey) + 1;
+                }
+                return (this._getItemIndexByKey(children[indexFromParent - 1].metadata.key) +
+                    this._getLocalDescendentCount(children[indexFromParent - 1].metadata.key) +
+                    1);
             }
             else {
-                newIndex =
-                    this._getItemIndexByKey(this._getLastItemByParentKey(parentKey).metadata.key) + 1;
+                return this._getOOBInsertIndex(parentKey);
             }
         }
-        return newIndex;
+    }
+    _getOOBInsertIndex(parentKey) {
+        if (this._mapParentKeyToInfo.get(parentKey).done) {
+            return this._getItemIndexByKey(parentKey) + this._getLocalDescendentCount(parentKey) + 1;
+        }
+        else {
+            return null;
+        }
     }
     _incrementIndexFromParent(newIndex, depth) {
         const lastIndex = this._getLastIndex();
@@ -572,17 +558,24 @@ class FlattenedTreeDataProviderView {
                     (!this._currentFilterCriteria ||
                         (this._currentFilterCriteria &&
                             this._currentFilterCriteria.filter(addEvent.data[index])))) {
-                    let newIndex = this._calculateItemIndex(parentKey, addEvent, index);
-                    const item = this._updateItemMetadata(new this.Item(this, addEvent.metadata[index], addEvent.data[index]), parentKey, addEvent.indexes[index]);
-                    this._spliceItemToCache(item, newIndex);
-                    this._incrementIndexFromParent(newIndex + 1, item.metadata.treeDepth);
-                    addDataArray.push(item.data);
-                    addMetadataArray.push(item.metadata);
-                    addIndexArray.push(newIndex + 1);
-                    addParentKeys.push(parentKey);
-                    addKeySet.add(addEvent.metadata[index].key);
-                    addBeforeKeys.push(this._getKeyByIndex(newIndex + 2));
-                    this._incrementIteratorOffset(newIndex + 1);
+                    const newIndex = this._calculateItemIndex(parentKey, addEvent, index);
+                    if (newIndex != null) {
+                        const lastIndex = this._getLastIndex();
+                        if (newIndex > lastIndex) {
+                            this._mapParentKeyToInfo.set(parentKey, { done: false });
+                        }
+                        const indexFromParent = (addEvent === null || addEvent === void 0 ? void 0 : addEvent.indexes) ? addEvent.indexes[index] : null;
+                        const item = this._updateItemMetadata(new this.Item(this, addEvent.metadata[index], addEvent.data[index]), parentKey, indexFromParent);
+                        this._cache.splice(newIndex, 0, item);
+                        this._incrementIndexFromParent(newIndex, item.metadata.treeDepth);
+                        addDataArray.push(item.data);
+                        addMetadataArray.push(item.metadata);
+                        addIndexArray.push(newIndex);
+                        addParentKeys.push(parentKey);
+                        addKeySet.add(addEvent.metadata[index].key);
+                        addBeforeKeys.push(this._getKeyByIndex(newIndex + 1));
+                        this._incrementIteratorOffset(newIndex);
+                    }
                 }
                 else {
                     this._mapParentKeyToInfo.delete(parentKey);
@@ -658,6 +651,7 @@ class FlattenedTreeDataProviderView {
                 const item = this._cache[i];
                 if (keys.has(item.metadata.key)) {
                     this._mapParentKeyToInfo.delete(item.metadata.key);
+                    this._markParentsAsNotDone(item);
                     const refreshEvent = new DataProviderRefreshEvent(new this.DataProviderRefreshEventDetail(item.metadata.key));
                     const removedItems = this._cache.splice(i + 1, this._cache.length);
                     removedItems.forEach((item) => {
@@ -674,6 +668,16 @@ class FlattenedTreeDataProviderView {
             this.dispatchEvent(new DataProviderRefreshEvent());
         }
     }
+    _markParentsAsNotDone(item) {
+        const parentKey = item.metadata.parentKey;
+        if (this._mapParentKeyToInfo.has(parentKey)) {
+            this._mapParentKeyToInfo.set(parentKey, { done: false });
+        }
+        if (parentKey === null) {
+            return;
+        }
+        this._markParentsAsNotDone(this._getItemByKey(parentKey));
+    }
     _getExpandedObservableValue(expanded, completionPromise) {
         return {
             value: expanded,
@@ -1089,9 +1093,6 @@ class FlattenedTreeDataProviderView {
                 this._getLocalDescendentCount(lastEntry.metadata.key);
         this._cache.splice(index + 1, 0, item);
     }
-    _spliceItemToCache(item, index) {
-        this._cache.splice(index + 1, 0, item);
-    }
     _removeKeysNotInCache(keysToExpand) {
         const keysInCache = new Set();
         keysToExpand.forEach((key) => {
@@ -1168,6 +1169,9 @@ class FlattenedTreeDataProviderView {
         return this._cache.length - 1;
     }
     _getLocalDescendentCount(key) {
+        if (key === null) {
+            return this._cache.length;
+        }
         const item = this._getItemByKey(key);
         let count = 0;
         if (item != null) {