@oracle/oraclejet 10.0.3 → 10.0.7

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

@@ -2379,8 +2379,6 @@ Table.prototype._refreshTableBody = function (resultObject, startIndex, keepVisi
   if (rows.length === 0 && tableBodyRows.length === 0) {
     this._showNoDataMessage();
   } else {
-    var tableBodyDocFrag;
-
     // for the pre-fetching case, we'll render items during idle cycles
     // don't do it when the scroll is caused by handling scroll position
     if (startIndex > 0 && this._isOverflow() && !this._fetchBySyncScroll) {
@@ -2392,6 +2390,8 @@ Table.prototype._refreshTableBody = function (resultObject, startIndex, keepVisi
           resultObject.isMouseWheel);
       }.bind(this));
     }
+    var layoutManager = this._getLayoutManager();
+    var tableBodyDocFrag = document.createDocumentFragment();
 
     var rowsCount = rows.length;
     if (this._animateOnFetch && this._IsCustomElement()) {
@@ -2400,20 +2400,25 @@ Table.prototype._refreshTableBody = function (resultObject, startIndex, keepVisi
       var rowIdxArray = [];
       for (i = 0; i < rowsCount; i++) {
         rowIdxArray.push(rows[i].rowIdx);
-        addedTableBodyRows.push(this._addSingleTableBodyRow(rows[i].rowIdx, rows[i].row));
+        addedTableBodyRows.push(
+          this._addSingleTableBodyRow(rows[i].rowIdx, rows[i].row,
+                                      tableBodyDocFrag, startIndex));
       }
+      layoutManager.handleAfterRowsProcessed(tableBodyDocFrag);
+      tableBody.appendChild(tableBodyDocFrag); // @HTMLUpdateOK
+      this._clearCachedDomRowData();
       return this._animateVisibleRows(addedTableBodyRows, rowIdxArray, 'add').then(function () {
-        return this._finalizeBodyRowRendering(addedTableBodyRows);
+        return this._afterRowsRendered(tableBody);
       }.bind(this));
     }
     this._animateOnFetch = false;
     if (!keepVisible) {
       tableBody.style[Table.CSS_PROP._VISIBILITY] = Table.CSS_VAL._HIDDEN;
     }
-    tableBodyDocFrag = document.createDocumentFragment();
     for (i = 0; i < rowsCount; i++) {
       this._renderRow(rows[i], tableBodyDocFrag, startIndex);
     }
+    layoutManager.handleAfterRowsProcessed(tableBodyDocFrag);
     tableBody.appendChild(tableBodyDocFrag); // @HTMLUpdateOK
     return this._afterRowsRendered(tableBody);
   }
@@ -5751,6 +5756,13 @@ const TableLayoutManager = function (table) {
 oj.Object.createSubclass(TableLayoutManager, oj.Object, 'TableLayoutManager');
 
 
+/**
+ * @private
+ */
+TableLayoutManager.prototype.unregisterListeners = function () {
+  this.unregisterScrollListeners();
+};
+
 /**
  * @private
  */
@@ -5846,17 +5858,11 @@ TableLayoutManager.prototype._finalizeTableDimensions = function (scrollTop, scr
       // Do not set to maxScrollTop or we will cause another fetch
       newScrollTop -= 1;
     }
-    // set flag so that scroll() will not cause an scrollPosition update
-    this._table._skipScrollUpdate = true;
     this.getScroller().scrollTop = newScrollTop;
-    $(this.getScroller()).scroll();
   }
 
   if (scrollLeft != null) {
-    // set flag so that scroll() will not cause an scrollPosition update
-    this._table._skipScrollUpdate = true;
-    setScrollLeft(this.getScroller(), scrollLeft);
-    $(this.getScroller()).scroll();
+    this._restoreScrollLeft(scrollLeft);
   }
 
   // cache the final dimensions
@@ -5866,6 +5872,7 @@ TableLayoutManager.prototype._finalizeTableDimensions = function (scrollTop, scr
 
   this._clearTableUpdates();
   this._enableTableVisibility();
+  this.registerScrollListeners();
 };
 
 /**
@@ -5876,12 +5883,96 @@ TableLayoutManager.prototype.handleAfterRowsProcessed = function () { };
 /**
  * @private
  */
-TableLayoutManager.prototype.handleScrollerScrollLeft = function () { };
+TableLayoutManager.prototype._handleScrollerScrollLeft = function (scrollLeft) {
+  this._table._scrollLeft = scrollLeft;
+};
+
+/**
+ * Handle scrollTop on scroller
+ * @private
+ */
+TableLayoutManager.prototype._handleScrollerScrollTop = function (scrollTop) {
+  // if no domScroller is set, make sure scroll pos busy state is cleared here
+  if (!this._table._domScroller) {
+    this._table._clearScrollPosBusyState();
+  }
+  if (scrollTop < 0) {
+    // eslint-disable-next-line no-param-reassign
+    scrollTop = 0;
+  }
+  this._table._scrollTop = scrollTop;
+  // keep track when scrollTop is triggered internally (syncScrollPosition)
+  this._table._scrollY = this._table._skipScrollUpdate ? scrollTop : null;
+
+  // update mobile touch selection affordance if present
+  this._table._moveTableBodyRowTouchSelectionAffordanceTop();
+  this._table._moveTableBodyRowTouchSelectionAffordanceBottom();
+};
+
+/**
+ * @private
+ */
+TableLayoutManager.prototype.registerScrollListeners = function () {
+  var scroller = this.getScroller();
+  if (scroller != 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;
+        if (newScrollLeft === this._table._scrollLeft && newScrollTop === this._table._scrollTop) {
+          // discard bogus scroll event
+          return;
+        }
+
+        this._handleScrollerScrollLeft(newScrollLeft);
+        this._handleScrollerScrollTop(newScrollTop);
+
+        // do not update scrollPosition if we are already adjusting
+        if (this._table._isScrollPositionAdjusted()) {
+          return;
+        }
+
+        if (!this._table._skipScrollUpdate && !this._ticking) {
+          window.requestAnimationFrame(function () {
+            // scrollPosition could have been adjusted or a new value is set while waiting for animation frame
+            if (!this._table._isScrollPositionAdjusted() && !this._table._skipScrollUpdate) {
+              this._table.option('scrollPosition', this._table._getCurrentScrollPosition(), {
+                _context: {
+                  originalEvent: event,
+                  internalSet: true
+                }
+              });
+            }
+            this._ticking = false;
+          }.bind(this));
+          this._ticking = true;
+        }
+        this._table._skipScrollUpdate = false;
+      }.bind(this));
+    }
+    // remove the event listener before adding to make sure only one is active at a time
+    scroller.removeEventListener('scroll', this._scrollEventListener);
+    scroller.addEventListener('scroll', this._scrollEventListener, false);
+  }
+};
+
+/**
+ * @private
+ */
+TableLayoutManager.prototype.unregisterScrollListeners = function () {
+  var scroller = this.getScroller();
+  if (scroller != null && this._scrollEventListener != null) {
+    scroller.removeEventListener('scroll', this._scrollEventListener);
+  }
+};
 
 /**
  * @private
  */
-TableLayoutManager.prototype.registerScrollListeners = function () { };
+TableLayoutManager.prototype._restoreScrollLeft = function (scrollLeft) {
+  setScrollLeft(this.getScroller(), scrollLeft);
+};
 
 /**
  * @param {Element} cell
@@ -6133,6 +6224,8 @@ TableLayoutManager.prototype.getClientHeight = function () {
  * @private
  */
 TableLayoutManager.prototype._removeTableDimensionsStyling = function () {
+  this.unregisterScrollListeners();
+
   var tableElem = this._table._getTable();
   var tableHeader = this._table._getTableHeader();
   var tableHeaderRow = this._table._getTableHeaderRow();
@@ -6459,7 +6552,8 @@ TableLegacyLayoutManager.prototype.handleAfterRowsProcessed = function (tableBod
 /**
  * @private
  */
-TableLegacyLayoutManager.prototype.handleScrollerScrollLeft = function (scrollLeft) {
+TableLegacyLayoutManager.prototype._handleScrollerScrollLeft = function (scrollLeft) {
+  TableLegacyLayoutManager.superclass._handleScrollerScrollLeft.call(this, scrollLeft);
   var tableHeaderRow = this._table._getTableHeaderRow();
   if (tableHeaderRow) {
     setScrollLeft(tableHeaderRow.parentNode, scrollLeft);
@@ -6474,12 +6568,14 @@ TableLegacyLayoutManager.prototype.handleScrollerScrollLeft = function (scrollLe
  * @private
  */
 TableLegacyLayoutManager.prototype.registerScrollListeners = function () {
+  TableLegacyLayoutManager.superclass.registerScrollListeners.call(this);
+
   // although header region does not contain scrollbars, browser may auto-scroll when contents gain focus
   var tableHeaderRow = this._table._getTableHeaderRow();
   if (tableHeaderRow != null) {
     var tableHeader = tableHeaderRow.parentNode;
-    if (this._table._headerScrollEventListener == null) {
-      this._table._headerScrollEventListener = (function (event) {
+    if (this._headerScrollEventListener == null) {
+      this._headerScrollEventListener = (function (event) {
         var scrollLeft = this._table._getElementScrollLeft(event.target);
         if (this._table._scrollLeft !== scrollLeft) {
           this._table._setScrollX(scrollLeft);
@@ -6487,8 +6583,58 @@ TableLegacyLayoutManager.prototype.registerScrollListeners = function () {
       }.bind(this));
     }
     // remove the event listener before adding to make sure only one is active at a time
-    tableHeader.removeEventListener('scroll', this._table._headerScrollEventListener);
-    tableHeader.addEventListener('scroll', this._table._headerScrollEventListener, false);
+    tableHeader.removeEventListener('scroll', this._headerScrollEventListener);
+    tableHeader.addEventListener('scroll', this._headerScrollEventListener, false);
+  }
+  // although footer region does not contain scrollbars, browser may auto-scroll when contents gain focus
+  var tableFooterRow = this._table._getTableFooterRow();
+  if (tableFooterRow != null) {
+    var tableFooter = tableFooterRow.parentNode;
+    if (this._footerScrollEventListener == null) {
+      this._footerScrollEventListener = (function (event) {
+        var scrollLeft = this._table._getElementScrollLeft(event.target);
+        if (this._table._scrollLeft !== scrollLeft) {
+          this._table._setScrollX(scrollLeft);
+        }
+      }.bind(this));
+    }
+    // remove the event listener before adding to make sure only one is active at a time
+    tableFooter.removeEventListener('scroll', this._footerScrollEventListener);
+    tableFooter.addEventListener('scroll', this._footerScrollEventListener, false);
+  }
+};
+
+/**
+ * @private
+ */
+TableLegacyLayoutManager.prototype.unregisterScrollListeners = function () {
+  TableLegacyLayoutManager.superclass.unregisterScrollListeners.call(this);
+
+  var tableHeaderRow = this._table._getTableHeaderRow();
+  if (tableHeaderRow != null && this._headerScrollEventListener != null) {
+    var tableHeader = tableHeaderRow.parentNode;
+    tableHeader.removeEventListener('scroll', this._headerScrollEventListener);
+  }
+
+  var tableFooterRow = this._table._getTableFooterRow();
+  if (tableFooterRow != null && this._footerScrollEventListener != null) {
+    var tableFooter = tableFooterRow.parentNode;
+    tableFooter.removeEventListener('scroll', this._footerScrollEventListener);
+  }
+};
+
+/**
+ * @private
+ */
+TableLegacyLayoutManager.prototype._restoreScrollLeft = function (scrollLeft) {
+  setScrollLeft(this.getScroller(), scrollLeft);
+  var tableHeaderRow = this._table._getTableHeaderRow();
+  if (tableHeaderRow) {
+    setScrollLeft(tableHeaderRow.parentNode, scrollLeft);
+  }
+  var tableFooterRow = this._table._getTableFooterRow();
+  if (tableFooterRow) {
+    setScrollLeft(tableFooterRow.parentNode, scrollLeft);
   }
 };
 
@@ -6537,17 +6683,20 @@ TableLegacyLayoutManager.prototype._freezeColumnWidths = function (fragment) {
   var columns = this._table._getColumnDefs();
   var columnsCount = columns.length;
 
-  var tableBodyCell;
   if (!this._frozenWidthRows) {
     this._frozenWidthRows = [];
   }
 
   var minWidths = [];
   for (var i = 0; i < columnsCount; i++) {
-    tableBodyCell = this._table._getTableBodyCell(0, i, null);
-    var minWidth = parseFloat(tableBodyCell.style[Table.CSS_PROP._MIN_WIDTH]);
-    if (!isNaN(minWidth)) {
-      minWidths.push(minWidth);
+    var tableBodyCell = this._table._getTableBodyCell(0, i, null);
+    if (tableBodyCell != null) {
+      var minWidth = parseFloat(tableBodyCell.style[Table.CSS_PROP._MIN_WIDTH]);
+      if (!isNaN(minWidth)) {
+        minWidths.push(minWidth);
+      } else {
+        minWidths.push(null);
+      }
     } else {
       minWidths.push(null);
     }
@@ -8025,7 +8174,8 @@ Table.prototype._executeTableBodyRowsAdd = function (eventDetail) {
         }
         return undefined;
       }
-      this._getLayoutManager().notifyTableUpdate(Table._UPDATE._ROWS_ADDED);
+      var layoutManager = this._getLayoutManager();
+      layoutManager.notifyTableUpdate(Table._UPDATE._ROWS_ADDED);
 
       // see if we should batch add
       // only batch if we are adding a block of contiguous rows
@@ -8034,6 +8184,9 @@ Table.prototype._executeTableBodyRowsAdd = function (eventDetail) {
       var rowIdxArray = [];
       var i;
       var rowsCount;
+      var tableBodyDocFrag;
+      var tableBodyRowBefore;
+      var tableBody = this._getTableBody();
 
       if (rows.length > 1) {
         rowsCount = rows.length;
@@ -8048,8 +8201,7 @@ Table.prototype._executeTableBodyRowsAdd = function (eventDetail) {
         }
 
         if (isContiguous) {
-          var tableBody = this._getTableBody();
-          var tableBodyDocFrag = document.createDocumentFragment();
+          tableBodyDocFrag = document.createDocumentFragment();
           rowsCount = rows.length;
           for (i = 0; i < rowsCount; i++) {
             addedTableBodyRows.push(this._addSingleTableBodyRow(rows[i].rowIdx,
@@ -8057,18 +8209,13 @@ Table.prototype._executeTableBodyRowsAdd = function (eventDetail) {
                                                                 tableBodyDocFrag,
                                                                 rows[0].rowIdx));
           }
-          if (rows[0].rowIdx === 0) {
-            tableBody.insertBefore(tableBodyDocFrag, tableBody.firstChild); // @HTMLUpdateOK
+          layoutManager.handleAfterRowsProcessed(tableBodyDocFrag);
+          tableBodyRowBefore = this._getTableBodyRow(rows[0].rowIdx);
+          if (tableBodyRowBefore != null) {
+            tableBody.insertBefore(tableBodyDocFrag, tableBodyRowBefore);// @HTMLUpdateOK
           } else {
-            var tableBodyRowBefore = this._getTableBodyRow(rows[0].rowIdx);
-            if (tableBodyRowBefore != null) {
-              tableBody.insertBefore(tableBodyDocFrag, tableBodyRowBefore);// @HTMLUpdateOK
-            } else {
-              tableBody.appendChild(tableBodyDocFrag, null);// @HTMLUpdateOK
-            }
+            tableBody.appendChild(tableBodyDocFrag, null);// @HTMLUpdateOK
           }
-          this._clearCachedDomRowData();
-          subtreeAttached(tableBody);
           batchAdd = true;
         }
       }
@@ -8076,7 +8223,17 @@ Table.prototype._executeTableBodyRowsAdd = function (eventDetail) {
       if (!batchAdd) {
         rowsCount = rows.length;
         for (i = 0; i < rowsCount; i++) {
-          addedTableBodyRows.push(this._addSingleTableBodyRow(rows[i].rowIdx, rows[i].row));
+          var rowIndex = rows[i].rowIdx;
+          tableBodyDocFrag = document.createDocumentFragment();
+          addedTableBodyRows.push(this._addSingleTableBodyRow(rowIndex, rows[i].row,
+                                                              tableBodyDocFrag, rowIndex));
+          layoutManager.handleAfterRowsProcessed(tableBodyDocFrag);
+          tableBodyRowBefore = this._getTableBodyRow(rowIndex);
+          if (tableBodyRowBefore != null) {
+            tableBody.insertBefore(tableBodyDocFrag, tableBodyRowBefore);// @HTMLUpdateOK
+          } else {
+            tableBody.appendChild(tableBodyDocFrag, null);// @HTMLUpdateOK
+          }
         }
       }
       this._clearCachedDomRowData();
@@ -8089,10 +8246,10 @@ Table.prototype._executeTableBodyRowsAdd = function (eventDetail) {
       }
       if (this._IsCustomElement()) {
         return this._animateVisibleRows(addedTableBodyRows, rowIdxArray, 'add').then(function () {
-          return this._finalizeBodyRowRendering(addedTableBodyRows);
+          return this._afterRowsRendered(tableBody);
         }.bind(this));
       }
-      return this._finalizeBodyRowRendering(addedTableBodyRows);
+      return this._afterRowsRendered(tableBody);
     }.bind(this));
   }
 };
@@ -9501,9 +9658,6 @@ Table.prototype._getTableBody = function () {
  */
 Table.prototype._getTableBodyCell = function (rowIdx, columnIdx, tableBodyRow) {
   var tableBodyCells = this._getTableBodyCells(rowIdx, tableBodyRow);
-  if (!tableBodyCells) {
-    return null;
-  }
 
   if (tableBodyCells.length > columnIdx) {
     return tableBodyCells[columnIdx];
@@ -9521,9 +9675,6 @@ Table.prototype._getTableBodyCell = function (rowIdx, columnIdx, tableBodyRow) {
  */
 Table.prototype._getTableBodyLogicalCells = function (rowIdx, tableBodyRow) {
   var tableBodyCells = this._getTableBodyCells(rowIdx, tableBodyRow);
-  if (!tableBodyCells) {
-    return null;
-  }
 
   return this._getColspanLogicalElements(tableBodyCells);
 };
@@ -9539,20 +9690,11 @@ Table.prototype._getTableBodyCells = function (rowIdx, tableBodyRow) {
   if (!tableBodyRow) {
     // eslint-disable-next-line no-param-reassign
     tableBodyRow = this._getTableBodyRow(rowIdx);
+    if (!tableBodyRow) {
+      return [];
+    }
   }
-
-  if (!tableBodyRow) {
-    return null;
-  }
-
-  var tableBodyCellElements = this._getTableElementsByClassName(tableBodyRow,
-    Table.CSS_CLASSES._TABLE_DATA_CELL_CLASS);
-
-  if (tableBodyCellElements.length > 0) {
-    return tableBodyCellElements;
-  }
-
-  return null;
+  return this._getTableElementsByClassName(tableBodyRow, Table.CSS_CLASSES._TABLE_DATA_CELL_CLASS);
 };
 
 /**
@@ -12916,9 +13058,6 @@ Table.prototype._setCellInRowFocus = function (rowIdx, columnIdx, forwardSearch)
     return;
   }
   var tableBodyCells = this._getTableBodyCells(rowIdx);
-  if (!tableBodyCells) {
-    return;
-  }
 
   var tableBodyCellsCount = tableBodyCells.length;
   for (var i = 0; i < tableBodyCellsCount; i++) {
@@ -13216,9 +13355,10 @@ Table.prototype._updateColumnStateCellsClass = function (columnIdx, selected) {
  */
 Table.prototype._updateRowStateCellsClass = function (rowIdx, state) {
   var tableBodyCells = this._getTableBodyCells(rowIdx);
-  if (!tableBodyCells) {
+  if (tableBodyCells.length === 0) {
     return;
   }
+
   if (this._isDefaultSelectorEnabled()) {
     var tableBodyRow = this._getTableBodyRow(rowIdx);
     var selectorCell = this._getTableBodySelectorCell(tableBodyRow);
@@ -13923,86 +14063,12 @@ Table.prototype._findClosestElementToTop = function (scrollPosition, currScrollT
   return result;
 };
 
-/**
- * Handle scrollLeft on scroller
- * @private
- */
-Table.prototype._handleScrollerScrollLeft = function (scrollLeft) {
-  this._scrollLeft = scrollLeft;
-  this._getLayoutManager().handleScrollerScrollLeft(scrollLeft);
-};
-
-/**
- * Handle scrollTop on scroller
- * @private
- */
-Table.prototype._handleScrollerScrollTop = function (scrollTop) {
-  // if no domScroller is set, make sure scroll pos busy state is cleared here
-  if (!this._domScroller) {
-    this._clearScrollPosBusyState();
-  }
-  if (scrollTop < 0) {
-    // eslint-disable-next-line no-param-reassign
-    scrollTop = 0;
-  }
-  this._scrollTop = scrollTop;
-  // keep track when scrollTop is triggered internally (syncScrollPosition)
-  this._scrollY = this._skipScrollUpdate ? scrollTop : null;
-
-  // update mobile touch selection affordance if present
-  this._moveTableBodyRowTouchSelectionAffordanceTop();
-  this._moveTableBodyRowTouchSelectionAffordanceBottom();
-};
-
 /**
  * Register event listeners which need to be registered directly on the DOM element.
  * @private
  */
 Table.prototype._registerDomEventListeners = function () {
-  var layoutManager = this._getLayoutManager();
-  var scroller = layoutManager.getScroller();
-  if (scroller != 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._getElementScrollLeft(event.target);
-        var newScrollTop = event.target.scrollTop;
-        if (newScrollLeft === this._scrollLeft && newScrollTop === this._scrollTop) {
-          // discard bogus scroll event
-          return;
-        }
-
-        this._handleScrollerScrollLeft(newScrollLeft);
-        this._handleScrollerScrollTop(newScrollTop);
-
-        // do not update scrollPosition if we are already adjusting
-        if (this._isScrollPositionAdjusted()) {
-          return;
-        }
-
-        if (!this._skipScrollUpdate && !this._ticking) {
-          window.requestAnimationFrame(function () {
-            // scrollPosition could have been adjusted or a new value is set while waiting for animation frame
-            if (!this._isScrollPositionAdjusted() && !this._skipScrollUpdate) {
-              this.option('scrollPosition', this._getCurrentScrollPosition(), {
-                _context: {
-                  originalEvent: event,
-                  internalSet: true
-                }
-              });
-            }
-            this._ticking = false;
-          }.bind(this));
-          this._ticking = true;
-        }
-        this._skipScrollUpdate = false;
-      }.bind(this));
-    }
-    // remove the event listener before adding to make sure only one is active at a time
-    scroller.removeEventListener('scroll', this._scrollEventListener);
-    scroller.addEventListener('scroll', this._scrollEventListener, false);
-  }
-  layoutManager.registerScrollListeners();
+  this._getLayoutManager().registerScrollListeners();
 };
 
 /**
@@ -17112,7 +17178,7 @@ TableFixedLayoutManager.prototype._resetTableElementStyling = function () {
  * @private
  */
 TableFixedLayoutManager.prototype._removeTableDimensionsStyling = function () {
-  // no-op for fixed layout
+  this.unregisterScrollListeners();
 };
 
 /**
@@ -20419,6 +20485,9 @@ Table.prototype._getLayoutManager = function () {
  * @private
  */
 Table.prototype._clearLayoutManager = function () {
+  if (this._layoutManager != null) {
+    this._layoutManager.unregisterListeners();
+  }
   this._layoutManager = null;
 };
 

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

@@ -38,9 +38,35 @@ oj._registerLegacyNamespaceProp('TreeDataProvider', TreeDataProvider);
  *               value: "(parentKey: K): TreeDataProvider<K, D> | null"}
  */
 
- /**
- * Get an asyncIterator which can be used to fetch a block of data.
- *
+/**
+ * Get an AsyncIterable object for iterating the data.
+ * <p>
+ * AsyncIterable contains a Symbol.asyncIterator method that returns an AsyncIterator.
+ * AsyncIterator contains a “next” method for fetching the next block of data.
+ * </p><p>
+ * The "next" method returns a promise that resolves to an object, which contains a "value" property for the data and a "done" property
+ * that is set to true when there is no more data to be fetched.  The "done" property should be set to true only if there is no "value"
+ * in the result.  Note that "done" only reflects whether the iterator is done at the time "next" is called.  Future calls to "next"
+ * may or may not return more rows for a mutable data source.
+ * </p><p>
+ * In order for JET components to work correctly, DataProvider implementations should ensure that:
+ * </p>
+ * <ul>
+ *   <li>
+ *     The iterator accounts for data mutations when returning the next block of data, and that no row is duplicated or skipped.
+ *     For example, an offset-based implementation may need to adjust the offset from which the next block of data starts if rows
+ *     have been added or removed in the returned data.
+ *   </li>
+ *   <li>
+ *     JET components may call "next" on the iterator even after the iterator has returned done:true.  If new data is available after
+ *     the last returned row, the iterator is expected to return the new data and set "done" to false.
+ *     This differs from the AsyncIterator spec for performance reasons.
+ *   </li>
+ * </ul>
+ * <p>
+ * Please see the <a href="DataProvider.html#custom-implementations-section">DataProvider documentation</a> for
+ * more information on custom implementations.
+ * </p>
  *
  * @since 4.2.0
  * @param {FetchListParameters=} params fetch parameters

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

@@ -82,11 +82,42 @@ import ListDataProviderView from 'ojs/ojlistdataproviderview';
  */
 
 /**
- * @inheritdoc
+ * Get an AsyncIterable object for iterating the data.
+ * <p>
+ * AsyncIterable contains a Symbol.asyncIterator method that returns an AsyncIterator.
+ * AsyncIterator contains a “next” method for fetching the next block of data.
+ * </p><p>
+ * The "next" method returns a promise that resolves to an object, which contains a "value" property for the data and a "done" property
+ * that is set to true when there is no more data to be fetched.  The "done" property should be set to true only if there is no "value"
+ * in the result.  Note that "done" only reflects whether the iterator is done at the time "next" is called.  Future calls to "next"
+ * may or may not return more rows for a mutable data source.
+ * </p>
+ * <p>
+ * Please see the <a href="DataProvider.html#custom-implementations-section">DataProvider documentation</a> for
+ * more information on custom implementations.
+ * </p>
+ *
+ * @param {FetchListParameters=} params fetch parameters
+ * @return {AsyncIterable.<FetchListResult>} AsyncIterable with {@link FetchListResult}
+ * @see {@link https://github.com/tc39/proposal-async-iteration} for further information on AsyncIterable.
+ * @export
+ * @expose
  * @memberof TreeDataProviderView
  * @instance
  * @method
  * @name fetchFirst
+ * @ojsignature {target: "Type",
+ *               value: "(parameters?: FetchListParameters<D>): AsyncIterable<FetchListResult<K, D>>"}
+ * @ojtsexample <caption>Get an asyncIterator and then fetch first block of data by executing next() on the iterator. Subsequent blocks can be fetched by executing next() again.</caption>
+ * let asyncIterator = dataprovider.fetchFirst(options)[Symbol.asyncIterator]();
+ * let result = await asyncIterator.next();
+ * let value = result.value;
+ * let data = value.data;
+ * let keys = value.metadata.map(function(val) {
+ *   return val.key;
+ * });
+ * // true or false for done
+ * let done = result.done;
  */
 
 /**