@oracle/oraclejet 16.0.6 → 16.1.0

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

@@ -10,6 +10,7 @@ import { SortUtils, FilterFactory, DataProviderMutationEvent, DataProviderRefres
 import { EventTargetMixin } from 'ojs/ojeventtarget';
 import ojMap from 'ojs/ojmap';
 import { BufferingDataProviderSubmittableChangeEvent } from 'ojs/ojbufferingdataproviderevents';
+import ojSet from 'ojs/ojset';
 import 'ojs/ojcomponentcore';
 
 /**
@@ -30,7 +31,7 @@ import 'ojs/ojcomponentcore';
  * @classdesc
  * <p>BufferingDataProvider is a wrapping DataProvider that provides edit buffering for an underlying DataProvider, so that
  * the edits can be committed to the data source later on.
- * The underlying DataProvider is responsible for fetchting data, and BufferingDataProvider will merge any buffered edits with
+ * The underlying DataProvider is responsible for fetching data, and BufferingDataProvider will merge any buffered edits with
  * the underlying data so that they appear as an unified set of data.
  * </p>
  * <p>Because all edits are tracked by keys, the underlying DataProvider must return unique keys in the metadata.  If new rows
@@ -316,7 +317,7 @@ import 'ojs/ojcomponentcore';
  * Note: Starting in 12.0.1, addItem supports passing in an item which has null key. If the key is null then
  * a string typed v4 UUID key is generated for the key. It is expected that the application will later call
  * setItemStatus with the newKey parameter to pass in the real key once it becomes available after commit. The
- * newKey will then be stored in an internal map with the generated key and then when the underyling DataProvider
+ * newKey will then be stored in an internal map with the generated key and then when the underlying DataProvider
  * subsequently dispatches an add mutation event which contains the new key then the BufferingDataProvider will
  * include a remove mutation which will remove the row with the generated key. If a non-string typed or
  * non-v4 UUID generated key is desired then please use the constructor option: keyGenerator.
@@ -530,47 +531,56 @@ class EditBuffer {
     constructor() {
         this.unsubmittedItems = new ojMap();
         this.submittingItems = new ojMap();
-        this.unsubmittedChangedItems = new ojMap();
+        this.submittedAddItems = new ojMap();
+        this.addItemOrder = [];
         this.mapOpTransform = new ojMap();
         this.mapEditItemStatus = new ojMap();
     }
     addItem(item) {
-        const unsubmitted = this.unsubmittedItems.get(item.metadata.key);
-        const submitting = this.submittingItems.get(item.metadata.key);
-        const changed = this.unsubmittedChangedItems.get(item.metadata.key);
+        const key = item.metadata.key;
+        const unsubmitted = this.unsubmittedItems.get(key);
+        const submitting = this.submittingItems.get(key);
         if ((unsubmitted && (unsubmitted.operation === 'add' || unsubmitted.operation === 'update')) ||
             (submitting && (submitting.operation === 'add' || submitting.operation === 'update'))) {
             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);
+            this.unsubmittedItems.delete(key);
             const editItem = { operation: 'update', item };
-            this.unsubmittedItems.set(item.metadata.key, editItem);
-            this.mapOpTransform.set(item.metadata.key, editItem);
+            this.unsubmittedItems.set(key, editItem);
+            this.mapOpTransform.set(key, editItem);
+            this.addItemOrder.unshift(key);
             return;
         }
-        this.unsubmittedItems.set(item.metadata.key, { operation: 'add', item });
+        this.unsubmittedItems.set(key, { operation: 'add', item });
+        this.addItemOrder.unshift(key);
     }
     removeItem(item) {
-        const unsubmitted = this.unsubmittedItems.get(item.metadata.key);
-        const submitting = this.submittingItems.get(item.metadata.key);
+        const key = item.metadata.key;
+        const unsubmitted = this.unsubmittedItems.get(key);
+        const submitting = this.submittingItems.get(key);
         if ((unsubmitted && unsubmitted.operation === 'remove') ||
             (submitting && submitting.operation === 'remove')) {
             throw new Error('Cannot remove item with same key as an item being removed');
         }
         else if (unsubmitted && unsubmitted.operation === 'add') {
-            this.unsubmittedItems.delete(item.metadata.key);
+            this.unsubmittedItems.delete(key);
+            this._removeFromAddItemOrder(key);
             return;
         }
         else if (unsubmitted && unsubmitted.operation === 'update') {
-            this.unsubmittedItems.set(item.metadata.key, {
+            this.unsubmittedItems.set(key, {
                 operation: 'remove',
                 item
             });
-            this.mapOpTransform.delete(item.metadata.key);
+            this.mapOpTransform.delete(key);
+            this._removeFromAddItemOrder(key);
+            this.submittedAddItems.delete(key);
             return;
         }
-        this.unsubmittedItems.set(item.metadata.key, { operation: 'remove', item });
+        this._removeFromAddItemOrder(key);
+        this.submittedAddItems.delete(key);
+        this.unsubmittedItems.set(key, { operation: 'remove', item });
     }
     updateItem(item) {
         const unsubmitted = this.unsubmittedItems.get(item.metadata.key);
@@ -585,10 +595,8 @@ class EditBuffer {
                 operation: unsubmitted.operation,
                 item
             });
-            this.mapOpTransform.delete(item.metadata.key);
             return;
         }
-        this.unsubmittedChangedItems.set(item.metadata.key, true);
         this.unsubmittedItems.set(item.metadata.key, { operation: 'update', item });
     }
     setItemMutated(editItem) {
@@ -598,6 +606,9 @@ class EditBuffer {
             const status = this.mapEditItemStatus.get(key);
             if (status === 'submitted') {
                 this.submittingItems.delete(key);
+                if (this._isAddOrMoveAdd(item)) {
+                    this.submittedAddItems.set(key, item);
+                }
             }
             else {
                 this.mapEditItemStatus.set(key, 'mutated');
@@ -616,12 +627,14 @@ class EditBuffer {
                 const status = this.mapEditItemStatus.get(key);
                 if (status === 'mutated') {
                     this.submittingItems.delete(key);
+                    if (this._isAddOrMoveAdd(editItem)) {
+                        this.submittedAddItems.set(key, editItem);
+                    }
                 }
                 else {
                     this.mapEditItemStatus.set(key, 'submitted');
                 }
             }
-            this.unsubmittedChangedItems.delete(key);
         }
         else if (newStatus === 'unsubmitted') {
             this.submittingItems.delete(key);
@@ -650,14 +663,22 @@ class EditBuffer {
     getSubmittingItems() {
         return this.submittingItems;
     }
-    isEmpty() {
-        return this.unsubmittedItems.size === 0 && this.submittingItems.size === 0;
+    getSubmittedAddItems() {
+        return this.submittedAddItems;
+    }
+    isEmpty(includeSubmitted) {
+        return (this.unsubmittedItems.size === 0 &&
+            this.submittingItems.size === 0 &&
+            (includeSubmitted ? this.submittedAddItems.size === 0 : true));
     }
-    getItem(key) {
+    getItem(key, includeSubmitted) {
         let editItem = this.unsubmittedItems.get(key);
         if (!editItem) {
             editItem = this.submittingItems.get(key);
         }
+        if (includeSubmitted && !editItem) {
+            editItem = this.submittedAddItems.get(key);
+        }
         return editItem;
     }
     isUpdateTransformed(key) {
@@ -666,12 +687,44 @@ class EditBuffer {
     getEditItemStatus(key) {
         return this.mapEditItemStatus.get(key);
     }
+    isSubmittingOrSubmitted(key) {
+        return this.submittingItems.has(key) || this.submittedAddItems.has(key);
+    }
     resetAllUnsubmittedItems() {
+        this._clearAddItemOrder();
         this.unsubmittedItems.clear();
         this.submittingItems.clear();
-        this.unsubmittedChangedItems.clear();
         this.mapOpTransform.clear();
     }
+    _clearAddItemOrder() {
+        this.unsubmittedItems.forEach((editItem, key) => {
+            if (this._isAddOrMoveAdd(editItem)) {
+                this._removeFromAddItemOrder(key);
+            }
+        });
+        this.submittingItems.forEach((editItem, key) => {
+            if (this._isAddOrMoveAdd(editItem)) {
+                this._removeFromAddItemOrder(key);
+            }
+        });
+    }
+    _removeFromAddItemOrder(key) {
+        let index = this.addItemOrder.findIndex((k) => {
+            return oj.KeyUtils.equals(k, key);
+        });
+        if (index !== -1) {
+            this.addItemOrder.splice(index, 1);
+        }
+    }
+    _isAddOrMoveAdd(editItem) {
+        return editItem.operation === 'add' || this._isMoveAdd(editItem);
+    }
+    _isMoveAdd(editItem) {
+        return editItem.operation === 'update' && this.isUpdateTransformed(editItem.item.metadata.key);
+    }
+    getAddItemOrder() {
+        return this.addItemOrder;
+    }
 }
 
 class BufferingDataProvider {
@@ -709,7 +762,7 @@ class BufferingDataProvider {
                 this._baseIterator = _baseIterator;
                 this._params = _params;
                 this.firstBaseKey = null;
-                this.mergedAddKeySet = new MutableKeySet();
+                this.mergedAddKeySet = new ojSet();
                 this.mergedItemArray = [];
                 this.nextOffset = 0;
                 if (this._params == null) {
@@ -957,65 +1010,94 @@ class BufferingDataProvider {
         }
         this._mergeAddEdits(filterObj, sortCriteria, newItemArray, mergedAddKeySet, lastBlock);
     }
-    _fetchFromOffset(params, newItemArray) {
+    async _fetchFromOffset(params) {
         const signal = params?.signal;
-        if (signal && signal.aborted) {
+        if (signal) {
             const reason = signal.reason;
-            return Promise.reject(new DOMException(reason, 'AbortError'));
+            if (signal.aborted) {
+                throw new DOMException(reason, 'AbortError');
+            }
+            signal.addEventListener('abort', () => {
+                throw new DOMException(reason, 'AbortError');
+            });
         }
-        return new Promise((resolve, reject) => {
-            if (signal) {
-                const reason = signal.reason;
-                signal.addEventListener('abort', (e) => {
-                    return reject(new DOMException(reason, 'AbortError'));
-                });
+        const offset = params.offset;
+        const isFetchAll = params.size == null || params.size === -1;
+        const size = params.size;
+        const mergedItems = [];
+        const { submitting, submitted, unsubmitted } = this._getEditBufferCounts();
+        const numUnsubmittedAdds = unsubmitted.numAdds;
+        const numAdds = numUnsubmittedAdds + submitting.numAdds + submitted.numAdds;
+        let results;
+        let baseItemArray = [];
+        let done = false;
+        let unbufferedResultsToIgnore = 0;
+        if (isFetchAll) {
+            results = await this.dataProvider.fetchByOffset(params);
+            if (this.editBuffer.isEmpty(true)) {
+                return results;
             }
-            return resolve(this.dataProvider.fetchByOffset(params).then((baseResults) => {
-                const editBuffer = this.editBuffer;
-                if (!editBuffer.isEmpty()) {
-                    const baseItemArray = baseResults.results;
-                    let sortCriteria = null;
-                    if (baseResults.fetchParameters && baseResults.fetchParameters.sortCriteria) {
-                        sortCriteria = baseResults.fetchParameters.sortCriteria;
-                    }
-                    else {
-                        sortCriteria = params.sortCriteria;
-                    }
-                    this._mergeEdits(baseItemArray, newItemArray, params.filterCriterion, sortCriteria, new MutableKeySet(), baseResults.done);
-                    let actualReturnSize = newItemArray.length;
-                    for (const newItem of newItemArray) {
-                        if (this._isItemRemoved(newItem.metadata.key)) {
-                            --actualReturnSize;
-                        }
-                    }
-                    if ((params.size && actualReturnSize < params.size) ||
-                        (params.size == null && actualReturnSize === 0)) {
-                        if (!baseResults.done) {
-                            const nextParams = {
-                                attributes: params.attributes,
-                                clientId: params.clientId,
-                                filterCriterion: params.filterCriterion,
-                                offset: params.offset + baseResults.results.length,
-                                size: params.size,
-                                sortCriteria: params.sortCriteria
-                            };
-                            return this._fetchFromOffset(nextParams, newItemArray);
-                        }
-                    }
-                    for (let i = 0; i < newItemArray.length; i++) {
-                        if (this._isItemRemoved(newItemArray[i].metadata.key)) {
-                            newItemArray.splice(i, 1);
-                            --i;
-                        }
-                    }
-                    if (params.size && params.size != -1 && newItemArray.length > params.size) {
-                        newItemArray.splice(params.size);
-                    }
-                    return { fetchParameters: params, results: newItemArray, done: baseResults.done };
-                }
-                return baseResults;
-            }));
-        });
+        }
+        else if (offset + size > numAdds) {
+            const numRemoves = unsubmitted.numRemoves + submitting.numRemoves;
+            const numMoveAdds = unsubmitted.numMoveAdds + submitting.numMoveAdds;
+            const numSubmittedOrSubmittingAdds = submitting.numAdds + submitted.numAdds;
+            let overrideParams;
+            if (numRemoves > 0 || numMoveAdds > 0 || numSubmittedOrSubmittingAdds > 0) {
+                overrideParams = {
+                    offset: 0,
+                    size: offset +
+                        size +
+                        numRemoves +
+                        numMoveAdds +
+                        numSubmittedOrSubmittingAdds -
+                        Math.max(numUnsubmittedAdds - offset, 0)
+                };
+                unbufferedResultsToIgnore = Math.max(offset - numAdds, 0);
+            }
+            else if (numUnsubmittedAdds > 0) {
+                overrideParams = {
+                    offset: Math.max(offset - numUnsubmittedAdds, 0),
+                    size: size - Math.max(numUnsubmittedAdds - offset, 0)
+                };
+            }
+            const underlyingFetchParams = { ...params, ...overrideParams };
+            results = await this.dataProvider.fetchByOffset(underlyingFetchParams);
+        }
+        if (results) {
+            baseItemArray = results.results;
+            done = results.done;
+        }
+        if (offset < numAdds) {
+            mergedItems.push(...this._getAllAdds().slice(offset, offset + size));
+        }
+        for (let index = 0; index < baseItemArray.length && (isFetchAll || mergedItems.length < size); index++) {
+            const item = baseItemArray[index];
+            const key = item.metadata.key;
+            if (this.editBuffer.isUpdateTransformed(key) ||
+                this._isItemRemoved(key) ||
+                this.editBuffer.isSubmittingOrSubmitted(key)) {
+                continue;
+            }
+            else if (unbufferedResultsToIgnore > 0) {
+                --unbufferedResultsToIgnore;
+            }
+            else {
+                const updatedItem = this.editBuffer.getItem(key);
+                mergedItems.push(updatedItem ? updatedItem.item : item);
+            }
+        }
+        if (!done && (isFetchAll || mergedItems.length < size)) {
+            const nextParams = {
+                ...params,
+                offset: params.offset + mergedItems.length,
+                size: isFetchAll ? params.size : params.size - mergedItems.length
+            };
+            let extraResults = await this._fetchFromOffset(nextParams);
+            mergedItems.push(...extraResults.results);
+            done = extraResults.done;
+        }
+        return { fetchParameters: params, results: mergedItems, done: done };
     }
     containsKeys(params) {
         const bufferResult = this._fetchByKeysFromBuffer(params);
@@ -1077,7 +1159,7 @@ class BufferingDataProvider {
         });
     }
     fetchByOffset(params) {
-        return this._fetchFromOffset(params, []);
+        return this._fetchFromOffset(params);
     }
     fetchFirst(params) {
         this.lastSortCriteria = params ? params.sortCriteria : null;
@@ -1102,6 +1184,35 @@ class BufferingDataProvider {
         });
         return sizeChange;
     }
+    _getEditBufferCounts() {
+        const submitting = this._getCounts(this.editBuffer.getSubmittingItems());
+        const unsubmitted = this._getCounts(this.editBuffer.getUnsubmittedItems());
+        const submitted = { numAdds: this.editBuffer.getSubmittedAddItems().size };
+        return { submitting, unsubmitted, submitted };
+    }
+    _getCounts(editItems) {
+        let numAdds = 0;
+        let numRemoves = 0;
+        let numMoveAdds = 0;
+        editItems.forEach((value, key) => {
+            if (value.operation === 'add') {
+                ++numAdds;
+            }
+            else if (value.operation === 'remove') {
+                ++numRemoves;
+            }
+            else if (value.operation === 'update' && this.editBuffer.isUpdateTransformed(key)) {
+                ++numMoveAdds;
+            }
+        });
+        return { numAdds, numRemoves, numMoveAdds };
+    }
+    _getAllAdds() {
+        let addOrder = this.editBuffer.getAddItemOrder();
+        return addOrder.map((key) => {
+            return this.editBuffer.getItem(key, true)?.item;
+        });
+    }
     getTotalSize() {
         return this.dataProvider.getTotalSize().then((totalSize) => {
             if (totalSize > -1) {
@@ -1664,47 +1775,6 @@ class BufferingDataProvider {
 BufferingDataProvider._REFRESH = 'refresh';
 BufferingDataProvider._MUTATE = 'mutate';
 BufferingDataProvider._ADDEVENTLISTENER = 'addEventListener';
-class MutableKeySet {
-    constructor() {
-        this.set = new Set();
-    }
-    has(key) {
-        return _has(this.set, key);
-    }
-    add(key) {
-        if (!_has(this.set, key)) {
-            this.set.add(key);
-        }
-    }
-    delete(key) {
-        const ret = _find(this.set, key);
-        if (ret.value) {
-            this.set.delete(ret.key);
-        }
-    }
-}
-const _has = (keys, keyToFind) => {
-    return _find(keys, keyToFind).value;
-};
-const _find = (keys, keyToFind) => {
-    if (keys.size === 0) {
-        return { value: false };
-    }
-    if (typeof keyToFind === 'string' ||
-        typeof keyToFind === 'number' ||
-        typeof keyToFind === 'boolean') {
-        return { value: keys.has(keyToFind), key: keyToFind };
-    }
-    const iterator = keys[Symbol.iterator]();
-    let key = iterator.next();
-    while (!key.done) {
-        if (oj.KeyUtils.equals(key.value, keyToFind)) {
-            return { value: true, key: key.value };
-        }
-        key = iterator.next();
-    }
-    return { value: false };
-};
 EventTargetMixin.applyMixin(BufferingDataProvider);
 oj._registerLegacyNamespaceProp('BufferingDataProvider', BufferingDataProvider);
 

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

@@ -32740,7 +32740,9 @@ class Chart extends BaseComponent {
 
     var context = this.getCtx();
 
-    var animationOnDataChange = this.Options ? this.Options['animationOnDataChange'] : 'none';
+    // current options takes precedent over previous options.
+    var animationOnDataChange =
+      options?.['animationOnDataChange'] || this.Options?.['animationOnDataChange'] || 'none';
 
     // Cache and cleanup objects from the previous render
     var oldChart = animationOnDataChange != 'none' ? new DvtChartDataChange(this) : null;
@@ -32763,7 +32765,12 @@ class Chart extends BaseComponent {
     DvtChartRenderer.render(this, container, new Rectangle(0, 0, this.Width, this.Height));
 
     // . We don't want the inner chart's listeners to be invoked when it is a spark chart, thus we are removing them.
-    if (DvtChartTypeUtils.isSpark(this)) this.EventManager.removeListeners(this);
+    if (DvtChartTypeUtils.isSpark(this)) {
+      this.EventManager.removeListeners(this);
+      // deferred data case won't have xAxis and yAxis initialized.
+      if (this.xAxis) this.xAxis.EventManager.removeListeners(this.xAxis);
+      if (this.yAxis) this.yAxis.EventManager.removeListeners(this.yAxis);
+    }
 
     // Animation Support
     this.StopAnimation();

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

@@ -37,12 +37,12 @@ const oj = {
    * @global
    * @member {string} version JET version numberr
    */
-  version: '16.0.6',
+  version: '16.1.0',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2024-05-03_09-32-18',
+  revision: '2024-05-03_10-41-36',
 
   // 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/ojcspexpressionevaluator-internal.js

@@ -5,7 +5,7 @@
  * as shown at https://oss.oracle.com/licenses/upl/
  * @ignore
  */
-import { ExpParser } from 'ojs/ojexpparser';
+import { ExpParser, NEW_EXP, FUNCTION_EXP, OBJECT_EXP, getKeyValue, ARRAY_EXP, CONDITIONAL_EXP, LOGICAL_EXP, BINARY_EXP, UNARY_EXP, IDENTIFIER, CALL_EXP, MEMBER_EXP, LITERAL } from 'ojs/ojexpparser';
 
 /**
  * @license
@@ -82,6 +82,9 @@ const CspExpressionEvaluatorInternal = function (options) {
     '||': function (a, b) {
       return a || b();
     },
+    '??': function (a, b) {
+      return a ?? b();
+    },
     '&&': function (a, b) {
       return a && b();
     },
@@ -141,6 +144,12 @@ const CspExpressionEvaluatorInternal = function (options) {
     },
     '%': function (a, b) {
       return a % b;
+    },
+    '**': function (a, b) {
+      return a ** b;
+    },
+    instanceof: function (a, b) {
+      return a instanceof b;
     }
   };
 
@@ -159,6 +168,9 @@ const CspExpressionEvaluatorInternal = function (options) {
     },
     '...': function (a) {
       return new _Spread(a);
+    },
+    typeof: function (a) {
+      return typeof a;
     }
   };
 
@@ -171,24 +183,24 @@ const CspExpressionEvaluatorInternal = function (options) {
   // eslint-disable-next-line consistent-return
   function _evaluate(node, contexts) {
     switch (node.type) {
-      case 1: // Identifier
+      case IDENTIFIER:
         return _getValue(contexts, node.name);
 
-      case 2: // 'MemberExpression'
+      case MEMBER_EXP:
         return _evaluateMember(node, contexts)[1];
 
-      case 3: // 'Literal'
+      case LITERAL:
         return node.value;
 
-      case 4: // 'CallExpression'
+      case CALL_EXP:
         var caller;
         var fn;
         var assign;
         switch (node.callee.type) {
-          case 1: // Identifier
+          case IDENTIFIER:
             assign = _getValueWithContext(contexts, node.callee.name);
             break;
-          case 2: // 'MemberExpression'
+          case MEMBER_EXP:
             assign = _evaluateMember(node.callee, contexts);
             break;
           default:
@@ -203,10 +215,19 @@ const CspExpressionEvaluatorInternal = function (options) {
         }
         return fn.apply(caller, _evaluateArray(node.arguments, contexts));
 
-      case 5: // 'UnaryExpression'
-        return _unops[node.operator](_evaluate(node.argument, contexts));
+      case UNARY_EXP:
+        var testValue;
+        try {
+          testValue = _evaluate(node.argument, contexts);
+        } catch (e) {
+          // Undefined identifier will throw an error, don't report it
+          if (node.argument.type !== IDENTIFIER) {
+            throw e;
+          }
+        }
+        return _unops[node.operator](testValue);
 
-      case 6: // 'BinaryExpression'
+      case BINARY_EXP:
         if (node.operator === '=') {
           return _evaluateAssignment(node.left, contexts, _evaluate(node.right, contexts));
         }
@@ -215,26 +236,26 @@ const CspExpressionEvaluatorInternal = function (options) {
           _evaluate(node.right, contexts)
         );
 
-      case 7: // 'LogicalExpression':
+      case LOGICAL_EXP:
         return _binops[node.operator](_evaluate(node.left, contexts), function () {
           return _evaluate(node.right, contexts);
         });
 
-      case 8: // 'ConditionalExpression'
+      case CONDITIONAL_EXP:
         return _evaluate(node.test, contexts)
           ? _evaluate(node.consequent, contexts)
           : _evaluate(node.alternate, contexts);
 
-      case 9: // 'ArrayExpression'
+      case ARRAY_EXP:
         return _evaluateArray(node.elements, contexts);
 
-      case 10: // 'ObjectExpression'
+      case OBJECT_EXP:
         return _evaluateObjectExpression(node, contexts);
 
-      case 11: // 'FunctionExpression'
+      case FUNCTION_EXP:
         return _evaluateFunctionExpression(node, contexts);
 
-      case 12: // 'ConstructorExpression'
+      case NEW_EXP:
         return _evaluateConstructorExpression(node, contexts);
 
       default:
@@ -256,8 +277,8 @@ const CspExpressionEvaluatorInternal = function (options) {
 
   function _evaluateMember(node, contexts) {
     var object = _evaluate(node.object, contexts);
-    if (!object && node.conditional) {
-      // handle conditional chaining operator: test?.prop
+    if (!object && node.optional) {
+      // handle optional chaining operator: test?.prop
       return [];
     } else if (node.computed) {
       return [object, object[_evaluate(node.property, contexts)]];
@@ -267,7 +288,8 @@ const CspExpressionEvaluatorInternal = function (options) {
 
   function _evaluateObjectExpression(node, contexts) {
     return node.properties.reduce(function (acc, curr) {
-      acc[curr.key] = _evaluate(curr.value, contexts);
+      const key = getKeyValue(curr.key);
+      acc[key] = _evaluate(curr.value, contexts);
       return acc;
     }, {});
   }
@@ -292,7 +314,7 @@ const CspExpressionEvaluatorInternal = function (options) {
 
   function _evaluateAssignment(node, contexts, val) {
     switch (node.type) {
-      case 1: // 'Identifier'
+      case IDENTIFIER:
         var name = node.name;
         var target = _getContextForIdentifier(contexts, name);
         if (!target) {
@@ -300,7 +322,7 @@ const CspExpressionEvaluatorInternal = function (options) {
         }
         target[name] = val;
         break;
-      case 2: // 'MemberExpression'
+      case MEMBER_EXP:
         var key = node.computed ? _evaluate(node.property, contexts) : node.property.name;
         _evaluateMember(node, contexts)[0][key] = val;
         break;