@finos/legend-query-builder 0.0.1

package/src/stores/explorer/QueryBuilderPropertySearchState.ts

@@ -0,0 +1,333 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  Class,
+  getAllOwnClassProperties,
+  getAllClassProperties,
+  getAllClassDerivedProperties,
+  PrimitiveType,
+  PRIMITIVE_TYPE,
+} from '@finos/legend-graph';
+import {
+  addUniqueEntry,
+  deleteEntry,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
+import { makeAutoObservable, observable, computed, action } from 'mobx';
+import {
+  QUERY_BUILDER_PROPERTY_SEARCH_MAX_DEPTH,
+  QUERY_BUILDER_PROPERTY_SEARCH_RESULTS_LIMIT,
+  QUERY_BUILDER_PROPERTY_SEARCH_TYPE,
+} from '../QueryBuilderConfig.js';
+import {
+  getQueryBuilderPropertyNodeData,
+  getQueryBuilderSubTypeNodeData,
+  type QueryBuilderExplorerTreeNodeData,
+  QueryBuilderExplorerTreePropertyNodeData,
+  QueryBuilderExplorerTreeSubTypeNodeData,
+} from './QueryBuilderExplorerState.js';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
+
+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[] = [];
+  isSearchPanelOpen = false;
+  isSearchPanelHidden = false;
+  searchText = '';
+  filterByMultiple: boolean;
+  typeFilters: QUERY_BUILDER_PROPERTY_SEARCH_TYPE[];
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    makeAutoObservable(this, {
+      queryBuilderState: false,
+      searchedMappedPropertyNodes: observable,
+      isSearchPanelOpen: observable,
+      isSearchPanelHidden: observable,
+      searchText: observable,
+      filteredPropertyNodes: computed,
+      setSearchText: action,
+      setSearchedMappedPropertyNodes: action,
+      setIsSearchPanelOpen: action,
+      setIsSearchPanelHidden: action,
+      refreshPropertyState: action,
+      setFilterByMultiple: action,
+      toggleTypeFilter: 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,
+    ];
+  }
+
+  toggleTypeFilter(val: QUERY_BUILDER_PROPERTY_SEARCH_TYPE): void {
+    if (this.typeFilters.includes(val)) {
+      deleteEntry(this.typeFilters, val);
+    } else {
+      addUniqueEntry(this.typeFilters, val);
+    }
+  }
+
+  setFilterByMultiple(val: boolean): void {
+    this.filterByMultiple = 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;
+    });
+  }
+
+  classPropertyNodes(): QueryBuilderExplorerTreeNodeData[] {
+    return this.searchedMappedPropertyNodes.filter((node) => {
+      if (node.type instanceof Class) {
+        return true;
+      }
+      return false;
+    });
+  }
+
+  stringPropertyNodes(): QueryBuilderExplorerTreeNodeData[] {
+    return this.searchedMappedPropertyNodes.filter((node) => {
+      if (
+        node.type instanceof PrimitiveType &&
+        node.type.name === PRIMITIVE_TYPE.STRING
+      ) {
+        return true;
+      }
+      return false;
+    });
+  }
+
+  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;
+    });
+  }
+
+  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;
+    });
+  }
+
+  booleanPropertyNodes(): QueryBuilderExplorerTreeNodeData[] {
+    return this.searchedMappedPropertyNodes.filter((node) => {
+      if (
+        node.type instanceof PrimitiveType &&
+        node.type.name === PRIMITIVE_TYPE.BOOLEAN
+      ) {
+        return true;
+      }
+      return false;
+    });
+  }
+
+  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;
+    });
+  }
+
+  fetchAllPropertyNodes(): void {
+    const treeData = this.queryBuilderState.explorerState.nonNullableTreeData;
+    let currentLevelPropertyNodes: QueryBuilderExplorerTreeNodeData[] = [];
+    let nextLevelPropertyNodes: QueryBuilderExplorerTreeNodeData[] = [];
+    Array.from(treeData.nodes.values())
+      .slice(1)
+      .forEach((node) => {
+        if (node.mappingData.mapped && !node.isPartOfDerivedPropertyBranch) {
+          currentLevelPropertyNodes.push(node);
+          this.allMappedPropertyNodes.push(node);
+        }
+      });
+    let currentDepth = 1;
+    const maxDepth = QUERY_BUILDER_PROPERTY_SEARCH_MAX_DEPTH;
+    while (currentLevelPropertyNodes.length && currentDepth <= maxDepth) {
+      const node = currentLevelPropertyNodes.shift();
+      if (node) {
+        if (node.childrenIds.length) {
+          if (
+            (node instanceof QueryBuilderExplorerTreePropertyNodeData ||
+              node instanceof QueryBuilderExplorerTreeSubTypeNodeData) &&
+            node.type instanceof Class
+          ) {
+            (node instanceof QueryBuilderExplorerTreeSubTypeNodeData
+              ? getAllOwnClassProperties(node.type)
+              : getAllClassProperties(node.type).concat(
+                  getAllClassDerivedProperties(node.type),
+                )
+            ).forEach((property) => {
+              const propertyTreeNodeData = getQueryBuilderPropertyNodeData(
+                property,
+                node,
+                guaranteeNonNullable(
+                  this.queryBuilderState.explorerState
+                    .mappingModelCoverageAnalysisResult,
+                ),
+              );
+              if (
+                propertyTreeNodeData?.mappingData.mapped &&
+                !propertyTreeNodeData.isPartOfDerivedPropertyBranch
+              ) {
+                nextLevelPropertyNodes.push(propertyTreeNodeData);
+                this.allMappedPropertyNodes.push(propertyTreeNodeData);
+              }
+            });
+            node.type._subclasses.forEach((subclass) => {
+              const subTypeTreeNodeData = getQueryBuilderSubTypeNodeData(
+                subclass,
+                node,
+                guaranteeNonNullable(
+                  this.queryBuilderState.explorerState
+                    .mappingModelCoverageAnalysisResult,
+                ),
+              );
+              nextLevelPropertyNodes.push(subTypeTreeNodeData);
+              this.allMappedPropertyNodes.push(subTypeTreeNodeData);
+            });
+          }
+        }
+      }
+      if (!currentLevelPropertyNodes.length) {
+        currentLevelPropertyNodes = nextLevelPropertyNodes;
+        nextLevelPropertyNodes = [];
+        currentDepth++;
+      }
+    }
+  }
+
+  fetchMappedPropertyNodes(propName: string): void {
+    const propertyName = propName.toLowerCase();
+    for (const node of this.allMappedPropertyNodes) {
+      if (node.label.toLowerCase().includes(propertyName)) {
+        this.searchedMappedPropertyNodes.push(node);
+        if (
+          this.searchedMappedPropertyNodes.length >
+          QUERY_BUILDER_PROPERTY_SEARCH_RESULTS_LIMIT
+        ) {
+          break;
+        }
+      }
+    }
+  }
+
+  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([]);
+  }
+}

package/src/stores/explorer/QueryFunctionsExplorerState.ts

@@ -0,0 +1,375 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  type PackageableElement,
+  ConcreteFunctionDefinition,
+  Package,
+  Unit,
+  ROOT_PACKAGE_NAME,
+} from '@finos/legend-graph';
+import {
+  addUniqueEntry,
+  guaranteeNonNullable,
+  isNonNullable,
+  uuid,
+} from '@finos/legend-shared';
+import { action, makeObservable, observable } from 'mobx';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
+import type { TreeNodeData, TreeData } from '@finos/legend-art';
+
+export const QUERY_BUILDER_FUNCTION_DND_TYPE = 'QUERY_BUILDER_FUNCTION';
+
+export interface QueryBuilderFunctionsExplorerDragSource {
+  node: QueryBuilderFunctionsExplorerTreeNodeData;
+}
+
+export class QueryBuilderFunctionsExplorerTreeNodeData implements TreeNodeData {
+  id: string;
+  label: string;
+  childrenIds: string[] = [];
+  isOpen?: boolean | undefined;
+  packageableElement: PackageableElement;
+
+  constructor(
+    id: string,
+    label: string,
+    packageableElement: PackageableElement,
+  ) {
+    this.id = id;
+    this.label = label;
+    this.packageableElement = packageableElement;
+  }
+}
+
+const getValidDisplayablePackageSet = (
+  queryBuilderState: QueryBuilderState,
+  rootPackageName: ROOT_PACKAGE_NAME,
+): Set<Package> => {
+  switch (rootPackageName) {
+    case ROOT_PACKAGE_NAME.PROJECT_DEPENDENCY_ROOT:
+      return queryBuilderState.functionsExplorerState
+        .dependencyDisplayablePackagesSet;
+    default:
+      return queryBuilderState.functionsExplorerState.displayablePackagesSet;
+  }
+};
+
+export const generateFunctionsExplorerTreeNodeData = (
+  queryBuilderState: QueryBuilderState,
+  element: PackageableElement,
+  rootPackageName: ROOT_PACKAGE_NAME,
+): QueryBuilderFunctionsExplorerTreeNodeData => ({
+  id: element.path,
+  label: element.name,
+  childrenIds:
+    element instanceof Package
+      ? element.children
+          .filter((child) => !(child instanceof Unit))
+          .filter(
+            (child) =>
+              (child instanceof Package &&
+                getValidDisplayablePackageSet(
+                  queryBuilderState,
+                  rootPackageName,
+                ).has(child)) ||
+              child instanceof ConcreteFunctionDefinition,
+          )
+          .map((child) => child.path)
+      : [],
+  packageableElement: element,
+});
+
+const generateFunctionsExplorerTreeNodeChilrdren = (
+  queryBuilderState: QueryBuilderState,
+  node: QueryBuilderFunctionsExplorerTreeNodeData,
+  data: TreeData<QueryBuilderFunctionsExplorerTreeNodeData>,
+  rootPackageName = ROOT_PACKAGE_NAME.MAIN,
+): void => {
+  const validDisplayablePackageSet = getValidDisplayablePackageSet(
+    queryBuilderState,
+    rootPackageName,
+  );
+  node.childrenIds = (node.packageableElement as Package).children
+    .filter((child) => !(child instanceof Unit))
+    .filter(
+      (child) =>
+        // avoid displaying empty packages
+        (child instanceof Package && validDisplayablePackageSet.has(child)) ||
+        child instanceof ConcreteFunctionDefinition,
+    )
+    .map((child) => child.path);
+  (node.packageableElement as Package).children
+    .filter((child) => !(child instanceof Unit))
+    .filter(
+      (child) =>
+        // avoid displaying empty packages
+        (child instanceof Package && validDisplayablePackageSet.has(child)) ||
+        child instanceof ConcreteFunctionDefinition,
+    )
+    .map((child) =>
+      generateFunctionsExplorerTreeNodeData(
+        queryBuilderState,
+        child,
+        rootPackageName,
+      ),
+    )
+    .forEach((childNode) => {
+      const currentNode = data.nodes.get(childNode.id);
+      if (currentNode) {
+        currentNode.childrenIds = childNode.childrenIds;
+        currentNode.label = childNode.label;
+      } else {
+        data.nodes.set(childNode.id, childNode);
+      }
+    });
+};
+
+export const getFunctionsExplorerTreeData = (
+  root: Package,
+  queryBuilderState: QueryBuilderState,
+  rootPackageName = ROOT_PACKAGE_NAME.MAIN,
+): TreeData<QueryBuilderFunctionsExplorerTreeNodeData> => {
+  const rootIds: string[] = [];
+  const nodes = new Map<string, QueryBuilderFunctionsExplorerTreeNodeData>();
+  const validDisplayablePackageSet = getValidDisplayablePackageSet(
+    queryBuilderState,
+    rootPackageName,
+  );
+  switch (rootPackageName) {
+    case ROOT_PACKAGE_NAME.PROJECT_DEPENDENCY_ROOT:
+      if (
+        queryBuilderState.graphManagerState.graph.dependencyManager.functions
+          .length === 0
+      ) {
+        return { rootIds, nodes };
+      }
+      break;
+    default:
+      if (queryBuilderState.graphManagerState.graph.ownFunctions.length === 0) {
+        return { rootIds, nodes };
+      }
+  }
+
+  root.children
+    .slice()
+    .filter((child) => !(child instanceof Unit))
+    .filter(
+      (child) =>
+        child instanceof Package && validDisplayablePackageSet.has(child),
+    )
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .sort(
+      (a, b) => (b instanceof Package ? 1 : 0) - (a instanceof Package ? 1 : 0),
+    )
+    .forEach((childPackage) => {
+      const childTreeNodeData = generateFunctionsExplorerTreeNodeData(
+        queryBuilderState,
+        childPackage,
+        rootPackageName,
+      );
+      addUniqueEntry(rootIds, childTreeNodeData.id);
+      nodes.set(childTreeNodeData.id, childTreeNodeData);
+    });
+  return { rootIds, nodes };
+};
+
+export const getFunctionsExplorerTreeNodeChildren = (
+  queryBuilderState: QueryBuilderState,
+  node: QueryBuilderFunctionsExplorerTreeNodeData,
+  data: TreeData<QueryBuilderFunctionsExplorerTreeNodeData>,
+  rootPackageName = ROOT_PACKAGE_NAME.MAIN,
+): QueryBuilderFunctionsExplorerTreeNodeData[] => {
+  generateFunctionsExplorerTreeNodeChilrdren(
+    queryBuilderState,
+    node,
+    data,
+    rootPackageName,
+  );
+  return node.childrenIds
+    .map((id) => data.nodes.get(id))
+    .filter(isNonNullable)
+    .sort((a, b) => a.label.localeCompare(b.label))
+    .sort(
+      (a, b) =>
+        (b.packageableElement instanceof Package ? 1 : 0) -
+        (a.packageableElement instanceof Package ? 1 : 0),
+    );
+};
+
+const getAllPackagesFromElement = (element: PackageableElement): Package[] => {
+  if (element.package) {
+    return [element.package].concat(getAllPackagesFromElement(element.package));
+  }
+  return [];
+};
+
+export class QueryFunctionExplorerState {
+  readonly uuid = uuid();
+  queryFunctionsState: QueryFunctionsExplorerState;
+  concreteFunctionDefinition: ConcreteFunctionDefinition;
+
+  constructor(
+    queryFunctionsState: QueryFunctionsExplorerState,
+    concreteFunctionDefinition: ConcreteFunctionDefinition,
+  ) {
+    makeObservable(this, {
+      concreteFunctionDefinition: observable,
+    });
+    this.queryFunctionsState = queryFunctionsState;
+    this.concreteFunctionDefinition = concreteFunctionDefinition;
+  }
+}
+
+export class QueryFunctionsExplorerState {
+  queryBuilderState: QueryBuilderState;
+  treeData?: TreeData<QueryBuilderFunctionsExplorerTreeNodeData> | undefined;
+  dependencyTreeData?:
+    | TreeData<QueryBuilderFunctionsExplorerTreeNodeData>
+    | undefined;
+  functionExplorerStates: QueryFunctionExplorerState[] = [];
+  dependencyFunctionExplorerStates: QueryFunctionExplorerState[] = [];
+  displayablePackagesSet: Set<Package> = new Set<Package>();
+  dependencyDisplayablePackagesSet: Set<Package> = new Set<Package>();
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    makeObservable(this, {
+      functionExplorerStates: observable.ref,
+      dependencyFunctionExplorerStates: observable.ref,
+      treeData: observable.ref,
+      dependencyTreeData: observable.ref,
+      setTreeData: action,
+      setDependencyTreeData: action,
+      refreshTree: action,
+      onTreeNodeSelect: action,
+    });
+    this.queryBuilderState = queryBuilderState;
+    this.initializeTreeData();
+  }
+
+  getTreeData(
+    rootPackageName = ROOT_PACKAGE_NAME.MAIN,
+  ): TreeData<QueryBuilderFunctionsExplorerTreeNodeData> | undefined {
+    switch (rootPackageName) {
+      case ROOT_PACKAGE_NAME.PROJECT_DEPENDENCY_ROOT:
+        return this.dependencyTreeData;
+      default:
+        return this.treeData;
+    }
+  }
+
+  async initializeDisplayablePackagesSet(): Promise<void> {
+    this.queryBuilderState.graphManagerState.graph.ownFunctions
+      .map((f) => getAllPackagesFromElement(f))
+      .flat()
+      .forEach((pkg) => this.displayablePackagesSet.add(pkg));
+  }
+
+  async initializeDependencyDisplayablePackagesSet(): Promise<void> {
+    this.queryBuilderState.graphManagerState.graph.dependencyManager.functions
+      .map((f) => getAllPackagesFromElement(f))
+      .flat()
+      .forEach((pkg) => this.dependencyDisplayablePackagesSet.add(pkg));
+  }
+
+  setTreeData(
+    val: TreeData<QueryBuilderFunctionsExplorerTreeNodeData> | undefined,
+  ): void {
+    this.treeData = val;
+  }
+
+  setDependencyTreeData(
+    val: TreeData<QueryBuilderFunctionsExplorerTreeNodeData> | undefined,
+  ): void {
+    this.dependencyTreeData = val;
+  }
+
+  refreshTree(): void {
+    if (this.treeData) {
+      this.treeData = { ...this.treeData };
+    }
+    if (this.dependencyTreeData) {
+      this.dependencyTreeData = { ...this.dependencyTreeData };
+    }
+  }
+
+  get nonNullableTreeData(): TreeData<QueryBuilderFunctionsExplorerTreeNodeData> {
+    return guaranteeNonNullable(
+      this.treeData,
+      'Query builder functions explorer tree data has not been initialized',
+    );
+  }
+
+  onTreeNodeSelect = (
+    queryBuilderState: QueryBuilderState,
+    node: QueryBuilderFunctionsExplorerTreeNodeData,
+    data: TreeData<QueryBuilderFunctionsExplorerTreeNodeData>,
+    rootPackageName = ROOT_PACKAGE_NAME.MAIN,
+  ): void => {
+    if (node.packageableElement instanceof Package) {
+      if (node.childrenIds.length) {
+        node.isOpen = !node.isOpen;
+        generateFunctionsExplorerTreeNodeChilrdren(
+          queryBuilderState,
+          node,
+          data,
+          rootPackageName,
+        );
+      }
+      switch (rootPackageName) {
+        case ROOT_PACKAGE_NAME.PROJECT_DEPENDENCY_ROOT:
+          this.setDependencyTreeData({ ...data });
+          break;
+        default:
+          this.setTreeData({ ...data });
+      }
+    }
+  };
+
+  initializeTreeData(): void {
+    this.initializeDisplayablePackagesSet().finally(() => {
+      this.setTreeData(
+        getFunctionsExplorerTreeData(
+          this.queryBuilderState.graphManagerState.graph.root,
+          this.queryBuilderState,
+        ),
+      );
+      this.functionExplorerStates =
+        this.queryBuilderState.graphManagerState.graph.ownFunctions.map(
+          (f) => new QueryFunctionExplorerState(this, f),
+        );
+    });
+    if (
+      this.queryBuilderState.graphManagerState.graph.dependencyManager
+        .hasDependencies
+    ) {
+      this.initializeDependencyDisplayablePackagesSet().finally(() => {
+        this.setDependencyTreeData(
+          getFunctionsExplorerTreeData(
+            this.queryBuilderState.graphManagerState.graph.dependencyManager
+              .root,
+            this.queryBuilderState,
+            ROOT_PACKAGE_NAME.PROJECT_DEPENDENCY_ROOT,
+          ),
+        );
+        this.dependencyFunctionExplorerStates =
+          this.queryBuilderState.graphManagerState.graph.dependencyManager.functions.map(
+            (f) => new QueryFunctionExplorerState(this, f),
+          );
+      });
+    }
+  }
+}