@oracle/oraclejet 11.0.6 → 11.1.1

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

@@ -0,0 +1,268 @@
+/**
+ * @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
+ */
+define(['exports', 'ojs/ojeventtarget', 'ojs/ojrestdataprovider', 'ojs/ojdataprovider', 'ojs/ojcomponentcore'], function (exports, ojeventtarget, ojrestdataprovider, ojdataprovider, ojcomponentcore) { 'use strict';
+
+    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 ojrestdataprovider.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 ojdataprovider.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 ojdataprovider.DataProviderMutationEvent(detail));
+        }
+        getChildDataProvider(key) {
+            const item = this._getItemFromKey(key);
+            const dataprovider = this.options.getChildDataProvider(item);
+            if (!dataprovider) {
+                return null;
+            }
+            return ojcomponentcore.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);
+        }
+    }
+    ojeventtarget.EventTargetMixin.applyMixin(RESTTreeDataProvider);
+
+    exports.RESTTreeDataProvider = RESTTreeDataProvider;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+});

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

@@ -2179,7 +2179,7 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
    * @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;
@@ -2216,7 +2216,7 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
 
   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;
@@ -2234,7 +2234,8 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
     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)
@@ -2665,6 +2666,9 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
      */
     _AfterCreate: function () {
       this._super();
+
+      this._initInputIdLabelForConnection(
+        this._GetContentElement()[0], this.OuterWrapper.id, this.options.labelledBy);
     },
 
     /**
@@ -2778,16 +2782,11 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
     _refreshRequired: ojeditablevalue.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: ojeditablevalue.EditableValueUtils._createOrUpdateReadonlyDiv,
+    _setTabIndex: ojeditablevalue.EditableValueUtils._setTabIndex,
 
     /**
      * Called to find out if aria-required is unsupported.
@@ -2914,7 +2913,7 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
         className: className,
         ariaLabel: OuterWrapper.getAttribute('aria-label'),
         ariaControls: OuterWrapper.getAttribute('aria-controls'),
-        idSuffix: idSuffix,
+        componentId: elemId,
         inputType: inputType,
         enabled: lovEnabled,
         readOnly: readonly,
@@ -2999,14 +2998,38 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
 
       // 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++) {
@@ -3212,7 +3235,7 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
       this._containerEventListeners = null;
 
       this.element
-        .removeAttr('aria-hidden tabindex')
+        .removeAttr('aria-hidden')
         .show();
 
       this._removeDataProviderEventListeners();
@@ -4489,7 +4512,20 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
       // 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;
@@ -4776,6 +4812,22 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
       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/ojselectcombobox.js

@@ -8114,7 +8114,7 @@ var __oj_select_many_metadata =
         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/ojselectsingle.js

@@ -210,6 +210,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:
@@ -745,9 +746,6 @@ var __oj_select_single_metadata =
     _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({
@@ -888,35 +886,58 @@ var __oj_select_single_metadata =
       /* 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
+      );
     },
 
     /**
@@ -968,16 +989,20 @@ var __oj_select_single_metadata =
           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/ojslider.js

@@ -1685,8 +1685,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);
@@ -2385,7 +2385,7 @@ var __oj_range_slider_metadata =
       //
       _unwrapSlider: function () {
         DomUtils.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/ojstreamlist.js

@@ -100,7 +100,7 @@ define(['exports', 'preact', 'ojs/ojvcomponent', 'ojs/ojdatacollection-common',
                     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;
@@ -241,7 +241,7 @@ define(['exports', 'preact', 'ojs/ojvcomponent', 'ojs/ojdatacollection-common',
                     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/ojsunburst.js

@@ -197,8 +197,8 @@ define(['ojs/ojcore-base', 'ojs/ojcomponentcore', 'jquery', 'ojs/ojdvt-base', 'o
    * @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"}]
    */
@@ -531,7 +531,7 @@ define(['ojs/ojcore-base', 'ojs/ojcomponentcore', 'jquery', 'ojs/ojdvt-base', 'o
    * @memberof! oj.ojSunburstNode
    * @instance
    * @type {Object=}
-   * @ojsignature [{target: "Type", value: "CSSStyleDeclaration", jsdocOverride: true}]
+   * @ojsignature [{target: "Type", value: "Partial<CSSStyleDeclaration>", jsdocOverride: true}]
    * @default {}
    */
   /**
@@ -607,7 +607,7 @@ define(['ojs/ojcore-base', 'ojs/ojcomponentcore', 'jquery', 'ojs/ojdvt-base', 'o
    * @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.
@@ -1687,7 +1687,7 @@ var __oj_sunburst_node_metadata =
           * @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/ojsuppressnodetreedataprovider.js

@@ -370,6 +370,13 @@ define(['exports', 'ojs/ojeventtarget'], function (exports, ojeventtarget) { 'us
                             : 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);
                 }