@oracle/oraclejet 15.1.8 → 15.1.10

package/dist/css/stable/oj-stable.css

@@ -333,7 +333,7 @@
   visibility: hidden; }
 
 .oj-theme-json {
-  font-family: '{"name":"stable","targetPlatform":"all","behavior":"redwood","jetReleaseVersion":"v15.1.8"}' !important; }
+  font-family: '{"name":"stable","targetPlatform":"all","behavior":"redwood","jetReleaseVersion":"v15.1.10"}' !important; }
 
 .oj-helper-hidden-accessible {
   border: 0;

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

@@ -37,12 +37,12 @@ define(['ojs/ojlogger'], function (Logger) { 'use strict';
      * @global
      * @member {string} version JET version numberr
      */
-    version: '15.1.8',
+    version: '15.1.10',
     /**
      * @global
      * @member {string} revision JET source code revision number
      */
-    revision: '2024-02-11_13-53-32',
+    revision: '2024-04-09_15-45-30',
 
     // 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/ojcorerouter.js

@@ -570,11 +570,14 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
       const transition = pendingTransitions.shift();
       const newRoutes = this._getParentRoutes().concat(this._getPendingState(transition));
       const newPath = urlAdapter.getUrlForRoutes(newRoutes);
-      window.history.replaceState(null, 'path', newPath);
+      if (!this._noHistory) {
+        window.history.replaceState(null, 'path', newPath);
+      }
       route = transition;
     } else {
       route = this._getRouteSegment();
     }
+
     // Transition to the new route, or a default one if no current one exists
     return this._execute(route || { path: '', params: {} })
       .then((state) => {
@@ -583,9 +586,6 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
         var childRouter = this.childRouter;
         if (childRouter) {
           p = childRouter.sync();
-        } else if (!this._noHistory) {
-          // Cleanup noHistorySegments after navigating any history-tracking routers
-          noHistorySegments = [];
         }
         return p;
       })
@@ -732,10 +732,6 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
       // Get the current routes for all active routers, and compare that to the
       // new routes for this transition.
       const currentPath = urlAdapter.getUrlForRoutes(getActiveRoutes());
-      // Insert the new transitions after the current router's route offset
-      const newRoutes = this._getParentRoutes().concat(this._getPendingState(first, true));
-      const newPath = urlAdapter.getUrlForRoutes(newRoutes);
-
       const prevNoHistorySegments = noHistorySegments;
       if (this._noHistory) {
         Logger.info(`Navigating non-history tracking router(${this._name}) to ${path}`);
@@ -743,8 +739,15 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
         // to store their transitions. Replace the segments after our index with
         // the new transitions
         noHistorySegments = noHistorySegments.slice(0, this._noHistoryOffset).concat(transitions);
-      } else if (currentPath !== newPath) {
-        window.history.pushState(null, 'path', newPath);
+      } else {
+        // Cleanup noHistorySegments when navigating any history-tracking routers
+        noHistorySegments = [];
+        // Insert the new transitions after the current router's route offset
+        const newRoutes = this._getParentRoutes().concat(this._getPendingState(first, true));
+        const newPath = urlAdapter.getUrlForRoutes(newRoutes);
+        if (currentPath !== newPath) {
+          window.history.pushState(null, 'path', newPath);
+        }
       }
       goP = this.sync().catch((ex) => {
         // Clear transitions if transition rejected
@@ -809,7 +812,7 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
       if (activeSync !== this._activeSync) {
         // If this isn't the latest sync, then reject the Promise because another
         // sync() is already underway
-        return Promise.reject();
+        return Promise.reject('sync overridden');
       }
       return s;
     });

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

@@ -4940,19 +4940,139 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
         }
       }
 
-      // JET-55775 - oj-select-single initiates fetch even when valueItem is provided in preact wrapper
-      // If we get a value update, while we are waiting for the valueItem update microtask, we can safely
-      // ignore the value update, if and only if the value is the same as the valueItem that we are currently
-      // processing.
-      if (
-        key === 'value' &&
-        this._currentProcessingValueItem &&
-        this._currentProcessingValueItem.key === value
-      ) {
-        return;
+      // JET-64632 - DataProvider refresh event can wipe out currently selected value
+      // If we get a DP refresh event we may re-set the currently selected value so that we fetch
+      // new data for it, in which case we don't want to fire a change event, so don't call the
+      // superclass.
+      var bSkipSuperclassCall = key === 'value' && this.options.value === value;
+
+      if (!bSkipSuperclassCall) {
+        this._super(key, value, flags);
       }
 
-      this._super(key, value, flags);
+      // In vdom architecture, there are multiple issues with value and valueItem property that we need to
+      // handle.
+      //
+      // JET-51307 - Wrapping select single with value item and value integrations going into loop
+      // with multiple instances of LOV in a page
+      // If we're wrapped by a VComponent and there are multiple instances on the page
+      // all bound to the same valueItem, then if the user selects a new value in one instance,
+      // the page can go into an infinite loop.
+      // If we synchronously update the value on our DOM element here, then when the next preact
+      // render compares the stale vcomp value property against the new value in the DOM, preact
+      // determines it must push the stale value property back down onto us, which then causes
+      // the valueItem to get sync'ed again, and the loop goes on.
+      //
+      // JET-55775 - oj-select-single initiates fetch even when valueItem is provided in preact wrapper
+      // In preact, when value & valueItem are set at the same time, we will receive them one after the other.
+      // So, if we process the value when we get it, then we might initiate an unnecessary fetch as we will
+      // later get the data from valueItem.
+      //
+      // JET-64359 - select - single handling of mutation on both value and valueItem properties coming from preact
+      // Also, when either value or valueItem property is ignored when updating props in the wrapper vcomponent,
+      // we will get a setOption call with a null / default value for that property. In these cases, depending on the
+      // order we receive the call, we might incorrectly end up setting the null / default value.
+      //
+      // In order to address all these cases, if we know we are in the vdom land, we will queue a microtask to process
+      // the value and valueItem. Since, preact calls setOptions synchronously for each option, in our microtask callback
+      // we will have access to the latest value for all the properties. We will be setting some flags here to determine
+      // which properties are set by the preact. Then we can use the flags as well as the latest value to determine
+      // how to process the value and valueItem correctly.
+      const elemState = ojcustomelementUtils.CustomElementUtils.getElementState(this.OuterWrapper);
+      if (elemState.getBindingProviderType() === 'preact') {
+        const processValueAndValueItem = () => {
+          // Get the latest value and valueItem
+          const _valueItem = this.options[this._GetValueItemPropertyName()];
+          const _value = this.options.value;
+          // Determine empty states
+          // Note that _Is*****ForPlaceholder simply checks whether the value/valueItem
+          // represents the empty/null state.
+          const isEmptyValue = this._IsValueForPlaceholder(_value);
+          const isEmptyValueItem = this._IsValueItemForPlaceholder(_valueItem);
+
+          // Cleanup function - things to do when exiting the microtask
+          const cleanup = () => {
+            // reset all the flags
+            this._processingSetOptionsMicroTask = false;
+            this._processingValue = false;
+            this._processingValueItem = false;
+          };
+
+          // This will use the value for updating the component
+          const updateUsingValue = () => {
+            abstractLovBase.setValue(_value);
+
+            //  - placeholder is not displayed after removing selections from select many
+            //  - resetting value when value-item and placeholder are set throws exception
+            if (isEmptyValue) {
+              // Note that _GetDefaultValueItemForPlaceholder is just a getter for the
+              // valueItem representing the empty state.
+              this._SetValueItem(this._GetDefaultValueItemForPlaceholder());
+            } else {
+              // update valueItem
+              this._UpdateValueItem(_value);
+            }
+
+            // need to update display value again after valueItem is set correctly
+            this._SetDisplayValue();
+          };
+          // This will use the valueItem for updating the component
+          const updateUsingValueItem = () => {
+            this._valueItemSetInternally = false;
+            this._SyncValueWithValueItem(_valueItem, _value);
+          };
+
+          // If both value and valueItem are provided, then compare them to decide
+          // what to do
+          if (this._processingValue && this._processingValueItem) {
+            // if valueItem and value are not null, and they are conflicting then
+            // throw an error
+            if (!isEmptyValue && !isEmptyValueItem && _valueItem.key !== _value) {
+              // make sure to clean up before throwing an error
+              cleanup();
+              throw new Error('Select Single: conflicting value-item and value');
+            }
+
+            // At this point, either one of them is empty or they both have the same
+            // key. So, if valueItem is not empty, use it. Otherwise, use the value.
+            if (!isEmptyValueItem) {
+              updateUsingValueItem();
+            } else {
+              updateUsingValue();
+            }
+          }
+          // If only value is provided, then use the value
+          else if (this._processingValue) {
+            updateUsingValue();
+          }
+          // If only valueItem is provided then use the valueItem for updating the value
+          else if (this._processingValueItem) {
+            updateUsingValueItem();
+          }
+
+          // Finally clean things up
+          cleanup();
+        };
+
+        // If we receive a value or valueItem setOption call, set the flag and
+        // defer processing them
+        if (key === 'value') {
+          this._processingValue = true;
+        } else if (key === this._GetValueItemPropertyName()) {
+          this._processingValueItem = true;
+        }
+
+        // if we are processing value or valueItem, then queue a microtask to
+        // process them together. Do this only if it is not already queued. Then
+        // return early without doing anything else.
+        if (this._processingValue || this._processingValueItem) {
+          if (!this._processingSetOptionsMicroTask) {
+            this._processingSetOptionsMicroTask = true;
+            window.queueMicrotask(processValueAndValueItem);
+          }
+          return;
+        }
+      }
 
       var processSetOptions;
       if (this._processSetOptions && this._processSetOptions.length > 0) {
@@ -4963,36 +5083,7 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
       //  - need to be able to specify the initial value of select components bound to dprv
       if (key === this._GetValueItemPropertyName()) {
         this._valueItemSetInternally = false;
-
-        // JET-51307 - Wrapping select single with value item and value integrations going into loop
-        // with multiple instances of LOV in a page
-        // If we're wrapped by a VComponent and there are multiple instances on the page
-        // all bound to the same valueItem, then if the user selects a new value in one instance,
-        // the page can go into an infinite loop.
-        // If we synchronously update the value on our DOM element here, then when the next preact
-        // render compares the stale vcomp value property against the new value in the DOM, preact
-        // determines it must push the stale value property back down onto us, which then causes
-        // the valueItem to get sync'ed again, and the loop goes on.
-        // By delaying updating the value on the DOM element here, we avoid preact finding a
-        // difference between its properties and the DOM value, so preact does not push the stale
-        // value prop back down on us.
-        const elemState = ojcustomelementUtils.CustomElementUtils.getElementState(this.OuterWrapper);
-        if (elemState.getBindingProviderType() === 'preact') {
-          // JET-55775 - oj-select-single initiates fetch even when valueItem is provided in preact wrapper
-          // In preact, when value & valueItem are set at the same time, we will receive them one after the other.
-          // Also, we get the valueItem update before the value update. So, we need to treat it as a single update
-          // and ignore the value update when we are waiting for the following microtask to run.
-          this._currentProcessingValueItem = value;
-          window.queueMicrotask(
-            function () {
-              this._SyncValueWithValueItem(value, this.options.value);
-              // as we processed the valueItem, delete the flag
-              this._currentProcessingValueItem = undefined;
-            }.bind(this)
-          );
-        } else {
-          this._SyncValueWithValueItem(value, this.options.value);
-        }
+        this._SyncValueWithValueItem(value, this.options.value);
       } else if (key === 'value') {
         // JET-34601 - SELECT SINGLE- CHANGING DISABLED PROPERTY GIVES A GLOWING EFFECT
         // save the processing function for execution in _setOptions

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

@@ -1560,6 +1560,7 @@ var __oj_select_single_metadata =
       }
 
       var newVal = this.options.value;
+      var origVal = this.options.value;
       if (event.type === 'mutate') {
         if (event.detail.remove != null) {
           var keys = event.detail.remove.keys;
@@ -1575,18 +1576,41 @@ var __oj_select_single_metadata =
         }
       }
 
-      // JET-42413: set flag while we're processing a value change so that if an app makes
-      // changes to the component from within the change listener, we can defer processing the
-      // new change until after we're done processing the current change
-      var resolveValueChangeFunc = this._StartMakingInternalValueChange();
+      var resolveBusyState = this._AddBusyState('ojSelectSingle processing DataProvider event');
+
+      // JET-64632 - DataProvider refresh event can wipe out currently selected value
+      // defer handling the event until the throttle promise (which is hooked into JET's Knockout
+      // throttling timeout) resolves so that we can correctly handle the case where we get both a
+      // new value set and a DP event
+      var throttlePromise = this._GetThrottlePromise();
+      throttlePromise.then(
+        function () {
+          // if the component was released before the promise resolved, simply resolve the busy
+          // state and return
+          if (this._bReleasedResources) {
+            resolveBusyState();
+            return;
+          }
 
-      // if the event wasn't dispatched internally, need to re-set the value now that the label may
-      // be available, or because a mutation event removed a selected value
-      this._setOption('value', newVal);
+          // if the event wasn't dispatched internally, and if the value has not been changed since
+          // the event was received, need to re-set the value now that the label may be available,
+          // or because a mutation event removed a selected value
+          if (origVal === this.options.value) {
+            // JET-42413: set flag while we're processing a value change so that if an app makes
+            // changes to the component from within the change listener, we can defer processing the
+            // new change until after we're done processing the current change
+            var resolveValueChangeFunc = this._StartMakingInternalValueChange();
 
-      resolveValueChangeFunc();
+            this._setOption('value', newVal);
 
-      this._abstractLovBase.handleDataProviderEvent(event);
+            resolveValueChangeFunc();
+          }
+
+          this._abstractLovBase.handleDataProviderEvent(event);
+
+          resolveBusyState();
+        }.bind(this)
+      );
     },
 
     /**

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

@@ -37,12 +37,12 @@ const oj = {
    * @global
    * @member {string} version JET version numberr
    */
-  version: '15.1.8',
+  version: '15.1.10',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2024-02-11_13-53-32',
+  revision: '2024-04-09_15-45-30',
 
   // 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

@@ -570,11 +570,14 @@ CoreRouter.prototype.sync = function () {
     const transition = pendingTransitions.shift();
     const newRoutes = this._getParentRoutes().concat(this._getPendingState(transition));
     const newPath = urlAdapter.getUrlForRoutes(newRoutes);
-    window.history.replaceState(null, 'path', newPath);
+    if (!this._noHistory) {
+      window.history.replaceState(null, 'path', newPath);
+    }
     route = transition;
   } else {
     route = this._getRouteSegment();
   }
+
   // Transition to the new route, or a default one if no current one exists
   return this._execute(route || { path: '', params: {} })
     .then((state) => {
@@ -583,9 +586,6 @@ CoreRouter.prototype.sync = function () {
       var childRouter = this.childRouter;
       if (childRouter) {
         p = childRouter.sync();
-      } else if (!this._noHistory) {
-        // Cleanup noHistorySegments after navigating any history-tracking routers
-        noHistorySegments = [];
       }
       return p;
     })
@@ -732,10 +732,6 @@ CoreRouter.prototype.go = function (...transitions) {
     // Get the current routes for all active routers, and compare that to the
     // new routes for this transition.
     const currentPath = urlAdapter.getUrlForRoutes(getActiveRoutes());
-    // Insert the new transitions after the current router's route offset
-    const newRoutes = this._getParentRoutes().concat(this._getPendingState(first, true));
-    const newPath = urlAdapter.getUrlForRoutes(newRoutes);
-
     const prevNoHistorySegments = noHistorySegments;
     if (this._noHistory) {
       info(`Navigating non-history tracking router(${this._name}) to ${path}`);
@@ -743,8 +739,15 @@ CoreRouter.prototype.go = function (...transitions) {
       // to store their transitions. Replace the segments after our index with
       // the new transitions
       noHistorySegments = noHistorySegments.slice(0, this._noHistoryOffset).concat(transitions);
-    } else if (currentPath !== newPath) {
-      window.history.pushState(null, 'path', newPath);
+    } else {
+      // Cleanup noHistorySegments when navigating any history-tracking routers
+      noHistorySegments = [];
+      // Insert the new transitions after the current router's route offset
+      const newRoutes = this._getParentRoutes().concat(this._getPendingState(first, true));
+      const newPath = urlAdapter.getUrlForRoutes(newRoutes);
+      if (currentPath !== newPath) {
+        window.history.pushState(null, 'path', newPath);
+      }
     }
     goP = this.sync().catch((ex) => {
       // Clear transitions if transition rejected
@@ -809,7 +812,7 @@ CoreRouter.prototype._prepublish = function (state) {
     if (activeSync !== this._activeSync) {
       // If this isn't the latest sync, then reject the Promise because another
       // sync() is already underway
-      return Promise.reject();
+      return Promise.reject('sync overridden');
     }
     return s;
   });

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

@@ -4953,19 +4953,139 @@ oj.__registerWidget('oj.ojSelectBase', $.oj.editableValue, {
       }
     }
 
-    // JET-55775 - oj-select-single initiates fetch even when valueItem is provided in preact wrapper
-    // If we get a value update, while we are waiting for the valueItem update microtask, we can safely
-    // ignore the value update, if and only if the value is the same as the valueItem that we are currently
-    // processing.
-    if (
-      key === 'value' &&
-      this._currentProcessingValueItem &&
-      this._currentProcessingValueItem.key === value
-    ) {
-      return;
+    // JET-64632 - DataProvider refresh event can wipe out currently selected value
+    // If we get a DP refresh event we may re-set the currently selected value so that we fetch
+    // new data for it, in which case we don't want to fire a change event, so don't call the
+    // superclass.
+    var bSkipSuperclassCall = key === 'value' && this.options.value === value;
+
+    if (!bSkipSuperclassCall) {
+      this._super(key, value, flags);
     }
 
-    this._super(key, value, flags);
+    // In vdom architecture, there are multiple issues with value and valueItem property that we need to
+    // handle.
+    //
+    // JET-51307 - Wrapping select single with value item and value integrations going into loop
+    // with multiple instances of LOV in a page
+    // If we're wrapped by a VComponent and there are multiple instances on the page
+    // all bound to the same valueItem, then if the user selects a new value in one instance,
+    // the page can go into an infinite loop.
+    // If we synchronously update the value on our DOM element here, then when the next preact
+    // render compares the stale vcomp value property against the new value in the DOM, preact
+    // determines it must push the stale value property back down onto us, which then causes
+    // the valueItem to get sync'ed again, and the loop goes on.
+    //
+    // JET-55775 - oj-select-single initiates fetch even when valueItem is provided in preact wrapper
+    // In preact, when value & valueItem are set at the same time, we will receive them one after the other.
+    // So, if we process the value when we get it, then we might initiate an unnecessary fetch as we will
+    // later get the data from valueItem.
+    //
+    // JET-64359 - select - single handling of mutation on both value and valueItem properties coming from preact
+    // Also, when either value or valueItem property is ignored when updating props in the wrapper vcomponent,
+    // we will get a setOption call with a null / default value for that property. In these cases, depending on the
+    // order we receive the call, we might incorrectly end up setting the null / default value.
+    //
+    // In order to address all these cases, if we know we are in the vdom land, we will queue a microtask to process
+    // the value and valueItem. Since, preact calls setOptions synchronously for each option, in our microtask callback
+    // we will have access to the latest value for all the properties. We will be setting some flags here to determine
+    // which properties are set by the preact. Then we can use the flags as well as the latest value to determine
+    // how to process the value and valueItem correctly.
+    const elemState = CustomElementUtils.getElementState(this.OuterWrapper);
+    if (elemState.getBindingProviderType() === 'preact') {
+      const processValueAndValueItem = () => {
+        // Get the latest value and valueItem
+        const _valueItem = this.options[this._GetValueItemPropertyName()];
+        const _value = this.options.value;
+        // Determine empty states
+        // Note that _Is*****ForPlaceholder simply checks whether the value/valueItem
+        // represents the empty/null state.
+        const isEmptyValue = this._IsValueForPlaceholder(_value);
+        const isEmptyValueItem = this._IsValueItemForPlaceholder(_valueItem);
+
+        // Cleanup function - things to do when exiting the microtask
+        const cleanup = () => {
+          // reset all the flags
+          this._processingSetOptionsMicroTask = false;
+          this._processingValue = false;
+          this._processingValueItem = false;
+        };
+
+        // This will use the value for updating the component
+        const updateUsingValue = () => {
+          abstractLovBase.setValue(_value);
+
+          //  - placeholder is not displayed after removing selections from select many
+          //  - resetting value when value-item and placeholder are set throws exception
+          if (isEmptyValue) {
+            // Note that _GetDefaultValueItemForPlaceholder is just a getter for the
+            // valueItem representing the empty state.
+            this._SetValueItem(this._GetDefaultValueItemForPlaceholder());
+          } else {
+            // update valueItem
+            this._UpdateValueItem(_value);
+          }
+
+          // need to update display value again after valueItem is set correctly
+          this._SetDisplayValue();
+        };
+        // This will use the valueItem for updating the component
+        const updateUsingValueItem = () => {
+          this._valueItemSetInternally = false;
+          this._SyncValueWithValueItem(_valueItem, _value);
+        };
+
+        // If both value and valueItem are provided, then compare them to decide
+        // what to do
+        if (this._processingValue && this._processingValueItem) {
+          // if valueItem and value are not null, and they are conflicting then
+          // throw an error
+          if (!isEmptyValue && !isEmptyValueItem && _valueItem.key !== _value) {
+            // make sure to clean up before throwing an error
+            cleanup();
+            throw new Error('Select Single: conflicting value-item and value');
+          }
+
+          // At this point, either one of them is empty or they both have the same
+          // key. So, if valueItem is not empty, use it. Otherwise, use the value.
+          if (!isEmptyValueItem) {
+            updateUsingValueItem();
+          } else {
+            updateUsingValue();
+          }
+        }
+        // If only value is provided, then use the value
+        else if (this._processingValue) {
+          updateUsingValue();
+        }
+        // If only valueItem is provided then use the valueItem for updating the value
+        else if (this._processingValueItem) {
+          updateUsingValueItem();
+        }
+
+        // Finally clean things up
+        cleanup();
+      };
+
+      // If we receive a value or valueItem setOption call, set the flag and
+      // defer processing them
+      if (key === 'value') {
+        this._processingValue = true;
+      } else if (key === this._GetValueItemPropertyName()) {
+        this._processingValueItem = true;
+      }
+
+      // if we are processing value or valueItem, then queue a microtask to
+      // process them together. Do this only if it is not already queued. Then
+      // return early without doing anything else.
+      if (this._processingValue || this._processingValueItem) {
+        if (!this._processingSetOptionsMicroTask) {
+          this._processingSetOptionsMicroTask = true;
+          window.queueMicrotask(processValueAndValueItem);
+        }
+        return;
+      }
+    }
 
     var processSetOptions;
     if (this._processSetOptions && this._processSetOptions.length > 0) {
@@ -4976,36 +5096,7 @@ oj.__registerWidget('oj.ojSelectBase', $.oj.editableValue, {
     //  - need to be able to specify the initial value of select components bound to dprv
     if (key === this._GetValueItemPropertyName()) {
       this._valueItemSetInternally = false;
-
-      // JET-51307 - Wrapping select single with value item and value integrations going into loop
-      // with multiple instances of LOV in a page
-      // If we're wrapped by a VComponent and there are multiple instances on the page
-      // all bound to the same valueItem, then if the user selects a new value in one instance,
-      // the page can go into an infinite loop.
-      // If we synchronously update the value on our DOM element here, then when the next preact
-      // render compares the stale vcomp value property against the new value in the DOM, preact
-      // determines it must push the stale value property back down onto us, which then causes
-      // the valueItem to get sync'ed again, and the loop goes on.
-      // By delaying updating the value on the DOM element here, we avoid preact finding a
-      // difference between its properties and the DOM value, so preact does not push the stale
-      // value prop back down on us.
-      const elemState = CustomElementUtils.getElementState(this.OuterWrapper);
-      if (elemState.getBindingProviderType() === 'preact') {
-        // JET-55775 - oj-select-single initiates fetch even when valueItem is provided in preact wrapper
-        // In preact, when value & valueItem are set at the same time, we will receive them one after the other.
-        // Also, we get the valueItem update before the value update. So, we need to treat it as a single update
-        // and ignore the value update when we are waiting for the following microtask to run.
-        this._currentProcessingValueItem = value;
-        window.queueMicrotask(
-          function () {
-            this._SyncValueWithValueItem(value, this.options.value);
-            // as we processed the valueItem, delete the flag
-            this._currentProcessingValueItem = undefined;
-          }.bind(this)
-        );
-      } else {
-        this._SyncValueWithValueItem(value, this.options.value);
-      }
+      this._SyncValueWithValueItem(value, this.options.value);
     } else if (key === 'value') {
       // JET-34601 - SELECT SINGLE- CHANGING DISABLED PROPERTY GIVES A GLOWING EFFECT
       // save the processing function for execution in _setOptions