@oracle/oraclejet 11.0.6 → 11.1.1

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

@@ -0,0 +1,267 @@
+/**
+ * @license
+ * Copyright (c) 2014, 2021, Oracle and/or its affiliates.
+ * Licensed under The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+import { EventTargetMixin } from 'ojs/ojeventtarget';
+import { RESTDataProvider } from 'ojs/ojrestdataprovider';
+import { DataProviderRefreshEvent, DataProviderMutationEvent } from 'ojs/ojdataprovider';
+import { DataProviderFeatureChecker } from 'ojs/ojcomponentcore';
+
+var __awaiter = (null && null.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+class RESTTreeDataProvider {
+    constructor(options) {
+        this.options = options;
+        this.TreeAsyncIterator = class {
+            constructor(_rootDataProvider, _baseIterable) {
+                this._rootDataProvider = _rootDataProvider;
+                this._baseIterable = _baseIterable;
+            }
+            ['next']() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const result = yield this._baseIterable[Symbol.asyncIterator]().next();
+                    for (let i = 0; i < result.value.data.length; i++) {
+                        this._rootDataProvider._setMapEntry(result.value.metadata[i].key, {
+                            data: result.value.data[i],
+                            metadata: result.value.metadata[i]
+                        });
+                    }
+                    return result;
+                });
+            }
+        };
+        this.TreeAsyncIterable = class {
+            constructor(_asyncIterator) {
+                this._asyncIterator = _asyncIterator;
+                this[Symbol.asyncIterator] = () => {
+                    return this._asyncIterator;
+                };
+            }
+        };
+        this._baseDataProvider = new RESTDataProvider(options);
+        this._mapKeyToItem = new Map();
+    }
+    fetchFirst(fetchParameters) {
+        const baseIterable = this._baseDataProvider.fetchFirst(fetchParameters);
+        const rootDataProvider = this._getRootDataProvider();
+        return new this.TreeAsyncIterable(new this.TreeAsyncIterator(rootDataProvider, baseIterable));
+    }
+    fetchByKeys(fetchParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unCachedKeys = new Set();
+            const results = new Map();
+            fetchParameters.keys.forEach((key) => {
+                const item = this._getItemFromKey(key);
+                if (item) {
+                    results.set(key, item);
+                }
+                else {
+                    unCachedKeys.add(key);
+                }
+            });
+            if (unCachedKeys.size) {
+                const fetchByKeysResult = yield this._baseDataProvider.fetchByKeys(Object.assign(Object.assign({}, fetchParameters), { keys: unCachedKeys }));
+                fetchByKeysResult.results.forEach((item) => {
+                    this._setMapEntry(item.metadata.key, item);
+                    results.set(item.metadata.key, item);
+                });
+            }
+            return {
+                fetchParameters,
+                results
+            };
+        });
+    }
+    fetchByOffset(fetchParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fetchByOffsetResult = yield this._baseDataProvider.fetchByOffset(fetchParameters);
+            fetchByOffsetResult.results.forEach((item) => {
+                this._setMapEntry(item.metadata.key, item);
+            });
+            return fetchByOffsetResult;
+        });
+    }
+    containsKeys(containsParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._baseDataProvider.containsKeys(containsParameters);
+        });
+    }
+    createOptimizedKeySet(initialSet) {
+        return this._baseDataProvider.createOptimizedKeySet(initialSet);
+    }
+    createOptimizedKeyMap(initialMap) {
+        return this._baseDataProvider.createOptimizedKeyMap(initialMap);
+    }
+    isEmpty() {
+        return this._baseDataProvider.isEmpty();
+    }
+    getCapability(capabilityName) {
+        return this._baseDataProvider.getCapability(capabilityName);
+    }
+    getTotalSize() {
+        return this._baseDataProvider.getTotalSize();
+    }
+    refresh() {
+        this._flushMaps();
+        this.dispatchEvent(new DataProviderRefreshEvent());
+    }
+    mutate(detail) {
+        this._addMetadataToMutationEventDetail(detail);
+        if (detail.remove) {
+            this._updateMapFromMutationDetail('remove', detail.remove);
+        }
+        if (detail.add) {
+            this._updateMapFromMutationDetail('add', detail.add);
+        }
+        if (detail.update) {
+            this._updateMapFromMutationDetail('update', detail.update);
+        }
+        this.dispatchEvent(new DataProviderMutationEvent(detail));
+    }
+    getChildDataProvider(key) {
+        const item = this._getItemFromKey(key);
+        const dataprovider = this.options.getChildDataProvider(item);
+        if (!dataprovider) {
+            return null;
+        }
+        return DataProviderFeatureChecker.isTreeDataProvider(dataprovider)
+            ? dataprovider
+            : new TreeDataProviderWrapper(dataprovider);
+    }
+    _getItemFromKey(key) {
+        const rootDataProvider = this._getRootDataProvider();
+        return rootDataProvider._mapKeyToItem.get(key);
+    }
+    _setMapEntry(key, item) {
+        const rootDataProvider = this._getRootDataProvider();
+        const currentValue = rootDataProvider._mapKeyToItem.get(key);
+        if (currentValue) {
+            rootDataProvider._mapKeyToItem.set(key, {
+                data: Object.assign(Object.assign({}, currentValue.data), item.data),
+                metadata: Object.assign(Object.assign({}, currentValue.metadata), item.metadata)
+            });
+        }
+        else {
+            rootDataProvider._mapKeyToItem.set(key, item);
+        }
+    }
+    _deleteMapEntry(key) {
+        const rootDataProvider = this._getRootDataProvider();
+        rootDataProvider._mapKeyToItem.delete(key);
+    }
+    _flushMaps() {
+        const rootDataProvider = this._getRootDataProvider();
+        rootDataProvider._mapKeyToItem.clear();
+    }
+    _getRootDataProvider() {
+        if (this.options.rootDataProvider) {
+            return this.options.rootDataProvider;
+        }
+        return this;
+    }
+    _addMetadataToMutationEventDetail(detail) {
+        Object.keys(detail).forEach((operation) => {
+            if (!detail[operation].metadata ||
+                (detail[operation].metadata && !detail[operation].metadata.length)) {
+                detail[operation].metadata = [];
+                detail[operation].keys.forEach((key) => {
+                    detail[operation].metadata.push({ key });
+                });
+            }
+        });
+    }
+    _updateMapFromMutationDetail(operation, detail) {
+        if (operation === 'remove') {
+            detail.keys.forEach((key) => {
+                this._deleteMapEntry(key);
+            });
+        }
+        else {
+            const data = detail.data;
+            const metadata = detail.metadata;
+            if (Array.isArray(data) && Array.isArray(metadata)) {
+                for (let i = 0; i < data.length; i++) {
+                    this._setMapEntry(metadata[i].key, { data: data[i], metadata: metadata[i] });
+                }
+            }
+            else if (Array.isArray(metadata)) {
+                for (let i = 0; i < metadata.length; i++) {
+                    const item = this._getItemFromKey(metadata[i].key);
+                    if (item) {
+                        this._setMapEntry(metadata[i].key, { data: item.data, metadata: metadata[i] });
+                    }
+                }
+            }
+        }
+    }
+}
+class TreeDataProviderWrapper {
+    constructor(dataprovider) {
+        this.dataprovider = dataprovider;
+    }
+    fetchFirst(fetchParameters) {
+        return this.dataprovider.fetchFirst(fetchParameters);
+    }
+    fetchByKeys(fetchParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dataprovider.fetchByKeys(fetchParameters);
+        });
+    }
+    fetchByOffset(fetchParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dataprovider.fetchByOffset(fetchParameters);
+        });
+    }
+    containsKeys(containsParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dataprovider.containsKeys(containsParameters);
+        });
+    }
+    createOptimizedKeySet(initialSet) {
+        return this.dataprovider.createOptimizedKeySet(initialSet);
+    }
+    createOptimizedKeyMap(initialMap) {
+        return this.dataprovider.createOptimizedKeyMap(initialMap);
+    }
+    isEmpty() {
+        const isEmpty = this.dataprovider.isEmpty();
+        if (isEmpty === 'yes') {
+            return 'yes';
+        }
+        else if (isEmpty === 'no') {
+            return 'no';
+        }
+        return 'unknown';
+    }
+    getCapability(capabilityName) {
+        return this.dataprovider.getCapability(capabilityName);
+    }
+    getTotalSize() {
+        return this.dataprovider.getTotalSize();
+    }
+    getChildDataProvider(key) {
+        return null;
+    }
+    addEventListener(event, listener) {
+        this.dataprovider.addEventListener(event, listener);
+    }
+    removeEventListener(event, listener) {
+        this.dataprovider.removeEventListener(event, listener);
+    }
+    dispatchEvent(event) {
+        return this.dataprovider.dispatchEvent(event);
+    }
+}
+EventTargetMixin.applyMixin(RESTTreeDataProvider);
+
+export { RESTTreeDataProvider };

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

@@ -2192,7 +2192,7 @@ LovDropdown.prototype._handleCollectionFocusinOnce = function (data) {
  * @private
  */
 const LovMainField = function (options) {
-  // {className, ariaLabel, ariaControls, idSuffix,
+  // {className, ariaLabel, ariaControls, componentId,
   //  inputType, enabled, readOnly, placeholder, addBusyStateFunc,
   //  forceReadOnly, endContent, createOrUpdateReadonlyDivFunc}
   this._addBusyStateFunc = options.addBusyStateFunc;
@@ -2229,7 +2229,7 @@ LovMainField.prototype.getInputText = function () {
 
 LovMainField.prototype._createInnerDom = function (options) {
   var className = options.className;
-  var idSuffix = options.idSuffix;
+  var componentId = options.componentId;
   var inputType = options.inputType;
   var enabled = options.enabled;
   var readonly = options.readOnly;
@@ -2247,7 +2247,8 @@ LovMainField.prototype._createInnerDom = function (options) {
   textFieldContainer.appendChild(labelValueDiv); // @HTMLUpdateOK
 
   var input = cachedMainFieldInputElement || document.createElement('input');
-  input.setAttribute('id', className + '-input-' + idSuffix);
+  // use the same id convention as EditableValueUtils._initInputIdLabelForConnection
+  input.setAttribute('id', componentId + '|input');
   // JET-37990 - oj-select-single: autocomplete is not disabled in chrome browser
   // Chrome used to ignore "off" value, but as of Chrome 81 it works more reliably
   // (https://stackoverflow.com/questions/57367813/2019-chrome-76-approach-to-autocomplete-off)
@@ -2678,6 +2679,9 @@ oj.__registerWidget('oj.ojSelectBase', $.oj.editableValue, {
    */
   _AfterCreate: function () {
     this._super();
+
+    this._initInputIdLabelForConnection(
+      this._GetContentElement()[0], this.OuterWrapper.id, this.options.labelledBy);
   },
 
   /**
@@ -2791,16 +2795,11 @@ oj.__registerWidget('oj.ojSelectBase', $.oj.editableValue, {
   _refreshRequired: EditableValueUtils._refreshRequired,
 
   /**
-   * Draw a readonly div if needed. When readonly, this div is shown and
-   * the input has display:none on it through theming, and vice versa.
-   * We set the textContent in _SetDisplayValue() if readonly, and
-   * in this function.
-   * @param {HTMLElement} pass in the input element.
    * @memberof! oj.ojSelectBase
    * @instance
    * @private
    */
-  _createOrUpdateReadonlyDiv: EditableValueUtils._createOrUpdateReadonlyDiv,
+  _setTabIndex: EditableValueUtils._setTabIndex,
 
   /**
    * Called to find out if aria-required is unsupported.
@@ -2927,7 +2926,7 @@ oj.__registerWidget('oj.ojSelectBase', $.oj.editableValue, {
       className: className,
       ariaLabel: OuterWrapper.getAttribute('aria-label'),
       ariaControls: OuterWrapper.getAttribute('aria-controls'),
-      idSuffix: idSuffix,
+      componentId: elemId,
       inputType: inputType,
       enabled: lovEnabled,
       readOnly: readonly,
@@ -3012,14 +3011,38 @@ oj.__registerWidget('oj.ojSelectBase', $.oj.editableValue, {
 
     // swap main field container for the element
     element
-      .attr('tabindex', '-1')
       .hide()
       .attr('aria-hidden', true);
 
+    // JET-46247 - Acc: described-by resets after changing the data provider
+    // if we're refreshing, restore aria-describedby on the input
+    if (cachedMainFieldInputElem) {
+      // set describedby on the element as aria-describedby
+      var describedBy = this.options.describedBy;
+      if (describedBy) {
+        this._describedByUpdated(null, describedBy);
+      }
+    }
+
     this._refreshRequired(options.required);
 
+    // JET-46247 - Acc: described-by resets after changing the data provider
+    // reconnect the input and label
+    this._initInputIdLabelForConnection(
+      this._GetContentElement()[0], OuterWrapper.id, this.options.labelledBy);
+
     this._updateLabel();
 
+    // JET-45967 - tabindex does not propagate for select-single
+    // transfer tabindex from hidden initnode input to appropriate inner DOM elements
+    this._setTabIndex(element[0], lovMainField.getInputElem());
+    if (readonly) {
+      var readonlyElem = this._getReadonlyDiv();
+      if (readonlyElem) {
+        this._setTabIndex(element[0], readonlyElem);
+      }
+    }
+
     // JET-32835 - SINGLESELECT'S INLINE MESSAGES IS SOMETIMES BELOW AND SOMETIMES ABOVE COMPONENT.
     // append pre-existing child nodes at the end of our internal DOM
     for (var j = 0; j < existingChildren.length; j++) {
@@ -3225,7 +3248,7 @@ oj.__registerWidget('oj.ojSelectBase', $.oj.editableValue, {
     this._containerEventListeners = null;
 
     this.element
-      .removeAttr('aria-hidden tabindex')
+      .removeAttr('aria-hidden')
       .show();
 
     this._removeDataProviderEventListeners();
@@ -4502,7 +4525,20 @@ oj.__registerWidget('oj.ojSelectBase', $.oj.editableValue, {
     // new change until after we're done processing the current change
     if (this._makingInternalValueChange) {
       this._queueValueChangeDeferredCallback(function () {
-        this._setOptions(options, flags);
+        // JET-46247 - Acc: described-by resets after changing the data provider
+        // don't re-set the same labelledBy again because it can affect whether the label
+        // actually gets read out by the screen reader (because it may change how the label is
+        // configured between the main and filter inputs)
+        var newOptions = Object.assign({}, options);
+        // eslint-disable-next-line no-prototype-builtins
+        if (newOptions.hasOwnProperty('labelledBy') &&
+            newOptions.labelledBy === this.options.labelledBy) {
+          delete newOptions.labelledBy;
+          if (Object.entries(newOptions).length === 0) {
+            return;
+          }
+        }
+        this._setOptions(newOptions, flags);
       }.bind(this));
 
       return;
@@ -4789,6 +4825,22 @@ oj.__registerWidget('oj.ojSelectBase', $.oj.editableValue, {
     this._OpenContextMenu(event, eventType, { launcher: launcher });
   },
 
+  /**
+   * @protected
+   * @memberof! oj.ojSelectBase
+   * @instance
+   */
+  _NotifyMessagingStrategyQueueAction: function (promise) {
+    // JET-46567 - JAWS is reading out error message even after selecting correct value
+    // this will be called from InlineMessagingStrategy._queueAction before the
+    // timer to update messages is fired so that we can defer processing until after
+    // the DOM has been changed
+    this._messagingStrategyQueueActionPromise = promise;
+    promise.then(function () {
+      this._messagingStrategyQueueActionPromise = null;
+    }.bind(this));
+  },
+
   /**
    * Returns the jquery element that represents the content part of the component.
    * This is usually the component that user sets focus on (tabindex is set 0) and

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

@@ -8124,7 +8124,7 @@ const _OjMultiCombobox = _ComboUtils.clazz(_AbstractMultiChoice,
       var contentStructure = [
         "<div class='oj-text-field-container' role='presentation'> ",
         "<ul class='oj-combobox-choices oj-combobox-accessible-container'>",
-        "  <li class='oj-combobox-search-field' role='presentation'><span class='oj-helper-hidden'>&nbsp;</span>",
+        "  <li class='oj-combobox-search-field'><span class='oj-helper-hidden'>&nbsp;</span>",
         "    <input type='text' role='combobox' aria-expanded='false' aria-autocomplete='list'",
         "           autocomplete='off' autocorrect='off' autocapitalize='off' spellcheck='false' class='oj-combobox-input'>",
         '  </li>',

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

@@ -213,6 +213,7 @@ var __oj_select_single_metadata =
 (function () {
   __oj_select_single_metadata.extension._WIDGET_NAME = 'ojSelectSingle';
   __oj_select_single_metadata.extension._INNER_ELEM = 'input';
+  __oj_select_single_metadata.extension._GLOBAL_TRANSFER_ATTRS = ['tabindex'];
   __oj_select_single_metadata.extension._ALIASED_PROPS = { readonly: 'readOnly' };
   oj.CustomElementBridge.register('oj-select-single', {
     metadata:
@@ -748,9 +749,6 @@ oj$1.__registerWidget('oj.ojSelectSingle', $.oj.ojSelectBase, {
   _AfterCreate: function () {
     this._super();
 
-    this._initInputIdLabelForConnection(
-      this._GetContentElement()[0], this.OuterWrapper.id, this.options.labelledBy);
-
     // need to apply the oj-focus marker selector for control of the floating label.
     var rootElement = this._getRootElement();
     this._focusable({
@@ -891,35 +889,58 @@ oj$1.__registerWidget('oj.ojSelectSingle', $.oj.ojSelectBase, {
     /* if (!(old === LovUtils.getOptionValue(data)))*/
     var newValueItem = this._IsValueItemForPlaceholder(valueItem) ?
       this._defaultValueItemForPlaceholder : valueItem;
-    this._handleUserSelectedValueItem(newValueItem, event, context);
-
-    if (!event || event.type !== 'blur') {
-      // this._lovMainField.focusCursorEndInputElem();
-      var inputElem = this._lovMainField.getInputElem();
-      if (!this._fullScreenPopup) {
-        if (this._IsValueItemForPlaceholder(newValueItem)) {
-          inputElem.value = '';
-        }
-        this._SetFilterFieldText(inputElem.value);
-        // JET-44746 - focus pulled back again after pressing Tab with DelayingDataProvider
-        // only show the filter field if the component should still have focus
-        if (!skipShowingFilterField) {
-          // show the filter field after selecting an item on desktop because we want the focus to
-          // go back to the main part of the component, and the user can tab out or reopen the
-          // dropdown or filter again
-          this._ShowFilterField();
+
+    var configureInputFieldsFunc = function () {
+      // JET-46874 - Select single busy state not cleared properly causing spectra test to fail
+      // don't try to do anything other than resolve the busy state if the component has been
+      // removed from the DOM
+      if (!this._bReleasedResources) {
+        if (!event || event.type !== 'blur') {
+          // this._lovMainField.focusCursorEndInputElem();
+          var inputElem = this._lovMainField.getInputElem();
+          if (!this._fullScreenPopup) {
+            if (this._IsValueItemForPlaceholder(newValueItem)) {
+              inputElem.value = '';
+            }
+            this._SetFilterFieldText(inputElem.value);
+            // JET-44746 - focus pulled back again after pressing Tab with DelayingDataProvider
+            // only show the filter field if the component should still have focus
+            if (!skipShowingFilterField) {
+              // show the filter field after selecting an item on desktop because we want the focus
+              // to go back to the main part of the component, and the user can tab out or reopen
+              // the dropdown or filter again
+              this._ShowFilterField();
+            }
+          } else {
+            // focus the input element after selecting an item on mobile because we want the focus
+            // to go back to the main part of the component, and the user can tab out or reopen the
+            // dropdown
+            inputElem.focus();
+          }
         }
-      } else {
-        // focus the input element after selecting an item on mobile because we want the focus to
-        // go back to the main part of the component, and the user can tab out or reopen the
-        // dropdown
-        inputElem.focus();
+
+        this._CloseDropdown();
       }
-    }
 
-    this._CloseDropdown();
+      resolveValueChangeFunc();
+    }.bind(this);
 
-    resolveValueChangeFunc();
+    var afterHandleFunc = function () {
+      // JET-46567 - JAWS is reading out error message even after selecting correct value
+      // wait until after the inline messages DOM has been updated before finishing processing
+      // so that when we change focus to the input element the screen reader will read out the
+      // new messages/invalid state instead of old state
+      if (this._messagingStrategyQueueActionPromise) {
+        this._messagingStrategyQueueActionPromise.then(
+          configureInputFieldsFunc, configureInputFieldsFunc);
+      } else {
+        configureInputFieldsFunc();
+      }
+    }.bind(this);
+
+    this._handleUserSelectedValueItem(newValueItem, event, context).then(
+      afterHandleFunc, afterHandleFunc
+    );
   },
 
   /**
@@ -971,16 +992,20 @@ oj$1.__registerWidget('oj.ojSelectSingle', $.oj.ojSelectBase, {
         this._resolveFetchDataAndSelectPromise = null;
       }
     }.bind(this);
+
     if (ret instanceof Promise) {
-      ret.then(
+      return ret.then(
         afterSetValue,
         function () {
           afterSetValue(false);
         }
       );
-    } else {
-      afterSetValue(ret);
     }
+
+    var afterFunc = function () {
+      afterSetValue(ret);
+    };
+    return Promise.resolve().then(afterFunc, afterFunc);
   },
 
   /**

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

@@ -1689,8 +1689,8 @@ var __oj_range_slider_metadata =
           this._styleFromInputTag = this.element[0].style.cssText;
         }
 
-        this._inputElementOriginalDisplay = this.element.css('display');
-        this.element.css('display', 'none');
+        this._inputElementOriginalDisplay = this.element[0].style.display;
+        this.element[0].style.display = 'none';
 
         if (this.OuterWrapper) {
           this._elementWrapped = $(this.OuterWrapper);
@@ -2389,7 +2389,7 @@ var __oj_range_slider_metadata =
     //
     _unwrapSlider: function () {
       unwrap(this.element, this._elementWrapped);
-      this.element.css('display', this._inputElementOriginalDisplay);
+      this.element[0].style.display = this._inputElementOriginalDisplay;
       this._RestoreAttributes(this.element);
     },
 

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

@@ -107,7 +107,7 @@ class StreamListContentHandler extends IteratingDataProviderContentHandler {
                 vnode.props['data-oj-key-type'] = 'number';
             }
             const styleClasses = this.getItemStyleClass(visible, this.newItemsTracker.has(key), initialFetch);
-            const classProp = vnode.props.className ? 'className' : 'class';
+            const classProp = vnode.props.class ? 'class' : 'className';
             const currentClasses = vnode.props[classProp]
                 ? [vnode.props[classProp], ...styleClasses]
                 : styleClasses;
@@ -248,7 +248,7 @@ class StreamListTreeContentHandler extends IteratingTreeDataProviderContentHandl
                 vnode.props['data-oj-key-type'] = 'number';
             }
             const styleClasses = this.getItemStyleClass(metadata, visible, this.newItemsTracker.has(metadata.key), initialFetch);
-            const classProp = vnode.props.className ? 'className' : 'class';
+            const classProp = vnode.props.class ? 'class' : 'className';
             const currentClasses = vnode.props[classProp]
                 ? [vnode.props[classProp], ...styleClasses]
                 : styleClasses;

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

@@ -200,8 +200,8 @@ import { getResourceUrl } from 'ojs/ojconfig';
  * @property {number} value The value of the node, which determines the relative size of the node.
  * @ojsignature [{target: "Type", value: "K", for: "id"},
  *               {target: "Type", value: "Array.<oj.ojSunburst.Node<K>>=", for: "nodes"},
- *               {target: "Type", value: "CSSStyleDeclaration", for: "labelStyle", jsdocOverride: true},
- *               {target: "Type", value: "CSSStyleDeclaration", for: "svgStyle", jsdocOverride: true},
+ *               {target: "Type", value: "Partial<CSSStyleDeclaration>", for: "labelStyle", jsdocOverride: true},
+ *               {target: "Type", value: "Partial<CSSStyleDeclaration>", for: "svgStyle", jsdocOverride: true},
  *               {target: "Type", value: "?(string | ((context: oj.ojSunburst.NodeShortDescContext<K,D>) => string))", jsdocOverride: true, for: "shortDesc"},
  *               {target: "Type", value: "<K,D=any>", for: "genericTypeParameters"}]
  */
@@ -534,7 +534,7 @@ import { getResourceUrl } from 'ojs/ojconfig';
  * @memberof! oj.ojSunburstNode
  * @instance
  * @type {Object=}
- * @ojsignature [{target: "Type", value: "CSSStyleDeclaration", jsdocOverride: true}]
+ * @ojsignature [{target: "Type", value: "Partial<CSSStyleDeclaration>", jsdocOverride: true}]
  * @default {}
  */
 /**
@@ -610,7 +610,7 @@ import { getResourceUrl } from 'ojs/ojconfig';
  * @memberof! oj.ojSunburstNode
  * @instance
  * @type {Object=}
- * @ojsignature [{target: "Type", value: "CSSStyleDeclaration", jsdocOverride: true}]
+ * @ojsignature [{target: "Type", value: "Partial<CSSStyleDeclaration>", jsdocOverride: true}]
  */
 /**
  * Specifies whether to display the expand/collapse button on hover for a specific node. If the button is clicked, the expanded attribute is updated with the new array of node ids.
@@ -1690,7 +1690,7 @@ oj.__registerWidget('oj.ojSunburst', $.oj.dvtBaseComponent,
         * @memberof! oj.ojSunburst
         * @instance
         * @type {Object=}
-        * @ojsignature [{target: "Type", value: "CSSStyleDeclaration", jsdocOverride: true}]
+        * @ojsignature [{target: "Type", value: "Partial<CSSStyleDeclaration>", jsdocOverride: true}]
         */
         labelStyle: undefined,
 

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

@@ -370,6 +370,13 @@ class SuppressNodeTreeDataProvider {
                         : true;
                 });
             }
+            else if (child.isEmpty() === 'unknown') {
+                return child.fetchByOffset({ offset: 0, size: 1 }).then((childResult) => {
+                    return childResult && childResult.results && childResult.results.length > 0
+                        ? false
+                        : true;
+                });
+            }
             else {
                 return Promise.resolve(false);
             }