ode-explorer 1.3.2-dev.202401091605 → 1.3.2-dev.202401091744

package/lib/index2.js

@@ -0,0 +1,1867 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { jsx, jsxs, Fragment as Fragment$1 } from "react/jsx-runtime";
+import { useState, useRef, useEffect, Suspense, lazy, Fragment } from "react";
+import { useScrollToTop, useOdeClient, IconButton, useToast, useUser, LoadingScreen, FormControl, Input, SearchButton, Dropdown, useToggle, TreeView, Button, useXitiTrackPageLoad, isActionAvailable, AppHeader, Breadcrumb, Grid } from "@edifice-ui/react";
+import { ArrowLeft, Filter, Delete, Plus } from "@edifice-ui/icons";
+import { useTranslation } from "react-i18next";
+import { odeServices, FOLDER, APP } from "edifice-ts-client";
+import { t } from "i18next";
+import { create } from "zustand";
+import { useQuery, useInfiniteQuery, useQueryClient, useMutation } from "@tanstack/react-query";
+const searchContext = async (searchParams) => {
+  const search = await odeServices.resource(searchParams.app).searchContext(searchParams);
+  return {
+    ...search,
+    folders: search.folders.filter((folder) => !folder.trashed)
+  };
+};
+const createFolder = async ({
+  searchParams,
+  name,
+  parentId
+}) => {
+  const createFolderParameters = {
+    name,
+    parentId,
+    app: searchParams.app,
+    type: searchParams.types[0]
+  };
+  return await odeServices.resource(searchParams.app).createFolder(createFolderParameters);
+};
+const updateFolder = async ({
+  folderId,
+  searchParams,
+  parentId,
+  name
+}) => {
+  const updateFolderParameters = {
+    folderId,
+    name,
+    parentId,
+    app: searchParams.app,
+    type: searchParams.types[0]
+  };
+  return await odeServices.resource(searchParams.app).updateFolder(updateFolderParameters);
+};
+const trashAll = async ({
+  searchParams,
+  resourceIds,
+  useAssetIds,
+  folderIds
+}) => {
+  const trashParameters = {
+    application: searchParams.app,
+    resourceType: searchParams.types[0],
+    resourceIds,
+    folderIds
+  };
+  return await odeServices.resource(searchParams.app).trashAll(trashParameters, useAssetIds);
+};
+const deleteAll = async ({
+  searchParams,
+  resourceIds,
+  useAssetIds,
+  folderIds
+}) => {
+  const deleteParameters = {
+    application: searchParams.app,
+    resourceType: searchParams.types[0],
+    resourceIds,
+    folderIds
+  };
+  return await odeServices.resource(searchParams.app).deleteAll(deleteParameters, useAssetIds);
+};
+const restoreAll = async ({
+  searchParams,
+  resourceIds,
+  folderIds,
+  useAssetIds
+}) => {
+  const trashParameters = {
+    application: searchParams.app,
+    resourceType: searchParams.types[0],
+    resourceIds,
+    folderIds
+  };
+  return await odeServices.resource(searchParams.app).restoreAll(trashParameters, useAssetIds);
+};
+const moveToFolder = async ({
+  searchParams,
+  resourceIds,
+  folderId,
+  folderIds,
+  useAssetIds
+}) => {
+  const moveParameters = {
+    application: searchParams.app,
+    folderId,
+    resourceIds,
+    folderIds
+  };
+  return await odeServices.resource(searchParams.app).moveToFolder(moveParameters, useAssetIds);
+};
+const shareResource = async ({
+  app,
+  resourceId,
+  rights
+}) => {
+  return await odeServices.share().saveRights(app, resourceId, rights);
+};
+const updateResource = async ({
+  app,
+  params
+}) => {
+  return await odeServices.resource(app).update(params);
+};
+const sessionHasWorkflowRights = async (actionRights) => {
+  return await odeServices.rights().sessionHasWorkflowRights(actionRights);
+};
+const goToResource = ({
+  searchParams,
+  assetId
+}) => {
+  return odeServices.resource(searchParams.app).gotoView(assetId);
+};
+const createResource = ({
+  searchParams,
+  params
+}) => {
+  const result = odeServices.resource(searchParams.app).create(params);
+  return result;
+};
+const printResource = ({
+  searchParams,
+  assetId
+}) => {
+  const result = odeServices.resource(searchParams.app).gotoPrint(assetId);
+  return result;
+};
+function arrayUnique(array) {
+  return array.filter((item, index) => array.indexOf(item) === index);
+}
+function findNodeById(id, data) {
+  var _a, _b;
+  let res;
+  if ((data == null ? void 0 : data.id) === id) {
+    return data;
+  }
+  if ((_a = data == null ? void 0 : data.children) == null ? void 0 : _a.length) {
+    (_b = data == null ? void 0 : data.children) == null ? void 0 : _b.every((childNode) => {
+      res = findNodeById(id, childNode);
+      return res === void 0;
+    });
+  }
+  return res;
+}
+function getAncestors(folderId, treeData) {
+  var _a;
+  const findItem = findNodeById(folderId, treeData);
+  if ((_a = findItem == null ? void 0 : findItem.folder) == null ? void 0 : _a.ancestors) {
+    const nodes = (findItem == null ? void 0 : findItem.folder.ancestors) || [];
+    return [...nodes, folderId];
+  } else if (folderId === FOLDER.BIN) {
+    return [FOLDER.BIN];
+  } else {
+    return [FOLDER.DEFAULT];
+  }
+}
+function hasChildren(folderId, data) {
+  if (data.id === folderId && data.children) {
+    return data.children.length > 0;
+  }
+  if (data.children) {
+    return data.children.some((child) => hasChildren(data.id, child));
+  }
+  return false;
+}
+function modifyNode(data, callback) {
+  const root = doModify(data, callback) || data;
+  return root;
+}
+function doModify(current, callback, parent) {
+  var _a;
+  const result = callback(current, parent);
+  if ((_a = result == null ? void 0 : result.children) == null ? void 0 : _a.length) {
+    const children = [];
+    for (const child of (result == null ? void 0 : result.children) || []) {
+      const res = doModify(child, callback, result);
+      if (res) {
+        children.push(res);
+      }
+    }
+    return {
+      ...result,
+      children
+    };
+  }
+  return result;
+}
+class TreeNodeFolderWrapper {
+  constructor(folder) {
+    __publicField(this, "id");
+    __publicField(this, "name");
+    __publicField(this, "childNumber");
+    __publicField(this, "section", false);
+    __publicField(this, "children", []);
+    this.folder = folder;
+    this.id = folder.id;
+    this.name = folder.name;
+    this.childNumber = folder.childNumber;
+  }
+}
+const wrapTreeNode = (treeNode, folders, parentId) => {
+  return modifyNode(treeNode, (node) => {
+    if (node.id === parentId) {
+      node.children = folders == null ? void 0 : folders.map((e) => new TreeNodeFolderWrapper(e));
+    }
+    return node;
+  });
+};
+const useStoreContext = create()((set, get) => ({
+  config: null,
+  searchConfig: {
+    minLength: 1
+  },
+  searchParams: {
+    app: "",
+    types: [],
+    filters: {
+      folder: "default",
+      owner: void 0,
+      shared: void 0,
+      public: void 0
+    },
+    orders: {
+      updatedAt: "desc"
+    },
+    pagination: {
+      startIdx: 0,
+      pageSize: 48,
+      maxIdx: 0
+    },
+    trashed: false
+  },
+  treeData: {
+    id: FOLDER.DEFAULT,
+    name: t("explorer.filters.mine"),
+    section: true,
+    children: []
+  },
+  selectedNodesIds: ["default"],
+  currentFolder: {
+    id: "default"
+  },
+  selectedFolders: [],
+  selectedResources: [],
+  folderIds: [],
+  resourceIds: [],
+  resourceIsTrash: false,
+  resourceActionDisable: false,
+  status: void 0,
+  updaters: {
+    setConfig: (config) => set({
+      config
+    }),
+    setSearchConfig: (searchConfig) => set((state) => ({
+      searchConfig: {
+        ...state.searchConfig,
+        ...searchConfig
+      }
+    })),
+    setTreeData: (treeData) => set(() => ({
+      treeData
+    })),
+    setSearchParams: (searchParams) => {
+      set((state) => {
+        const {
+          searchParams: previousSearchParams
+        } = state;
+        if (previousSearchParams.search !== searchParams.search) {
+          if (searchParams.search) {
+            return {
+              ...state,
+              selectedFolders: [],
+              selectedNodesIds: [],
+              selectedResources: [],
+              currentFolder: void 0,
+              searchParams: {
+                ...previousSearchParams,
+                ...searchParams,
+                trashed: false,
+                filters: {
+                  ...previousSearchParams.filters,
+                  folder: void 0
+                }
+              }
+            };
+          } else {
+            return {
+              ...state,
+              selectedFolders: [],
+              selectedNodesIds: ["default"],
+              selectedResources: [],
+              currentFolder: {
+                id: "default"
+              },
+              searchParams: {
+                ...previousSearchParams,
+                ...searchParams,
+                trashed: false,
+                filters: {
+                  ...previousSearchParams.filters
+                }
+              }
+            };
+          }
+        } else {
+          return {
+            searchParams: {
+              ...previousSearchParams,
+              ...searchParams
+            }
+          };
+        }
+      });
+    },
+    setSelectedFolders: (selectedFolders) => set(() => ({
+      selectedFolders
+    })),
+    setSelectedResources: (selectedResources) => set(() => ({
+      selectedResources
+    })),
+    setFolderIds: (folderIds) => set(() => ({
+      folderIds
+    })),
+    setResourceIds: (resourceIds) => set(() => ({
+      resourceIds
+    })),
+    setResourceIsTrash: (resourceIsTrash) => set(() => ({
+      resourceIsTrash
+    })),
+    setResourceActionDisable: (resourceActionDisable) => set(() => ({
+      resourceActionDisable
+    })),
+    setCurrentFolder: (currentFolder) => set(() => ({
+      currentFolder
+    })),
+    clearSelectedItems: () => set(() => ({
+      selectedFolders: [],
+      selectedResources: []
+    })),
+    clearSelectedIds: () => set(() => ({
+      resourceIds: [],
+      folderIds: []
+    })),
+    openResource: (resource) => {
+      try {
+        const {
+          searchParams
+        } = get();
+        goToResource({
+          searchParams,
+          assetId: resource.assetId
+        });
+      } catch (error) {
+        console.error("explorer open failed: ", error);
+      }
+    },
+    printSelectedResource: () => {
+      try {
+        const {
+          searchParams,
+          selectedResources,
+          resourceIds
+        } = get();
+        if (selectedResources.length !== 1) {
+          throw new Error("Cannot open more than 1 resource");
+        }
+        const item = selectedResources.find((resource) => resource.id === resourceIds[0]);
+        printResource({
+          searchParams,
+          assetId: item.assetId
+        });
+      } catch (error) {
+        console.error("explorer print failed: ", error);
+      }
+    },
+    openFolder: ({
+      folderId,
+      folder
+    }) => {
+      const {
+        searchParams,
+        treeData
+      } = get();
+      const previousId = searchParams.filters.folder;
+      const ancestors = getAncestors(folderId, treeData);
+      const selectedNodesIds = arrayUnique([...ancestors, folderId]);
+      if (previousId === folderId)
+        return;
+      set((state) => {
+        return {
+          ...state,
+          // reset selection when changing folder
+          folderIds: [],
+          resourceIds: [],
+          selectedNodesIds,
+          currentFolder: folder || {
+            id: folderId
+          },
+          searchParams: {
+            ...searchParams,
+            search: void 0,
+            filters: {
+              ...searchParams.filters,
+              folder: folderId
+            },
+            trashed: folderId === FOLDER.BIN
+          }
+        };
+      });
+    },
+    foldTreeItem: () => set((state) => ({
+      ...state,
+      status: "fold"
+    })),
+    unfoldTreeItem: async (folderId, queryClient) => {
+      const {
+        treeData,
+        searchParams
+      } = get();
+      set((state) => ({
+        ...state,
+        status: "unfold"
+      }));
+      if (!hasChildren(folderId, treeData)) {
+        await queryClient.prefetchInfiniteQuery({
+          queryKey: ["prefetchContext", {
+            folderId,
+            trashed: false
+          }],
+          queryFn: async () => await searchContext({
+            ...searchParams,
+            filters: {
+              ...searchParams.filters,
+              folder: folderId
+            }
+          })
+        });
+        const data = queryClient.getQueryData(["prefetchContext", {
+          folderId,
+          trashed: false
+        }]);
+        set((state) => {
+          var _a;
+          return {
+            ...state,
+            treeData: wrapTreeNode(treeData, (_a = data == null ? void 0 : data.pages[0]) == null ? void 0 : _a.folders, folderId || FOLDER.DEFAULT)
+          };
+        });
+      }
+    },
+    selectTreeItem: (folderId) => {
+      const {
+        treeData
+      } = get();
+      const {
+        openFolder
+      } = get().updaters;
+      const folder = findNodeById(folderId, treeData);
+      const goToTop = useScrollToTop();
+      goToTop();
+      set((state) => ({
+        ...state,
+        searchParams: {
+          ...state.searchParams,
+          search: void 0
+        },
+        status: "select",
+        selectedResources: []
+      }));
+      openFolder({
+        folder,
+        folderId
+      });
+    },
+    gotoPreviousFolder: () => {
+      const {
+        selectedNodesIds,
+        treeData
+      } = get();
+      const {
+        openFolder
+      } = get().updaters;
+      const selectedNodesIdsLength = selectedNodesIds.length;
+      if (selectedNodesIdsLength < 2) {
+        return void 0;
+      }
+      const previousFolder = findNodeById(selectedNodesIds[selectedNodesIdsLength - 2], treeData);
+      openFolder({
+        folder: previousFolder,
+        folderId: (previousFolder == null ? void 0 : previousFolder.id) || FOLDER.DEFAULT
+      });
+    },
+    goToTrash: () => set((state) => ({
+      ...state,
+      selectedNodesIds: [],
+      selectedResources: [],
+      resourceIds: [],
+      folderIds: [],
+      status: "select",
+      searchParams: {
+        ...state.searchParams,
+        search: void 0,
+        filters: {
+          folder: FOLDER.BIN
+        },
+        trashed: true
+      },
+      currentFolder: {
+        id: FOLDER.BIN
+      }
+    }))
+  }
+}));
+const useSearchParams = () => useStoreContext((state) => state.searchParams);
+const useSelectedNodesIds = () => useStoreContext((state) => state.selectedNodesIds);
+const useTreeData = () => useStoreContext((state) => state.treeData);
+const useSelectedFolders = () => useStoreContext((state) => state.selectedFolders);
+const useSelectedResources = () => useStoreContext((state) => state.selectedResources);
+const useSearchConfig = () => useStoreContext((state) => state.searchConfig);
+const useFolderIds = () => useStoreContext((state) => state.folderIds);
+const useResourceIds = () => useStoreContext((state) => state.resourceIds);
+const useResourceAssetIds = () => useStoreContext((state) => state.selectedResources.map((r) => r.assetId));
+const useResourceWithoutIds = () => useStoreContext((state) => state.selectedResources.filter((r) => r.assetId === r.id));
+const useCurrentFolder = () => useStoreContext((state) => state.currentFolder);
+const useStoreActions = () => useStoreContext((state) => state.updaters);
+const useIsTrash = () => {
+  const currentFolder = useCurrentFolder();
+  return (currentFolder == null ? void 0 : currentFolder.id) === FOLDER.BIN;
+};
+const useResourceIsTrash = () => {
+  return useStoreContext((state) => state.resourceIsTrash);
+};
+const useResourceActionDisable = () => {
+  return useStoreContext((state) => state.resourceActionDisable);
+};
+const useIsRoot = () => {
+  const currentFolder = useCurrentFolder();
+  return (currentFolder == null ? void 0 : currentFolder.id) === "default";
+};
+const useHasSelectedNodes = () => {
+  const selectedNodesIds = useSelectedNodesIds();
+  return selectedNodesIds.length > 1;
+};
+const useTreeStatus = () => useStoreContext((state) => state.status);
+const useSearchForm = () => {
+  const searchParams = useSearchParams();
+  const [inputSearch, setInputSearch] = useState("");
+  const searchConfig = useSearchConfig();
+  const status = useTreeStatus();
+  const formRef = useRef(null);
+  const {
+    setSearchParams
+  } = useStoreActions();
+  const handleInputSearchChange = (event) => {
+    const newText = event.target.value;
+    setInputSearch(newText.toString());
+  };
+  const handleKeyPress = (event) => {
+    if (event.key === "Enter" || event.key === "Return") {
+      event.preventDefault();
+      setSearchParams({
+        search: inputSearch ? inputSearch : void 0
+      });
+    }
+  };
+  const handleSearchSubmit = (e) => {
+    e.preventDefault();
+    setSearchParams({
+      search: inputSearch ? inputSearch : void 0
+    });
+  };
+  useEffect(() => {
+    const shouldUpdateSearch = inputSearch.length == 0 || inputSearch.length >= searchConfig.minLength;
+    const searchPartial = shouldUpdateSearch ? {
+      search: inputSearch ? inputSearch : void 0
+    } : {};
+    setSearchParams({
+      ...searchParams,
+      ...searchPartial
+    });
+  }, [inputSearch, searchConfig.minLength]);
+  useEffect(() => {
+    if (status === "select")
+      setInputSearch("");
+  }, [status]);
+  useEffect(() => {
+    setInputSearch(() => {
+      var _a;
+      return ((_a = searchParams.search) == null ? void 0 : _a.toString()) ?? "";
+    });
+  }, [searchParams]);
+  return {
+    formRef,
+    inputSearch,
+    handleInputSearchChange,
+    handleKeyPress,
+    handleSearchSubmit
+  };
+};
+function ExplorerBreadcrumb() {
+  const {
+    appCode
+  } = useOdeClient();
+  const {
+    gotoPreviousFolder
+  } = useStoreActions();
+  const {
+    t: t2
+  } = useTranslation();
+  const {
+    inputSearch
+  } = useSearchForm();
+  const selectedNodesIds = useSelectedNodesIds();
+  const isTrashFolder = useIsTrash();
+  const currentFolder = useCurrentFolder();
+  const trashName = t2("explorer.tree.trash");
+  const searchName = t2("explorer.tree.search");
+  const rootName = t2("explorer.filters.mine", {
+    ns: appCode
+  });
+  const previousName = (currentFolder == null ? void 0 : currentFolder.name) || rootName;
+  return /* @__PURE__ */ jsx("div", { className: "py-16", children: selectedNodesIds.length > 1 && !isTrashFolder ? /* @__PURE__ */ jsxs("div", { className: "d-flex align-items-center gap-8", children: [
+    /* @__PURE__ */ jsx(IconButton, { icon: /* @__PURE__ */ jsx(ArrowLeft, {}), variant: "ghost", color: "tertiary", "aria-label": t2("back"), className: "ms-n16", onClick: gotoPreviousFolder }),
+    /* @__PURE__ */ jsx("p", { className: "body py-8 text-truncate", children: /* @__PURE__ */ jsx("strong", { children: previousName }) })
+  ] }) : /* @__PURE__ */ jsx("h2", { className: "body py-8 fw-bold", children: inputSearch.length !== 0 ? searchName : !isTrashFolder ? rootName : trashName }) });
+}
+const useDisableModal = () => {
+  const isActionDisableModalOpen = useResourceActionDisable();
+  const {
+    clearSelectedIds,
+    setResourceActionDisable,
+    clearSelectedItems
+  } = useStoreActions();
+  const onActionDisableCancel = () => {
+    clearSelectedIds();
+    clearSelectedItems();
+    setResourceActionDisable(false);
+  };
+  return {
+    isActionDisableModalOpen,
+    onActionDisableCancel
+  };
+};
+const useTrashModal = () => {
+  const isTrashedModalOpen = useResourceIsTrash();
+  const {
+    clearSelectedIds,
+    setResourceIsTrash,
+    clearSelectedItems
+  } = useStoreActions();
+  const onTrashedCancel = () => {
+    clearSelectedIds();
+    clearSelectedItems();
+    setResourceIsTrash(false);
+  };
+  return {
+    isTrashedModalOpen,
+    onTrashedCancel
+  };
+};
+function addNode(treeData, {
+  parentId,
+  newFolder
+}) {
+  return modifyNode(treeData, (node) => {
+    var _a;
+    if (node.id === parentId) {
+      const parentAncestors = [...((_a = node.folder) == null ? void 0 : _a.ancestors) || []];
+      const ancestors = arrayUnique([...parentAncestors, node.id]);
+      const newNode = {
+        ...node,
+        children: [...node.children || [], new TreeNodeFolderWrapper({
+          ...newFolder,
+          ancestors
+        })]
+      };
+      return newNode;
+    } else {
+      return node;
+    }
+  });
+}
+function deleteNode(treeData, {
+  folders
+}) {
+  return modifyNode(treeData, (node) => {
+    if (folders.includes(node.id)) {
+      return void 0;
+    } else {
+      return node;
+    }
+  });
+}
+function moveNode(treeData, {
+  destinationId,
+  folders
+}) {
+  return modifyNode(treeData, (node, parent) => {
+    var _a, _b;
+    if (destinationId === node.id) {
+      const parentAncestors = [...((_a = node.folder) == null ? void 0 : _a.ancestors) || []];
+      const ancestors = arrayUnique([...parentAncestors, node.id]);
+      const newChildren = [...node.children || []];
+      const childrenIds = ((_b = node.children) == null ? void 0 : _b.map((child) => child.id)) || [];
+      for (const folder of folders) {
+        if (!childrenIds.includes(folder)) {
+          const item = findNodeById(folder, treeData);
+          item && newChildren.push({
+            ...item,
+            folder: {
+              ...item == null ? void 0 : item.folder,
+              ancestors
+            }
+          });
+        }
+      }
+      const newNode = {
+        ...node,
+        children: newChildren
+      };
+      return newNode;
+    } else if (folders.includes(node.id) && destinationId !== (parent == null ? void 0 : parent.id)) {
+      return void 0;
+    } else {
+      return node;
+    }
+  });
+}
+function updateNode(treeData, {
+  folderId,
+  newFolder
+}) {
+  return modifyNode(treeData, (node) => {
+    if (node.id === folderId) {
+      return new TreeNodeFolderWrapper(newFolder);
+    } else {
+      return node;
+    }
+  });
+}
+const useActions = () => {
+  const config = useStoreContext((state) => state.config);
+  return useQuery({
+    queryKey: ["actions"],
+    queryFn: async () => {
+      const actionRights = config.actions.map((action) => action.workflow);
+      const availableRights = await sessionHasWorkflowRights(actionRights);
+      return availableRights;
+    },
+    select: (data) => {
+      return config.actions.map((action) => ({
+        ...action,
+        available: data[action.workflow]
+      }));
+    },
+    staleTime: Infinity,
+    enabled: !!config
+  });
+};
+const useSearchContext = () => {
+  const config = useStoreContext((state) => state.config);
+  const searchParams = useSearchParams();
+  const {
+    filters,
+    trashed,
+    search
+  } = searchParams;
+  const queryKey = ["context", {
+    folderId: filters.folder,
+    filters,
+    trashed,
+    search
+  }];
+  return useInfiniteQuery({
+    queryKey,
+    queryFn: async ({
+      pageParam
+    }) => {
+      return await searchContext({
+        ...searchParams,
+        app: config == null ? void 0 : config.app,
+        types: config == null ? void 0 : config.types,
+        pagination: {
+          ...searchParams.pagination,
+          startIdx: pageParam
+        }
+      });
+    },
+    initialPageParam: 0,
+    enabled: !!config,
+    retry: false,
+    getNextPageParam: (lastPage) => {
+      return lastPage.pagination.startIdx + lastPage.pagination.pageSize;
+    }
+  });
+};
+const useTrash = () => {
+  const toast = useToast();
+  const queryClient = useQueryClient();
+  const searchParams = useSearchParams();
+  const treeData = useTreeData();
+  const folderIds = useFolderIds();
+  const assetIds = useResourceAssetIds();
+  const resourceRealIds = useResourceIds();
+  const useAssetIds = useResourceWithoutIds().length > 0;
+  const resourceIds = useAssetIds ? assetIds : resourceRealIds;
+  const {
+    clearSelectedItems,
+    clearSelectedIds,
+    setTreeData,
+    setSearchParams
+  } = useStoreActions();
+  const {
+    filters,
+    trashed
+  } = searchParams;
+  const queryKey = ["context", {
+    folderId: filters.folder,
+    filters,
+    trashed
+  }];
+  return useMutation({
+    mutationFn: async () => await trashAll({
+      searchParams,
+      folderIds,
+      resourceIds,
+      useAssetIds
+    }),
+    onError(error) {
+      if (typeof error === "string")
+        toast.error(t(error));
+    },
+    onSuccess: async (data) => {
+      await queryClient.cancelQueries({
+        queryKey
+      });
+      const previousData = queryClient.getQueryData(queryKey);
+      if (previousData) {
+        toast.success(t("explorer.trash.title"));
+        return queryClient.setQueryData(queryKey, (prev) => {
+          var _a;
+          if (prev) {
+            const newData = {
+              ...prev,
+              pages: prev == null ? void 0 : prev.pages.map((page) => {
+                var _a2;
+                return {
+                  ...page,
+                  folders: page.folders.filter((folder) => !folderIds.includes(folder.id)),
+                  pagination: {
+                    ...page.pagination,
+                    // @ts-ignore
+                    maxIdx: ((_a2 = page == null ? void 0 : page.pagination) == null ? void 0 : _a2.maxIdx) - data.resources.length
+                  },
+                  resources: page.resources.filter((resource) => {
+                    if (useAssetIds) {
+                      return !assetIds.includes(resource.assetId);
+                    } else {
+                      return !resourceIds.includes(resource.id);
+                    }
+                  })
+                };
+              })
+            };
+            const update = deleteNode(treeData, {
+              folders: folderIds
+            });
+            setTreeData(update);
+            setSearchParams({
+              ...searchParams,
+              pagination: {
+                ...searchParams.pagination,
+                // @ts-ignore
+                maxIdx: ((_a = searchParams.pagination) == null ? void 0 : _a.maxIdx) - data.resources.length
+              }
+            });
+            return newData;
+          }
+          return void 0;
+        });
+      }
+    },
+    onSettled: () => {
+      clearSelectedItems();
+      clearSelectedIds();
+    }
+  });
+};
+const useRestore = () => {
+  const toast = useToast();
+  const queryClient = useQueryClient();
+  const searchParams = useSearchParams();
+  const folderIds = useFolderIds();
+  const assetIds = useResourceAssetIds();
+  const resourceRealIds = useResourceIds();
+  const useAssetIds = useResourceWithoutIds().length > 0;
+  const resourceIds = useAssetIds ? assetIds : resourceRealIds;
+  const {
+    setFolderIds,
+    setResourceIds,
+    setSelectedResources,
+    setSelectedFolders
+  } = useStoreActions();
+  const {
+    filters,
+    trashed
+  } = searchParams;
+  const queryKey = ["context", {
+    folderId: filters.folder,
+    filters,
+    trashed
+  }];
+  return useMutation({
+    mutationFn: async () => await restoreAll({
+      searchParams,
+      folderIds,
+      resourceIds,
+      useAssetIds
+    }),
+    onError(error) {
+      if (typeof error === "string")
+        toast.error(t(error));
+    },
+    onSuccess: async () => {
+      await queryClient.cancelQueries({
+        queryKey
+      });
+      const previousData = queryClient.getQueryData(queryKey);
+      if (previousData) {
+        toast.success(t("explorer.trash.toast"));
+        return queryClient.setQueryData(queryKey, (prev) => {
+          if (prev) {
+            return {
+              ...prev,
+              pages: prev == null ? void 0 : prev.pages.map((page) => {
+                return {
+                  ...page,
+                  folders: page.folders.filter((folder) => !folderIds.includes(folder.id)),
+                  resources: page.resources.filter((resource) => {
+                    if (useAssetIds) {
+                      return !assetIds.includes(resource.assetId);
+                    } else {
+                      return !resourceIds.includes(resource.id);
+                    }
+                  })
+                };
+              })
+            };
+          }
+          return void 0;
+        });
+      }
+    },
+    onSettled: () => {
+      setResourceIds([]);
+      setSelectedResources([]);
+      setFolderIds([]);
+      setSelectedFolders([]);
+    }
+  });
+};
+const useDelete = () => {
+  const toast = useToast();
+  const queryClient = useQueryClient();
+  const searchParams = useSearchParams();
+  const folderIds = useFolderIds();
+  const assetIds = useResourceAssetIds();
+  const resourceRealIds = useResourceIds();
+  const useAssetIds = useResourceWithoutIds().length > 0;
+  const resourceIds = useAssetIds ? assetIds : resourceRealIds;
+  const {
+    clearSelectedItems,
+    clearSelectedIds
+  } = useStoreActions();
+  const {
+    filters,
+    trashed
+  } = searchParams;
+  const queryKey = ["context", {
+    folderId: filters.folder,
+    filters,
+    trashed
+  }];
+  return useMutation({
+    mutationFn: async () => await deleteAll({
+      searchParams,
+      folderIds,
+      resourceIds,
+      useAssetIds
+    }),
+    onError(error) {
+      if (typeof error === "string")
+        toast.error(t(error));
+    },
+    onSuccess: async () => {
+      await queryClient.cancelQueries({
+        queryKey
+      });
+      const previousData = queryClient.getQueryData(queryKey);
+      if (previousData) {
+        toast.success(t("explorer.removed.from.trash"));
+        return queryClient.setQueryData(queryKey, (prev) => {
+          if (prev) {
+            const newData = {
+              ...prev,
+              pages: prev == null ? void 0 : prev.pages.map((page) => {
+                return {
+                  ...page,
+                  folders: page.folders.filter((folder) => !folderIds.includes(folder.id)),
+                  resources: page.resources.filter((resource) => {
+                    if (useAssetIds) {
+                      return !assetIds.includes(resource.assetId);
+                    } else {
+                      return !resourceIds.includes(resource.id);
+                    }
+                  })
+                };
+              })
+            };
+            return newData;
+          }
+          return void 0;
+        });
+      }
+    },
+    onSettled: () => {
+      clearSelectedItems();
+      clearSelectedIds();
+    }
+  });
+};
+const useMoveItem = () => {
+  const toast = useToast();
+  const queryClient = useQueryClient();
+  const searchParams = useSearchParams();
+  const treeData = useTreeData();
+  const folderIds = useFolderIds();
+  const assetIds = useResourceAssetIds();
+  const resourceRealIds = useResourceIds();
+  const useAssetIds = useResourceWithoutIds().length > 0;
+  const resourceIds = useAssetIds ? assetIds : resourceRealIds;
+  const {
+    clearSelectedIds,
+    clearSelectedItems,
+    setTreeData,
+    setSearchParams
+  } = useStoreActions();
+  const {
+    filters,
+    trashed
+  } = searchParams;
+  const queryKey = ["context", {
+    folderId: filters.folder,
+    filters,
+    trashed
+  }];
+  return useMutation({
+    mutationFn: async (folderId) => await moveToFolder({
+      searchParams,
+      folderId,
+      folderIds,
+      resourceIds,
+      useAssetIds
+    }),
+    onError(error) {
+      if (typeof error === "string")
+        toast.error(t(error));
+    },
+    onSuccess: async (data, variables) => {
+      const previousData = queryClient.getQueryData(queryKey);
+      if (previousData) {
+        return queryClient.setQueryData(queryKey, (prev) => {
+          var _a;
+          if (prev) {
+            const update = moveNode(treeData, {
+              destinationId: variables,
+              folders: folderIds
+            });
+            const newData = {
+              ...prev,
+              pages: prev == null ? void 0 : prev.pages.map((page) => {
+                var _a2;
+                return {
+                  ...page,
+                  folders: page.folders.filter((folder) => !folderIds.includes(folder.id)),
+                  pagination: {
+                    ...page.pagination,
+                    // @ts-ignore
+                    maxIdx: ((_a2 = page.pagination) == null ? void 0 : _a2.maxIdx) - data.resources.length
+                  },
+                  resources: page.resources.filter((resource) => {
+                    if (useAssetIds) {
+                      return !assetIds.includes(resource.assetId);
+                    } else {
+                      return !resourceIds.includes(resource.id);
+                    }
+                  })
+                };
+              })
+            };
+            setTreeData(update);
+            setSearchParams({
+              ...searchParams,
+              pagination: {
+                ...searchParams.pagination,
+                // @ts-ignore
+                maxIdx: ((_a = searchParams.pagination) == null ? void 0 : _a.maxIdx) - data.resources.length
+              }
+            });
+            return newData;
+          }
+          return void 0;
+        });
+      }
+    },
+    onSettled: () => {
+      clearSelectedItems();
+      clearSelectedIds();
+    }
+  });
+};
+const useCreateFolder = () => {
+  const toast = useToast();
+  const queryClient = useQueryClient();
+  const searchParams = useSearchParams();
+  const treeData = useTreeData();
+  const {
+    setTreeData
+  } = useStoreActions();
+  const {
+    filters,
+    trashed
+  } = searchParams;
+  const queryKey = ["context", {
+    folderId: filters.folder,
+    filters,
+    trashed
+  }];
+  return useMutation({
+    mutationFn: async ({
+      name,
+      parentId
+    }) => await createFolder({
+      searchParams,
+      name,
+      parentId
+    }),
+    onError(error) {
+      if (typeof error === "string")
+        toast.error(t(error));
+    },
+    onSuccess: async (data, variables) => {
+      await queryClient.cancelQueries({
+        queryKey
+      });
+      const previousData = queryClient.getQueryData(queryKey);
+      const newFolder = {
+        ...data,
+        parentId: variables.parentId,
+        children: [],
+        rights: [`creator:${data == null ? void 0 : data.creator_id}`]
+      };
+      if (previousData) {
+        return queryClient.setQueryData(queryKey, (prev) => {
+          if (prev) {
+            const newData = {
+              ...prev,
+              pages: prev == null ? void 0 : prev.pages.map((page) => {
+                return {
+                  ...page,
+                  folders: [...page.folders, newFolder]
+                };
+              })
+            };
+            const update = addNode(treeData, {
+              parentId: variables.parentId,
+              newFolder
+            });
+            setTreeData(update);
+            return newData;
+          }
+          return void 0;
+        });
+      }
+    }
+  });
+};
+const useUpdatefolder = () => {
+  const toast = useToast();
+  const queryClient = useQueryClient();
+  const searchParams = useSearchParams();
+  const treeData = useTreeData();
+  const {
+    setFolderIds,
+    setSelectedFolders,
+    setTreeData
+  } = useStoreActions();
+  const {
+    filters,
+    trashed
+  } = searchParams;
+  const queryKey = ["context", {
+    folderId: filters.folder,
+    filters,
+    trashed
+  }];
+  return useMutation({
+    mutationFn: async ({
+      folderId,
+      name,
+      parentId
+    }) => await updateFolder({
+      searchParams,
+      folderId,
+      parentId,
+      name
+    }),
+    onError(error) {
+      if (typeof error === "string")
+        toast.error(t(error));
+    },
+    onSuccess: async (data, variables) => {
+      await queryClient.cancelQueries({
+        queryKey
+      });
+      const previousData = queryClient.getQueryData(queryKey);
+      if (previousData) {
+        return queryClient.setQueryData(queryKey, (prev) => {
+          if (prev) {
+            const newData = {
+              ...prev,
+              pages: prev == null ? void 0 : prev.pages.map((page) => {
+                return {
+                  ...page,
+                  folders: page.folders.map((folder) => {
+                    if (folder.id === data.id) {
+                      return {
+                        ...data,
+                        parentId: variables.parentId,
+                        rights: folder.rights
+                      };
+                    } else {
+                      return folder;
+                    }
+                  })
+                };
+              })
+            };
+            const update = updateNode(treeData, {
+              folderId: variables.folderId,
+              newFolder: data
+            });
+            setTreeData(update);
+            return newData;
+          }
+          return void 0;
+        });
+      }
+    },
+    onSettled: () => {
+      setFolderIds([]);
+      setSelectedFolders([]);
+    }
+  });
+};
+const useShareResource = () => {
+  const toast = useToast();
+  const queryClient = useQueryClient();
+  const searchParams = useSearchParams();
+  const {
+    setResourceIds,
+    setSelectedResources
+  } = useStoreActions();
+  const {
+    filters,
+    trashed,
+    app
+  } = searchParams;
+  const queryKey = ["context", {
+    folderId: filters.folder,
+    filters,
+    trashed
+  }];
+  return useMutation({
+    mutationFn: async ({
+      resourceId,
+      rights
+    }) => await shareResource({
+      app,
+      resourceId,
+      rights
+    }),
+    onError(error) {
+      if (typeof error === "string")
+        toast.error(t("explorer.shared.status.error"));
+    },
+    onSuccess: async (_data, variables) => {
+      await queryClient.cancelQueries({
+        queryKey
+      });
+      const previousData = queryClient.getQueryData(queryKey);
+      if (previousData) {
+        toast.success(t("explorer.shared.status.saved"));
+        return queryClient.setQueryData(queryKey, (prev) => {
+          if (prev) {
+            return {
+              ...prev,
+              pages: prev == null ? void 0 : prev.pages.map((page) => {
+                return {
+                  ...page,
+                  resources: page.resources.map((resource) => {
+                    if (resource.assetId === (variables == null ? void 0 : variables.resourceId)) {
+                      let rights = [`creator:${resource.creatorId}`];
+                      if ((variables == null ? void 0 : variables.rights.length) >= 1) {
+                        rights = [...rights, ...variables.rights.flatMap((right) => {
+                          return right.actions.map((action) => {
+                            return `${right.type}:${right.id}:${action.id}`;
+                          });
+                        })];
+                      }
+                      return {
+                        ...resource,
+                        rights
+                      };
+                    } else {
+                      return resource;
+                    }
+                  })
+                };
+              })
+            };
+          }
+          return void 0;
+        });
+      }
+    },
+    onSettled: () => {
+      setResourceIds([]);
+      setSelectedResources([]);
+    }
+  });
+};
+const useUpdateResource = () => {
+  const toast = useToast();
+  const queryClient = useQueryClient();
+  const searchParams = useSearchParams();
+  const {
+    filters,
+    trashed,
+    app
+  } = searchParams;
+  const queryKey = ["context", {
+    folderId: filters.folder,
+    filters,
+    trashed
+  }];
+  return useMutation({
+    mutationFn: async (params) => await updateResource({
+      app,
+      params
+    }),
+    onError(error) {
+      if (typeof error === "string")
+        toast.error(t(error));
+    },
+    onSuccess: async (_data, variables) => {
+      await queryClient.cancelQueries({
+        queryKey
+      });
+      const previousData = queryClient.getQueryData(queryKey);
+      if (previousData) {
+        return queryClient.setQueryData(queryKey, (prev) => {
+          if (prev) {
+            return {
+              ...prev,
+              pages: prev == null ? void 0 : prev.pages.map((page) => {
+                return {
+                  ...page,
+                  resources: page.resources.map((resource) => {
+                    if (resource.assetId === (variables == null ? void 0 : variables.entId)) {
+                      const {
+                        name,
+                        thumbnail,
+                        public: pub,
+                        description,
+                        slug,
+                        ...others
+                      } = variables;
+                      return {
+                        ...resource,
+                        ...others,
+                        // add any custom field
+                        name,
+                        thumbnail: typeof thumbnail === "string" ? thumbnail : URL.createObjectURL(thumbnail),
+                        public: pub,
+                        description,
+                        slug
+                      };
+                    } else {
+                      return resource;
+                    }
+                  })
+                };
+              })
+            };
+          }
+          return void 0;
+        });
+      }
+    }
+  });
+};
+const useCreateResource = () => {
+  const toast = useToast();
+  const queryClient = useQueryClient();
+  const searchParams = useSearchParams();
+  const {
+    user
+  } = useUser();
+  const {
+    appCode: application
+  } = useOdeClient();
+  const queryKey = ["context", {
+    folderId: searchParams.filters.folder,
+    filters: searchParams.filters,
+    trashed: searchParams.trashed
+  }];
+  return useMutation({
+    mutationFn: async (params) => await createResource({
+      searchParams,
+      params
+    }),
+    onError(error) {
+      if (typeof error === "string")
+        toast.error(t(error));
+    },
+    onSuccess: async (data, variables) => {
+      var _a, _b, _c;
+      await queryClient.cancelQueries({
+        queryKey
+      });
+      const previousData = queryClient.getQueryData(queryKey);
+      const {
+        thumbnail
+      } = variables;
+      const newResource = {
+        ...variables,
+        thumbnail: thumbnail ? URL.createObjectURL(thumbnail) : "",
+        application,
+        assetId: data._id || data.entId || "",
+        id: data._id || data.entId || "",
+        creatorId: user == null ? void 0 : user.userId,
+        creatorName: user == null ? void 0 : user.username,
+        createdAt: Date.now(),
+        slug: variables.slug || "",
+        modifiedAt: ((_a = data.modified) == null ? void 0 : _a.$date) || "",
+        modifierId: ((_b = data.author) == null ? void 0 : _b.userId) || "",
+        modifierName: ((_c = data.author) == null ? void 0 : _c.username) || "",
+        updatedAt: Date.now(),
+        trashed: false,
+        rights: [`creator:${user == null ? void 0 : user.userId}`]
+      };
+      if (previousData) {
+        return queryClient.setQueryData(queryKey, (prev) => {
+          if (prev) {
+            return {
+              ...prev,
+              pages: prev == null ? void 0 : prev.pages.map((page) => {
+                return {
+                  ...page,
+                  resources: [newResource, ...page.resources]
+                };
+              })
+            };
+          }
+          return void 0;
+        });
+      }
+    }
+  });
+};
+const EmptyScreenApp = /* @__PURE__ */ lazy(async () => await import("./EmptyScreenApp.js"));
+const EmptyScreenSearch = /* @__PURE__ */ lazy(async () => await import("./EmptyScreenSearch.js"));
+const EmptyScreenError = /* @__PURE__ */ lazy(async () => await import("./EmptyScreenError.js"));
+const EmptyScreenNoContentInFolder = /* @__PURE__ */ lazy(async () => await import("./EmptyScreenNoContentInFolder.js"));
+const EmptyScreenTrash = /* @__PURE__ */ lazy(async () => await import("./EmptyScreenTrash.js"));
+const FoldersList = /* @__PURE__ */ lazy(async () => await import("./FoldersList.js"));
+const ResourcesList = /* @__PURE__ */ lazy(async () => await import("./ResourcesList.js"));
+const List = () => {
+  const isRoot = useIsRoot();
+  const isTrashFolder = useIsTrash();
+  const hasSelectedNodes = useHasSelectedNodes();
+  const searchParams = useSearchParams();
+  const currentFolder = useCurrentFolder();
+  const treeData = useTreeData();
+  const toast = useToast();
+  const {
+    appCode
+  } = useOdeClient();
+  const {
+    t: t2
+  } = useTranslation();
+  const {
+    setSearchParams,
+    setSearchConfig,
+    setTreeData
+  } = useStoreActions();
+  const {
+    data,
+    isError,
+    error,
+    isLoading,
+    isFetching,
+    fetchNextPage
+  } = useSearchContext();
+  const hasNoFolders = (data == null ? void 0 : data.pages[0].folders.length) === 0;
+  const hasNoResources = (data == null ? void 0 : data.pages[0].resources.length) === 0;
+  const hasNoData = hasNoFolders && hasNoResources;
+  useEffect(() => {
+    var _a, _b, _c;
+    if (data) {
+      const folders = [...((_a = data == null ? void 0 : data.pages[0]) == null ? void 0 : _a.folders) ?? []];
+      if ((_b = data == null ? void 0 : data.pages[0]) == null ? void 0 : _b.searchConfig) {
+        setSearchConfig(data.pages[0].searchConfig);
+      }
+      if (!searchParams.search) {
+        if ((currentFolder == null ? void 0 : currentFolder.id) === "default") {
+          setTreeData({
+            id: FOLDER.DEFAULT,
+            section: true,
+            children: folders.map((folder) => new TreeNodeFolderWrapper(folder)),
+            name: t2("explorer.filters.mine", {
+              ns: appCode
+            })
+          });
+        } else {
+          setTreeData(wrapTreeNode(treeData, folders, searchParams.filters.folder || FOLDER.DEFAULT));
+        }
+      }
+      setSearchParams({
+        ...searchParams,
+        pagination: (_c = data == null ? void 0 : data.pages[(data == null ? void 0 : data.pages.length) - 1]) == null ? void 0 : _c.pagination
+      });
+    }
+  }, [data]);
+  useEffect(() => {
+    if (error && typeof error === "string") {
+      toast.error(t2(error));
+    }
+  }, [error]);
+  if (isLoading)
+    return /* @__PURE__ */ jsx(LoadingScreen, {});
+  if (isError) {
+    return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingScreen, {}), children: /* @__PURE__ */ jsx(EmptyScreenError, {}) });
+  }
+  if (searchParams.search && hasNoData) {
+    return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingScreen, {}), children: /* @__PURE__ */ jsx(EmptyScreenSearch, {}) });
+  }
+  if (isRoot && hasNoData) {
+    return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingScreen, {}), children: /* @__PURE__ */ jsx(EmptyScreenApp, {}) });
+  }
+  if (hasSelectedNodes && hasNoData && !isTrashFolder) {
+    return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingScreen, {}), children: /* @__PURE__ */ jsx(EmptyScreenNoContentInFolder, {}) });
+  }
+  if (isTrashFolder && (data == null ? void 0 : data.pages[0].resources.length) === 0) {
+    return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingScreen, {}), children: /* @__PURE__ */ jsx(EmptyScreenTrash, {}) });
+  }
+  return /* @__PURE__ */ jsxs(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingScreen, {}), children: [
+    /* @__PURE__ */ jsx(FoldersList, { data, isFetching }),
+    /* @__PURE__ */ jsx(ResourcesList, { data, isFetching, fetchNextPage })
+  ] });
+};
+const useSelectedFilters = () => {
+  const {
+    appCode,
+    currentApp
+  } = useOdeClient();
+  const {
+    t: t2
+  } = useTranslation();
+  const [selectedFilters, setSelectedFilters] = useState("");
+  const handleOnSelectFilter = (value) => {
+    if (value === "0") {
+      setSelectedFilters("");
+      return;
+    }
+    setSelectedFilters(value);
+  };
+  const currentFolder = useCurrentFolder();
+  const searchParams = useSearchParams();
+  const {
+    setSearchParams
+  } = useStoreActions();
+  useEffect(() => {
+    const isOwnerSelected = () => {
+      return selectedFilters.includes("1") ? true : void 0;
+    };
+    const isSharedSelected = () => {
+      return selectedFilters.includes("2") ? true : void 0;
+    };
+    const isPublicSelected = () => {
+      return selectedFilters.includes("7") ? true : void 0;
+    };
+    setSearchParams({
+      ...searchParams,
+      filters: {
+        owner: isOwnerSelected(),
+        public: isPublicSelected(),
+        shared: isSharedSelected(),
+        folder: currentFolder ? currentFolder.id : "default"
+      }
+    });
+  }, [currentFolder, setSearchParams, selectedFilters]);
+  const options = [{
+    label: t2("explorer.filter.all", {
+      ns: appCode
+    }),
+    value: "0"
+  }, {
+    label: t2("explorer.filter.owner", {
+      ns: appCode
+    }),
+    value: "1"
+  }, {
+    label: t2("explorer.filter.shared", {
+      ns: appCode
+    }),
+    value: "2"
+  }, ...(currentApp == null ? void 0 : currentApp.displayName) == APP.EXERCIZER ? [{
+    label: "Exercices interactifs",
+    value: "3"
+  }] : [], ...(currentApp == null ? void 0 : currentApp.displayName) == APP.EXERCIZER ? [{
+    label: "Exercices à rendre",
+    value: "4"
+  }] : [], ...(currentApp == null ? void 0 : currentApp.displayName) == "pages" ? [{
+    label: "Projets publics",
+    value: "5"
+  }] : [], ...(currentApp == null ? void 0 : currentApp.displayName) == "pages" ? [{
+    label: "Projets internes",
+    value: "6"
+  }] : [], ...(currentApp == null ? void 0 : currentApp.displayName) == APP.BLOG ? [{
+    label: t2("explorer.filter.public", {
+      ns: appCode
+    }),
+    value: "7"
+  }] : []];
+  return {
+    selectedFilters,
+    options,
+    handleOnSelectFilter
+  };
+};
+const SearchForm = () => {
+  const {
+    appCode
+  } = useOdeClient();
+  const {
+    t: t2
+  } = useTranslation();
+  const {
+    selectedFilters,
+    options,
+    handleOnSelectFilter
+  } = useSelectedFilters();
+  const {
+    formRef,
+    inputSearch,
+    handleInputSearchChange,
+    handleKeyPress,
+    handleSearchSubmit
+  } = useSearchForm();
+  const count = selectedFilters.length > 0 ? selectedFilters.length : void 0;
+  return /* @__PURE__ */ jsxs("form", { noValidate: true, className: "bg-light p-16 ps-24 ms-n16 ms-lg-n24 me-n16 position-relative z-3 d-flex gap-8", ref: formRef, children: [
+    /* @__PURE__ */ jsxs(FormControl, { id: "search", className: "input-group", children: [
+      /* @__PURE__ */ jsx(Input, { type: "search", placeholder: t2("explorer.label.search", {
+        ns: appCode
+      }), size: "lg", noValidationIcon: true, value: inputSearch, onChange: handleInputSearchChange, onKeyDown: handleKeyPress }),
+      /* @__PURE__ */ jsx(SearchButton, { type: "submit", "aria-label": t2("explorer.label.search", {
+        ns: appCode
+      }), onClick: handleSearchSubmit })
+    ] }),
+    /* @__PURE__ */ jsxs(Dropdown, { placement: "bottom-end", children: [
+      /* @__PURE__ */ jsx(Dropdown.Trigger, { label: t2("explorer.filters"), icon: /* @__PURE__ */ jsx(Filter, { width: 20 }), variant: "ghost", badgeContent: count }),
+      /* @__PURE__ */ jsx(Dropdown.Menu, { children: options.map((option) => {
+        if (option.value === "0") {
+          return /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Dropdown.RadioItem, { value: option.value, model: selectedFilters, onChange: () => handleOnSelectFilter(option.value), children: option.label }),
+            /* @__PURE__ */ jsx(Dropdown.Separator, {})
+          ] }, "0");
+        }
+        return /* @__PURE__ */ jsx(Dropdown.RadioItem, { value: option.value, model: selectedFilters, onChange: () => handleOnSelectFilter(option.value), children: option.label }, option.value);
+      }) })
+    ] })
+  ] });
+};
+const TrashButton = ({
+  id,
+  selected,
+  onSelect
+}) => {
+  const {
+    t: t2
+  } = useTranslation();
+  return /* @__PURE__ */ jsx("div", { className: "treeview", children: /* @__PURE__ */ jsx("ul", { role: "tree", className: "m-0 p-0", children: /* @__PURE__ */ jsx("li", { id, role: "treeitem", "aria-selected": selected, children: /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx("div", { className: "action-container", children: /* @__PURE__ */ jsx("div", { onClick: onSelect, role: "button", tabIndex: 0, children: /* @__PURE__ */ jsxs("div", { className: "d-flex align-items-center gap-8 py-8 ps-24", children: [
+    /* @__PURE__ */ jsx(Delete, { width: "20", height: "20" }),
+    /* @__PURE__ */ jsx("span", { children: t2("explorer.tree.trash") })
+  ] }) }) }) }) }) }) });
+};
+const CreateFolderModal = /* @__PURE__ */ lazy(async () => await import("./FolderModal.js"));
+const TreeViewContainer = () => {
+  const queryclient = useQueryClient();
+  const [isModalOpen, toggle] = useToggle();
+  const treeData = useTreeData();
+  const isTrashFolder = useIsTrash();
+  const selectedNodesIds = useSelectedNodesIds();
+  const {
+    appCode
+  } = useOdeClient();
+  const {
+    t: t2
+  } = useTranslation(["common", appCode]);
+  const {
+    goToTrash,
+    selectTreeItem,
+    unfoldTreeItem,
+    foldTreeItem,
+    clearSelectedItems,
+    clearSelectedIds
+  } = useStoreActions();
+  const handleTreeItemUnfold = async (folderId) => {
+    await unfoldTreeItem(folderId, queryclient);
+  };
+  const handleOnFolderCreate = () => {
+    clearSelectedItems();
+    clearSelectedIds();
+    toggle();
+  };
+  return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+    /* @__PURE__ */ jsx(TreeView, { data: treeData, selectedNodesIds, onTreeItemSelect: selectTreeItem, onTreeItemFold: foldTreeItem, onTreeItemUnfold: handleTreeItemUnfold }),
+    /* @__PURE__ */ jsx(TrashButton, { id: FOLDER.BIN, selected: isTrashFolder, onSelect: goToTrash }),
+    /* @__PURE__ */ jsx("div", { className: "d-grid my-16", children: /* @__PURE__ */ jsx(Button, { disabled: isTrashFolder, type: "button", color: "primary", variant: "outline", leftIcon: /* @__PURE__ */ jsx(Plus, {}), onClick: handleOnFolderCreate, children: t2("explorer.folder.new") }) }),
+    /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingScreen, {}), children: isModalOpen && /* @__PURE__ */ jsx(CreateFolderModal, { edit: false, isOpen: isModalOpen, onSuccess: toggle, onCancel: toggle }) })
+  ] });
+};
+const style = "";
+const OnboardingModal = /* @__PURE__ */ lazy(async () => {
+  const module = await import("@edifice-ui/react");
+  return {
+    default: module.OnboardingModal
+  };
+});
+const AppAction = /* @__PURE__ */ lazy(async () => await import("./AppAction.js"));
+const Library = /* @__PURE__ */ lazy(async () => await import("./Library.js"));
+const ActionBar = /* @__PURE__ */ lazy(async () => await import("./ActionBarContainer.js"));
+const ActionResourceDisableModal = /* @__PURE__ */ lazy(async () => await import("./DisableModal.js"));
+const TrashedResourceModal = /* @__PURE__ */ lazy(async () => await import("./TrashModal.js"));
+const Explorer = ({
+  config
+}) => {
+  const searchParams = useSearchParams();
+  const {
+    setConfig,
+    setSearchParams
+  } = useStoreActions();
+  useEffect(() => {
+    setConfig(config || {});
+    setSearchParams({
+      ...searchParams,
+      app: config.app,
+      types: config.types
+    });
+  }, [config]);
+  const {
+    currentApp
+  } = useOdeClient();
+  const {
+    data: actions
+  } = useActions();
+  const {
+    isTrashedModalOpen,
+    onTrashedCancel
+  } = useTrashModal();
+  const {
+    isActionDisableModalOpen,
+    onActionDisableCancel
+  } = useDisableModal();
+  useXitiTrackPageLoad();
+  const canPublish = isActionAvailable("publish", actions);
+  const canCreate = isActionAvailable("create", actions);
+  return config && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+    /* @__PURE__ */ jsx(AppHeader, { render: () => canCreate ? /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingScreen, {}), children: /* @__PURE__ */ jsx(AppAction, {}) }) : null, children: /* @__PURE__ */ jsx(Breadcrumb, { app: currentApp }) }),
+    /* @__PURE__ */ jsxs(Grid, { className: "flex-grow-1", children: [
+      /* @__PURE__ */ jsx(Grid.Col, { sm: "3", lg: "2", xl: "3", className: "border-end pt-16 pe-16 d-none d-lg-block", as: "aside", children: /* @__PURE__ */ jsxs(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingScreen, {}), children: [
+        /* @__PURE__ */ jsx(TreeViewContainer, {}),
+        canPublish && /* @__PURE__ */ jsx(Library, {})
+      ] }) }),
+      /* @__PURE__ */ jsxs(Grid.Col, { sm: "4", md: "8", lg: "6", xl: "9", children: [
+        /* @__PURE__ */ jsx(SearchForm, {}),
+        /* @__PURE__ */ jsx(ExplorerBreadcrumb, {}),
+        /* @__PURE__ */ jsx(List, {})
+      ] }),
+      /* @__PURE__ */ jsxs(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingScreen, {}), children: [
+        /* @__PURE__ */ jsx(ActionBar, {}),
+        /* @__PURE__ */ jsx(OnboardingModal, { id: "showOnboardingTrash", items: [{
+          src: "onboarding/illu-trash-menu.svg",
+          alt: "explorer.modal.onboarding.trash.screen1.alt",
+          text: "explorer.modal.onboarding.trash.screen1.title"
+        }, {
+          src: "onboarding/illu-trash-notif.svg",
+          alt: "explorer.modal.onboarding.trash.screen2.alt",
+          text: "explorer.modal.onboarding.trash.screen2.alt"
+        }, {
+          src: "onboarding/illu-trash-delete.svg",
+          alt: "explorer.modal.onboarding.trash.screen3.alt",
+          text: "explorer.modal.onboarding.trash.screen3.title"
+        }], modalOptions: {
+          title: "explorer.modal.onboarding.trash.title",
+          prevText: "explorer.modal.onboarding.trash.prev",
+          nextText: "explorer.modal.onboarding.trash.next",
+          closeText: "explorer.modal.onboarding.trash.close"
+        } }),
+        isTrashedModalOpen && /* @__PURE__ */ jsx(TrashedResourceModal, { isOpen: isTrashedModalOpen, onCancel: onTrashedCancel }),
+        isActionDisableModalOpen && /* @__PURE__ */ jsx(ActionResourceDisableModal, { isOpen: isActionDisableModalOpen, onCancel: onActionDisableCancel })
+      ] })
+    ] })
+  ] });
+};
+export {
+  Explorer as E,
+  useActions as a,
+  useCurrentFolder as b,
+  useCreateResource as c,
+  useIsTrash as d,
+  useStoreContext as e,
+  useResourceIds as f,
+  useSelectedResources as g,
+  useSelectedFolders as h,
+  useFolderIds as i,
+  useRestore as j,
+  useResourceIsTrash as k,
+  useShareResource as l,
+  useUpdateResource as m,
+  useSearchParams as n,
+  useCreateFolder as o,
+  useUpdatefolder as p,
+  useDelete as q,
+  useTrash as r,
+  useMoveItem as s,
+  useTreeData as t,
+  useStoreActions as u
+};