@oracle/oraclejet 14.0.4 → 14.0.6

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

@@ -2145,6 +2145,8 @@ var __oj_table_metadata =
     this._isEditPending = null;
     this._active = null;
     this._isTableTab = null;
+    this._renderedTableHeaderColumns = false;
+
     // clear any pending timeouts
     this._clearAllComponentTimeouts();
     // remove any pending busy states
@@ -2180,17 +2182,6 @@ var __oj_table_metadata =
         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
@@ -2199,6 +2190,12 @@ var __oj_table_metadata =
       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]);
+    }
   };
 
   /**
@@ -3069,7 +3066,6 @@ var __oj_table_metadata =
               tableBodyRow = docFrag.children[rowIdx - docFragStartIdx];
             }
           }
-          // eslint-disable-next-line no-param-reassign
           this._hasRowTemplate = true;
         }
       }
@@ -3729,6 +3725,7 @@ var __oj_table_metadata =
           nodes.forEach(function (node) {
             noDataContentCell.appendChild(node); // @HTMLUpdateOK
           });
+          this._hasNoDataTemplate = true;
         }
       } else {
         var emptyTextMsg = null;
@@ -3770,6 +3767,7 @@ var __oj_table_metadata =
           if (noDataRow != null) {
             this._cleanTemplateNodes(noDataRow);
             $(noDataRow).remove();
+            this._hasNoDataTemplate = false;
           }
         }
       }

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.
@@ -557,6 +545,7 @@ class EditBuffer {
             throw new Error('Cannot add item with same key as an item being added or updated');
         }
         else if (unsubmitted && unsubmitted.operation === 'remove') {
+            this.unsubmittedItems.delete(item.metadata.key);
             const editItem = { operation: 'update', item };
             this.unsubmittedItems.set(item.metadata.key, editItem);
             this.mapOpTransform.set(item.metadata.key, editItem);
@@ -580,6 +569,7 @@ class EditBuffer {
                 operation: 'remove',
                 item
             });
+            this.mapOpTransform.delete(item.metadata.key);
             return;
         }
         this.unsubmittedItems.set(item.metadata.key, { operation: 'remove', item });
@@ -731,6 +721,7 @@ class BufferingDataProvider {
                 this._params = _params;
                 this.firstBaseKey = null;
                 this.mergedAddKeySet = new Set();
+                this.unFetchedAddItemSet = new Set();
                 this.mergedItemArray = [];
                 this.nextOffset = 0;
                 if (this._params == null) {
@@ -764,6 +755,15 @@ class BufferingDataProvider {
                         });
                         this._parent.totalFilteredRowCount = result.value.totalFilteredRowCount;
                         yield this._parent._mergeEdits(baseItemArray, this.mergedItemArray, this._params.filterCriterion, this._parent.lastSortCriteria, true, this.mergedAddKeySet, result.done);
+                        if (this.nextOffset === 0) {
+                            for (let i = 0; i < this.mergedItemArray.length; i++) {
+                                const key = this.mergedItemArray[i].metadata.key;
+                                if (!this._parent._isItemRemoved(key)) {
+                                    this.firstBaseKey = key;
+                                    break;
+                                }
+                            }
+                        }
                         let actualReturnSize = this.mergedItemArray.length - this.nextOffset;
                         for (let i = this.nextOffset; i < this.mergedItemArray.length; i++) {
                             const item = this.mergedItemArray[i];
@@ -780,6 +780,11 @@ class BufferingDataProvider {
                         }
                         const newDataArray = [];
                         const newMetaArray = [];
+                        this.unFetchedAddItemSet.forEach((item) => {
+                            newDataArray.push(item.data);
+                            newMetaArray.push(item.metadata);
+                        });
+                        this.unFetchedAddItemSet.clear();
                         let idx;
                         for (idx = this.nextOffset; idx < this.mergedItemArray.length; idx++) {
                             ++this.nextOffset;
@@ -792,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,
@@ -833,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();
     }
@@ -861,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;
@@ -903,44 +890,45 @@ class BufferingDataProvider {
                     }
                 }
             }
-            if (editItem.operation === 'add' && !mergedAddKeySet.has(key)) {
+            if ((editItem.operation === 'add' || editItem.operation === 'update') &&
+                !mergedAddKeySet.has(key)) {
                 if (!filterObj || filterObj.filter(editItem.item.data)) {
-                    itemArray.push(editItem.item);
-                    mergedAddKeySet.add(key);
-                }
-            }
-            else if (editItem.operation === 'update' &&
-                !mergedAddKeySet.has(key) &&
-                this.editBuffer.isUpdateTransformed(key)) {
-                for (let i = 0; i < itemArray.length; i++) {
-                    if (itemArray[i].metadata.key === key) {
-                        itemArray.splice(i, 1);
-                        break;
+                    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 {
+                        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);
                     }
                 }
-                itemArray.push(editItem.item);
             }
         }));
-        if (sortCriteria && sortCriteria.length) {
-            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);
-                    }
-                    else if (this.lastSortIndex.get(key) === index) {
-                        this.itemsInWrongPosition.delete(item);
-                    }
-                }
-            });
-        }
     }
     _mergeAddEdits(filterObj, sortCriteria, newItemArray, mergedAddKeySet, lastBlock) {
         this._insertAddEdits(this.editBuffer.getUnsubmittedItems(), filterObj, sortCriteria, newItemArray, mergedAddKeySet, lastBlock);
@@ -971,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) {
@@ -1170,16 +1152,34 @@ class BufferingDataProvider {
             }
             else {
                 addBeforeKey = this.lastIterator.firstBaseKey;
+                if (this.editBuffer.isUpdateTransformed(item.metadata.key)) {
+                    for (let i = 0; i < this.lastIterator.mergedItemArray.length; i++) {
+                        if (this.lastIterator.mergedItemArray[i].metadata.key === item.metadata.key) {
+                            this.lastIterator.mergedItemArray.splice(i, 1);
+                            break;
+                        }
+                    }
+                }
+                this.lastIterator.mergedItemArray.splice(0, 0, item);
+                this.lastIterator.mergedAddKeySet.add(item.metadata.key);
+                if (addBeforeKey === null) {
+                    this.lastIterator.unFetchedAddItemSet.add(item);
+                }
+                this.lastIterator.firstBaseKey = item.metadata.key;
+                this.lastIterator.nextOffset++;
             }
         }
         return addBeforeKey;
     }
-    _getNextKey(key) {
+    _getNextKey(key, bRemoved = false) {
         let nextKey = key;
         if (this.lastIterator) {
             const mergedItemArray = this.lastIterator.mergedItemArray;
             let keyIdx = this._findKeyInItems(key, mergedItemArray);
-            while (nextKey && this._isItemRemoved(nextKey)) {
+            while (nextKey !== null && (bRemoved || this._isItemRemoved(nextKey))) {
+                if (bRemoved) {
+                    bRemoved = false;
+                }
                 nextKey =
                     keyIdx === -1
                         ? null
@@ -1199,9 +1199,6 @@ class BufferingDataProvider {
         }
         this.editBuffer.addItem(addItem);
         const addBeforeKey = this._addToMergedArrays(addItem, false);
-        if (this.lastIterator) {
-            this.lastIterator.firstBaseKey = addItem.metadata.key;
-        }
         const detail = {
             add: {
                 data: [addItem.data],
@@ -1220,7 +1217,7 @@ class BufferingDataProvider {
             const mergedAddKeySet = this.lastIterator.mergedAddKeySet;
             const keyIdx = this._findKeyInItems(key, mergedItemArray);
             if (keyIdx !== -1) {
-                if (fromBaseDP || mergedAddKeySet.has(key) || this.editBuffer.isUpdateTransformed(key)) {
+                if (fromBaseDP || mergedAddKeySet.has(key)) {
                     mergedItemArray.splice(keyIdx, 1);
                     mergedAddKeySet.delete(key);
                     if (keyIdx < this.lastIterator.nextOffset) {
@@ -1248,6 +1245,12 @@ class BufferingDataProvider {
         }
     }
     removeItem(item) {
+        const removeKey = item.metadata.key;
+        if (this.lastIterator &&
+            this.lastIterator.firstBaseKey !== null &&
+            this.lastIterator.firstBaseKey === removeKey) {
+            this.lastIterator.firstBaseKey = this._getNextKey(item.metadata.key, true);
+        }
         this.editBuffer.removeItem(item);
         this._removeFromMergedArrays(item.metadata.key, false);
         const detail = {

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.4',
+  version: '14.0.6',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2023-02-28_18-01-45',
+  revision: '2023-04-05_08-53-26',
 
   // 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/ojcorerouter.js

@@ -742,6 +742,7 @@ CoreRouter.prototype.go = function (...transitions) {
     }
     goP = this.sync().catch((ex) => {
       // Rollback transitions if navigation rejected
+      pendingTransitions = [];
       if (this._noHistory) {
         noHistorySegments = prevNoHistorySegments;
       } else {

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/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;
       }