@finos/legend-query-builder 0.0.2 → 0.1.1

package/src/stores/explorer/QueryBuilderPropertySearchState.ts

@@ -21,17 +21,27 @@ import {
   getAllClassDerivedProperties,
   PrimitiveType,
   PRIMITIVE_TYPE,
+  CORE_PURE_PATH,
+  PURE_DOC_TAG,
 } from '@finos/legend-graph';
 import {
+  ActionState,
   addUniqueEntry,
   deleteEntry,
   guaranteeNonNullable,
 } from '@finos/legend-shared';
-import { makeAutoObservable, observable, computed, action } from 'mobx';
+import {
+  observable,
+  computed,
+  action,
+  makeObservable,
+  runInAction,
+} from 'mobx';
 import {
   QUERY_BUILDER_PROPERTY_SEARCH_MAX_DEPTH,
   QUERY_BUILDER_PROPERTY_SEARCH_RESULTS_LIMIT,
   QUERY_BUILDER_PROPERTY_SEARCH_TYPE,
+  QUERY_BUILDER_PROPERTY_SEARCH_MAX_NODES,
 } from '../QueryBuilderConfig.js';
 import {
   getQueryBuilderPropertyNodeData,
@@ -41,206 +51,190 @@ import {
   QueryBuilderExplorerTreeSubTypeNodeData,
 } from './QueryBuilderExplorerState.js';
 import type { QueryBuilderState } from '../QueryBuilderState.js';
+import { Fuse } from '@finos/legend-art';
+import { TextSearchAdvancedConfigState } from '@finos/legend-application';
 
 export class QueryBuilderPropertySearchState {
   queryBuilderState: QueryBuilderState;
-  // TODO: Check if we could clean this up as this seems quite complicated and its purpose is not clear to me
-  // See https://github.com/finos/legend-studio/pull/1212
-  allMappedPropertyNodes: QueryBuilderExplorerTreeNodeData[] = [];
-  searchedMappedPropertyNodes: QueryBuilderExplorerTreeNodeData[] = [];
+
+  /**
+   * When we initialize property search engine, we practically extend
+   * the existing explorer by a few depth. As such, we create new explorer
+   * nodes which are not part of the main explorer tree. Together with the
+   * nodes already explored in the tree, these nodes are stored here to help
+   * searching. Think of this as the knowledge base of property search
+   *
+   * NOTE: a big reason why we want to store these as explorer tree nodes
+   * is that we could interact with the searched nodes, i.e. drag them to
+   * various panels to create filter, fetch-structure, etc.
+   */
+  indexedExplorerTreeNodes: QueryBuilderExplorerTreeNodeData[] = [];
+
+  // search
+  searchEngine: Fuse<QueryBuilderExplorerTreeNodeData>;
+  searchConfigurationState: TextSearchAdvancedConfigState;
+  searchState = ActionState.create();
+  searchText = '';
+  searchResults: QueryBuilderExplorerTreeNodeData[] = [];
+  isOverSearchLimit = false;
   isSearchPanelOpen = false;
   isSearchPanelHidden = false;
-  searchText = '';
-  filterByMultiple: boolean;
-  typeFilters: QUERY_BUILDER_PROPERTY_SEARCH_TYPE[];
+  showSearchConfigurationMenu = false;
+
+  // filter
+  typeFilters = [
+    QUERY_BUILDER_PROPERTY_SEARCH_TYPE.CLASS,
+    QUERY_BUILDER_PROPERTY_SEARCH_TYPE.STRING,
+    QUERY_BUILDER_PROPERTY_SEARCH_TYPE.BOOLEAN,
+    QUERY_BUILDER_PROPERTY_SEARCH_TYPE.NUMBER,
+    QUERY_BUILDER_PROPERTY_SEARCH_TYPE.DATE,
+  ];
 
   constructor(queryBuilderState: QueryBuilderState) {
-    makeAutoObservable(this, {
-      queryBuilderState: false,
-      searchedMappedPropertyNodes: observable,
+    makeObservable(this, {
+      indexedExplorerTreeNodes: observable,
+      searchText: observable,
+      searchResults: observable,
+      isOverSearchLimit: observable,
       isSearchPanelOpen: observable,
       isSearchPanelHidden: observable,
-      searchText: observable,
-      filteredPropertyNodes: computed,
+      showSearchConfigurationMenu: observable,
+      typeFilters: observable,
+      filteredSearchResults: computed,
+      search: action,
+      resetSearch: action,
       setSearchText: action,
-      setSearchedMappedPropertyNodes: action,
+      setShowSearchConfigurationMenu: action,
       setIsSearchPanelOpen: action,
       setIsSearchPanelHidden: action,
-      refreshPropertyState: action,
-      setFilterByMultiple: action,
-      toggleTypeFilter: action,
+      toggleFilterForType: action,
+      initialize: action,
     });
 
     this.queryBuilderState = queryBuilderState;
-    this.filterByMultiple = true;
-    this.typeFilters = [
-      QUERY_BUILDER_PROPERTY_SEARCH_TYPE.CLASS,
-      QUERY_BUILDER_PROPERTY_SEARCH_TYPE.STRING,
-      QUERY_BUILDER_PROPERTY_SEARCH_TYPE.BOOLEAN,
-      QUERY_BUILDER_PROPERTY_SEARCH_TYPE.NUMBER,
-      QUERY_BUILDER_PROPERTY_SEARCH_TYPE.DATE,
-    ];
+    this.searchConfigurationState = new TextSearchAdvancedConfigState(
+      (): void => this.search(),
+    );
+    this.searchEngine = new Fuse(this.indexedExplorerTreeNodes);
   }
 
-  toggleTypeFilter(val: QUERY_BUILDER_PROPERTY_SEARCH_TYPE): void {
-    if (this.typeFilters.includes(val)) {
-      deleteEntry(this.typeFilters, val);
-    } else {
-      addUniqueEntry(this.typeFilters, val);
-    }
+  setIsSearchPanelOpen(val: boolean): void {
+    this.isSearchPanelOpen = val;
   }
 
-  setFilterByMultiple(val: boolean): void {
-    this.filterByMultiple = val;
+  setIsSearchPanelHidden(val: boolean): void {
+    this.isSearchPanelHidden = val;
   }
 
-  getMultiplePropertyNodes(): QueryBuilderExplorerTreeNodeData[] {
-    return this.searchedMappedPropertyNodes.filter((node) => {
-      if (node instanceof QueryBuilderExplorerTreePropertyNodeData) {
-        if (
-          node.property.multiplicity.upperBound === undefined ||
-          node.property.multiplicity.upperBound > 1
-        ) {
-          return true;
-        }
-        const parentNode = this.allMappedPropertyNodes.find(
-          (pn) => pn.id === node.parentId,
-        );
-        if (
-          parentNode instanceof QueryBuilderExplorerTreePropertyNodeData &&
-          (parentNode.property.multiplicity.upperBound === undefined ||
-            parentNode.property.multiplicity.upperBound > 1)
-        ) {
-          return true;
-        }
-      }
-      return false;
-    });
+  setShowSearchConfigurationMenu(val: boolean): void {
+    this.showSearchConfigurationMenu = val;
   }
 
-  classPropertyNodes(): QueryBuilderExplorerTreeNodeData[] {
-    return this.searchedMappedPropertyNodes.filter((node) => {
-      if (node.type instanceof Class) {
-        return true;
-      }
-      return false;
-    });
+  setSearchText(val: string): void {
+    this.searchText = val;
   }
 
-  stringPropertyNodes(): QueryBuilderExplorerTreeNodeData[] {
-    return this.searchedMappedPropertyNodes.filter((node) => {
-      if (
-        node.type instanceof PrimitiveType &&
-        node.type.name === PRIMITIVE_TYPE.STRING
-      ) {
-        return true;
-      }
-      return false;
-    });
+  resetSearch(): void {
+    this.searchText = '';
+    this.searchResults = [];
+    this.searchState.complete();
   }
 
-  numberPropertyNodes(): QueryBuilderExplorerTreeNodeData[] {
-    return this.searchedMappedPropertyNodes.filter((node) => {
-      if (
-        node.type instanceof PrimitiveType &&
-        (node.type.name === PRIMITIVE_TYPE.DECIMAL ||
-          node.type.name === PRIMITIVE_TYPE.NUMBER ||
-          node.type.name === PRIMITIVE_TYPE.INTEGER ||
-          node.type.name === PRIMITIVE_TYPE.FLOAT)
-      ) {
-        return true;
-      }
-      return false;
-    });
+  toggleFilterForType(val: QUERY_BUILDER_PROPERTY_SEARCH_TYPE): void {
+    if (this.typeFilters.includes(val)) {
+      deleteEntry(this.typeFilters, val);
+    } else {
+      addUniqueEntry(this.typeFilters, val);
+    }
   }
 
-  datePropertyNodes(): QueryBuilderExplorerTreeNodeData[] {
-    return this.searchedMappedPropertyNodes.filter((node) => {
-      if (
-        node.type instanceof PrimitiveType &&
-        (node.type.name === PRIMITIVE_TYPE.DATE ||
-          node.type.name === PRIMITIVE_TYPE.DATETIME ||
-          node.type.name === PRIMITIVE_TYPE.STRICTDATE ||
-          node.type.name === PRIMITIVE_TYPE.STRICTTIME ||
-          node.type.name === PRIMITIVE_TYPE.LATESTDATE)
-      ) {
-        return true;
-      }
-      return false;
-    });
-  }
+  search(): void {
+    if (!this.searchText) {
+      this.searchResults = [];
+      return;
+    }
+    this.searchState.inProgress();
 
-  booleanPropertyNodes(): QueryBuilderExplorerTreeNodeData[] {
-    return this.searchedMappedPropertyNodes.filter((node) => {
-      if (
-        node.type instanceof PrimitiveType &&
-        node.type.name === PRIMITIVE_TYPE.BOOLEAN
-      ) {
-        return true;
-      }
-      return false;
-    });
-  }
+    // NOTE: performanced of fuzzy search is impacted by the number of indexed entries and the length
+    // of the search pattern, so to a certain extent this could become laggy. If this becomes too inconvenient
+    // for the users, we might need to use another fuzzy-search implementation, or have appropriate search
+    // policy, e.g. limit length of search text, etc.
+    //
+    // See https://github.com/farzher/fuzzysort
+    const searchResults = Array.from(
+      this.searchEngine
+        .search(
+          this.searchConfigurationState.generateSearchText(
+            this.searchText.toLowerCase(),
+          ),
+          {
+            // NOTE: search for limit + 1 item so we can know if there are more search results
+            limit: QUERY_BUILDER_PROPERTY_SEARCH_RESULTS_LIMIT + 1,
+          },
+        )
+        .values(),
+    ).map((result) => result.item);
 
-  get filteredPropertyNodes(): QueryBuilderExplorerTreeNodeData[] {
-    return this.searchedMappedPropertyNodes.filter((p) => {
-      if (
-        !this.filterByMultiple &&
-        this.getMultiplePropertyNodes().includes(p)
-      ) {
-        return false;
-      }
-      if (
-        !this.typeFilters.includes(QUERY_BUILDER_PROPERTY_SEARCH_TYPE.CLASS) &&
-        this.classPropertyNodes().includes(p)
-      ) {
-        return false;
-      }
-      if (
-        !this.typeFilters.includes(QUERY_BUILDER_PROPERTY_SEARCH_TYPE.STRING) &&
-        this.stringPropertyNodes().includes(p)
-      ) {
-        return false;
-      }
-      if (
-        !this.typeFilters.includes(QUERY_BUILDER_PROPERTY_SEARCH_TYPE.NUMBER) &&
-        this.numberPropertyNodes().includes(p)
-      ) {
-        return false;
-      }
-      if (
-        !this.typeFilters.includes(
-          QUERY_BUILDER_PROPERTY_SEARCH_TYPE.BOOLEAN,
-        ) &&
-        this.booleanPropertyNodes().includes(p)
-      ) {
-        return false;
-      }
-      if (
-        !this.typeFilters.includes(QUERY_BUILDER_PROPERTY_SEARCH_TYPE.DATE) &&
-        this.datePropertyNodes().includes(p)
-      ) {
-        return false;
-      }
-      return true;
-    });
+    // check if the search results exceed the limit
+    if (searchResults.length > QUERY_BUILDER_PROPERTY_SEARCH_RESULTS_LIMIT) {
+      this.isOverSearchLimit = true;
+      this.searchResults = searchResults.slice(
+        0,
+        QUERY_BUILDER_PROPERTY_SEARCH_RESULTS_LIMIT,
+      );
+    } else {
+      this.isOverSearchLimit = false;
+      this.searchResults = searchResults;
+    }
+
+    this.searchState.complete();
   }
 
-  fetchAllPropertyNodes(): void {
-    const treeData = this.queryBuilderState.explorerState.nonNullableTreeData;
+  /**
+   * From the current explorer tree, navigate breadth-first to find more mapped
+   * property nodes, then index these property nodes for searching.
+   *
+   * NOTE: fortunately, since we restrict the depth and number of nodes in this navigation
+   * this process is often not the performance bottleneck, else, we would need to make this
+   * asynchronous and block the UI while waiting.
+   */
+  initialize(): void {
+    this.indexedExplorerTreeNodes = [];
+
     let currentLevelPropertyNodes: QueryBuilderExplorerTreeNodeData[] = [];
     let nextLevelPropertyNodes: QueryBuilderExplorerTreeNodeData[] = [];
-    Array.from(treeData.nodes.values())
+
+    Array.from(
+      this.queryBuilderState.explorerState.nonNullableTreeData.nodes.values(),
+    )
       .slice(1)
       .forEach((node) => {
         if (node.mappingData.mapped && !node.isPartOfDerivedPropertyBranch) {
           currentLevelPropertyNodes.push(node);
-          this.allMappedPropertyNodes.push(node);
+          this.indexedExplorerTreeNodes.push(node);
         }
       });
+
+    // ensure we don't navigate more nodes than the limit so we could
+    // keep the initialization/indexing time within acceptable range
+    const NODE_LIMIT =
+      this.indexedExplorerTreeNodes.length +
+      QUERY_BUILDER_PROPERTY_SEARCH_MAX_NODES;
+    const addNode = (node: QueryBuilderExplorerTreeNodeData): void =>
+      runInAction(() => {
+        if (this.indexedExplorerTreeNodes.length > NODE_LIMIT) {
+          return;
+        }
+        this.indexedExplorerTreeNodes.push(node);
+      });
+
+    // limit the depth of navigation to keep the initialization/indexing
+    // time within acceptable range
     let currentDepth = 1;
-    const maxDepth = QUERY_BUILDER_PROPERTY_SEARCH_MAX_DEPTH;
-    while (currentLevelPropertyNodes.length && currentDepth <= maxDepth) {
+    while (
+      currentLevelPropertyNodes.length &&
+      currentDepth <= QUERY_BUILDER_PROPERTY_SEARCH_MAX_DEPTH
+    ) {
       const node = currentLevelPropertyNodes.shift();
       if (node) {
         if (node.childrenIds.length) {
@@ -268,7 +262,7 @@ export class QueryBuilderPropertySearchState {
                 !propertyTreeNodeData.isPartOfDerivedPropertyBranch
               ) {
                 nextLevelPropertyNodes.push(propertyTreeNodeData);
-                this.allMappedPropertyNodes.push(propertyTreeNodeData);
+                addNode(propertyTreeNodeData);
               }
             });
             node.type._subclasses.forEach((subclass) => {
@@ -281,53 +275,125 @@ export class QueryBuilderPropertySearchState {
                 ),
               );
               nextLevelPropertyNodes.push(subTypeTreeNodeData);
-              this.allMappedPropertyNodes.push(subTypeTreeNodeData);
+              addNode(subTypeTreeNodeData);
             });
           }
         }
       }
-      if (!currentLevelPropertyNodes.length) {
+
+      // when we done processing one depth, we will do check on the depth and the total
+      // number of indexed nodes to figureo ut if we should proceed further
+      if (
+        !currentLevelPropertyNodes.length &&
+        this.indexedExplorerTreeNodes.length < NODE_LIMIT
+      ) {
         currentLevelPropertyNodes = nextLevelPropertyNodes;
         nextLevelPropertyNodes = [];
         currentDepth++;
       }
     }
+
+    // indexing
+    this.searchEngine = new Fuse(this.indexedExplorerTreeNodes, {
+      includeScore: true,
+      shouldSort: true,
+      // Ignore location when computing the search score
+      // See https://fusejs.io/concepts/scoring-theory.html
+      ignoreLocation: true,
+      // This specifies the point the search gives up
+      // `0.0` means exact match where `1.0` would match anything
+      // We set a relatively low threshold to filter out irrelevant results
+      threshold: 0.2,
+      keys: [
+        {
+          name: 'label',
+          weight: 4,
+        },
+        {
+          name: 'taggedValues',
+          weight: 2,
+          // aggregate the property documentation, do not account for class documentation
+          getFn: (node: QueryBuilderExplorerTreeNodeData) =>
+            node instanceof QueryBuilderExplorerTreePropertyNodeData
+              ? node.property.taggedValues
+                  .filter(
+                    (taggedValue) =>
+                      taggedValue.tag.ownerReference.value.path ===
+                        CORE_PURE_PATH.PROFILE_DOC &&
+                      taggedValue.tag.value.value === PURE_DOC_TAG,
+                  )
+                  .map((taggedValue) => taggedValue.value)
+                  .join('\n')
+              : '',
+        },
+      ],
+      // extended search allows for exact word match through single quote
+      // See https://fusejs.io/examples.html#extended-search
+      useExtendedSearch: true,
+    });
   }
 
-  fetchMappedPropertyNodes(propName: string): void {
-    const propertyName = propName.toLowerCase();
-    for (const node of this.allMappedPropertyNodes) {
-      if (node.label.toLowerCase().includes(propertyName)) {
-        this.searchedMappedPropertyNodes.push(node);
+  get filteredSearchResults(): QueryBuilderExplorerTreeNodeData[] {
+    return this.searchResults.filter((node) => {
+      if (this.typeFilters.includes(QUERY_BUILDER_PROPERTY_SEARCH_TYPE.CLASS)) {
+        if (node.type instanceof Class) {
+          return true;
+        }
+      }
+      if (
+        this.typeFilters.includes(QUERY_BUILDER_PROPERTY_SEARCH_TYPE.STRING)
+      ) {
         if (
-          this.searchedMappedPropertyNodes.length >
-          QUERY_BUILDER_PROPERTY_SEARCH_RESULTS_LIMIT
+          node.type instanceof PrimitiveType &&
+          node.type.name === PRIMITIVE_TYPE.STRING
         ) {
-          break;
+          return true;
         }
       }
-    }
-  }
-
-  setIsSearchPanelOpen(val: boolean): void {
-    this.isSearchPanelOpen = val;
-  }
-
-  setIsSearchPanelHidden(val: boolean): void {
-    this.isSearchPanelHidden = val;
-  }
-
-  setSearchText(val: string): void {
-    this.searchText = val;
-  }
-
-  setSearchedMappedPropertyNodes(
-    val: QueryBuilderExplorerTreeNodeData[],
-  ): void {
-    this.searchedMappedPropertyNodes = val;
-  }
-
-  refreshPropertyState(): void {
-    this.setSearchedMappedPropertyNodes([]);
+      if (
+        this.typeFilters.includes(QUERY_BUILDER_PROPERTY_SEARCH_TYPE.NUMBER)
+      ) {
+        if (
+          node.type instanceof PrimitiveType &&
+          (
+            [
+              PRIMITIVE_TYPE.NUMBER,
+              PRIMITIVE_TYPE.DECIMAL,
+              PRIMITIVE_TYPE.INTEGER,
+              PRIMITIVE_TYPE.FLOAT,
+            ] as string[]
+          ).includes(node.type.name)
+        ) {
+          return true;
+        }
+      }
+      if (
+        this.typeFilters.includes(QUERY_BUILDER_PROPERTY_SEARCH_TYPE.BOOLEAN)
+      ) {
+        if (
+          node.type instanceof PrimitiveType &&
+          node.type.name === PRIMITIVE_TYPE.BOOLEAN
+        ) {
+          return true;
+        }
+      }
+      if (this.typeFilters.includes(QUERY_BUILDER_PROPERTY_SEARCH_TYPE.DATE)) {
+        if (
+          node.type instanceof PrimitiveType &&
+          (
+            [
+              PRIMITIVE_TYPE.DATE,
+              PRIMITIVE_TYPE.DATETIME,
+              PRIMITIVE_TYPE.STRICTDATE,
+              PRIMITIVE_TYPE.STRICTTIME,
+              PRIMITIVE_TYPE.LATESTDATE,
+            ] as string[]
+          ).includes(node.type.name)
+        ) {
+          return true;
+        }
+      }
+      return false;
+    });
   }
 }

package/src/stores/fetch-structure/QueryBuilderFetchStructureImplementationState.ts

@@ -19,6 +19,7 @@ import type {
   CompilationError,
   LambdaFunction,
 } from '@finos/legend-graph';
+import type { Hashable } from '@finos/legend-shared';
 import { computed, makeObservable } from 'mobx';
 import type { QueryBuilderExplorerTreePropertyNodeData } from '../explorer/QueryBuilderExplorerState.js';
 import type { QueryBuilderState } from '../QueryBuilderState.js';
@@ -30,9 +31,11 @@ export enum FETCH_STRUCTURE_IMPLEMENTATION {
   GRAPH_FETCH = 'GRAPH_FETCH',
 }
 
-export abstract class QueryBuilderFetchStructureImplementationState {
-  queryBuilderState: QueryBuilderState;
-  fetchStructureState: QueryBuilderFetchStructureState;
+export abstract class QueryBuilderFetchStructureImplementationState
+  implements Hashable
+{
+  readonly queryBuilderState: QueryBuilderState;
+  readonly fetchStructureState: QueryBuilderFetchStructureState;
 
   constructor(
     queryBuilderState: QueryBuilderState,
@@ -41,6 +44,7 @@ export abstract class QueryBuilderFetchStructureImplementationState {
     makeObservable(this, {
       usedExplorerTreePropertyNodeIDs: computed,
       validationIssues: computed,
+      hashCode: computed,
     });
 
     this.queryBuilderState = queryBuilderState;
@@ -62,4 +66,5 @@ export abstract class QueryBuilderFetchStructureImplementationState {
     lambdaFunction: LambdaFunction,
     options?: LambdaFunctionBuilderOption,
   ): void;
+  abstract get hashCode(): string;
 }

package/src/stores/fetch-structure/QueryBuilderFetchStructureState.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { action, makeAutoObservable } from 'mobx';
+import { action, makeObservable, observable } from 'mobx';
 import type { QueryBuilderState } from '../QueryBuilderState.js';
 import { QueryBuilderGraphFetchTreeState } from './graph-fetch/QueryBuilderGraphFetchTreeState.js';
 import { QueryBuilderProjectionState } from './projection/QueryBuilderProjectionState.js';
@@ -30,12 +30,12 @@ import {
 } from './QueryBuilderFetchStructureImplementationState.js';
 
 export class QueryBuilderFetchStructureState {
-  queryBuilderState: QueryBuilderState;
+  readonly queryBuilderState: QueryBuilderState;
   implementation: QueryBuilderFetchStructureImplementationState;
 
   constructor(queryBuilderState: QueryBuilderState) {
-    makeAutoObservable(this, {
-      queryBuilderState: false,
+    makeObservable(this, {
+      implementation: observable,
       changeImplementation: action,
     });
 

package/src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.ts

@@ -45,9 +45,17 @@ import {
 } from '@finos/legend-application';
 import type { LambdaFunctionBuilderOption } from '../../QueryBuilderValueSpecificationBuilderHelper.js';
 import { appendGraphFetch } from './QueryBuilderGraphFetchValueSpecificationBuilder.js';
-import { guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  guaranteeNonNullable,
+  hashArray,
+  type Hashable,
+} from '@finos/legend-shared';
+import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../graphManager/QueryBuilderHashUtils.js';
 
-export class QueryBuilderGraphFetchTreeState extends QueryBuilderFetchStructureImplementationState {
+export class QueryBuilderGraphFetchTreeState
+  extends QueryBuilderFetchStructureImplementationState
+  implements Hashable
+{
   treeData?: QueryBuilderGraphFetchTreeData | undefined;
   /**
    * If set to `true` we will use `graphFetchChecked` function instead of `graphFetch`.
@@ -237,4 +245,12 @@ export class QueryBuilderGraphFetchTreeState extends QueryBuilderFetchStructureI
       onChange();
     }
   }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.GRAPH_FETCH_STATE,
+      this.isChecked.toString(),
+      this.treeData?.tree ?? '',
+    ]);
+  }
 }