@oracle/oraclejet 14.0.5 → 14.0.7

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

@@ -6,7 +6,7 @@
  * @ignore
  */
 import oj from 'ojs/ojcore-base';
-import { DataProviderMutationEvent, FilterFactory, DataProviderRefreshEvent } from 'ojs/ojdataprovider';
+import { SortUtils, FilterFactory, DataProviderMutationEvent, DataProviderRefreshEvent } from 'ojs/ojdataprovider';
 import { EventTargetMixin } from 'ojs/ojeventtarget';
 import ojMap from 'ojs/ojmap';
 import { BufferingDataProviderSubmittableChangeEvent } from 'ojs/ojbufferingdataproviderevents';
@@ -97,22 +97,10 @@ import 'ojs/ojcomponentcore';
  * <p>
  * Subsequent to a new/updated row but before the commit, the row can be sorted or filtered.
  * The sorted/filtered position of the row stays after the commit until a subsequent re-order/refresh.
- * Will dispatch remove event for rows which are not in correct position because the sorting is based on fetched row sets.
  *
  * When uncommitted rows are sorted in current row set, their position may not correspond to server side position once they are committed.
- * Therefore a 'remove' event may be fired when new row sets are fetched and it determines that the rows are not in current positions.
  * Uncommitted rows will be sorted according to updated row set.
  * </p>
- * <pre class="prettyprint"><code>
- * // dispatch a remove event for rows in wrong position.
- * // ie row with id 40 is in wrong position
- *{
- *  remove: {
- *    metadata: [{key: 40}],
- *    ...
- *  }
- *}
- * </code></pre>
  *
  * <p>BufferingDataProvider does not validate the item key and data.  It is up to the application to perform any validation
  * prior to creating edit items in the buffer.
@@ -809,22 +797,6 @@ class BufferingDataProvider {
                                 }
                             }
                         }
-                        if (this._parent.itemsInWrongPosition.size > 0) {
-                            const detail = {
-                                remove: {
-                                    data: [],
-                                    keys: new Set(),
-                                    metadata: []
-                                }
-                            };
-                            this._parent.itemsInWrongPosition.forEach((item) => {
-                                detail.remove.data.push(item.data);
-                                detail.remove.keys.add(item.metadata.key);
-                                detail.remove.metadata.push(item.metadata);
-                            });
-                            const event = new DataProviderMutationEvent(detail);
-                            this._parent.dispatchEvent(event);
-                        }
                         const done = result.done && newDataArray.length === 0;
                         return {
                             done,
@@ -850,8 +822,6 @@ class BufferingDataProvider {
         this.lastIterator = null;
         this.customKeyGenerator = options === null || options === void 0 ? void 0 : options.keyGenerator;
         this.generatedKeyMap = new Map();
-        this.lastSortIndex = new Map();
-        this.itemsInWrongPosition = new Set();
         this.totalFilteredRowCount = 0;
         this.dataBeforeUpdated = new Map();
     }
@@ -878,11 +848,11 @@ class BufferingDataProvider {
     }
     _compareItem(d1, d2, sortCriteria) {
         for (const sortCrt of sortCriteria) {
-            if (d1[sortCrt.attribute] > d2[sortCrt.attribute]) {
-                return sortCrt.direction === 'ascending' ? 1 : -1;
-            }
-            else if (d1[sortCrt.attribute] < d2[sortCrt.attribute]) {
-                return sortCrt.direction === 'ascending' ? -1 : 1;
+            let comparator = SortUtils.getNaturalSortComparator();
+            const descendingResult = sortCrt.direction === 'descending' ? -1 : 1;
+            const comparatorResult = comparator(d1[sortCrt.attribute], d2[sortCrt.attribute]) * descendingResult;
+            if (comparatorResult !== 0) {
+                return comparatorResult;
             }
         }
         return 0;
@@ -920,35 +890,45 @@ class BufferingDataProvider {
                     }
                 }
             }
-            if ((editItem.operation === 'add' ||
-                (editItem.operation === 'update' && this.editBuffer.isUpdateTransformed(key))) &&
+            if ((editItem.operation === 'add' || editItem.operation === 'update') &&
                 !mergedAddKeySet.has(key)) {
                 if (!filterObj || filterObj.filter(editItem.item.data)) {
-                    itemArray.splice(0, 0, editItem.item);
-                    mergedAddKeySet.add(key);
-                }
-            }
-        }));
-        if (sortCriteria && sortCriteria.length && !this.editBuffer.isEmpty()) {
-            itemArray.sort((a, b) => {
-                return this._compareItem(a.data, b.data, sortCriteria);
-            });
-            itemArray.forEach((item, index) => {
-                const key = item.metadata.key;
-                if (editItems.has(key)) {
-                    if (this.lastSortIndex.get(key) === undefined) {
-                        this.lastSortIndex.set(key, index);
-                    }
-                    else if (this.lastSortIndex.get(key) !== index) {
-                        this.itemsInWrongPosition.add(item);
-                        this.lastSortIndex.set(key, index);
+                    if (sortCriteria && sortCriteria.length) {
+                        let inserted = false;
+                        for (let i = 0; i < itemArray.length; i++) {
+                            if (this._compareItem(editItem.item.data, itemArray[i].data, sortCriteria) < 0) {
+                                itemArray.splice(i, 0, editItem.item);
+                                mergedAddKeySet.add(key);
+                                inserted = true;
+                                break;
+                            }
+                        }
+                        if (!inserted && lastBlock) {
+                            itemArray.push(editItem.item);
+                            mergedAddKeySet.add(key);
+                        }
                     }
-                    else if (this.lastSortIndex.get(key) === index) {
-                        this.itemsInWrongPosition.delete(item);
+                    else {
+                        let allItemsRemoved = true;
+                        itemArray.forEach((item) => {
+                            if (key !== item.metadata.key &&
+                                !mergedAddKeySet.has(key) &&
+                                !this._isItemRemoved(item.metadata.key)) {
+                                allItemsRemoved = false;
+                                return;
+                            }
+                        });
+                        if (allItemsRemoved) {
+                            itemArray.push(editItem.item);
+                        }
+                        else {
+                            itemArray.splice(0, 0, editItem.item);
+                        }
+                        mergedAddKeySet.add(key);
                     }
                 }
-            });
-        }
+            }
+        }));
     }
     _mergeAddEdits(filterObj, sortCriteria, newItemArray, mergedAddKeySet, lastBlock) {
         this._insertAddEdits(this.editBuffer.getUnsubmittedItems(), filterObj, sortCriteria, newItemArray, mergedAddKeySet, lastBlock);
@@ -979,12 +959,6 @@ class BufferingDataProvider {
                 if (editItem.operation === 'remove') {
                     newItemArray.push(baseItem);
                 }
-                else if (editItem.operation === 'update' &&
-                    !this.editBuffer.isUpdateTransformed(editItem.item.metadata.key)) {
-                    if (!filterObj || filterObj.filter(editItem.item.data)) {
-                        newItemArray.push(editItem.item);
-                    }
-                }
             }
         }
         if (sortCriteria && sortCriteria.length) {

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.5',
+  version: '14.0.7',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2023-03-16_09-38-48',
+  revision: '2023-04-12_12-18-33',
 
   // 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/ojflattenedtreedataproviderview.js

@@ -878,7 +878,7 @@ class FlattenedTreeDataProviderView {
             return result.fetchResult;
         });
     }
-    _fetchChildrenByOffsetFromAncestors(params, dataprovider, parentKey, finalParams, expandKey) {
+    _fetchChildrenByOffsetFromAncestors(params, dataProvider, parentKey, finalParams, expandKey) {
         const handleFetchFromAncestors = (lastParentKey, result) => {
             const lastEntry = this._getItemByKey(lastParentKey);
             if (this._checkCacheByOffset(finalParams, expandKey) ||
@@ -895,7 +895,7 @@ class FlattenedTreeDataProviderView {
             const childrenPromise = this._fetchChildrenByOffsetFromDataProvider(newParams, childDataProvider, lastEntryParentKey, finalParams, expandKey);
             return childrenPromise.then(handleFetchFromAncestors.bind(this, lastEntryParentKey));
         };
-        return this._fetchChildrenByOffsetFromDataProvider(params, dataprovider, parentKey, finalParams, expandKey)
+        return this._fetchChildrenByOffsetFromDataProvider(params, dataProvider, parentKey, finalParams, expandKey)
             .then(handleFetchFromAncestors.bind(this, parentKey))
             .then(() => {
             const result = this._getFetchByOffsetResultsFromCache(finalParams);
@@ -916,10 +916,12 @@ class FlattenedTreeDataProviderView {
                 finalParams.filterCriterion = result.fetchParameters.filterCriterion;
             }
             if (results.length === 0 || this._checkCacheByOffset(finalParams, expandKey)) {
-                if (expandKey && result.done === true) {
-                    return Promise.resolve({ expandKey: expandKey, done: result.done });
+                const returnObject = {};
+                if (expandKey) {
+                    returnObject.expandKey = expandKey;
                 }
-                return Promise.resolve({ done: results.length === 0 ? result.done : false });
+                returnObject.done = results.length === 0 ? result.done : false;
+                return Promise.resolve(returnObject);
             }
             const item = results.shift();
             const updatedItem = this._updateItemMetadata(item, parentKey);
@@ -927,7 +929,7 @@ class FlattenedTreeDataProviderView {
             if (this._isExpanded(updatedItem.metadata.key)) {
                 const parentKeyInfo = this._mapParentKeyToInfo.get(updatedItem.metadata.key);
                 const childDataProvider = this.getChildDataProvider(updatedItem.metadata.key);
-                const remainingSize = this._getRemainingSize(finalParams);
+                const remainingSize = this._getRemainingSize(finalParams, expandKey);
                 if (childDataProvider != null && !parentKeyInfo.done && remainingSize !== 0) {
                     const newParams = new this.FetchByOffsetParameters(this, 0, remainingSize, params.sortCriteria, params.filterCriterion, params.attributes);
                     yield this._fetchChildrenByOffsetFromDataProvider(newParams, childDataProvider, updatedItem.metadata.key, finalParams, expandKey);
@@ -938,21 +940,46 @@ class FlattenedTreeDataProviderView {
         return dataProvider
             .fetchByOffset(params)
             .then(handleNextItemInResults)
-            .then((returnObject) => {
+            .then((nextItemResults) => {
             this._mapParentKeyToInfo.set(parentKey, {
-                done: returnObject.done
+                done: nextItemResults.done
             });
             const result = this._getFetchByOffsetResultsFromCache(finalParams);
-            if (returnObject.expandKey) {
-                return { returnObject: returnObject, fetchResult: result };
+            const validationObject = {
+                fetchResult: result
+            };
+            if (nextItemResults.expandKey) {
+                validationObject.returnObject = nextItemResults;
+                nextItemResults.done =
+                    nextItemResults.done === true
+                        ? this._isDescendentTreeDone(nextItemResults.expandKey)
+                        : false;
             }
-            return { fetchResult: result };
+            return validationObject;
         });
     }
-    _getRemainingSize(params) {
+    _isDescendentTreeDone(key) {
+        const children = this._getChildrenFromCacheByParentKey(key);
+        if (children.length === 0) {
+            return true;
+        }
+        const itemDone = this._isDone(key);
+        if (!itemDone) {
+            return false;
+        }
+        const childKey = children[children.length - 1].metadata.key;
+        return this._isDescendentTreeDone(childKey);
+    }
+    _isDone(key) {
+        return this._mapParentKeyToInfo.has(key) && this._mapParentKeyToInfo.get(key).done;
+    }
+    _getRemainingSize(params, expandKey) {
         if (params.size === -1) {
             return -1;
         }
+        if (expandKey) {
+            return params.size - this._getLocalDescendentCount(expandKey);
+        }
         return params.size + params.offset - this._cache.length;
     }
     _isExpanded(key) {
@@ -1022,14 +1049,25 @@ class FlattenedTreeDataProviderView {
                     });
                 }
                 if (previousCacheIndex !== null) {
-                    const removedItems = this._cache.splice(previousCacheIndex + 1, this._cache.length);
-                    removedItems.forEach(() => {
-                        this._decrementIteratorOffset(previousCacheIndex + 1);
+                    const lastDescendentItem = this._getLastDescendentByParentKey(disregardAfterKey);
+                    const lastDescendentIndex = this._getItemIndexByKey(lastDescendentItem.metadata.key);
+                    const removedItems = this._cache.splice(lastDescendentIndex + 1, this._cache.length);
+                    removedItems.forEach((item) => {
+                        this._mapParentKeyToInfo.delete(item.metadata.key);
+                        if (this._mapParentKeyToInfo.has(item.metadata.parentKey)) {
+                            this._mapParentKeyToInfo.set(item.metadata.parentKey, { done: false });
+                        }
                     });
+                    const decrementValueTotal = removedItems.length + fetchedCountMap.get(disregardAfterKey).count;
+                    for (let i = 0; i < decrementValueTotal; i++) {
+                        this._decrementIteratorOffset(previousCacheIndex + 1);
+                    }
                 }
                 if (disregardAfterKey === null) {
                     const mutationEventDetail = new this.DataProviderMutationEventDetail(this, operationAddEventDetail, operationRemoveEventDetail, null);
-                    this.dispatchEvent(new DataProviderMutationEvent(mutationEventDetail));
+                    if (operationAddEventDetail.keys.size > 0 || operationRemoveEventDetail.keys.size > 0) {
+                        this.dispatchEvent(new DataProviderMutationEvent(mutationEventDetail));
+                    }
                 }
                 if (disregardAfterKey !== null) {
                     const refreshEvent = new DataProviderRefreshEvent(new this.DataProviderRefreshEventDetail(disregardAfterKey));
@@ -1103,6 +1141,16 @@ class FlattenedTreeDataProviderView {
     _getEntry(i) {
         return this._cache[i];
     }
+    _getLastDescendentByParentKey(parentKey) {
+        const lastItem = this._getLastItemByParentKey(parentKey);
+        if (!lastItem) {
+            return this._getItemByKey(parentKey);
+        }
+        if (lastItem.metadata.isLeaf) {
+            return lastItem;
+        }
+        return this._getLastDescendentByParentKey(lastItem.metadata.key);
+    }
     _getLastItemByParentKey(parentKey) {
         let returnItem = null;
         this._cache

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

@@ -516,6 +516,11 @@ class KeySetImpl extends KeySet {
             keys: undefined
         };
         this.keys.keys = new Set(keys);
+        Object.defineProperty(this, '_keys', {
+            get: () => {
+                return this.keys.keys;
+            }
+        });
     }
     has(key) {
         return _has(this.keys.keys, key);
@@ -569,6 +574,11 @@ class AllKeySetImpl extends KeySet {
             deletedKeys: undefined
         };
         this.keys.deletedKeys = new Set(keys);
+        Object.defineProperty(this, '_keys', {
+            get: () => {
+                return this.keys.deletedKeys;
+            }
+        });
     }
     has(key) {
         return !_has(this.keys.deletedKeys, key);

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

@@ -23,22 +23,33 @@
  *
  * <p>If the logging options are changed at a later point, the Logger will use the modified options for the subsequent log operations.
  *
+ * <p>The logging level can be overridden via sessionStorage.setItem() call for the current browser session.
+ * Use 'ojet.logLevel' as the key with one of the following values: 'none' (least verbose), 'error', 'warning', 'info', 'log' (most verbose).
+ * Set the value in the browser console and refresh the browser in order for the value to take effect.
+ * </p>
+ * <h3> Session storage usage : </h3>
+ * <pre class="prettyprint">
+ * <code>
+ * // override logging level for the current session
+ * sessionStorage.setItem('ojet.logLevel', 'log');
+ * </code></pre>
+ *
  * <p>All the logging methods support string formatting, accept variable number of arguments and accept a function as a parameter.
  * When a callback function is specified as a parameter the function will be called if the log level is sufficient.
  *
- * <h3> Usage : </h3>
+ * <h3> Logger usage : </h3>
  * <pre class="prettyprint">
  * <code>
  * //optional calls, see defaults
- * oj.Logger.option("level",  oj.Logger.LEVEL_INFO);
- * oj.Logger.option("writer",  customWriter);  //an object that implements the following methods: log(), info(), warn(), error()
+ * Logger.option("level",  Logger.LEVEL_INFO);
+ * Logger.option("writer",  customWriter);  //an object that implements the following methods: log(), info(), warn(), error()
  *
  * // logging a message
- * oj.Logger.info("My log level is %d", oj.Logger.option("level"));  // string formatting
- * oj.Logger.warn("Beware of bugs", "in the above code");            // multiple parameters
+ * Logger.info("My log level is %d", Logger.option("level"));  // string formatting
+ * Logger.warn("Beware of bugs", "in the above code");            // multiple parameters
  *
  * // using a callback function as a parameter
- * oj.Logger.info(function(){
+ * Logger.info(function(){
  *    var foo = "This ";
  *    var bar = "is ";
  *    var zing = "a function";
@@ -105,6 +116,47 @@ Logger._METHOD_LOG = 'log';
 Logger._defaultOptions = { level: Logger.LEVEL_ERROR, writer: null };
 Logger._options = Logger._defaultOptions;
 
+/*
+ * Helper method that retrieves and parses session storage setting
+ */
+const _getSessionStorage = () => {
+  const sessionValue =
+    typeof window !== 'undefined' && window.sessionStorage !== undefined
+      ? sessionStorage.getItem('ojet.logLevel')
+      : undefined;
+  let logLevel;
+  switch (sessionValue) {
+    case 'none':
+      logLevel = Logger.LEVEL_NONE;
+      break;
+    case 'error':
+      logLevel = Logger.LEVEL_ERROR;
+      break;
+    case 'warning':
+      logLevel = Logger.LEVEL_WARN;
+      break;
+    case 'info':
+      logLevel = Logger.LEVEL_INFO;
+      break;
+    case 'log':
+      logLevel = Logger.LEVEL_LOG;
+      break;
+    default:
+      logLevel = undefined;
+  }
+  return logLevel;
+};
+
+/* SessionStorage setting */
+const _sessionStorage = _getSessionStorage();
+
+/*
+ * Helper method - returns current log level from session storage or options
+ */
+const _getLogLevel = () => {
+  return _sessionStorage || Logger._options.level;
+};
+
 /* public members*/
 /**
  * Writes an error message.
@@ -208,12 +260,23 @@ Logger.option = function (key, value) {
   if (arguments.length === 0) {
     keys = Object.keys(Logger._options);
     for (i = 0; i < keys.length; i++) {
-      ret[keys[i]] = Logger._options[keys[i]];
+      ret[keys[i]] = key === 'level' ? _getLogLevel() : Logger._options[keys[i]];
     }
     return ret;
   }
   if (typeof key === 'string' && value === undefined) {
-    return Logger._options[key] === undefined ? null : Logger._options[key];
+    let optValue;
+    switch (key) {
+      case 'level':
+        optValue = _getLogLevel();
+        break;
+      case 'writer':
+        optValue = Logger._options.writer;
+        break;
+      default:
+        optValue = null;
+    }
+    return optValue;
   }
 
   // setters

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

@@ -1402,6 +1402,13 @@ const _ojNavigationListView = _NavigationListUtils.clazz(
         return;
       }
       if ($target.hasClass(this.getNavListRemoveIcon()) && this.isTabBar()) {
+        // click on the 'X' should not change selection, but it should still change currentItem
+        this.HandleClickActive(item, event);
+        var contentElement = this.getItemContentElement(item);
+        if (contentElement.length > 0) {
+          // make sure it gets focus otherwise focus goes to the body as 'X' is no longer in DOM
+          contentElement[0].focus();
+        }
         this._handleRemove(event, item);
         return;
       }

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

@@ -8409,16 +8409,28 @@ const _AbstractMultiChoice = _ComboUtils.clazz(_AbstractOjChoice, {
     items.forEach(
       function (item) {
         values.push(this.id(item));
-        valueOptions.push({
+
+        var newValueOption = {
           label: item.label,
           value: this.id(item)
-        });
+        };
 
         // populate data and metadata only when using a data provider
         if (isDataProvider) {
+          // JET-57010 - oj-select-many valueOptionsChanged event does not contain data
+          // and metadata
+          // include the data and metadata from the data provider in the item itself so that they
+          // will be included in the valueOptionsChanged event that gets fired, similar to what
+          // would happen if the user selected an item from the dropdown
+          newValueOption.data = item.data;
+          newValueOption.metadata = item.metadata;
           valueOptionsData.push(item.data);
           valueOptionsMetadata.push(item.metadata);
         }
+
+        // valueOptions is similar to value, but each item in the array is an object containing
+        // the value and label for that item
+        valueOptions.push(newValueOption);
       }.bind(this)
     );
 

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

@@ -2166,6 +2166,8 @@ Table.prototype._cleanComponent = function (isDestroy) {
   this._isEditPending = null;
   this._active = null;
   this._isTableTab = null;
+  this._renderedTableHeaderColumns = false;
+
   // clear any pending timeouts
   this._clearAllComponentTimeouts();
   // remove any pending busy states
@@ -2201,17 +2203,6 @@ Table.prototype._cleanComponent = function (isDestroy) {
       this._data.destroy();
     }
 
-    // If any template is being used, clean up the nodes to avoid memory leak in Knockout
-    if (
-      this._hasHeaderTemplate ||
-      this._hasCellTemplate ||
-      this._hasFooterTemplate ||
-      this._hasRowTemplate ||
-      this._hasAddRowTemplate
-    ) {
-      this._cleanTemplateNodes(this.element[0]);
-    }
-
     this._componentDestroyed = true;
   } else {
     // cleanup needed for 'ReleaseResources()' call only
@@ -2220,6 +2211,12 @@ Table.prototype._cleanComponent = function (isDestroy) {
     this._unregisterDataSourceEventListeners();
     this._unregisterResizeListener();
   }
+
+  // If any template is being used, clean up the nodes to avoid memory leak in Knockout
+  if (this._hasHeaderTemplate || this._hasCellTemplate || this._hasFooterTemplate ||
+      this._hasRowTemplate || this._hasAddRowTemplate || this._hasNoDataTemplate) {
+    this._cleanTemplateNodes(this.element[0]);
+  }
 };
 
 /**
@@ -3090,7 +3087,6 @@ Table.prototype._refreshTableBodyRow = function (
             tableBodyRow = docFrag.children[rowIdx - docFragStartIdx];
           }
         }
-        // eslint-disable-next-line no-param-reassign
         this._hasRowTemplate = true;
       }
     }
@@ -3750,6 +3746,7 @@ Table.prototype._showNoDataMessage = function () {
         nodes.forEach(function (node) {
           noDataContentCell.appendChild(node); // @HTMLUpdateOK
         });
+        this._hasNoDataTemplate = true;
       }
     } else {
       var emptyTextMsg = null;
@@ -3791,6 +3788,7 @@ Table.prototype._hideNoDataMessage = function () {
         if (noDataRow != null) {
           this._cleanTemplateNodes(noDataRow);
           $(noDataRow).remove();
+          this._hasNoDataTemplate = false;
         }
       }
     }

package/dist/js/libs/oj/main-template.js

@@ -15,9 +15,9 @@
   requirejs.config({
     // Path mappings for the logical module names
     paths: {
-      'ojs': 'libs/oj/14.0.5/min@insertESLevelPath@',
-      'ojL10n': 'libs/oj/14.0.5/ojL10n',
-      'ojtranslations': 'libs/oj/14.0.5/resources',
+      'ojs': 'libs/oj/14.0.7/min@insertESLevelPath@',
+      'ojL10n': 'libs/oj/14.0.7/ojL10n',
+      'ojtranslations': 'libs/oj/14.0.7/resources',
       
   'knockout': 'libs/knockout/knockout-3.5.1',
   'jquery': 'libs/jquery/jquery-3.6.1.min',