@infinite-table/infinite-react 9.1.5 → 9.3.0

package/index.dev.js

@@ -15185,6 +15185,7 @@ function lazyGroup(groupParams, rootData) {
           childrenAvailable: false,
           commonData: dataObject,
           totalChildrenCount: dataArray[i].totalChildrenCount,
+          totalChildrenCountUnfiltered: dataArray[i].totalChildrenCountUnfiltered,
           reducerResults: dataArray[i].aggregations || {},
           isTree: false,
           isGroupBy: true
@@ -16736,6 +16737,52 @@ function getGroupKeysForDataItem(data, groupBy) {
 }
 
 // src/components/DataSource/RowSelectionState.ts
+var EMPTY_UNFILTERED_GROUPS = new DeepMap();
+var unfilteredGroupsCache = /* @__PURE__ */ new WeakMap();
+function getUnfilteredGroups(config) {
+  const { originalDataArray, groupBy, toPrimaryKey } = config;
+  if (!originalDataArray || !groupBy.length) {
+    return EMPTY_UNFILTERED_GROUPS;
+  }
+  const cached = unfilteredGroupsCache.get(originalDataArray);
+  if (cached && cached.groupBy === groupBy) {
+    return cached.groups;
+  }
+  const groups = new DeepMap();
+  const lastLevel = groupBy.length;
+  const keys = [];
+  originalDataArray.forEach((data) => {
+    const groupKeys = getGroupKeysForDataItem(data, groupBy);
+    keys.length = 0;
+    for (let i = 0; i < groupKeys.length; i++) {
+      keys.push(groupKeys[i]);
+      let group2 = groups.get(keys);
+      if (!group2) {
+        group2 = { count: 0 };
+        if (keys.length === lastLevel) {
+          group2.primaryKeys = [];
+        }
+        groups.set(keys, group2);
+      }
+      group2.count++;
+      group2.primaryKeys?.push(toPrimaryKey(data));
+    }
+  });
+  unfilteredGroupsCache.set(originalDataArray, { groupBy, groups });
+  return groups;
+}
+function getUnfilteredPrimaryKeysInsideGroup(groups, groupKeys) {
+  const result = [];
+  groups.getLeafNodesStartingWith(groupKeys, (pair) => {
+    const primaryKeys = pair.value?.primaryKeys;
+    if (primaryKeys) {
+      for (let i = 0; i < primaryKeys.length; i++) {
+        result.push(primaryKeys[i]);
+      }
+    }
+  });
+  return result;
+}
 var RowSelectionState = class _RowSelectionState {
   constructor(state, getConfig, _forTestingOnly) {
     this.selectedRows = null;
@@ -16787,26 +16834,123 @@ var RowSelectionState = class _RowSelectionState {
   getGroupDeepMap() {
     return this.getConfig().groupDeepMap;
   }
+  /**
+   * The selection acts only on the rows that pass the filter, and some rows are filtered out
+   */
+  targetsVisibleRowsOnly() {
+    const { multiRowSelectionTarget, someRowsFilteredOut } = this.getConfig();
+    return multiRowSelectionTarget === "visible" && !!someRowsFilteredOut;
+  }
+  /**
+   * The selection also acts on rows that are filtered out, and some rows are filtered out
+   */
+  targetsFilteredOutRows() {
+    const { multiRowSelectionTarget, someRowsFilteredOut } = this.getConfig();
+    return multiRowSelectionTarget !== "visible" && !!someRowsFilteredOut;
+  }
+  getVisibleDataInsideGroup(groupKeys) {
+    const { postFilterDataArray, groupDeepMap } = this.getConfig();
+    if (!groupKeys.length) {
+      return postFilterDataArray ?? [];
+    }
+    return groupDeepMap?.get(groupKeys)?.items ?? [];
+  }
+  hasFilteredOutRowsInsideGroup(groupKeys) {
+    const config = this.getConfig();
+    if (!config.someRowsFilteredOut) {
+      return false;
+    }
+    const allCount = groupKeys.length ? getUnfilteredGroups(config).get(groupKeys)?.count ?? 0 : config.originalDataArray?.length ?? 0;
+    return allCount > this.getVisibleDataInsideGroup(groupKeys).length;
+  }
+  /**
+   * Sets the selection of each visible row inside the group, by its full path,
+   * so the rows of the group that are filtered out keep their selection
+   */
+  setVisibleRowsSelection(groupKeys, selected) {
+    const { groupBy, toPrimaryKey } = this.getConfig();
+    const mapToSet = selected ? this.selectedMap : this.deselectedMap;
+    const mapToClear = selected ? this.deselectedMap : this.selectedMap;
+    this.xcache();
+    this.getVisibleDataInsideGroup(groupKeys).forEach((data) => {
+      const rowGroupKeys = getGroupKeysForDataItem(data, groupBy);
+      const pk = toPrimaryKey(data);
+      const finalKey = [...rowGroupKeys, pk];
+      mapToClear.delete(finalKey);
+      if (this.isRowSelected(pk, rowGroupKeys) !== selected) {
+        mapToSet.set(finalKey, true);
+      }
+    });
+    this.xcache();
+  }
+  /**
+   * Lazy load, when the selection also acts on rows that are filtered out:
+   * the count of all the rows inside the group without the filter, if the server sent it
+   */
+  getLazyUnfilteredCount(groupKeys) {
+    const config = this.getConfig();
+    if (!config.lazyLoad || config.multiRowSelectionTarget === "visible") {
+      return void 0;
+    }
+    if (!groupKeys.length) {
+      return config.lazyUnfilteredCount;
+    }
+    return config.groupDeepMap?.get(groupKeys)?.totalChildrenCountUnfiltered;
+  }
+  /**
+   * Lazy load, when the selection also acts on rows that are filtered out:
+   * the count of the rows inside the group (not at the last level) that are not inside
+   * its loaded groups - so the rows of the groups hidden by the filter or not loaded yet
+   */
+  getLazyHiddenRowsCount(groupKeys) {
+    const unfilteredCount = groupKeys.length < this.getGroupByLength() ? this.getLazyUnfilteredCount(groupKeys) : void 0;
+    if (unfilteredCount === void 0) {
+      return 0;
+    }
+    const { groupDeepMap } = this.getConfig();
+    let childrenCount = 0;
+    this.getGroupKeysDirectlyInsideGroup(groupKeys).forEach((keys) => {
+      childrenCount += this.getLazyUnfilteredCount(keys) ?? (groupDeepMap?.get(keys)?.totalChildrenCount || 0);
+    });
+    return Math.max(unfilteredCount - childrenCount, 0);
+  }
   getGroupCount(groupKeys) {
     if (groupKeys.length == 0) {
-      return this.getConfig().totalCount;
+      return this.getLazyUnfilteredCount([]) ?? this.getConfig().totalCount;
+    }
+    if (this.targetsFilteredOutRows()) {
+      return getUnfilteredGroups(this.getConfig()).get(groupKeys)?.count ?? 0;
     }
     const groupDeepMap = this.getGroupDeepMap();
     const deepMapValue = groupDeepMap?.get(groupKeys);
     if (!deepMapValue) {
       return 0;
     }
-    return deepMapValue.totalChildrenCount ?? (deepMapValue.items.length || 0);
+    return this.getLazyUnfilteredCount(groupKeys) ?? deepMapValue.totalChildrenCount ?? (deepMapValue.items.length || 0);
   }
   getGroupKeysDirectlyInsideGroup(groupKeys) {
-    const { groupDeepMap } = this.getConfig();
-    return groupDeepMap?.getKeysStartingWith(groupKeys, {
-      excludeSelf: true,
-      depthLimit: 1
-    }) || [];
+    const config = this.getConfig();
+    const options = { excludeSelf: true, depthLimit: 1 };
+    if (this.targetsFilteredOutRows()) {
+      return getUnfilteredGroups(config).getKeysStartingWith(
+        groupKeys,
+        options
+      );
+    }
+    return config.groupDeepMap?.getKeysStartingWith(groupKeys, options) || [];
   }
   getAllPrimaryKeysInsideGroup(groupKeys) {
-    const { groupDeepMap } = this.getConfig();
+    const config = this.getConfig();
+    const { groupDeepMap, toPrimaryKey } = config;
+    if (this.targetsFilteredOutRows()) {
+      return groupKeys.length ? getUnfilteredPrimaryKeysInsideGroup(
+        getUnfilteredGroups(config),
+        groupKeys
+      ) : (config.originalDataArray ?? []).map(toPrimaryKey);
+    }
+    if (!config.groupBy.length) {
+      return this.getVisibleDataInsideGroup([]).map(toPrimaryKey);
+    }
     if (!groupKeys.length) {
       const topLevelKeys = groupDeepMap?.getKeysStartingWith([], {
         excludeSelf: true,
@@ -16844,7 +16988,7 @@ var RowSelectionState = class _RowSelectionState {
         if (this.onlyUsePrimaryKeys) {
           return keys[0];
         }
-        return keys.length > groupByLength ? keys.pop() : keys;
+        return groupByLength === 0 && keys.length === 1 ? keys[0] : keys;
       });
     };
     const selectedRows = normalize(this.selectedMap.topDownKeys());
@@ -16856,6 +17000,14 @@ var RowSelectionState = class _RowSelectionState {
     };
   }
   deselectAll() {
+    if (this.targetsVisibleRowsOnly()) {
+      if (this.onlyUsePrimaryKeys) {
+        this.deselectGroupRow([]);
+      } else {
+        this.setVisibleRowsSelection([], false);
+      }
+      return;
+    }
     this.update({
       defaultSelection: false,
       selectedRows: [],
@@ -16863,6 +17015,14 @@ var RowSelectionState = class _RowSelectionState {
     });
   }
   selectAll() {
+    if (this.targetsVisibleRowsOnly()) {
+      if (this.onlyUsePrimaryKeys) {
+        this.selectGroupRow([]);
+      } else {
+        this.setVisibleRowsSelection([], true);
+      }
+      return;
+    }
     this.update({
       defaultSelection: true,
       deselectedRows: [],
@@ -17017,6 +17177,10 @@ var RowSelectionState = class _RowSelectionState {
       this.xcache();
       return;
     }
+    if (this.targetsVisibleRowsOnly() && this.hasFilteredOutRowsInsideGroup(groupKeys)) {
+      this.setVisibleRowsSelection(groupKeys, true);
+      return;
+    }
     const selectedKeys = this.selectedMap.getKeysStartingWith(groupKeys, {
       excludeSelf: true
     });
@@ -17045,6 +17209,10 @@ var RowSelectionState = class _RowSelectionState {
       this.xcache();
       return;
     }
+    if (this.targetsVisibleRowsOnly() && this.hasFilteredOutRowsInsideGroup(groupKeys)) {
+      this.setVisibleRowsSelection(groupKeys, false);
+      return;
+    }
     const deselectedKeys = this.deselectedMap.getKeysStartingWith(groupKeys, {
       excludeSelf: true
     });
@@ -17143,7 +17311,7 @@ var RowSelectionState = class _RowSelectionState {
       this.selectionCountCache.set(groupKeys, result2);
       return result2;
     }
-    if (groupByLength && this.onlyUsePrimaryKeys) {
+    if (this.onlyUsePrimaryKeys && (groupByLength || this.targetsVisibleRowsOnly())) {
       const allKeys2 = this.getAllPrimaryKeysInsideGroup(groupKeys);
       let selectedCount2 = 0;
       let deselectedCount2 = 0;
@@ -17169,6 +17337,21 @@ var RowSelectionState = class _RowSelectionState {
       this.selectionCountCache.set(groupKeys, result2);
       return result2;
     }
+    if (groupKeys.length === groupByLength && this.targetsVisibleRowsOnly()) {
+      const { toPrimaryKey } = this.getConfig();
+      let selectedCount2 = 0;
+      let deselectedCount2 = 0;
+      this.getVisibleDataInsideGroup(groupKeys).forEach((data) => {
+        if (this.isRowSelected(toPrimaryKey(data), groupKeys)) {
+          selectedCount2++;
+        } else {
+          deselectedCount2++;
+        }
+      });
+      const result2 = { selectedCount: selectedCount2, deselectedCount: deselectedCount2 };
+      this.selectionCountCache.set(groupKeys, result2);
+      return result2;
+    }
     parentSelected = parentSelected ?? this.getGroupRowBooleanSelectionStateFromParent(groupKeys);
     let allKeys = this.getGroupKeysDirectlyInsideGroup(groupKeys);
     if (groupKeys.length === this.getGroupByLength()) {
@@ -17192,8 +17375,9 @@ var RowSelectionState = class _RowSelectionState {
     }
     let selectedCount = 0;
     let deselectedCount = 0;
-    if (this.getConfig().lazyLoad && !allKeys.length) {
-      const totalChildrenCount = this.getConfig().groupDeepMap?.get(groupKeys)?.totalChildrenCount || 0;
+    const { lazyLoad, groupDeepMap } = this.getConfig();
+    if (lazyLoad && !allKeys.length) {
+      const totalChildrenCount = this.getLazyUnfilteredCount(groupKeys) ?? (groupDeepMap?.get(groupKeys)?.totalChildrenCount || 0);
       if (parentSelected) {
         selectedCount = totalChildrenCount;
         deselectedCount = this.deselectedMap.getAllChildrenSizeFor(groupKeys);
@@ -17216,6 +17400,12 @@ var RowSelectionState = class _RowSelectionState {
       selectedCount += selCount;
       deselectedCount += deselCount;
     });
+    const hiddenCount = allKeys.length ? this.getLazyHiddenRowsCount(groupKeys) : 0;
+    if (parentSelected) {
+      selectedCount += hiddenCount;
+    } else {
+      deselectedCount += hiddenCount;
+    }
     const result = {
       selectedCount,
       deselectedCount
@@ -17235,14 +17425,22 @@ function cloneRowSelection(rowSelection, stateOrGetDataSourceState) {
 function rowSelectionStateConfigGetter(stateOrStateGetter) {
   return () => {
     const state = typeof stateOrStateGetter === "function" ? stateOrStateGetter() : stateOrStateGetter;
+    const { originalDataArray, postFilterDataArray } = state;
+    const lazyLoad = !!state.lazyLoad;
+    const lazyRoot = lazyLoad ? state.originalLazyGroupData.get([LAZY_ROOT_KEY_FOR_GROUPS]) : void 0;
     return {
-      lazyLoad: !!state.lazyLoad,
+      lazyLoad,
       toPrimaryKey: state.toPrimaryKey,
       onlyUsePrimaryKeys: !state.useGroupKeysForMultiRowSelection,
       groupBy: state.groupBy,
       groupDeepMap: state.groupDeepMap,
       indexer: state.indexer,
-      totalCount: state.unfilteredCount
+      totalCount: lazyLoad ? originalDataArray?.length ?? 0 : state.unfilteredCount,
+      lazyUnfilteredCount: state.groupBy.length ? lazyRoot?.totalChildrenCountUnfiltered : lazyRoot?.totalCountUnfiltered,
+      multiRowSelectionTarget: state.multiRowSelectionTarget,
+      someRowsFilteredOut: !state.lazyLoad && !!originalDataArray && !!postFilterDataArray && postFilterDataArray.length < originalDataArray.length,
+      originalDataArray,
+      postFilterDataArray
     };
   };
 }
@@ -18177,6 +18375,9 @@ var TreeExpandState = class {
 };
 
 // src/components/DataSource/TreeSelectionState.ts
+var toTreePathsMap = (treePaths) => {
+  return Array.isArray(treePaths) ? new DeepMap(treePaths.map((path) => [path, true])) : treePaths;
+};
 var shortestToLongest = (a, b) => a.length - b.length;
 var TreeSelectionState = class _TreeSelectionState {
   constructor(state, getConfig) {
@@ -18203,13 +18404,7 @@ var TreeSelectionState = class _TreeSelectionState {
     }
   }
   getTreePaths(treePaths) {
-    if (treePaths) {
-      if (Array.isArray(treePaths)) {
-        return new DeepMap(treePaths.map((path) => [path, true]));
-      }
-      return treePaths;
-    }
-    return this.config.treePaths;
+    return treePaths ? toTreePathsMap(treePaths) : this.config.treePaths;
   }
   withTreePaths(fn, treePaths) {
     const initialTreePaths = this.config.treePaths;
@@ -18282,11 +18477,38 @@ var TreeSelectionState = class _TreeSelectionState {
   setConfig(getConfig) {
     const config = typeof getConfig === "function" ? getConfig() : getConfig;
     this.config = {
-      treePaths: Array.isArray(config.treePaths) ? new DeepMap(config.treePaths.map((path) => [path, true])) : config.treePaths,
-      strictCheckPaths: config.strictCheckPaths ?? true
+      treePaths: toTreePathsMap(config.treePaths),
+      strictCheckPaths: config.strictCheckPaths ?? true,
+      multiRowSelectionTarget: config.multiRowSelectionTarget,
+      unfilteredTreePaths: config.unfilteredTreePaths ? toTreePathsMap(config.unfilteredTreePaths) : void 0
     };
     this.xcache();
   }
+  hasFilteredOutLeavesInside(nodePath) {
+    const { multiRowSelectionTarget, unfilteredTreePaths, treePaths } = this.config;
+    if (multiRowSelectionTarget !== "visible" || !unfilteredTreePaths || unfilteredTreePaths === treePaths) {
+      return false;
+    }
+    return unfilteredTreePaths.getAllChildrenSizeFor(nodePath) > treePaths.getAllChildrenSizeFor(nodePath);
+  }
+  /**
+   * Sets the selection of each visible leaf node inside the node, by its path,
+   * so the leaf nodes that are filtered out keep their selection
+   */
+  setVisibleLeafNodesSelection(nodePath, selected) {
+    const { unfilteredTreePaths, treePaths } = this.config;
+    this.xcache();
+    treePaths.getKeysForLeafNodesStartingWith(nodePath).forEach((leafPath) => {
+      if (unfilteredTreePaths.getAllChildrenSizeFor(leafPath) > 0) {
+        return;
+      }
+      this.selectionMap.delete(leafPath);
+      if (this.isNodeSelected(leafPath) !== selected) {
+        this.setSelectionForPath(leafPath, selected);
+      }
+    });
+    this.xcache();
+  }
   xcache() {
     this.cache.clear();
   }
@@ -18327,6 +18549,10 @@ var TreeSelectionState = class _TreeSelectionState {
     };
   }
   deselectAll() {
+    if (this.hasFilteredOutLeavesInside([])) {
+      this.setVisibleLeafNodesSelection([], false);
+      return;
+    }
     this.update({
       defaultSelection: false,
       selectedPaths: [],
@@ -18334,6 +18560,10 @@ var TreeSelectionState = class _TreeSelectionState {
     });
   }
   selectAll() {
+    if (this.hasFilteredOutLeavesInside([])) {
+      this.setVisibleLeafNodesSelection([], true);
+      return;
+    }
     this.update({
       defaultSelection: true,
       deselectedPaths: [],
@@ -18485,6 +18715,10 @@ var TreeSelectionState = class _TreeSelectionState {
     if (!nodePath.length) {
       return;
     }
+    if (this.hasFilteredOutLeavesInside(nodePath)) {
+      this.setVisibleLeafNodesSelection(nodePath, selected);
+      return;
+    }
     this.xcache();
     const keys = this.selectionMap.getKeysStartingWith(nodePath);
     keys.forEach((nodePath2) => {
@@ -18541,8 +18775,17 @@ function cloneTreeSelection(treeSelection2, stateOrGetState) {
 function treeSelectionStateConfigGetter(stateOrStateGetter) {
   return () => {
     const state = typeof stateOrStateGetter === "function" ? stateOrStateGetter() : stateOrStateGetter;
+    const { treePaths, unfilteredTreePaths, multiRowSelectionTarget } = state;
+    if (multiRowSelectionTarget === "visible") {
+      return {
+        treePaths,
+        unfilteredTreePaths,
+        multiRowSelectionTarget
+      };
+    }
     return {
-      treePaths: state.treePaths
+      treePaths: unfilteredTreePaths ?? treePaths,
+      multiRowSelectionTarget
     };
   };
 }
@@ -20607,6 +20850,7 @@ var forwardProps3 = (setupState, props) => {
     treeFilterFunction: 1,
     filterValue: 1,
     useGroupKeysForMultiRowSelection: (useGroupKeysForMultiRowSelection) => useGroupKeysForMultiRowSelection ?? false,
+    multiRowSelectionTarget: (multiRowSelectionTarget) => multiRowSelectionTarget ?? "all",
     filterDelay: (filterDelay) => filterDelay ?? 200,
     filterTypes: (filterTypes) => {
       return { ...defaultFilterTypes2, ...filterTypes };
@@ -21670,12 +21914,14 @@ function concludeReducer(params) {
     "rowSelection",
     "cellSelection",
     "isRowSelected",
+    "multiRowSelectionTarget",
     "originalLazyGroupDataChangeDetect"
   ]);
   const treeSelectionDepsChanged = haveDepsChanged(previousState, state, [
     "treeSelection",
     "cellSelection",
     "isNodeSelected",
+    "multiRowSelectionTarget",
     "originalLazyGroupDataChangeDetect"
   ]);
   const groupsDepsChanged = originalDataArrayChanged || sortDepsChanged || haveDepsChanged(previousState, state, [
@@ -21809,6 +22055,9 @@ function concludeReducer(params) {
   const rowSelectionState = state.rowSelection instanceof RowSelectionState ? state.rowSelection : void 0;
   const treeExpandState = state.treeExpandState instanceof TreeExpandState ? state.treeExpandState : void 0;
   const cellSelectionState = state.cellSelection instanceof CellSelectionState ? state.cellSelection : void 0;
+  if (rowSelectionState) {
+    rowSelectionState.getConfig = rowSelectionStateConfigGetter(state);
+  }
   rowSelectionState?.xcache();
   let isRowSelected = state.selectionMode === "single-row" ? (rowInfo) => {
     return rowInfo.id === state.rowSelection;
@@ -22103,6 +22352,14 @@ function concludeReducer(params) {
           }
         }
       });
+      const { rowSelection } = state;
+      if (rowSelection instanceof RowSelectionState && rowSelection.getLazyHiddenRowsCount([])) {
+        if (rowSelection.defaultSelection) {
+          someRowsSelected = true;
+        } else {
+          allRowsSelected = false;
+        }
+      }
       state.allRowsSelected = allRowsSelected;
       state.someRowsSelected = someRowsSelected;
       if (debugId) {
@@ -22115,10 +22372,14 @@ function concludeReducer(params) {
           debugId
         ).track.DataSource.label.ComputeSelectionCount.start();
       }
-      const dataArrayCount = state.isTree ? state.totalLeafNodesCount : state.filteredCount;
-      const selectedRowCount = state.isTree ? state.treeSelectionState ? state.treeSelectionState.getSelectedCount() : 0 : state.rowSelection.getSelectedCount();
-      state.allRowsSelected = dataArrayCount === selectedRowCount;
-      state.someRowsSelected = selectedRowCount > 0;
+      const selectionCount = state.isTree ? state.treeSelectionState?.getSelectionCountFor([]) : state.rowSelection.getSelectionCountFor([]);
+      if (selectionCount) {
+        state.allRowsSelected = selectionCount.deselectedCount === 0;
+        state.someRowsSelected = selectionCount.selectedCount > 0;
+      } else {
+        state.allRowsSelected = state.totalLeafNodesCount === 0;
+        state.someRowsSelected = false;
+      }
       if (debugId) {
         marker?.end();
         marker = void 0;
@@ -22217,6 +22478,9 @@ function buildDataSourceDataParams(componentState, overrides, masterContext) {
       dataSourceParams.lazyLoadStartIndex = 0;
     }
     dataSourceParams.groupKeys = [];
+    if (componentState.selectionMode === "multi-row") {
+      dataSourceParams.multiRowSelectionTarget = componentState.multiRowSelectionTarget;
+    }
   }
   if (overrides) {
     Object.assign(dataSourceParams, overrides);
@@ -22293,8 +22557,7 @@ function loadData(data, componentState, actions, overrides, masterContext) {
         childrenLoading: true,
         childrenAvailable: false,
         cache: CACHE_DEFAULT,
-        totalCount: 0,
-        totalCountUnfiltered: 0
+        totalCount: 0
       });
     }
     actions.originalLazyGroupDataChangeDetect = getChangeDetect();
@@ -22333,7 +22596,9 @@ function loadData(data, componentState, actions, overrides, masterContext) {
             childrenLoading: false,
             childrenAvailable: true,
             totalCount: remoteData2.totalCount ?? dataArray2.length,
-            totalCountUnfiltered: remoteData2.totalCount ?? dataArray2.length,
+            // set even when missing, so a previous response's values are not kept
+            totalCountUnfiltered: remoteData2.totalCountUnfiltered,
+            totalChildrenCountUnfiltered: remoteData2.totalChildrenCountUnfiltered,
             children: dataArray2,
             error: remoteData2.error
           };
@@ -27893,7 +28158,7 @@ var useLicense = (licenseKey = "") => {
     }
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "9.1.5"
+      version: "9.3.0"
     });
     if (!licenseKey && !valid2 && isInsidePlayground) {
       return true;