@oracle/oraclejet 10.1.1 → 10.1.6

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

@@ -199,6 +199,8 @@ define(['exports', 'ojs/ojdomutils', 'ojs/ojlistdataproviderview', 'jquery', 'oj
             if (props.suggestions) {
                 this._dataProvider = this._wrapDataProviderIfNeeded(this.props.suggestions);
             }
+            const agentInfo = oj.AgentUtils.getAgentInfo();
+            this._isAndroidDevice = agentInfo.os === oj.AgentUtils.OS.ANDROID;
             this.state = {
                 dropdownOpen: false,
                 dropdownAbove: false,
@@ -412,7 +414,7 @@ define(['exports', 'ojs/ojdomutils', 'ojs/ojlistdataproviderview', 'jquery', 'oj
             });
         }
         _handleInput(event) {
-            if (!this._isComposing) {
+            if (!this._isComposing || this._isAndroidDevice) {
                 let autocomplete;
                 const filterText = this.state.filterText || '';
                 const lowercaseFilter = filterText.toLowerCase();

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

@@ -1565,6 +1565,10 @@ var __oj_text_area_metadata =
         var readOnly = this.options.readOnly;
 
         this._rtl = this._GetReadingDirection() === 'rtl';
+        // JET-39086 - raw-value is not getting updated until space in android devices
+        // In android device we need to update rawValue even for composition events
+        // Get and store agent info
+        this._isAndroidDevice = (oj.AgentUtils.getAgentInfo().os === oj.AgentUtils.OS.ANDROID);
 
         // update element state using options
         if (typeof readOnly === 'boolean') {
@@ -2192,7 +2196,20 @@ var __oj_text_area_metadata =
         // The keystroke sequence is bracketed by compositionstart and compositionend events,
         // and each keystroke also fires the input event.  Including the intermediate input
         // in rawValue makes it hard to do meaningful validation.
-        if (!this._isComposing) {
+        // JET-39086 - raw-value is not getting updated until space in android devices
+        // In android devices, typing in an English word will behave similar to what one
+        // would see when they compose a CJK character in desktop devices. So, we need to
+        // update the raw-value for all the input events in Android devices without considering
+        // composition events so that the property gets updated for each english character and not
+        // only for delimiters. In GBoard all the CJK keyboard layouts directly allow users
+        // to input a CJK character, so we do not need to rely on composition events for that.
+        // In Japanese keyboard, one of the three available layouts uses english chars
+        // to compose a Japanese character in which case circumventing the logic would end up
+        // updating the property with garbage values. But, it is highly unlikely for one to
+        // use this layout as the other two layouts would allow users to directly type in Japanese
+        // characters. So, for now we will not have to worry about composition events in
+        // Android devices.
+        if (!this._isComposing || this._isAndroidDevice) {
           if (this._hasMaxLength()) {
             this._filterTextAndSetValues(this.lastFilteredText,
               this._GetContentElement().val(), false, true);

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

@@ -577,6 +577,7 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget'], function
             cachedData[ListDataProviderView._ITEMS] = [];
             cachedData[ListDataProviderView._DONE] = false;
             cachedData[ListDataProviderView._STARTINDEX] = 0;
+            cachedData[ListDataProviderView._LASTDONEHASDATA] = false;
             let size = params != null ? params[ListDataProviderView._SIZE] : null;
             let sortCriteria = params != null ? params[ListDataProviderView._SORTCRITERIA] : null;
             if (sortCriteria == null) {
@@ -630,9 +631,17 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget'], function
                 let cachedAsyncIterator = this.dataProvider[ListDataProviderView._FETCHFIRST](updatedParams)[Symbol.asyncIterator]();
                 return new this.AsyncIterable(this, new this.AsyncIterator(this, (function (cachedData, cachedAsyncIterator) {
                     return function () {
+                        if (cachedData[ListDataProviderView._LASTDONEHASDATA]) {
+                            cachedData[ListDataProviderView._LASTDONEHASDATA] = false;
+                            return Promise.resolve(new self.AsyncIteratorReturnResult(self, new self.FetchListResult(this, params, [], [])));
+                        }
                         return cachedAsyncIterator.next().then(function (result) {
-                            let data = result[ListDataProviderView._VALUE][ListDataProviderView._DATA];
-                            let metadata = result[ListDataProviderView._VALUE][ListDataProviderView._METADATA];
+                            let resultValue = result[ListDataProviderView._VALUE];
+                            if (!resultValue) {
+                                resultValue = { data: [], metadata: [], fetchParameters: null };
+                            }
+                            const data = resultValue[ListDataProviderView._DATA];
+                            const metadata = resultValue[ListDataProviderView._METADATA];
                             let items = data.map(function (value, index) {
                                 return new self.Item(self, metadata[index], data[index]);
                             });
@@ -644,7 +653,7 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget'], function
                             cachedData[ListDataProviderView._DONE] = result[ListDataProviderView._DONE];
                             let size = params != null ? params[ListDataProviderView._SIZE] : null;
                             let offset = params != null ? params[ListDataProviderView._OFFSET] : null;
-                            let resultFetchParams = result[ListDataProviderView._VALUE][ListDataProviderView._FETCHPARAMETERS];
+                            let resultFetchParams = resultValue[ListDataProviderView._FETCHPARAMETERS];
                             let resultSortCriteria = resultFetchParams != null
                                 ? resultFetchParams[ListDataProviderView._SORTCRITERIA]
                                 : null;
@@ -748,7 +757,7 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget'], function
                 let mappedFilterCriterion = this._getMappedFilterCriterion(params[ListDataProviderView._FILTERCRITERION]);
                 this._filterResult(mappedFilterCriterion, cachedItems);
             }
-            if (cachedItems.length < fetchSize) {
+            if (params && params[ListDataProviderView._SIZE] > 0 && cachedItems.length < fetchSize) {
                 if (!cachedData[ListDataProviderView._DONE]) {
                     return cachedAsyncIterator.next().then(function (nextResult) {
                         let data = nextResult[ListDataProviderView._VALUE][ListDataProviderView._DATA];
@@ -763,10 +772,7 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget'], function
                         let mappedResult = self._getMappedItems(items);
                         self._cacheResult(cachedData, mappedResult);
                         cachedData[ListDataProviderView._DONE] = nextResult[ListDataProviderView._DONE];
-                        if (data.length === 0) {
-                            return self._createResultPromise(params, cachedData, cachedItems);
-                        }
-                        return self._fetchUntilOffset(nextResult[ListDataProviderView._VALUE][ListDataProviderView._FETCHPARAMETERS], offset, data.length, cachedData, cachedAsyncIterator);
+                        return self._fetchUntilOffset(params, offset, data.length, cachedData, cachedAsyncIterator);
                     });
                 }
             }
@@ -781,7 +787,16 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget'], function
             let metadata = cachedItems.map(function (item) {
                 return item[ListDataProviderView._METADATA];
             });
-            if (data.length === 0) {
+            let isDone = false;
+            if (cachedData[ListDataProviderView._DONE]) {
+                if (data.length === 0) {
+                    isDone = true;
+                }
+                else {
+                    cachedData[ListDataProviderView._LASTDONEHASDATA] = true;
+                }
+            }
+            if (isDone) {
                 return Promise.resolve(new this.AsyncIteratorReturnResult(this, new this.FetchListResult(this, params, data, metadata)));
             }
             return Promise.resolve(new this.AsyncIteratorYieldResult(this, new this.FetchListResult(this, params, data, metadata)));
@@ -915,6 +930,7 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget'], function
     ListDataProviderView._FETCHPARAMETERS = 'fetchParameters';
     ListDataProviderView._VALUE = 'value';
     ListDataProviderView._DONE = 'done';
+    ListDataProviderView._LASTDONEHASDATA = 'lastDoneHasData';
     ListDataProviderView._DATAMAPPING = 'dataMapping';
     ListDataProviderView._MAPFIELDS = 'mapFields';
     ListDataProviderView._MAPSORTCRITERIA = 'mapSortCriteria';

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

@@ -5104,7 +5104,22 @@ var __oj_list_view_metadata =
           event.preventDefault();
         } else {
           // click on item
-          var item = this._findItem(target);
+          var item = this._findItem(target, true);
+          if (item != null && this._isClickthroughDisabled(item)) {
+            // if the target is an input element and also a descendent of an element with
+            // clickthrough disabled (only when data-oj-clickthrough syntax is used), we'll still
+            // need to make it as current and enter actionable mode
+            if (DataCollectionUtils.isClickthroughDisabled(item.get(0)) &&
+              this._isInputElement(target.get(0))) {
+              item = this.FindItem(target.get(0));
+              if (item != null) {
+                this.HandleClickActive(item, event);
+                this._enterActionableMode();
+              }
+            }
+            item = null;
+          }
+
           if (item == null || item.length === 0) {
             // can't find item
             return;

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

@@ -6793,13 +6793,6 @@ var __oj_tab_bar_metadata =
   SlidingNavListHandler.prototype.IsSelectable = function (item) {
     // Slider items don't have Aria-selected tag, overrding selction for slider navlist
     var itemSelectionMarkerAttr = 'aria-selected';
-    var prevAnchorTag;
-    var anchor = this.m_widget.getFocusItem($(item))[0];
-    var collapseClass = this.m_widget.getCollapseIconStyleClass();
-    prevAnchorTag = anchor.previousElementSibling;
-   if (prevAnchorTag && prevAnchorTag.classList.contains(collapseClass)) {
-      return false;
-   }
     return (this.m_widget.getFocusItem($(item))[0].getAttribute('role') === 'menuitem' &&
      !this.m_widget.getFocusItem($(item))[0].hasAttribute(itemSelectionMarkerAttr));
   };

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

@@ -3181,7 +3181,10 @@ var __oj_select_many_metadata =
         this.headerInitialized = false;
         this.isOjOption = this.ojContext._IsCustomElement() && !opts.options &&
                             opts.element.find('oj-option').length > 0;
-
+        // JET-39086 - raw-value is not getting updated until space in android devices
+        // In android device we need to update rawValue even for composition events
+        // Get and store agent info
+        this._isAndroidDevice = (oj$1.AgentUtils.getAgentInfo().os === oj$1.AgentUtils.OS.ANDROID);
         // 'opts.element' is initialized in _setup() method in component files
         // ojcombobox.js, ojselect.js and ojInputSearch.js.
         // destroy if called on an existing component
@@ -5955,6 +5958,7 @@ var __oj_select_many_metadata =
        */
       _selectItemFromArray: function (values, options) {
         const optionsArray = this.ojContext.options.options;
+        const optionsKeys = this.ojContext.options.optionsKeys || {};
         let foundItems = new Map();
         let items = [];
 
@@ -5963,9 +5967,10 @@ var __oj_select_many_metadata =
         }
 
         for (let i = 0; i < optionsArray.length; i++) {
-          const _item = optionsArray[i];
-          if (values.includes(this.id(_item))) {
-            foundItems.set(this.id(_item), _item);
+          const item = optionsArray[i];
+          const value = _ComboUtils.lookupOptionKeys(item, optionsKeys, 'value');
+          if (values.includes(value)) {
+            foundItems.set(value, item);
 
             // prematurely break the loop if all values are found
             if (values.length === foundItems.size) {
@@ -5986,7 +5991,16 @@ var __oj_select_many_metadata =
           }
 
           // Push the created item in the array if it is not null
-          if (_item != null) items.push(_item);
+          if (_item != null) {
+            // Map using optionsKeys if specified
+            if (optionsKeys.value != null) {
+              _item.value = _item[optionsKeys.value];
+            }
+            if (optionsKeys.label != null) {
+              _item.label = _item[optionsKeys.label];
+            }
+            items.push(_item);
+          }
         }));
 
         return this._InvokeSelection(items, options);
@@ -6512,7 +6526,20 @@ var __oj_select_many_metadata =
         }));
 
         this.search.on('input', this._bind(function (e) {
-          if (!this.ojContext._isComposing) {
+          // JET-39086 - raw-value is not getting updated until space in android devices
+          // In android devices, typing in an English word will behave similar to what one
+          // would see when they compose a CJK character in desktop devices. So, we need to
+          // update the raw-value for all the input events in Android devices without considering
+          // composition events so that the property gets updated for each english character and not
+          // only for delimiters. In GBoard all the CJK keyboard layouts directly allow users
+          // to input a CJK character, so we do not need to rely on composition events for that.
+          // In Japanese keyboard, one of the three available layouts uses english chars
+          // to compose a Japanese character in which case circumventing the logic would end up
+          // updating the property with garbage values. But, it is highly unlikely for one to
+          // use this layout as the other two layouts would allow users to directly type in Japanese
+          // characters. So, for now we will not have to worry about composition events in
+          // Android devices.
+          if (!this.ojContext._isComposing || this._isAndroidDevice) {
             this._onSearchInputHandler(e);
           }
         }));
@@ -7514,24 +7541,34 @@ var __oj_select_many_metadata =
         const opts = _ComboUtils.getOpts(this.ojContext);
         const isDataProvider = opts ? _ComboUtils.isDataProvider(opts.options) : false;
 
-        let valueOptionsData = [];
-        let valueOptionsMetadata = [];
+        const values = [];
+        const valueOptions = [];
+        const valueOptionsData = [];
+        const valueOptionsMetadata = [];
+
+        // Iterate through the items and generate value and valueOptions
+        items.forEach(function (item) {
+          values.push(this.id(item));
+          valueOptions.push({
+            label: item.label,
+            value: this.id(item)
+          });
 
-        if (isDataProvider) {
-          items.forEach(function (item) {
+          // populate data and metadata only when using a data provider
+          if (isDataProvider) {
             valueOptionsData.push(item.data);
             valueOptionsMetadata.push(item.metadata);
-          });
-        }
+          }
+        }.bind(this));
+
         let context = { optionMetadata: { trigger: options.trigger } };
         context = _ComboUtils.getContextWithExtraData(context, opts, valueOptionsData,
           valueOptionsMetadata);
 
         // set valueOptions
-        this.setValOpts(items);
+        this.setValOpts(valueOptions);
         this._skipSetValueOptions = true;
 
-        const values = items.map(this.id);
         const setValueReturn = this.setVal(values, null, context);
 
         if (setValueReturn instanceof Promise) {
@@ -7622,7 +7659,7 @@ var __oj_select_many_metadata =
         // combobox many in most of situations (since we do not call this method unless
         // we know for a fact that the value is not present), when having label-edge=inside,
         // this method will be called unconditionally on focus events. Since the placeholder
-        // is being updated programatically for label animations.
+        // is being updated programmatically for label animations.
         // This results in the placeholder being set even when there is a value which
         // is causing issues.
         // In oj-combobox-one, this is not a problem as the placeholder is set on the input
@@ -7630,11 +7667,26 @@ var __oj_select_many_metadata =
         // will not be shown when there is a value selected.
         // To fix this in oj-combobox-many, we will be setting the placeholder only when there is
         // no value.
-        if (_ComboUtils.isValueForPlaceholder(true, this.getVal()) &&
-          _ComboUtils.isValueOptionsForPlaceholder(true, this.getValOpts())) {
-          // Now that we know, there is no value selected, call the superclass' method to
+        // JET-45520 - [jet10] oj-combobox-many: placeholder text is missing is if "required" turned on
+        // A regression from the fix for JET-39650. When the component is in invalid state, the
+        // this.getVal() might not reflect the actual displayValue. So, in those cases we need to
+        // use this.currentValue instead.
+        const isValid = this.ojContext.isValid();
+        const isValidValueForPlaceholder = _ComboUtils.isValueForPlaceholder(true, this.getVal()) &&
+          _ComboUtils.isValueOptionsForPlaceholder(true, this.getValOpts());
+        const isCurrentValueForPlaceholder =
+          _ComboUtils.isValueForPlaceholder(true, this.currentValue) &&
+          _ComboUtils.isValueOptionsForPlaceholder(true, this.currentItem);
+        if (
+          (isValid && isValidValueForPlaceholder) ||
+          (!isValid && isCurrentValueForPlaceholder)
+        ) {
+          // Now that we know, there are no selected pills, call the superclass' method to
           // apply the placeholder.
           _OjMultiCombobox.superclass._setPlaceholder.apply(this, arguments);
+          // After setting the placeholder, resize the input field to make sure it has proper
+          // width
+          this._resizeSearch();
         }
       },
 
@@ -8025,7 +8077,20 @@ var __oj_select_many_metadata =
         }));
 
         this.search.on('input', this._bind(function (e) {
-          if (!this.ojContext._isComposing) {
+          // JET-39086 - raw-value is not getting updated until space in android devices
+          // In android devices, typing in an English word will behave similar to what one
+          // would see when they compose a CJK character in desktop devices. So, we need to
+          // update the raw-value for all the input events in Android devices without considering
+          // composition events so that the property gets updated for each english character and not
+          // only for delimiters. In GBoard all the CJK keyboard layouts directly allow users
+          // to input a CJK character, so we do not need to rely on composition events for that.
+          // In Japanese keyboard, one of the three available layouts uses english chars
+          // to compose a Japanese character in which case circumventing the logic would end up
+          // updating the property with garbage values. But, it is highly unlikely for one to
+          // use this layout as the other two layouts would allow users to directly type in Japanese
+          // characters. So, for now we will not have to worry about composition events in
+          // Android devices.
+          if (!this.ojContext._isComposing || this._isAndroidDevice) {
             this._onSearchInputHandler(e);
           }
         }));