@oracle/oraclejet 15.1.10 → 15.1.12

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.10"}' !important; }
+  font-family: '{"name":"stable","targetPlatform":"all","behavior":"redwood","jetReleaseVersion":"v15.1.12"}' !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.10',
+    version: '15.1.12',
     /**
      * @global
      * @member {string} revision JET source code revision number
      */
-    revision: '2024-04-09_15-45-30',
+    revision: '2024-08-27_12-07-50',
 
     // 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,14 +570,11 @@ 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);
-      if (!this._noHistory) {
-        window.history.replaceState(null, 'path', newPath);
-      }
+      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) => {
@@ -586,6 +583,9 @@ 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,6 +732,10 @@ 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}`);
@@ -739,15 +743,8 @@ 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 {
-        // 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);
-        }
+      } else if (currentPath !== newPath) {
+        window.history.pushState(null, 'path', newPath);
       }
       goP = this.sync().catch((ex) => {
         // Clear transitions if transition rejected
@@ -812,7 +809,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('sync overridden');
+        return Promise.reject();
       }
       return s;
     });

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

@@ -4940,140 +4940,20 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
         }
       }
 
-      // 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);
-      }
-
-      // 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;
-        }
+      // 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;
       }
 
+      this._super(key, value, flags);
+
       var processSetOptions;
       if (this._processSetOptions && this._processSetOptions.length > 0) {
         // use the last processSetOptions object, which is the one for the current _setOptions call
@@ -5083,7 +4963,36 @@ 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;
-        this._SyncValueWithValueItem(value, this.options.value);
+
+        // 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);
+        }
       } 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/ojselectcombobox.js

@@ -9033,7 +9033,7 @@ var __oj_select_many_metadata =
             if (
               (!selectionData && value !== '') ||
               (selectionData && selectionData.label !== value) ||
-              (!this.ojContext.isValid() && value !== this.ojContext._GetDisplayValue())
+              (!this.ojContext.isValid() && value !== this._previousDisplayValue)
             ) {
               var onSelectReturn = this._onSelect(valopt, options, e);
               optionalCleanupPromise = onSelectReturn;

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

@@ -1560,7 +1560,6 @@ 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;
@@ -1576,41 +1575,18 @@ var __oj_select_single_metadata =
         }
       }
 
-      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, 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();
-
-            this._setOption('value', newVal);
+      // 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();
-          }
+      // 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);
 
-          this._abstractLovBase.handleDataProviderEvent(event);
+      resolveValueChangeFunc();
 
-          resolveBusyState();
-        }.bind(this)
-      );
+      this._abstractLovBase.handleDataProviderEvent(event);
     },
 
     /**

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.10',
+  version: '15.1.12',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2024-04-09_15-45-30',
+  revision: '2024-08-27_12-07-50',
 
   // 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,14 +570,11 @@ CoreRouter.prototype.sync = function () {
     const transition = pendingTransitions.shift();
     const newRoutes = this._getParentRoutes().concat(this._getPendingState(transition));
     const newPath = urlAdapter.getUrlForRoutes(newRoutes);
-    if (!this._noHistory) {
-      window.history.replaceState(null, 'path', newPath);
-    }
+    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) => {
@@ -586,6 +583,9 @@ 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,6 +732,10 @@ 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}`);
@@ -739,15 +743,8 @@ 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 {
-      // 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);
-      }
+    } else if (currentPath !== newPath) {
+      window.history.pushState(null, 'path', newPath);
     }
     goP = this.sync().catch((ex) => {
       // Clear transitions if transition rejected
@@ -812,7 +809,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('sync overridden');
+      return Promise.reject();
     }
     return s;
   });

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

@@ -4953,140 +4953,20 @@ oj.__registerWidget('oj.ojSelectBase', $.oj.editableValue, {
       }
     }
 
-    // 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);
-    }
-
-    // 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;
-      }
+    // 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;
     }
 
+    this._super(key, value, flags);
+
     var processSetOptions;
     if (this._processSetOptions && this._processSetOptions.length > 0) {
       // use the last processSetOptions object, which is the one for the current _setOptions call
@@ -5096,7 +4976,36 @@ 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;
-      this._SyncValueWithValueItem(value, this.options.value);
+
+      // 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);
+      }
     } 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_esm/ojselectcombobox.js

@@ -9043,7 +9043,7 @@ const _AbstractSingleChoice = _ComboUtils.clazz(_AbstractOjChoice, {
           if (
             (!selectionData && value !== '') ||
             (selectionData && selectionData.label !== value) ||
-            (!this.ojContext.isValid() && value !== this.ojContext._GetDisplayValue())
+            (!this.ojContext.isValid() && value !== this._previousDisplayValue)
           ) {
             var onSelectReturn = this._onSelect(valopt, options, e);
             optionalCleanupPromise = onSelectReturn;