@edifice.io/react 2.0.0-develop-rc.14 → 2.0.0-develop-rc.16

package/dist/components/TreeView/hooks/useTreeView.js

@@ -0,0 +1,105 @@
+import { useState, useRef, useEffect, useMemo, useImperativeHandle } from "react";
+import { findNodeById, findPathById } from "../utilities/treeview.js";
+const useTreeView = ({
+  data,
+  ref,
+  externalSelectedNodeId,
+  draggedNode,
+  allExpandedNodes,
+  onTreeItemUnfold,
+  onTreeItemFold,
+  onTreeItemClick
+}) => {
+  const [internalSelectedNodeId, setInternalSelectedNodeId] = useState(void 0), [expandedNodes, setExpandedNodes] = useState(/* @__PURE__ */ new Set()), siblingsNodes = useRef(/* @__PURE__ */ new Set()), [draggedNodeId, setDraggedNodeId] = useState(void 0), selectedNodeId = internalSelectedNodeId ?? externalSelectedNodeId;
+  function addNodesWithSiblingHavingChildren(data2) {
+    var _a;
+    Array.isArray(data2) ? data2.forEach((node) => {
+      const resultSet = new Set(siblingsNodes.current);
+      data2.filter(({
+        id
+      }) => id !== node.id).some((sibling) => sibling.children && sibling.children.length > 0) && resultSet.add(node.id), node.children && node.children.length > 0 && node.children.forEach((child) => {
+        var _a2;
+        const childSiblings = (_a2 = node.children) == null ? void 0 : _a2.filter(({
+          id
+        }) => id !== child.id);
+        (childSiblings == null ? void 0 : childSiblings.some((sibling) => sibling.children && sibling.children.length > 0)) && resultSet.add(child.id), addNodesWithSiblingHavingChildren(child);
+      });
+    }) : (_a = data2.children) == null || _a.forEach((child) => {
+      var _a2;
+      const resultSet = new Set(siblingsNodes.current), siblings = (_a2 = data2.children) == null ? void 0 : _a2.filter((c) => c.id !== child.id);
+      (siblings == null ? void 0 : siblings.some((sibling) => sibling.children && sibling.children.length > 0)) && (resultSet.add(child.id), siblingsNodes.current = resultSet), addNodesWithSiblingHavingChildren(child);
+    });
+  }
+  const expandedAllNodes = (allExpandedNodes2) => {
+    const initExpandedNodes = new Set("");
+    data && Array.isArray(data) && allExpandedNodes2 && (data.forEach((node) => {
+      initExpandedNodes.add(node.id);
+    }), setExpandedNodes(initExpandedNodes));
+  };
+  useEffect(() => {
+    data && addNodesWithSiblingHavingChildren(data);
+  }, [data]), useEffect(() => {
+    draggedNode != null && draggedNode.isOver && draggedNode.isTreeview ? (draggedNode.overId && handleItemDrag(draggedNode.overId), setDraggedNodeId(draggedNode.overId)) : setDraggedNodeId(void 0);
+  }, [draggedNode]);
+  const handlers = useMemo(
+    () => ({
+      unselectAll() {
+        setInternalSelectedNodeId(void 0);
+      },
+      select(nodeId) {
+        handleItemClick(nodeId);
+      },
+      allExpandedNodes() {
+        expandedAllNodes(allExpandedNodes);
+      }
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  useImperativeHandle(ref, () => handlers, [handlers]), useEffect(() => {
+    expandedAllNodes(allExpandedNodes);
+  }, []), useEffect(() => {
+    externalSelectedNodeId && !allExpandedNodes ? (handleExternalSelectedNodeId(externalSelectedNodeId), setInternalSelectedNodeId(externalSelectedNodeId)) : setInternalSelectedNodeId(void 0);
+  }, [externalSelectedNodeId]);
+  const handleExternalSelectedNodeId = (nodeId) => {
+    if (!findNodeById(data, selectedNodeId)) {
+      setInternalSelectedNodeId(void 0);
+      return;
+    }
+    if (externalSelectedNodeId === "default") {
+      expandedNodes.forEach((node) => onTreeItemUnfold == null ? void 0 : onTreeItemUnfold(node));
+      return;
+    }
+    handleExpandNode(nodeId);
+  }, handleExpandNode = (nodeId) => {
+    const updatedExpandedNodes = new Set(expandedNodes), parents = findPathById(data, nodeId), arrayOrder = Array.from(updatedExpandedNodes);
+    parents.forEach((parent) => {
+      const index = arrayOrder.indexOf(parent);
+      index > -1 && arrayOrder.splice(index, 1), arrayOrder.push(parent);
+    }), updatedExpandedNodes.clear(), arrayOrder.forEach((node) => updatedExpandedNodes.add(node)), updatedExpandedNodes.forEach((node) => onTreeItemUnfold == null ? void 0 : onTreeItemUnfold(node)), setExpandedNodes(updatedExpandedNodes);
+  }, handleCollapseNode = (nodeId) => {
+    const updatedExpandedNodes = new Set(expandedNodes);
+    updatedExpandedNodes.delete(nodeId), updatedExpandedNodes.forEach((node) => onTreeItemFold == null ? void 0 : onTreeItemFold(node)), setExpandedNodes(updatedExpandedNodes);
+  }, handleToggleNode = (nodeId) => {
+    expandedNodes.has(nodeId) ? handleCollapseNode(nodeId) : handleExpandNode(nodeId);
+  }, handleSelectedItem = (nodeId) => {
+    selectedNodeId !== nodeId && setInternalSelectedNodeId(nodeId);
+  }, handleItemClick = (nodeId) => {
+    handleSelectedItem(nodeId), handleExpandNode(nodeId), onTreeItemClick == null || onTreeItemClick(nodeId);
+  }, handleFoldUnfold = (nodeId) => {
+    handleToggleNode(nodeId);
+  }, handleItemDrag = (nodeId) => {
+    findNodeById(data, externalSelectedNodeId) && handleExpandNode(nodeId);
+  };
+  return {
+    selectedNodeId,
+    expandedNodes,
+    siblingsNodes,
+    draggedNodeId,
+    handleItemClick,
+    handleFoldUnfold
+  };
+};
+export {
+  useTreeView
+};

package/dist/components/TreeView/index.d.ts

@@ -1,3 +1,5 @@
-export { default as TreeView } from './TreeView';
+export * from './hooks/useTreeView';
 export * from './TreeNode';
 export * from './TreeView';
+export { default as TreeView } from './TreeView';
+export * from './utilities';

package/dist/components/TreeView/utilities/index.d.ts

@@ -0,0 +1 @@
+export * from './treeview';

package/dist/components/TreeView/utilities/treeview.d.ts

@@ -0,0 +1,35 @@
+import { IFolder } from '@edifice.io/ts-client';
+import { TreeData } from '../../../types';
+export declare function findTreeNode(root: TreeData, predicate: (node: TreeData) => boolean): TreeData | undefined;
+export declare function findNodeById(data: TreeData | TreeData[], id: string): TreeData | undefined;
+export declare function addNode(node: TreeData, { parentId, newFolder }: {
+    parentId: string;
+    newFolder: IFolder;
+}): TreeData;
+export declare function arrayUnique<T>(array: T[]): T[];
+export declare function deleteNode(node: TreeData, { folders }: {
+    folders: string[];
+}): TreeData;
+export declare const findParentNode: (parentNode: TreeData, childId: string) => TreeData | undefined;
+export declare function getAncestors(data: TreeData, folderId: string): string[];
+export declare function hasChildren(folderId: string, data: TreeData): boolean;
+export declare function modifyNode(data: TreeData, callback: (node: TreeData, parent?: TreeData) => TreeData | undefined): TreeData;
+export declare function moveNode(node: TreeData, { destinationId, folders }: {
+    destinationId: string;
+    folders: string[];
+}): TreeData;
+export declare const wrapTreeNode: (node: TreeData, folders: IFolder[] | undefined, parentId: string) => TreeData;
+export declare function updateNode(node: TreeData, { folderId, newFolder }: {
+    folderId: string;
+    newFolder: IFolder;
+}): TreeData;
+export declare function findPathById(tree: TreeData | TreeData[], nodeId: string): string[];
+export declare class TreeNodeFolderWrapper implements TreeData {
+    readonly folder: IFolder;
+    constructor(folder: IFolder);
+    readonly id: string;
+    readonly name: string;
+    readonly childNumber: number;
+    section: boolean;
+    readonly children: TreeData[];
+}

package/dist/components/TreeView/utilities/treeview.js

@@ -0,0 +1,177 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+import { FOLDER } from "@edifice.io/ts-client";
+function findTreeNode(root, predicate) {
+  if (predicate(root)) return root;
+  if (Array.isArray(root.children))
+    for (const child of root.children) {
+      const found = findTreeNode(child, predicate);
+      if (found) return found;
+    }
+}
+function findNodeById(data, id) {
+  if (Array.isArray(data))
+    for (const node of data) {
+      const result = findNodeById(node, id);
+      if (result)
+        return result;
+    }
+  else {
+    if (data.id === id) return data;
+    if (data.children)
+      for (const child of data.children) {
+        const result = findNodeById(child, id);
+        if (result)
+          return result;
+      }
+  }
+}
+function addNode(node, {
+  parentId,
+  newFolder
+}) {
+  return modifyNode(node, (node2) => {
+    var _a;
+    if (node2.id === parentId) {
+      const parentAncestors = [...((_a = node2.folder) == null ? void 0 : _a.ancestors) || []], ancestors = arrayUnique([...parentAncestors, node2.id]);
+      return {
+        ...node2,
+        children: [...node2.children || [], new TreeNodeFolderWrapper({
+          ...newFolder,
+          ancestors
+        })]
+      };
+    } else
+      return node2;
+  });
+}
+function arrayUnique(array) {
+  return array.filter((item, index) => array.indexOf(item) === index);
+}
+function deleteNode(node, {
+  folders
+}) {
+  return modifyNode(node, (node2) => {
+    if (!folders.includes(node2.id))
+      return node2;
+  });
+}
+const findParentNode = (parentNode, childId) => {
+  if (parentNode.children)
+    for (const child of parentNode.children) {
+      if (child.id === childId)
+        return parentNode;
+      const foundNode = findParentNode(child, childId);
+      if (foundNode)
+        return foundNode;
+    }
+};
+function getAncestors(data, folderId) {
+  var _a;
+  const findItem = findNodeById(data, folderId);
+  return (_a = findItem == null ? void 0 : findItem.folder) != null && _a.ancestors ? [...(findItem == null ? void 0 : findItem.folder.ancestors) || [], folderId] : folderId === FOLDER.BIN ? [FOLDER.BIN] : [FOLDER.DEFAULT];
+}
+function hasChildren(folderId, data) {
+  return data.id === folderId && data.children ? data.children.length > 0 : data.children ? data.children.some((child) => hasChildren(data.id, child)) : !1;
+}
+function modifyNode(data, callback) {
+  return doModify(data, callback) || data;
+}
+function doModify(current, callback, parent) {
+  var _a;
+  const result = callback(current, parent);
+  if ((_a = result == null ? void 0 : result.children) != null && _a.length) {
+    const children = [];
+    for (const child of (result == null ? void 0 : result.children) || []) {
+      const res = doModify(child, callback, result);
+      res && children.push(res);
+    }
+    return {
+      ...result,
+      children
+    };
+  }
+  return result;
+}
+function moveNode(node, {
+  destinationId,
+  folders
+}) {
+  return modifyNode(node, (node2, parent) => {
+    var _a, _b;
+    if (destinationId === node2.id) {
+      const parentAncestors = [...((_a = node2.folder) == null ? void 0 : _a.ancestors) || []], ancestors = arrayUnique([...parentAncestors, node2.id]), newChildren = [...node2.children || []], childrenIds = ((_b = node2.children) == null ? void 0 : _b.map((child) => child.id)) || [];
+      for (const folder of folders)
+        if (!childrenIds.includes(folder)) {
+          const item = findNodeById(node2, folder);
+          item && newChildren.push({
+            ...item,
+            folder: {
+              ...item == null ? void 0 : item.folder,
+              ancestors
+            }
+          });
+        }
+      return {
+        ...node2,
+        children: newChildren
+      };
+    } else return folders.includes(node2.id) && destinationId !== (parent == null ? void 0 : parent.id) ? void 0 : node2;
+  });
+}
+const wrapTreeNode = (node, folders, parentId) => modifyNode(node, (node2) => (node2.id === parentId && (node2.children = folders == null ? void 0 : folders.map((e) => new TreeNodeFolderWrapper(e))), node2));
+function updateNode(node, {
+  folderId,
+  newFolder
+}) {
+  return modifyNode(node, (node2) => node2.id === folderId ? new TreeNodeFolderWrapper(newFolder) : node2);
+}
+function findPathById(tree, nodeId) {
+  let path = [];
+  function traverse(node, currentPath) {
+    if (node.id === nodeId)
+      return path = currentPath.concat(node.id), !0;
+    if (node.children) {
+      for (const child of node.children)
+        if (traverse(child, currentPath.concat(node.id)))
+          return !0;
+    }
+    return !1;
+  }
+  function startTraverse(nodes) {
+    if (Array.isArray(nodes)) {
+      for (const node of nodes)
+        if (traverse(node, []))
+          break;
+    } else
+      traverse(nodes, []);
+  }
+  return startTraverse(tree), path;
+}
+class TreeNodeFolderWrapper {
+  constructor(folder) {
+    __publicField(this, "id");
+    __publicField(this, "name");
+    __publicField(this, "childNumber");
+    __publicField(this, "section", !1);
+    __publicField(this, "children", []);
+    this.folder = folder, this.id = folder.id, this.name = folder.name, this.childNumber = folder.childNumber;
+  }
+}
+export {
+  TreeNodeFolderWrapper,
+  addNode,
+  arrayUnique,
+  deleteNode,
+  findNodeById,
+  findParentNode,
+  findPathById,
+  findTreeNode,
+  getAncestors,
+  hasChildren,
+  modifyNode,
+  moveNode,
+  updateNode,
+  wrapTreeNode
+};

package/dist/components/index.d.ts

@@ -3,7 +3,6 @@ export * from './Alert';
 export * from './AppHeader';
 export * from './AppIcon';
 export * from './Attachment';
-export * from './Audience';
 export * from './Avatar';
 export * from './Badge';
 export * from './Breadcrumb';
@@ -15,14 +14,14 @@ export * from './Combobox';
 export * from './Dropdown';
 export * from './Dropzone';
 export * from './EmptyScreen';
-export * from './FileCard';
 export * from './Form';
 export * from './Grid';
 export * from './Heading';
 export * from './Image';
-export * from './ImagePicker';
 export * from './Input';
 export * from './Label';
+export * from './Layout';
+export * from './List';
 export * from './Loading';
 export * from './LoadingScreen';
 export * from './Logo';
@@ -37,6 +36,6 @@ export * from './Tabs';
 export * from './TextArea';
 export * from './Toolbar';
 export * from './Tooltip';
+export * from './Tree';
 export * from './TreeView';
-export * from './UploadCard';
 export * from './VisuallyHidden';

package/dist/editor.js

@@ -0,0 +1,58 @@
+import { EditorContent, useEditor } from "@tiptap/react";
+import { default as default2 } from "./modules/editor/components/Editor/Editor.js";
+import { default as default3 } from "./modules/editor/components/BubbleMenuEditImage/BubbleMenuEditImage.js";
+import { default as default4 } from "./modules/editor/components/NodeView/AudioNodeView.js";
+import { default as default5 } from "./modules/editor/components/NodeView/AttachmentNodeView.js";
+import { default as default6 } from "./modules/editor/components/NodeView/ImageNodeView.js";
+import { default as default7 } from "./modules/editor/components/NodeView/LinkerNodeView.js";
+import { default as default8 } from "./modules/editor/components/NodeView/VideoNodeView.js";
+import { default as default9 } from "./modules/editor/components/Renderer/AudioRenderer.js";
+import { default as default10 } from "./modules/editor/components/Renderer/AttachmentRenderer.js";
+import { default as default11 } from "./modules/editor/components/Renderer/LinkerRenderer.js";
+import { default as default12 } from "./modules/editor/components/Renderer/MediaRenderer.js";
+import { default as default13 } from "./modules/editor/components/Toolbar/TableToolbar.js";
+import { default as default14 } from "./modules/editor/components/Toolbar/LinkToolbar.js";
+import { EditorToolbar } from "./modules/editor/components/EditorToolbar/EditorToolbar.js";
+import { useActionOptions } from "./modules/editor/hooks/useActionOptions.js";
+import { useCommentEditor } from "./modules/editor/hooks/useCommentEditor.js";
+import { EditorContext, useEditorContext } from "./modules/editor/hooks/useEditorContext.js";
+import { useImageModal } from "./modules/editor/hooks/useImageModal.js";
+import { useImageSelection } from "./modules/editor/hooks/useImageSelection.js";
+import { useLinkToolbar } from "./modules/editor/hooks/useLinkToolbar.js";
+import { useMathsModal } from "./modules/editor/hooks/useMathsModal.js";
+import { useMediaLibraryEditor } from "./modules/editor/hooks/useMediaLibraryEditor.js";
+import { useResizeMedia } from "./modules/editor/hooks/useResizeMedia.js";
+import { useSpeechRecognition } from "./modules/editor/hooks/useSpeechRecognition.js";
+import { useSpeechSynthetisis } from "./modules/editor/hooks/useSpeechSynthetisis.js";
+import { useTipTapEditor } from "./modules/editor/hooks/useTipTapEditor.js";
+export {
+  default5 as AttachmentNodeView,
+  default10 as AttachmentRenderer,
+  default4 as AudioNodeView,
+  default9 as AudioRenderer,
+  default3 as BubbleMenuEditImage,
+  default2 as Editor,
+  EditorContent,
+  EditorContext,
+  EditorToolbar,
+  default6 as ImageNodeView,
+  default14 as LinkToolbar,
+  default7 as LinkerNodeView,
+  default11 as LinkerRenderer,
+  default12 as MediaRenderer,
+  default13 as TableToolbar,
+  default8 as VideoNodeView,
+  useActionOptions,
+  useCommentEditor,
+  useEditor,
+  useEditorContext,
+  useImageModal,
+  useImageSelection,
+  useLinkToolbar,
+  useMathsModal,
+  useMediaLibraryEditor,
+  useResizeMedia,
+  useSpeechRecognition,
+  useSpeechSynthetisis,
+  useTipTapEditor
+};

package/dist/hooks/index.d.ts

@@ -1,14 +1,40 @@
+export * from './useAvatar';
+export * from './useBookmark';
+export * from './useBreakpoint';
 export * from './useBrowserInfo';
+export * from './useCantoo';
+export * from './useCheckable';
 export * from './useClickOutside';
+export * from './useConf';
+export * from './useConversation';
+export * from './useDate';
 export * from './useDebounce';
+export * from './useDirectory';
 export * from './useDropdown';
 export * from './useDropzone';
-export * from './useDropzone';
-export * from './useToast';
+export * from './useEdificeIcons';
+export * from './useHasWorkflow';
+export * from './useHeader';
 export * from './useHover';
+export * from './useHttpErrorToast';
 export * from './useImage';
+export * from './useIsAdml';
 export * from './useKeyPress';
+export * from './useLibraryUrl';
+export * from './useMediaLibrary';
+export * from './usePaths';
+export * from './useResourceSearch';
 export * from './useScrollToTop';
+export * from './useSession';
 export * from './useTitle';
+export * from './useToast';
 export * from './useToggle';
 export * from './useTrapFocus';
+export * from './useTrashedResource';
+export * from './useUpload';
+export * from './useUploadFiles';
+export * from './useUser';
+export * from './useWorkspaceFile';
+export * from './useWorkspaceSearch';
+export * from './useXitiTrackPageLoad';
+export * from './useZendeskGuide';

package/dist/hooks/useAvatar/useAvatar.d.ts

@@ -0,0 +1,6 @@
+import { ID, UserProfile } from '@edifice.io/ts-client';
+export default function useAvatar(userId: ID, userProfile?: UserProfile[number]): {
+    badge: JSX.Element | null;
+    avatarURL: string;
+    userbookURL: string;
+};

package/dist/hooks/useAvatar/useAvatar.js

@@ -0,0 +1,30 @@
+import { jsx } from "react/jsx-runtime";
+import { odeServices } from "@edifice.io/ts-client";
+import { useMemo } from "react";
+import { useTranslation } from "react-i18next";
+import Badge from "../../components/Badge/Badge.js";
+function useAvatar(userId, userProfile) {
+  const {
+    t
+  } = useTranslation(), badge = useMemo(() => {
+    const profile = (userProfile == null ? void 0 : userProfile.toLowerCase()) ?? "guest";
+    return ["teacher", "student", "relative", "personnel"].includes(profile) ? /* @__PURE__ */ jsx(Badge, { variant: {
+      type: "user",
+      profile
+    }, children: t(profile) }) : null;
+  }, [userProfile, t]);
+  function getAvatarURL(userId2) {
+    return odeServices.directory().getAvatarUrl(userId2, "user");
+  }
+  function getUserbookURL(userId2) {
+    return odeServices.directory().getDirectoryUrl(userId2, "user");
+  }
+  return {
+    badge,
+    avatarURL: getAvatarURL(userId),
+    userbookURL: getUserbookURL(userId)
+  };
+}
+export {
+  useAvatar as default
+};

package/dist/hooks/useBookmark/useBookmark.d.ts

@@ -0,0 +1,2 @@
+import { IWebApp } from '@edifice.io/ts-client';
+export default function useBookmark(): IWebApp[] | undefined;

package/dist/hooks/useBookmark/useBookmark.js

@@ -0,0 +1,14 @@
+import { useEdificeClient } from "../../providers/EdificeClientProvider/EdificeClientProvider.hook.js";
+function useBookmark() {
+  var _a;
+  const {
+    sessionQuery
+  } = useEdificeClient(), set = /* @__PURE__ */ new Set();
+  return (_a = sessionQuery == null ? void 0 : sessionQuery.data) == null ? void 0 : _a.bookmarkedApps.filter((el) => {
+    const duplicate = set.has(el.displayName);
+    return set.add(el.displayName), !duplicate;
+  });
+}
+export {
+  useBookmark as default
+};

package/dist/hooks/useBreakpoint/index.d.ts

@@ -0,0 +1 @@
+export { default as useBreakpoint } from './useBreakpoint';

package/dist/hooks/useBreakpoint/useBreakpoint.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Hook based on Bootstrap 5.x breakpoints
+ * Respect mobile-first breakpoints
+ * @returns $grid-breakpoints: (
+  xs: 0,
+  sm: 375px,
+  md: 768px,
+  lg: 1024px,
+  xl: 1280px,
+  xxl: 1400px,
+) !default;
+ */
+export default function useBreakpoint(): {
+    xs: boolean;
+    sm: boolean;
+    md: boolean;
+    lg: boolean;
+    xl: boolean;
+    xxl: boolean;
+};

package/dist/hooks/useBreakpoint/useBreakpoint.js

@@ -0,0 +1,14 @@
+import { useMediaQuery } from "@uidotdev/usehooks";
+function useBreakpoint() {
+  return {
+    xs: useMediaQuery("only screen and (min-width: 0)"),
+    sm: useMediaQuery("only screen and (min-width: 375px)"),
+    md: useMediaQuery("only screen and (min-width: 768px)"),
+    lg: useMediaQuery("only screen and (min-width: 1024px)"),
+    xl: useMediaQuery("only screen and (min-width: 1280px)"),
+    xxl: useMediaQuery("only screen and (min-width: 1400px)")
+  };
+}
+export {
+  useBreakpoint as default
+};

package/dist/hooks/useCantoo/useCantoo.js

@@ -0,0 +1,18 @@
+import { useEffect } from "react";
+import { odeServices } from "@edifice.io/ts-client";
+import useHasWorkflow from "../useHasWorkflow/useHasWorkflow.js";
+function useCantoo() {
+  const hasWorkflow = useHasWorkflow("org.entcore.portal.controllers.PortalController|optionalFeatureCantoo");
+  return useEffect(() => {
+    hasWorkflow && !document.getElementById("cantoo-edifice-script") && (async () => {
+      const cantooResponse = await odeServices.http().get("/optionalFeature/cantoo");
+      if (cantooResponse && cantooResponse.scriptPath) {
+        const script = document.createElement("script");
+        script.id = "cantoo-edifice-script", script.src = cantooResponse.scriptPath, script.async = !0, document.body.appendChild(script);
+      }
+    })();
+  }, [hasWorkflow]), null;
+}
+export {
+  useCantoo as default
+};

package/dist/hooks/useCheckable/index.d.ts

@@ -0,0 +1 @@
+export * from './useCheckable';

package/dist/hooks/useCheckable/useCheckable.d.ts

@@ -0,0 +1,9 @@
+export declare const useCheckable: <T extends {
+    _id: string;
+}>(data: T[] | undefined) => {
+    selectedItems: string[];
+    allItemsSelected: boolean;
+    isIndeterminate: boolean;
+    handleOnSelectAllItems: (deselect: boolean) => void;
+    handleOnSelectItem: (itemId: string) => void;
+};

package/dist/hooks/useCheckable/useCheckable.js

@@ -0,0 +1,21 @@
+import { useState } from "react";
+const useCheckable = (data) => {
+  const [selectedItems, setSelectedItems] = useState([]), handleOnSelectItem = (itemId) => {
+    setSelectedItems((currentSelection) => {
+      const newSelection = [...currentSelection];
+      return newSelection.includes(itemId) ? newSelection.splice(newSelection.indexOf(itemId), 1) : newSelection.push(itemId), newSelection;
+    });
+  }, handleOnSelectAllItems = (deselect) => {
+    setSelectedItems(() => deselect ? [] : (data == null ? void 0 : data.map((item) => item._id)) ?? []);
+  }, allItemsSelected = (selectedItems == null ? void 0 : selectedItems.length) === (data == null ? void 0 : data.length), isIndeterminate = data ? (selectedItems == null ? void 0 : selectedItems.length) > 0 && (selectedItems == null ? void 0 : selectedItems.length) < (data == null ? void 0 : data.length) : !1;
+  return {
+    selectedItems,
+    allItemsSelected,
+    isIndeterminate,
+    handleOnSelectAllItems,
+    handleOnSelectItem
+  };
+};
+export {
+  useCheckable
+};

package/dist/hooks/useClickOutside/useClickOutside.d.ts

@@ -1,2 +1 @@
-/// <reference types="react" />
 export default function useClickOutside<T extends HTMLElement = any>(handler: () => void, events?: string[] | null, nodes?: Array<HTMLElement | null>): import('react').MutableRefObject<T | undefined>;

package/dist/hooks/useConf/useConf.d.ts

@@ -0,0 +1,4 @@
+import { App } from '@edifice.io/ts-client';
+export default function useConf({ appCode }: {
+    appCode: App;
+}): QueryObserverResult<TData, TError>;

package/dist/hooks/useConf/useConf.js

@@ -0,0 +1,13 @@
+import { odeServices } from "@edifice.io/ts-client";
+import { useQuery } from "@tanstack/react-query";
+function useConf({
+  appCode
+}) {
+  return useQuery({
+    queryKey: ["conf"],
+    queryFn: async () => await odeServices.conf().getConf(appCode)
+  });
+}
+export {
+  useConf as default
+};