@oracle/oraclejet 10.0.3 → 10.0.7

package/dist/js/libs/oj/debug_es5/ojwaterfalllayout.js

@@ -1,5 +1,5 @@
 (function() {
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
@@ -7,23 +7,23 @@ function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread n
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
 
 function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
 
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
@@ -35,7 +35,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
 /**
  * @license
@@ -769,7 +769,7 @@ define(['exports', 'ojs/ojcore-base', 'ojs/ojdatacollection-common', 'ojs/ojanim
 
   var WaterfallLayout_1;
 
-  var Props = function Props() {
+  var Props = /*#__PURE__*/_createClass(function Props() {
     _classCallCheck(this, Props);
 
     this.data = null;
@@ -782,7 +782,7 @@ define(['exports', 'ojs/ojcore-base', 'ojs/ojdatacollection-common', 'ojs/ojanim
     this.scrollPosition = {
       y: 0
     };
-  };
+  });
 
   exports.WaterfallLayout = WaterfallLayout_1 = /*#__PURE__*/function (_ojvcomponentElement$) {
     _inherits(WaterfallLayout, _ojvcomponentElement$);

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

@@ -56,8 +56,6 @@ let ActionCard = class ActionCard extends ElementVComponent {
         if (!this._isFromActiveSource(event)) {
             if (this.state.active) {
                 this.updateState({ active: false });
-                event.preventDefault();
-                event.stopPropagation();
                 (_b = (_a = this.props).onOjAction) === null || _b === void 0 ? void 0 : _b.call(_a, { originalEvent: event });
             }
         }
@@ -85,8 +83,6 @@ let ActionCard = class ActionCard extends ElementVComponent {
         var _a, _b;
         if (!this._isFromActiveSource(event)) {
             if (event.key === 'Enter' || event.key === ' ') {
-                event.preventDefault();
-                event.stopPropagation();
                 this.updateState({ active: false });
                 (_b = (_a = this.props).onOjAction) === null || _b === void 0 ? void 0 : _b.call(_a, { originalEvent: event });
             }
@@ -101,8 +97,6 @@ let ActionCard = class ActionCard extends ElementVComponent {
         var _a, _b;
         if (!this._isFromActiveSource(event)) {
             if (this.state.active) {
-                event.preventDefault();
-                event.stopPropagation();
                 this.updateState({ active: false });
                 (_b = (_a = this.props).onOjAction) === null || _b === void 0 ? void 0 : _b.call(_a, { originalEvent: event });
             }

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

@@ -160,11 +160,42 @@ import 'ojs/ojcomponentcore';
  */
 
 /**
- * @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 BufferingDataProvider
  * @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;
  */
 
 /**

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

@@ -62,11 +62,45 @@ import 'ojs/ojdataprovideradapter';
  */
 
 /**
- * @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>
+ * The iterator accounts for data mutations when returning the next block of data, so that no row is duplicated or skipped.
+ * It will adjust the offset from which the next block of data starts if rows
+ * have been added or removed in the returned data.
+ * </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 CollectionDataProvider
  * @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;
  */
 
 /**

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

@@ -45,12 +45,12 @@ const oj = {
    * @global
    * @member {string} version JET version numberr
    */
-  version: '10.0.3',
+  version: '10.0.7',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2021-03-17_12-00-27',
+  revision: '2021-12-14_08-10-04',
 
   // 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/ojdataprovider.js

@@ -223,13 +223,95 @@ import { GenericEvent } from 'ojs/ojeventtarget';
  * It is for convenience and may not provide the most efficient implementation for your data provider.
  * Classes that implement the DataProvider interface are encouraged to provide a more efficient implementation.
  * </p>
+ * <p>
+ * In order for JET components to work correctly, DataProvider implementations should ensure that:
+ * <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>
+ * <p>Assuming that a DataProvider has returned rows indexed 0 to 9. Normally it should start the next block at index 10. Now consider
+ *    the following distinct mutation cases:</p>
+ * <ul>
+ *   <li>If a row is added at index 5, the DataProvider should fire a "mutate" event with the added row, and starts the
+ *       next block at index 11.</li>
+ *   <li>On the other hand, if a row is removed at index 5, the DataProvider should fire a "mutate" event with the removed row, and starts the
+ *       next block at index 9.</li>
+ * </ul>
+ * <i>Example of adjusting the offset upon mutations for a DataProvider implementation that keeps track of its own offset.
+ * This is just an illustration of what some implementations might do. The necessary adjustment is highly dependent of the
+ * individual implementation.
+ * </i>
+ * <pre class="prettyprint"><code>
+ * // offset is the current offset to start the next fetch
+ * // removeIndexes is an array of indexes for removed items relative to the original dataset
+ * // addIndexes is an array of indexes for added items relative to the dataset after the mutations
+ * function getNewOffset(offset, removeIndexes, addIndexes) {
+ *   let removeCount = 0;
+ *
+ *   if (removeIndexes) {
+ *     removeIndexes.forEach(function (index) {
+ *       // only count the changes below the last offset
+ *       if (index < offset) {
+ *         ++removeCount;
+ *       }
+ *     });
+ *   }
+ *
+ *   offset -= removeCount;
+ *   if (addIndexes) {
+ *     addIndexes.forEach(function (index) {
+ *       // only count the changes below the last offset
+ *       if (index < offset) {
+ *         ++offset;
+ *       }
+ *     });
+ *   }
+ *
+ *   return offset;
+ * }
+ * </code></pre>
  */
 oj.DataProvider = function () {
 };
 
 /**
- * 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/ojdataproviderscroller.js

@@ -621,7 +621,7 @@ DataProviderContentHandler.prototype.getIndex = function (keys, index) {
  */
 DataProviderContentHandler.prototype.handleModelAddEvent = function (event) {
   // if listview is busy, queue it for processing later
-  if (!this.IsReadyForMutation()) {
+  if (!this.IsReady()) {
     this._pushToEventQueue({ type: event.type, event: event });
     return;
   }
@@ -827,8 +827,8 @@ DataProviderContentHandler.prototype.handleModelRemoveEvent = function (event) {
     return false;
   }
 
-    // if listview is busy, hold that off until later
-  if (!this.IsReadyForMutation()) {
+  // if listview is busy, hold that off until later
+  if (!this.IsReady()) {
     this._pushToEventQueue({ type: event.type, event: event });
     return false;
   }
@@ -2592,12 +2592,31 @@ IteratingDataProviderContentHandler.prototype.GetReferenceNode = function (paren
   return referenceNode;
 };
 
+/**
+ * @private
+ */
+IteratingDataProviderContentHandler.prototype._isIterateAfterDoneNotAllowed = function () {
+  var dataProvider = this.getDataProvider();
+  if (dataProvider && dataProvider.getCapability) {
+    var capability = dataProvider.getCapability('fetchFirst');
+    if (capability && capability.iterateAfterDone === 'notAllowed') {
+      return true;
+    }
+  }
+  return false;
+};
+
 /**
  * Gets the maximum index for insert event
  * @private
  */
 IteratingDataProviderContentHandler.prototype._getMaxIndexForInsert = function () {
   var max = Number.MAX_VALUE;
+  // temporary solution for SDP
+  if (this._isIterateAfterDoneNotAllowed() && !this.hasMoreToFetch()) {
+    return max;
+  }
+
   // only care about child count if there's more to fetch
   if (this._isLoadMoreOnScroll()) {
     max = $(this.m_root).children('li.' + this.m_widget.getItemElementStyleClass()).length;
@@ -2625,6 +2644,12 @@ IteratingDataProviderContentHandler.prototype.addItemsForModelInsert =
 
     var promises = [];
     for (var i = 0; i < data.length; i++) {
+      // ignore if the item with key already exists
+      if (this.FindElementByKey(keys[i]) != null) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+
       this.signalTaskStart('handling model add event for item: ' + keys[i]); // signal add item start
       // indexes takes precedence
       var index;
@@ -2636,7 +2661,9 @@ IteratingDataProviderContentHandler.prototype.addItemsForModelInsert =
           index = isBeforeKeys ? index : index + 1;
         } else if (this._isLoadMoreOnScroll()) {
           // if append to the end
-          index = max;
+          if (!this._isIterateAfterDoneNotAllowed() || this.hasMoreToFetch()) {
+            index = max;
+          }
         }
       }
       // we skip any insert/append outside of range if there's still more to fetch

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

@@ -72,11 +72,42 @@ import { DataProviderFeatureChecker } from 'ojs/ojcomponentcore';
  */
 
 /**
- * @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 DeferredDataProvider
  * @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;
  */
 
 /**

package/dist/js/libs/oj/debug_esm/ojdvt-toolkit.js

@@ -10895,8 +10895,8 @@ HtmlTooltipManager.prototype.getCustomTooltip = function (tooltipFunc, dataConte
  */
 HtmlTooltipManager._restoreTag = function (text, tag) {
   // Match the following: <tag...>, </tag...>, and <tag.../>
-  var regExp = new RegExp('&lt;(/?)' + tag + '([^&]*)(/?)&gt;', 'g');
-  return text.replace(regExp, '<$1' + tag + '$2$3>');
+  var regExp = new RegExp('&lt;(/?)(' + tag + ')(?=[\\s&/])([^&]*)(/?)&gt;', 'g');
+  return text.replace(regExp, '<$1' + tag + '$3$4>');
 };
 
 /**

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

@@ -5,6 +5,8 @@
  * as shown at https://oss.oracle.com/licenses/upl/
  * @ignore
  */
+import oj from 'ojs/ojcore-base';
+
 /**
  * @license
  * Copyright (c) 2017 2021, Oracle and/or its affiliates.
@@ -41,8 +43,17 @@
  * @property {'single' | 'multiple'} selectionMode - Whether to allow single or multiple file selection.  Single is the default.
  */
 
-function pickFiles(callback, fileOptions) {
-    const input = document.createElement('input');
+let input;
+const isIOS = oj.AgentUtils.getAgentInfo().os === oj.AgentUtils.OS.IOS;
+const teardownInput = () => {
+    if (isIOS)
+        document.body.removeChild(input);
+    input = null;
+};
+const setupInput = (fileOptions) => {
+    if (input)
+        teardownInput();
+    input = document.createElement('input');
     input.type = 'file';
     if ((fileOptions === null || fileOptions === void 0 ? void 0 : fileOptions.capture) && fileOptions.capture != 'none') {
         input.capture = fileOptions.capture;
@@ -51,8 +62,15 @@ function pickFiles(callback, fileOptions) {
     const accept = acceptProp && acceptProp.length ? acceptProp.join(',') : null;
     input.accept = accept;
     input.multiple = (fileOptions === null || fileOptions === void 0 ? void 0 : fileOptions.selectionMode) == 'multiple';
+    input.style.display = 'none';
+    if (isIOS)
+        document.body.appendChild(input);
+};
+function pickFiles(callback, fileOptions) {
+    setupInput(fileOptions);
     input.onchange = function () {
         callback(input.files);
+        teardownInput();
     };
     input.click();
 }

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

@@ -161,11 +161,42 @@ import ojMap from 'ojs/ojmap';
  */
 
 /**
- * @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 FlattenedTreeDataProviderView
  * @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;
  */
 
 /**

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

@@ -117,12 +117,24 @@ import KeyMap from 'ojs/ojmap';
  *               value: "(params: FetchByOffsetParameters<D>): Promise<FetchByOffsetResults<K, D>>"}
  */
 
-
 /**
- * Fetch the first 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>
+ * Please see the <a href="DataProvider.html#custom-implementations-section">DataProvider documentation</a> for
+ * more information on custom implementations.
+ * </p>
  *
- * @param {oj.FetchListParameters=} params Fetch parameters
- * @return {AsyncIterable.<oj.FetchListResult>} AsyncIterable with {@link oj.FetchListResult}
+ * @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
@@ -131,7 +143,17 @@ import KeyMap from 'ojs/ojmap';
  * @method
  * @name fetchFirst
  * @ojsignature {target: "Type",
- *               value: "(params?: FetchListParameters<D>): AsyncIterable<FetchListResult<K, D>>"}
+ *               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;
  */
 
 /**

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

@@ -136,11 +136,42 @@ import { warn } from 'ojs/ojlogger';
  */
 
 /**
- * @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 JoiningDataProvider
  * @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;
  */
 
 /**