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

package/dist/hooks/useConversation/useConversation.js

@@ -0,0 +1,43 @@
+import { useState, useEffect } from "react";
+import { odeServices } from "@edifice.io/ts-client";
+import useHasWorkflow from "../useHasWorkflow/useHasWorkflow.js";
+const useConversation = () => {
+  const zimbraWorkflow = useHasWorkflow("fr.openent.zimbra.controllers.ZimbraController|view"), zimbraPreauth = useHasWorkflow("fr.openent.zimbra.controllers.ZimbraController|preauth"), [messages, setMessages] = useState(0), [msgLink, setMsgLink] = useState(""), queryParams = {
+    unread: !0,
+    _: (/* @__PURE__ */ new Date()).getTime()
+  }, refreshMails = async () => {
+    const url = zimbraWorkflow ? "/zimbra/count/INBOX" : "/conversation/count/INBOX";
+    try {
+      const {
+        count
+      } = await odeServices.http().get(url, {
+        queryParams
+      });
+      setMessages(count ?? 0);
+    } catch (error) {
+      console.error(error), setMessages(0);
+    }
+  }, goToMessagerie = async () => {
+    const defaultLink = "/zimbra/zimbra";
+    try {
+      const {
+        preference
+      } = await odeServices.http().get("/userbook/preference/zimbra"), isExpertMode = preference ? JSON.parse(preference).modeExpert : !1;
+      setMsgLink(isExpertMode && zimbraPreauth ? "/zimbra/preauth" : window.location.origin + defaultLink);
+    } catch (error) {
+      console.error(error), setMsgLink(window.location.origin + defaultLink);
+    }
+  };
+  return useEffect(() => {
+    refreshMails();
+  }, []), useEffect(() => {
+    goToMessagerie();
+  }, []), {
+    messages,
+    msgLink,
+    zimbraWorkflow
+  };
+};
+export {
+  useConversation as default
+};

package/dist/hooks/useDate/useDate.d.ts

@@ -0,0 +1,14 @@
+export type MongoDate = {
+    $date: number | string;
+};
+export type IsoDate = string;
+export type NumberDate = number;
+/** Date formats we are going to deal with. */
+export type CoreDate = IsoDate | MongoDate | NumberDate;
+/**
+ * Hook to compute user-friendly dates from various format.
+ */
+export default function useDate(): {
+    fromNow: (date: CoreDate | NumberDate) => string;
+    formatDate: (date: CoreDate, format?: string) => string;
+};

package/dist/hooks/useDate/useDate.js

@@ -0,0 +1,65 @@
+import { useCallback } from "react";
+import dayjs from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat.js";
+import localizedFormat from "dayjs/plugin/localizedFormat.js";
+import relativeTime from "dayjs/plugin/relativeTime.js";
+import "dayjs/locale/de.js";
+import "dayjs/locale/es.js";
+import "dayjs/locale/fr.js";
+import "dayjs/locale/it.js";
+import "dayjs/locale/pt.js";
+import { useEdificeClient } from "../../providers/EdificeClientProvider/EdificeClientProvider.hook.js";
+dayjs.extend(relativeTime);
+dayjs.extend(customParseFormat);
+dayjs.extend(localizedFormat);
+function useDate() {
+  const {
+    currentLanguage
+  } = useEdificeClient(), parseDate = useCallback((date, lang) => {
+    if (date.length < 11) return dayjs(date, ["YYYY-MM-DD"], lang);
+    if (date.split("").findIndex((char) => "0" > char || char > "9") < 0)
+      return dayjs(Number.parseInt(date)).locale(currentLanguage);
+    {
+      let day = dayjs(date).locale(currentLanguage);
+      return day.isValid() || (day = dayjs(date, ["YYYY-MM-DD HH:mm:ss.SSS"]).locale(currentLanguage)), day;
+    }
+  }, [currentLanguage]), fromNow = useCallback((date) => {
+    let computedDate = dayjs();
+    try {
+      return typeof date > "u" ? "" : (typeof date == "string" ? computedDate = parseDate(date) : typeof date == "number" ? computedDate = dayjs(date).locale(currentLanguage) : typeof date.$date == "number" ? computedDate = dayjs(new Date(date.$date)).locale(currentLanguage) : typeof date.$date == "string" && (computedDate = parseDate(date.$date)), computedDate.isValid() ? computedDate.fromNow() : "");
+    } catch {
+      return "";
+    }
+  }, [currentLanguage, parseDate]), formatDate = useCallback((date, format = "short") => {
+    let computedDate = dayjs();
+    try {
+      if (typeof date > "u")
+        return "";
+      typeof date == "string" ? computedDate = parseDate(date) : typeof date == "number" ? computedDate = dayjs(date).locale(currentLanguage) : typeof date.$date == "number" ? computedDate = dayjs(new Date(date.$date)).locale(currentLanguage) : typeof date.$date == "string" && (computedDate = parseDate(date.$date));
+      let dayjsFormat = "";
+      switch (format) {
+        case "short":
+          dayjsFormat = "L";
+          break;
+        case "long":
+          dayjsFormat = "LL";
+          break;
+        case "abbr":
+          dayjsFormat = "ll";
+          break;
+        default:
+          dayjsFormat = format;
+      }
+      return computedDate.isValid() ? computedDate.locale(currentLanguage).format(dayjsFormat) : "";
+    } catch {
+      return "";
+    }
+  }, [currentLanguage, parseDate]);
+  return {
+    fromNow,
+    formatDate
+  };
+}
+export {
+  useDate as default
+};

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

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

package/dist/hooks/useDirectory/useDirectory.d.ts

@@ -0,0 +1,6 @@
+import { ID } from '@edifice.io/ts-client';
+declare const useDirectory: () => {
+    getAvatarURL: (userId: ID, type: "user" | "group") => string;
+    getUserbookURL: (userId: ID, type: "user" | "group") => string;
+};
+export default useDirectory;

package/dist/hooks/useDirectory/useDirectory.js

@@ -0,0 +1,16 @@
+import { odeServices } from "@edifice.io/ts-client";
+const useDirectory = () => {
+  function getAvatarURL(userId, type) {
+    return odeServices.directory().getAvatarUrl(userId, type);
+  }
+  function getUserbookURL(userId, type) {
+    return odeServices.directory().getDirectoryUrl(userId, type);
+  }
+  return {
+    getAvatarURL,
+    getUserbookURL
+  };
+};
+export {
+  useDirectory as default
+};

package/dist/hooks/useDropdown/useDropdown.d.ts

@@ -1,4 +1,4 @@
-import { MutableRefObject, Dispatch, SetStateAction } from 'react';
+import { Dispatch, MutableRefObject, SetStateAction } from 'react';
 import { Placement } from '@floating-ui/react';
 export declare enum KEYS {
     Enter = "Enter",
@@ -28,5 +28,5 @@ export interface UseDropdownProps {
     itemProps: Record<string, any>;
     setVisible: Dispatch<SetStateAction<boolean>>;
 }
-declare const useDropdown: (placement: Placement | undefined, extraTriggerKeyDownHandler?: ((event: React.KeyboardEvent<HTMLButtonElement>) => void) | undefined, isTriggerHovered?: boolean) => UseDropdownProps;
+declare const useDropdown: (placement: Placement | undefined, extraTriggerKeyDownHandler?: (event: React.KeyboardEvent<HTMLButtonElement>) => void, isTriggerHovered?: boolean) => UseDropdownProps;
 export default useDropdown;

package/dist/hooks/useDropdown/useDropdown.js

@@ -0,0 +1,158 @@
+import { useId, useState, useRef, useEffect, useCallback } from "react";
+import { useFloating, autoUpdate, offset, size, flip, useHover, safePolygon } from "@floating-ui/react";
+import { mergeRefs } from "../../utilities/refs/ref.js";
+const useDropdown = (placement, extraTriggerKeyDownHandler, isTriggerHovered = !1) => {
+  const id = useId(), [visible, setVisible] = useState(!1), [activeIndex, setActiveIndex] = useState(-1), [isFocused, setIsFocused] = useState(null), {
+    refs,
+    floatingStyles,
+    context
+  } = useFloating({
+    placement,
+    open: visible,
+    onOpenChange: setVisible,
+    whileElementsMounted: autoUpdate,
+    middleware: [offset(4), size({
+      apply({
+        rects,
+        elements
+      }) {
+        elements.floating.style.minWidth = `${rects.reference.width}px`;
+      }
+    }), flip({
+      padding: 0
+    })]
+  });
+  useHover(context, {
+    enabled: isTriggerHovered,
+    // Configure the delay for opening and closing separately.
+    delay: {
+      open: 200
+    },
+    handleClose: safePolygon()
+  });
+  const menuRef = useRef(null), triggerRef = useRef(null), itemRefs = useRef({});
+  useEffect(() => {
+    visible ? menuRef.current && (menuRef.current.focus(), setActiveIndex(0)) : (setActiveIndex(-1), itemRefs.current = {});
+  }, [visible]), useEffect(() => {
+    if (activeIndex !== -1) {
+      const currentItem = Object.values(itemRefs.current)[activeIndex];
+      if (currentItem) {
+        const id2 = currentItem.getAttribute("id");
+        setIsFocused(id2), currentItem.focus();
+      }
+    }
+  }, [activeIndex]);
+  const nextItem = () => {
+    const itemCount = Object.values(itemRefs.current).length;
+    setActiveIndex((prevIndex) => (prevIndex + 1) % itemCount);
+  }, previousItem = () => {
+    const itemCount = Object.values(itemRefs.current).length;
+    setActiveIndex((prevIndex) => (prevIndex - 1 + itemCount) % itemCount);
+  }, firstItem = () => {
+    setActiveIndex(0);
+  }, lastItem = () => {
+    const itemCount = Object.values(itemRefs.current).length;
+    setActiveIndex(itemCount - 1);
+  }, openDropdown = useCallback(() => {
+    setVisible(!0);
+  }, []), closeDropdown = useCallback(() => {
+    triggerRef.current && (triggerRef.current.focus({
+      preventScroll: !0
+    }), setVisible(!1));
+  }, []), stopEvents = (flag, event) => {
+    flag && (event.stopPropagation(), event.preventDefault());
+  }, onTriggerKeyDown = useCallback((event) => {
+    let flag = !1;
+    switch (event.code) {
+      case " ":
+      case "Space":
+      case "Enter":
+      case "ArrowDown":
+      case "Down":
+        openDropdown(), flag = !0;
+        break;
+      case "Esc":
+      case "Escape":
+        closeDropdown(), flag = !0;
+        break;
+      case "Up":
+      case "ArrowUp":
+        openDropdown(), flag = !0;
+        break;
+    }
+    extraTriggerKeyDownHandler == null || extraTriggerKeyDownHandler(event), stopEvents(flag, event);
+  }, [closeDropdown, openDropdown]), onMenuItemMouseEnter = (event) => {
+    const index = Object.values(itemRefs.current).findIndex((item) => item.id === event.currentTarget.getAttribute("id"));
+    setActiveIndex(index);
+  }, onMenuItemKeyDown = useCallback((event, onSuccess) => {
+    let flag = !1;
+    if (event.shiftKey)
+      event.key === "Tab" && (closeDropdown(), flag = !0);
+    else {
+      switch (event.code) {
+        case "Escape":
+          closeDropdown();
+          break;
+        case " ":
+        case "Enter":
+          activeIndex !== -1 && (Object.values(itemRefs.current)[activeIndex].getAttribute("role") === "menuitem" && triggerRef.current && (triggerRef.current.focus(), setVisible(!1)), onSuccess == null || onSuccess()), flag = !0;
+          break;
+        case "ArrowDown":
+        case "Down":
+          nextItem(), flag = !0;
+          break;
+        case "ArrowUp":
+        case "Up":
+          previousItem(), flag = !0;
+          break;
+        case "Home":
+          firstItem(), flag = !0;
+          break;
+        case "End":
+          lastItem(), flag = !0;
+          break;
+      }
+      stopEvents(flag, event);
+    }
+  }, [activeIndex, closeDropdown]), onTriggerClick = useCallback((event) => {
+    setVisible(visible !== !0), event.stopPropagation(), event.preventDefault();
+  }, [visible]);
+  return {
+    isFocused,
+    visible,
+    itemRefs,
+    triggerRef,
+    menuRef,
+    /* TriggerProps to spread to any Trigger component */
+    triggerProps: {
+      ref: mergeRefs(triggerRef, refs.setReference),
+      id: `dropdown-toggle-${id}`,
+      "aria-haspopup": "menu",
+      "aria-controls": `dropdown-${id}`,
+      "aria-expanded": !!visible,
+      className: `${visible ? "selected" : ""}`,
+      onClick: onTriggerClick,
+      onKeyDown: onTriggerKeyDown,
+      "aria-activedescendant": isFocused
+    },
+    /* MenuProps to spread to any Menu Component */
+    menuProps: {
+      ref: mergeRefs(menuRef, refs.setFloating),
+      className: "dropdown-menu",
+      "aria-labelledby": `dropdown-toggle-${id}`,
+      style: {
+        ...floatingStyles
+      }
+    },
+    /* ItemProps to spread to any item Component */
+    itemProps: {
+      onMenuItemMouseEnter,
+      onMenuItemClick: closeDropdown,
+      onMenuItemKeyDown
+    },
+    setVisible
+  };
+};
+export {
+  useDropdown as default
+};

package/dist/hooks/useDropzone/useDropzone.d.ts

@@ -13,11 +13,11 @@ declare const useDropzone: (props?: {
     /** Truthy when a drag event is triggered. */
     dragging: boolean;
     /** Callback to attach to your drop zone (any HTMLElement). */
-    handleDragging: <T extends HTMLElement>(event: import('react').DragEvent<T>) => void;
+    handleDragging: <T extends HTMLElement>(event: React.DragEvent<T>) => void;
     /** Callback to attach to your drop zone (any HTMLElement). */
-    handleDragLeave: <T_1 extends HTMLElement>(event: import('react').DragEvent<T_1>) => void;
+    handleDragLeave: <T extends HTMLElement>(event: React.DragEvent<T>) => void;
     /** Callback to attach to your drop zone (any HTMLElement). */
-    handleDrop: <T_2 extends HTMLElement>(event: import('react').DragEvent<T_2>) => void;
+    handleDrop: <T extends HTMLElement>(event: React.DragEvent<T>) => void;
     /** Replace a file in the `files` list. */
     replaceFileAt: (index: number, file: File) => void;
     /** Remove a file from the `files` list. */

package/dist/hooks/useDropzone/useDropzone.js

@@ -0,0 +1,78 @@
+import { useState, useRef } from "react";
+const useDropzone = (props) => {
+  const [dragging, setDragging] = useState(!1), [files, setFiles] = useState([]), inputRef = useRef(null), addFile = (file) => {
+    addFiles([file]);
+  }, deleteFile = (file) => {
+    setFiles((prevFiles) => prevFiles.filter((prevFile) => prevFile.name !== file.name));
+  }, replaceFileAt = (index, file) => {
+    setFiles((prevFiles) => {
+      if (0 <= index && index < prevFiles.length) {
+        const firstPart = prevFiles.slice(0, index), lastPart = index === prevFiles.length - 1 ? [] : prevFiles.slice(index + 1);
+        return [...firstPart, file, ...lastPart];
+      }
+      return prevFiles;
+    });
+  }, applyInputFiltersOn = (files2) => {
+    var _a;
+    let filteredFiles = files2;
+    if ((_a = inputRef.current) != null && _a.accept) {
+      const filters = inputRef.current.accept.split(",").map((filter) => filter.trim().toLowerCase()), extensions = filters.filter((filter) => filter.startsWith(".")), mimes = filters.filter((filter) => !filter.startsWith(".")).map((mime) => mime.replace("*", ""));
+      filteredFiles = [], files2.forEach((file) => {
+        const fileName = file.name.toLowerCase();
+        (extensions.some((extension) => fileName.endsWith(extension)) || mimes.some((mime) => file.type.includes(mime))) && filteredFiles.push(file);
+      });
+    }
+    return filteredFiles;
+  }, addFiles = (files2) => {
+    let filesToAdd = files2.map((file) => (
+      // #WB-3377: Remove special characters from the file name. (it can cause issues with vertx which replace it or remove it)
+      new File([file], file.name.replace(/[!:,;="']/g, ""), {
+        type: file.type
+      })
+    ));
+    props != null && props.forceFilters ? (filesToAdd = applyInputFiltersOn(filesToAdd), filesToAdd && filesToAdd.length && setFiles((prevFiles) => [...prevFiles, ...filesToAdd])) : setFiles((prevFiles) => [...prevFiles, ...files2]);
+  }, cleanFiles = () => {
+    setFiles([]);
+  }, handleOnChange = (event) => {
+    const files2 = event.target.files;
+    files2 && addFiles([...files2]);
+  }, handleDragging = (event) => {
+    event.preventDefault(), event.stopPropagation(), setDragging(!0);
+  }, handleDragLeave = (event) => {
+    event.preventDefault(), event.stopPropagation(), setDragging(!1);
+  };
+  return {
+    /** Reference to an `input[type=file]` HTMLElement, null at first. */
+    inputRef,
+    /** Read-only list of File·s  managed by this hook. */
+    files,
+    /** Truthy when a drag event is triggered. */
+    dragging,
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    handleDragging,
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    handleDragLeave,
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    handleDrop: (event) => {
+      var _a;
+      handleDragLeave(event);
+      const files2 = (_a = event.dataTransfer) == null ? void 0 : _a.files;
+      files2 && (addFiles([...files2]), inputRef != null && inputRef.current && (inputRef.current.files = files2));
+    },
+    /** Replace a file in the `files` list. */
+    replaceFileAt,
+    /** Remove a file from the `files` list. */
+    deleteFile,
+    /** Add a file to the `files` list. */
+    addFile,
+    /** Add many files to the `files` list. */
+    addFiles,
+    /** Empty the `files` list. */
+    cleanFiles,
+    /** Callback to attach to your `input[type=file]` HTMLElement. */
+    handleOnChange
+  };
+};
+export {
+  useDropzone as default
+};

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

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

package/dist/hooks/useEdificeIcons/useEdificeIcons.d.ts

@@ -0,0 +1,9 @@
+import { IWebApp, IWidget } from '@edifice.io/ts-client';
+export default function useEdificeIcons(): {
+    getIconClass: (app: IWebApp | string) => string;
+    getBackgroundIconClass: (app: IWebApp | string) => string;
+    getBackgroundLightIconClass: (app: IWebApp | string) => string;
+    getIconCode: (app: IWebApp | string | undefined) => string;
+    getWidgetIconClass: (widget: IWidget) => string;
+    isIconUrl: (icon: string) => string | boolean;
+};

package/dist/hooks/useEdificeIcons/useEdificeIcons.js

@@ -0,0 +1,92 @@
+function useEdificeIcons() {
+  const iconOfWidget = {
+    "last-infos-widget": "ic-widget-actualites",
+    birthday: "ic-star",
+    "calendar-widget": "ic-widget-calendar",
+    "carnet-de-bord": "ic-widget-carnet-de-bord",
+    "record-me": "ic-widget-microphone",
+    mood: "ic-star",
+    "my-apps": "ic-widget-apps",
+    notes: "ic-widget-notes",
+    "rss-widget": "ic-widget-rss",
+    "bookmark-widget": "ic-widget-signets",
+    qwant: "ic-widget-qwant",
+    "qwant-junior": "ic-widget-qwant",
+    "agenda-widget": "ic-widget-agenda",
+    "cursus-widget": "ic-widget-aide-devoirs",
+    "maxicours-widget": "ic-widget-maxicours",
+    "school-widget": "ic-widget-schoolbook",
+    "universalis-widget": "ic-widget-universalis",
+    "briefme-widget": "ic-widget-briefme"
+  };
+  function getIconCode(app) {
+    let appCode = "";
+    switch (typeof app == "string" ? appCode = app : appCode = (app == null ? void 0 : app.icon) !== void 0 ? app == null ? void 0 : app.icon.trim().toLowerCase() : "placeholder", appCode && appCode.length > 0 ? appCode.endsWith("-large") && (appCode = appCode.replace("-large", "")) : typeof app == "object" && (appCode = (app == null ? void 0 : app.displayName) !== void 0 ? app == null ? void 0 : app.displayName.trim().toLowerCase() : ""), appCode) {
+      case "admin.title":
+        appCode = "admin";
+        break;
+      case "banques des savoirs":
+        appCode = "banquesavoir";
+        break;
+      case "collaborativewall":
+        appCode = "collaborative-wall";
+        break;
+      case "communautés":
+        appCode = "community";
+        break;
+      case "directory.user":
+        appCode = "userbook";
+        break;
+      case "emploi du temps":
+        appCode = "edt";
+        break;
+      case "formulaire":
+        appCode = "forms";
+        break;
+      case "messagerie":
+        appCode = "conversation";
+        break;
+      case "news":
+        appCode = "actualites";
+        break;
+      case "homeworks":
+      case "cahier de texte":
+        appCode = "cahier-de-texte";
+        break;
+      case "diary":
+      case "cahier de texte 2d":
+        appCode = "cahier-textes";
+        break;
+    }
+    return appCode;
+  }
+  function isIconUrl(icon) {
+    return icon && (icon.startsWith("/") || icon.startsWith("http://") || icon.startsWith("https://"));
+  }
+  function getIconClass(app) {
+    const appCode = getIconCode(app);
+    return appCode ? `color-app-${appCode}` : "color-app-placeholder";
+  }
+  function getBackgroundIconClass(app) {
+    const appCode = getIconCode(app);
+    return appCode ? `bg-app-${appCode}` : "bg-app-placeholder";
+  }
+  function getBackgroundLightIconClass(app) {
+    const appCode = getIconCode(app);
+    return appCode ? `bg-light-${appCode}` : "bg-light-placeholder";
+  }
+  function getWidgetIconClass(widget) {
+    return iconOfWidget[widget.platformConf.name];
+  }
+  return {
+    getIconClass,
+    getBackgroundIconClass,
+    getBackgroundLightIconClass,
+    getIconCode,
+    getWidgetIconClass,
+    isIconUrl
+  };
+}
+export {
+  useEdificeIcons as default
+};

package/dist/hooks/useHasWorkflow/useHasWorkflow.js

@@ -0,0 +1,22 @@
+import { useState, useEffect } from "react";
+import { odeServices } from "@edifice.io/ts-client";
+import { useMockedData } from "../../providers/MockedDataProvider/MockedDataProvider.js";
+function useHasWorkflow(workflow) {
+  const mock = useMockedData(), [state, setState] = useState();
+  return useEffect(() => {
+    (async () => {
+      let response;
+      if (mock != null && mock.hasWorkflow)
+        if (typeof workflow == "string")
+          response = await mock.hasWorkflow(workflow);
+        else
+          throw "not.implemented.yet)";
+      else
+        typeof workflow == "string" ? response = await odeServices.rights().sessionHasWorkflowRight(workflow) : response = await odeServices.rights().sessionHasWorkflowRights(workflow);
+      setState(response);
+    })();
+  }, [workflow, mock]), state;
+}
+export {
+  useHasWorkflow as default
+};

package/dist/hooks/useHeader/useHeader.d.ts

@@ -0,0 +1,5 @@
+import { IUserInfo } from '@edifice.io/ts-client';
+export default function useHeader({ user, avatar, }: {
+    user: IUserInfo | undefined;
+    avatar: string;
+}): any;

package/dist/hooks/useHeader/useHeader.js

@@ -0,0 +1,46 @@
+import { useState, useId, useCallback, useMemo } from "react";
+import { odeServices } from "@edifice.io/ts-client";
+import { useTranslation } from "react-i18next";
+import { useEdificeClient } from "../../providers/EdificeClientProvider/EdificeClientProvider.hook.js";
+import { useEdificeTheme } from "../../providers/EdificeThemeProvider/EdificeThemeProvider.hook.js";
+import useHover from "../useHover/useHover.js";
+import useBookmark from "../useBookmark/useBookmark.js";
+import useHasWorkflow from "../useHasWorkflow/useHasWorkflow.js";
+function useHeader({
+  user,
+  avatar
+}) {
+  const {
+    appCode
+  } = useEdificeClient(), {
+    t
+  } = useTranslation(), {
+    theme
+  } = useEdificeTheme(), title = t(appCode), [isCollapsed, setIsCollapsed] = useState(!0), [appsRef, isAppsHovered] = useHover(), popoverAppsId = useId(), popoverSearchId = useId(), userAvatar = avatar, userName = user == null ? void 0 : user.username, welcomeUser = t("welcome", {
+    username: user == null ? void 0 : user.firstName
+  }), bookmarkedApps = useBookmark(), communityWorkflow = useHasWorkflow("net.atos.entng.community.controllers.CommunityController|view"), conversationWorflow = useHasWorkflow("org.entcore.conversation.controllers.ConversationController|view"), searchWorkflow = useHasWorkflow("fr.openent.searchengine.controllers.SearchEngineController|view"), toggleCollapsedNav = useCallback(() => {
+    setIsCollapsed(!isCollapsed);
+  }, [isCollapsed]), handleLogout = async () => {
+    await odeServices.session().logout(), window.location.href = (theme == null ? void 0 : theme.logoutCallback) ?? "/auth/login";
+  };
+  return useMemo(() => ({
+    title,
+    bookmarkedApps,
+    appsRef,
+    isAppsHovered,
+    popoverAppsId,
+    popoverSearchId,
+    userAvatar,
+    userName,
+    welcomeUser,
+    communityWorkflow,
+    conversationWorflow,
+    searchWorkflow,
+    isCollapsed,
+    toggleCollapsedNav,
+    handleLogout
+  }), [appsRef, bookmarkedApps, communityWorkflow, conversationWorflow, isAppsHovered, isCollapsed, popoverAppsId, popoverSearchId, searchWorkflow, title, toggleCollapsedNav, userAvatar, userName, welcomeUser]);
+}
+export {
+  useHeader as default
+};

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

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

package/dist/hooks/useHttpErrorToast/useHttpErrorToast.d.ts

@@ -0,0 +1,3 @@
+import { CustomToastOptions } from '../../hooks/useToast/useToast';
+declare const useHttpErrorToast: (options?: CustomToastOptions) => string | undefined;
+export default useHttpErrorToast;

package/dist/hooks/useHttpErrorToast/useHttpErrorToast.js

@@ -0,0 +1,21 @@
+import React, { useRef, useEffect } from "react";
+import { odeServices, LAYER_NAME } from "@edifice.io/ts-client";
+import { useTranslation } from "react-i18next";
+import useToast from "../useToast/useToast.js";
+const useHttpErrorToast = (options) => {
+  const message = useRef(), toast = useToast(), {
+    t
+  } = useTranslation();
+  return useEffect(() => {
+    const subscription = odeServices.notify().events().subscribe(LAYER_NAME.TRANSPORT, (event) => {
+      var _a, _b;
+      message.current = t(((_b = (_a = event == null ? void 0 : event.data) == null ? void 0 : _a.payload) == null ? void 0 : _b.error) || event.data.response.statusText), toast.error(/* @__PURE__ */ React.createElement("div", {
+        children: [message.current]
+      }), options);
+    });
+    return () => subscription.revoke();
+  }, [t, toast]), message.current;
+};
+export {
+  useHttpErrorToast as default
+};

package/dist/hooks/useIsAdml/useIsAdml.js

@@ -0,0 +1,18 @@
+import { useState, useEffect, useCallback } from "react";
+import { odeServices } from "@edifice.io/ts-client";
+function useIsAdml() {
+  const [isAdml, setIsAdml] = useState(!1);
+  useEffect(() => {
+    initIsAdml();
+  }, []);
+  const initIsAdml = useCallback(async () => {
+    const isAdmlRes = await odeServices.session().isAdml();
+    setIsAdml(isAdmlRes);
+  }, []);
+  return {
+    isAdml
+  };
+}
+export {
+  useIsAdml as default
+};