@oracle/oraclejet 14.0.5 → 14.0.7

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":"v14.0.5"}' !important; }
+  font-family: '{"name":"stable","targetPlatform":"all","behavior":"redwood","jetReleaseVersion":"v14.0.7"}' !important; }
 
 .oj-helper-hidden-accessible {
   border: 0;

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

@@ -95,22 +95,10 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget', 'ojs/ojmap
      * <p>
      * Subsequent to a new/updated row but before the commit, the row can be sorted or filtered.
      * The sorted/filtered position of the row stays after the commit until a subsequent re-order/refresh.
-     * Will dispatch remove event for rows which are not in correct position because the sorting is based on fetched row sets.
      *
      * When uncommitted rows are sorted in current row set, their position may not correspond to server side position once they are committed.
-     * Therefore a 'remove' event may be fired when new row sets are fetched and it determines that the rows are not in current positions.
      * Uncommitted rows will be sorted according to updated row set.
      * </p>
-     * <pre class="prettyprint"><code>
-     * // dispatch a remove event for rows in wrong position.
-     * // ie row with id 40 is in wrong position
-     *{
-     *  remove: {
-     *    metadata: [{key: 40}],
-     *    ...
-     *  }
-     *}
-     * </code></pre>
      *
      * <p>BufferingDataProvider does not validate the item key and data.  It is up to the application to perform any validation
      * prior to creating edit items in the buffer.
@@ -807,22 +795,6 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget', 'ojs/ojmap
                                     }
                                 }
                             }
-                            if (this._parent.itemsInWrongPosition.size > 0) {
-                                const detail = {
-                                    remove: {
-                                        data: [],
-                                        keys: new Set(),
-                                        metadata: []
-                                    }
-                                };
-                                this._parent.itemsInWrongPosition.forEach((item) => {
-                                    detail.remove.data.push(item.data);
-                                    detail.remove.keys.add(item.metadata.key);
-                                    detail.remove.metadata.push(item.metadata);
-                                });
-                                const event = new ojdataprovider.DataProviderMutationEvent(detail);
-                                this._parent.dispatchEvent(event);
-                            }
                             const done = result.done && newDataArray.length === 0;
                             return {
                                 done,
@@ -848,8 +820,6 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget', 'ojs/ojmap
             this.lastIterator = null;
             this.customKeyGenerator = options === null || options === void 0 ? void 0 : options.keyGenerator;
             this.generatedKeyMap = new Map();
-            this.lastSortIndex = new Map();
-            this.itemsInWrongPosition = new Set();
             this.totalFilteredRowCount = 0;
             this.dataBeforeUpdated = new Map();
         }
@@ -876,11 +846,11 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget', 'ojs/ojmap
         }
         _compareItem(d1, d2, sortCriteria) {
             for (const sortCrt of sortCriteria) {
-                if (d1[sortCrt.attribute] > d2[sortCrt.attribute]) {
-                    return sortCrt.direction === 'ascending' ? 1 : -1;
-                }
-                else if (d1[sortCrt.attribute] < d2[sortCrt.attribute]) {
-                    return sortCrt.direction === 'ascending' ? -1 : 1;
+                let comparator = ojdataprovider.SortUtils.getNaturalSortComparator();
+                const descendingResult = sortCrt.direction === 'descending' ? -1 : 1;
+                const comparatorResult = comparator(d1[sortCrt.attribute], d2[sortCrt.attribute]) * descendingResult;
+                if (comparatorResult !== 0) {
+                    return comparatorResult;
                 }
             }
             return 0;
@@ -918,35 +888,45 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget', 'ojs/ojmap
                         }
                     }
                 }
-                if ((editItem.operation === 'add' ||
-                    (editItem.operation === 'update' && this.editBuffer.isUpdateTransformed(key))) &&
+                if ((editItem.operation === 'add' || editItem.operation === 'update') &&
                     !mergedAddKeySet.has(key)) {
                     if (!filterObj || filterObj.filter(editItem.item.data)) {
-                        itemArray.splice(0, 0, editItem.item);
-                        mergedAddKeySet.add(key);
-                    }
-                }
-            }));
-            if (sortCriteria && sortCriteria.length && !this.editBuffer.isEmpty()) {
-                itemArray.sort((a, b) => {
-                    return this._compareItem(a.data, b.data, sortCriteria);
-                });
-                itemArray.forEach((item, index) => {
-                    const key = item.metadata.key;
-                    if (editItems.has(key)) {
-                        if (this.lastSortIndex.get(key) === undefined) {
-                            this.lastSortIndex.set(key, index);
-                        }
-                        else if (this.lastSortIndex.get(key) !== index) {
-                            this.itemsInWrongPosition.add(item);
-                            this.lastSortIndex.set(key, index);
+                        if (sortCriteria && sortCriteria.length) {
+                            let inserted = false;
+                            for (let i = 0; i < itemArray.length; i++) {
+                                if (this._compareItem(editItem.item.data, itemArray[i].data, sortCriteria) < 0) {
+                                    itemArray.splice(i, 0, editItem.item);
+                                    mergedAddKeySet.add(key);
+                                    inserted = true;
+                                    break;
+                                }
+                            }
+                            if (!inserted && lastBlock) {
+                                itemArray.push(editItem.item);
+                                mergedAddKeySet.add(key);
+                            }
                         }
-                        else if (this.lastSortIndex.get(key) === index) {
-                            this.itemsInWrongPosition.delete(item);
+                        else {
+                            let allItemsRemoved = true;
+                            itemArray.forEach((item) => {
+                                if (key !== item.metadata.key &&
+                                    !mergedAddKeySet.has(key) &&
+                                    !this._isItemRemoved(item.metadata.key)) {
+                                    allItemsRemoved = false;
+                                    return;
+                                }
+                            });
+                            if (allItemsRemoved) {
+                                itemArray.push(editItem.item);
+                            }
+                            else {
+                                itemArray.splice(0, 0, editItem.item);
+                            }
+                            mergedAddKeySet.add(key);
                         }
                     }
-                });
-            }
+                }
+            }));
         }
         _mergeAddEdits(filterObj, sortCriteria, newItemArray, mergedAddKeySet, lastBlock) {
             this._insertAddEdits(this.editBuffer.getUnsubmittedItems(), filterObj, sortCriteria, newItemArray, mergedAddKeySet, lastBlock);
@@ -977,12 +957,6 @@ define(['ojs/ojcore-base', 'ojs/ojdataprovider', 'ojs/ojeventtarget', 'ojs/ojmap
                     if (editItem.operation === 'remove') {
                         newItemArray.push(baseItem);
                     }
-                    else if (editItem.operation === 'update' &&
-                        !this.editBuffer.isUpdateTransformed(editItem.item.metadata.key)) {
-                        if (!filterObj || filterObj.filter(editItem.item.data)) {
-                            newItemArray.push(editItem.item);
-                        }
-                    }
                 }
             }
             if (sortCriteria && sortCriteria.length) {

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: '14.0.5',
+    version: '14.0.7',
     /**
      * @global
      * @member {string} revision JET source code revision number
      */
-    revision: '2023-03-16_09-38-48',
+    revision: '2023-04-12_12-18-33',
 
     // 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/ojflattenedtreedataproviderview.js

@@ -876,7 +876,7 @@ define(['ojs/ojcore-base', 'ojs/ojset', 'ojs/ojeventtarget', 'ojs/ojobservable',
                 return result.fetchResult;
             });
         }
-        _fetchChildrenByOffsetFromAncestors(params, dataprovider, parentKey, finalParams, expandKey) {
+        _fetchChildrenByOffsetFromAncestors(params, dataProvider, parentKey, finalParams, expandKey) {
             const handleFetchFromAncestors = (lastParentKey, result) => {
                 const lastEntry = this._getItemByKey(lastParentKey);
                 if (this._checkCacheByOffset(finalParams, expandKey) ||
@@ -893,7 +893,7 @@ define(['ojs/ojcore-base', 'ojs/ojset', 'ojs/ojeventtarget', 'ojs/ojobservable',
                 const childrenPromise = this._fetchChildrenByOffsetFromDataProvider(newParams, childDataProvider, lastEntryParentKey, finalParams, expandKey);
                 return childrenPromise.then(handleFetchFromAncestors.bind(this, lastEntryParentKey));
             };
-            return this._fetchChildrenByOffsetFromDataProvider(params, dataprovider, parentKey, finalParams, expandKey)
+            return this._fetchChildrenByOffsetFromDataProvider(params, dataProvider, parentKey, finalParams, expandKey)
                 .then(handleFetchFromAncestors.bind(this, parentKey))
                 .then(() => {
                 const result = this._getFetchByOffsetResultsFromCache(finalParams);
@@ -914,10 +914,12 @@ define(['ojs/ojcore-base', 'ojs/ojset', 'ojs/ojeventtarget', 'ojs/ojobservable',
                     finalParams.filterCriterion = result.fetchParameters.filterCriterion;
                 }
                 if (results.length === 0 || this._checkCacheByOffset(finalParams, expandKey)) {
-                    if (expandKey && result.done === true) {
-                        return Promise.resolve({ expandKey: expandKey, done: result.done });
+                    const returnObject = {};
+                    if (expandKey) {
+                        returnObject.expandKey = expandKey;
                     }
-                    return Promise.resolve({ done: results.length === 0 ? result.done : false });
+                    returnObject.done = results.length === 0 ? result.done : false;
+                    return Promise.resolve(returnObject);
                 }
                 const item = results.shift();
                 const updatedItem = this._updateItemMetadata(item, parentKey);
@@ -925,7 +927,7 @@ define(['ojs/ojcore-base', 'ojs/ojset', 'ojs/ojeventtarget', 'ojs/ojobservable',
                 if (this._isExpanded(updatedItem.metadata.key)) {
                     const parentKeyInfo = this._mapParentKeyToInfo.get(updatedItem.metadata.key);
                     const childDataProvider = this.getChildDataProvider(updatedItem.metadata.key);
-                    const remainingSize = this._getRemainingSize(finalParams);
+                    const remainingSize = this._getRemainingSize(finalParams, expandKey);
                     if (childDataProvider != null && !parentKeyInfo.done && remainingSize !== 0) {
                         const newParams = new this.FetchByOffsetParameters(this, 0, remainingSize, params.sortCriteria, params.filterCriterion, params.attributes);
                         yield this._fetchChildrenByOffsetFromDataProvider(newParams, childDataProvider, updatedItem.metadata.key, finalParams, expandKey);
@@ -936,21 +938,46 @@ define(['ojs/ojcore-base', 'ojs/ojset', 'ojs/ojeventtarget', 'ojs/ojobservable',
             return dataProvider
                 .fetchByOffset(params)
                 .then(handleNextItemInResults)
-                .then((returnObject) => {
+                .then((nextItemResults) => {
                 this._mapParentKeyToInfo.set(parentKey, {
-                    done: returnObject.done
+                    done: nextItemResults.done
                 });
                 const result = this._getFetchByOffsetResultsFromCache(finalParams);
-                if (returnObject.expandKey) {
-                    return { returnObject: returnObject, fetchResult: result };
+                const validationObject = {
+                    fetchResult: result
+                };
+                if (nextItemResults.expandKey) {
+                    validationObject.returnObject = nextItemResults;
+                    nextItemResults.done =
+                        nextItemResults.done === true
+                            ? this._isDescendentTreeDone(nextItemResults.expandKey)
+                            : false;
                 }
-                return { fetchResult: result };
+                return validationObject;
             });
         }
-        _getRemainingSize(params) {
+        _isDescendentTreeDone(key) {
+            const children = this._getChildrenFromCacheByParentKey(key);
+            if (children.length === 0) {
+                return true;
+            }
+            const itemDone = this._isDone(key);
+            if (!itemDone) {
+                return false;
+            }
+            const childKey = children[children.length - 1].metadata.key;
+            return this._isDescendentTreeDone(childKey);
+        }
+        _isDone(key) {
+            return this._mapParentKeyToInfo.has(key) && this._mapParentKeyToInfo.get(key).done;
+        }
+        _getRemainingSize(params, expandKey) {
             if (params.size === -1) {
                 return -1;
             }
+            if (expandKey) {
+                return params.size - this._getLocalDescendentCount(expandKey);
+            }
             return params.size + params.offset - this._cache.length;
         }
         _isExpanded(key) {
@@ -1020,14 +1047,25 @@ define(['ojs/ojcore-base', 'ojs/ojset', 'ojs/ojeventtarget', 'ojs/ojobservable',
                         });
                     }
                     if (previousCacheIndex !== null) {
-                        const removedItems = this._cache.splice(previousCacheIndex + 1, this._cache.length);
-                        removedItems.forEach(() => {
-                            this._decrementIteratorOffset(previousCacheIndex + 1);
+                        const lastDescendentItem = this._getLastDescendentByParentKey(disregardAfterKey);
+                        const lastDescendentIndex = this._getItemIndexByKey(lastDescendentItem.metadata.key);
+                        const removedItems = this._cache.splice(lastDescendentIndex + 1, this._cache.length);
+                        removedItems.forEach((item) => {
+                            this._mapParentKeyToInfo.delete(item.metadata.key);
+                            if (this._mapParentKeyToInfo.has(item.metadata.parentKey)) {
+                                this._mapParentKeyToInfo.set(item.metadata.parentKey, { done: false });
+                            }
                         });
+                        const decrementValueTotal = removedItems.length + fetchedCountMap.get(disregardAfterKey).count;
+                        for (let i = 0; i < decrementValueTotal; i++) {
+                            this._decrementIteratorOffset(previousCacheIndex + 1);
+                        }
                     }
                     if (disregardAfterKey === null) {
                         const mutationEventDetail = new this.DataProviderMutationEventDetail(this, operationAddEventDetail, operationRemoveEventDetail, null);
-                        this.dispatchEvent(new ojdataprovider.DataProviderMutationEvent(mutationEventDetail));
+                        if (operationAddEventDetail.keys.size > 0 || operationRemoveEventDetail.keys.size > 0) {
+                            this.dispatchEvent(new ojdataprovider.DataProviderMutationEvent(mutationEventDetail));
+                        }
                     }
                     if (disregardAfterKey !== null) {
                         const refreshEvent = new ojdataprovider.DataProviderRefreshEvent(new this.DataProviderRefreshEventDetail(disregardAfterKey));
@@ -1101,6 +1139,16 @@ define(['ojs/ojcore-base', 'ojs/ojset', 'ojs/ojeventtarget', 'ojs/ojobservable',
         _getEntry(i) {
             return this._cache[i];
         }
+        _getLastDescendentByParentKey(parentKey) {
+            const lastItem = this._getLastItemByParentKey(parentKey);
+            if (!lastItem) {
+                return this._getItemByKey(parentKey);
+            }
+            if (lastItem.metadata.isLeaf) {
+                return lastItem;
+            }
+            return this._getLastDescendentByParentKey(lastItem.metadata.key);
+        }
         _getLastItemByParentKey(parentKey) {
             let returnItem = null;
             this._cache

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

@@ -518,6 +518,11 @@ define(['exports', 'ojs/ojcore-base', 'ojs/ojkeysetimpl'], function (exports, oj
                 keys: undefined
             };
             this.keys.keys = new Set(keys);
+            Object.defineProperty(this, '_keys', {
+                get: () => {
+                    return this.keys.keys;
+                }
+            });
         }
         has(key) {
             return _has(this.keys.keys, key);
@@ -571,6 +576,11 @@ define(['exports', 'ojs/ojcore-base', 'ojs/ojkeysetimpl'], function (exports, oj
                 deletedKeys: undefined
             };
             this.keys.deletedKeys = new Set(keys);
+            Object.defineProperty(this, '_keys', {
+                get: () => {
+                    return this.keys.deletedKeys;
+                }
+            });
         }
         has(key) {
             return !_has(this.keys.deletedKeys, key);

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

@@ -25,22 +25,33 @@ define(['exports'], function (exports) { 'use strict';
    *
    * <p>If the logging options are changed at a later point, the Logger will use the modified options for the subsequent log operations.
    *
+   * <p>The logging level can be overridden via sessionStorage.setItem() call for the current browser session.
+   * Use 'ojet.logLevel' as the key with one of the following values: 'none' (least verbose), 'error', 'warning', 'info', 'log' (most verbose).
+   * Set the value in the browser console and refresh the browser in order for the value to take effect.
+   * </p>
+   * <h3> Session storage usage : </h3>
+   * <pre class="prettyprint">
+   * <code>
+   * // override logging level for the current session
+   * sessionStorage.setItem('ojet.logLevel', 'log');
+   * </code></pre>
+   *
    * <p>All the logging methods support string formatting, accept variable number of arguments and accept a function as a parameter.
    * When a callback function is specified as a parameter the function will be called if the log level is sufficient.
    *
-   * <h3> Usage : </h3>
+   * <h3> Logger usage : </h3>
    * <pre class="prettyprint">
    * <code>
    * //optional calls, see defaults
-   * oj.Logger.option("level",  oj.Logger.LEVEL_INFO);
-   * oj.Logger.option("writer",  customWriter);  //an object that implements the following methods: log(), info(), warn(), error()
+   * Logger.option("level",  Logger.LEVEL_INFO);
+   * Logger.option("writer",  customWriter);  //an object that implements the following methods: log(), info(), warn(), error()
    *
    * // logging a message
-   * oj.Logger.info("My log level is %d", oj.Logger.option("level"));  // string formatting
-   * oj.Logger.warn("Beware of bugs", "in the above code");            // multiple parameters
+   * Logger.info("My log level is %d", Logger.option("level"));  // string formatting
+   * Logger.warn("Beware of bugs", "in the above code");            // multiple parameters
    *
    * // using a callback function as a parameter
-   * oj.Logger.info(function(){
+   * Logger.info(function(){
    *    var foo = "This ";
    *    var bar = "is ";
    *    var zing = "a function";
@@ -107,6 +118,47 @@ define(['exports'], function (exports) { 'use strict';
   Logger._defaultOptions = { level: Logger.LEVEL_ERROR, writer: null };
   Logger._options = Logger._defaultOptions;
 
+  /*
+   * Helper method that retrieves and parses session storage setting
+   */
+  const _getSessionStorage = () => {
+    const sessionValue =
+      typeof window !== 'undefined' && window.sessionStorage !== undefined
+        ? sessionStorage.getItem('ojet.logLevel')
+        : undefined;
+    let logLevel;
+    switch (sessionValue) {
+      case 'none':
+        logLevel = Logger.LEVEL_NONE;
+        break;
+      case 'error':
+        logLevel = Logger.LEVEL_ERROR;
+        break;
+      case 'warning':
+        logLevel = Logger.LEVEL_WARN;
+        break;
+      case 'info':
+        logLevel = Logger.LEVEL_INFO;
+        break;
+      case 'log':
+        logLevel = Logger.LEVEL_LOG;
+        break;
+      default:
+        logLevel = undefined;
+    }
+    return logLevel;
+  };
+
+  /* SessionStorage setting */
+  const _sessionStorage = _getSessionStorage();
+
+  /*
+   * Helper method - returns current log level from session storage or options
+   */
+  const _getLogLevel = () => {
+    return _sessionStorage || Logger._options.level;
+  };
+
   /* public members*/
   /**
    * Writes an error message.
@@ -210,12 +262,23 @@ define(['exports'], function (exports) { 'use strict';
     if (arguments.length === 0) {
       keys = Object.keys(Logger._options);
       for (i = 0; i < keys.length; i++) {
-        ret[keys[i]] = Logger._options[keys[i]];
+        ret[keys[i]] = key === 'level' ? _getLogLevel() : Logger._options[keys[i]];
       }
       return ret;
     }
     if (typeof key === 'string' && value === undefined) {
-      return Logger._options[key] === undefined ? null : Logger._options[key];
+      let optValue;
+      switch (key) {
+        case 'level':
+          optValue = _getLogLevel();
+          break;
+        case 'writer':
+          optValue = Logger._options.writer;
+          break;
+        default:
+          optValue = null;
+      }
+      return optValue;
     }
 
     // setters

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

@@ -1396,6 +1396,13 @@ var __oj_tab_bar_metadata =
           return;
         }
         if ($target.hasClass(this.getNavListRemoveIcon()) && this.isTabBar()) {
+          // click on the 'X' should not change selection, but it should still change currentItem
+          this.HandleClickActive(item, event);
+          var contentElement = this.getItemContentElement(item);
+          if (contentElement.length > 0) {
+            // make sure it gets focus otherwise focus goes to the body as 'X' is no longer in DOM
+            contentElement[0].focus();
+          }
           this._handleRemove(event, item);
           return;
         }

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

@@ -8399,16 +8399,28 @@ var __oj_select_many_metadata =
       items.forEach(
         function (item) {
           values.push(this.id(item));
-          valueOptions.push({
+
+          var newValueOption = {
             label: item.label,
             value: this.id(item)
-          });
+          };
 
           // populate data and metadata only when using a data provider
           if (isDataProvider) {
+            // JET-57010 - oj-select-many valueOptionsChanged event does not contain data
+            // and metadata
+            // include the data and metadata from the data provider in the item itself so that they
+            // will be included in the valueOptionsChanged event that gets fired, similar to what
+            // would happen if the user selected an item from the dropdown
+            newValueOption.data = item.data;
+            newValueOption.metadata = item.metadata;
             valueOptionsData.push(item.data);
             valueOptionsMetadata.push(item.metadata);
           }
+
+          // valueOptions is similar to value, but each item in the array is an object containing
+          // the value and label for that item
+          valueOptions.push(newValueOption);
         }.bind(this)
       );
 

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

@@ -2145,6 +2145,8 @@ var __oj_table_metadata =
     this._isEditPending = null;
     this._active = null;
     this._isTableTab = null;
+    this._renderedTableHeaderColumns = false;
+
     // clear any pending timeouts
     this._clearAllComponentTimeouts();
     // remove any pending busy states
@@ -2180,17 +2182,6 @@ var __oj_table_metadata =
         this._data.destroy();
       }
 
-      // If any template is being used, clean up the nodes to avoid memory leak in Knockout
-      if (
-        this._hasHeaderTemplate ||
-        this._hasCellTemplate ||
-        this._hasFooterTemplate ||
-        this._hasRowTemplate ||
-        this._hasAddRowTemplate
-      ) {
-        this._cleanTemplateNodes(this.element[0]);
-      }
-
       this._componentDestroyed = true;
     } else {
       // cleanup needed for 'ReleaseResources()' call only
@@ -2199,6 +2190,12 @@ var __oj_table_metadata =
       this._unregisterDataSourceEventListeners();
       this._unregisterResizeListener();
     }
+
+    // If any template is being used, clean up the nodes to avoid memory leak in Knockout
+    if (this._hasHeaderTemplate || this._hasCellTemplate || this._hasFooterTemplate ||
+        this._hasRowTemplate || this._hasAddRowTemplate || this._hasNoDataTemplate) {
+      this._cleanTemplateNodes(this.element[0]);
+    }
   };
 
   /**
@@ -3069,7 +3066,6 @@ var __oj_table_metadata =
               tableBodyRow = docFrag.children[rowIdx - docFragStartIdx];
             }
           }
-          // eslint-disable-next-line no-param-reassign
           this._hasRowTemplate = true;
         }
       }
@@ -3729,6 +3725,7 @@ var __oj_table_metadata =
           nodes.forEach(function (node) {
             noDataContentCell.appendChild(node); // @HTMLUpdateOK
           });
+          this._hasNoDataTemplate = true;
         }
       } else {
         var emptyTextMsg = null;
@@ -3770,6 +3767,7 @@ var __oj_table_metadata =
           if (noDataRow != null) {
             this._cleanTemplateNodes(noDataRow);
             $(noDataRow).remove();
+            this._hasNoDataTemplate = false;
           }
         }
       }