@edifice.io/react 1.7.4-develop-pedago.20241211160712

package/dist/hooks/useCookiesConsent/useCookiesConsent.js

@@ -0,0 +1,29 @@
+import { useState, useEffect } from "react";
+import usePreferences from "../usePreferences/usePreferences.js";
+function useCookiesConsent() {
+  const [showCookiesConsent, setShowCookiesConsent] = useState(!1), {
+    getPreference,
+    savePreference
+  } = usePreferences("rgpdCookies");
+  return useEffect(() => {
+    (async () => {
+      const res = await getPreference();
+      setShowCookiesConsent(res === null ? !0 : res.showInfoTip);
+    })();
+  }, []), {
+    showCookiesConsent,
+    handleConsultCookies: () => {
+      document.location.href = "/userbook/mon-compte", savePreference({
+        showInfoTip: !1
+      }), setShowCookiesConsent(!1);
+    },
+    handleCloseCookiesConsent: () => {
+      savePreference({
+        showInfoTip: !1
+      }), setShowCookiesConsent(!1);
+    }
+  };
+}
+export {
+  useCookiesConsent as default
+};

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

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

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 (error) {
+      return console.error(error), "";
+    }
+  }, [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 (error) {
+      return console.error(error), "";
+    }
+  }, [currentLanguage, parseDate]);
+  return {
+    fromNow,
+    formatDate
+  };
+}
+export {
+  useDate as default
+};

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

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

package/dist/hooks/useDebounce/useDebounce.d.ts

@@ -0,0 +1,2 @@
+declare function useDebounce<T>(value: T, delay?: number): T;
+export default useDebounce;

package/dist/hooks/useDebounce/useDebounce.js

@@ -0,0 +1,15 @@
+import { useState, useEffect } from "react";
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  return useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay || 500);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]), debouncedValue;
+}
+export {
+  useDebounce 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/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/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/index.d.ts

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

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

@@ -0,0 +1,32 @@
+import { Dispatch, MutableRefObject, SetStateAction } from 'react';
+import { Placement } from '@floating-ui/react';
+export declare enum KEYS {
+    Enter = "Enter",
+    Space = "Space",
+    ArrowDown = "ArrowDown",
+    ArrowUp = "ArrowUp",
+    Down = "Down",
+    Up = "Up",
+    Tab = "Tab",
+    Esc = "Esc",
+    Escape = "Escape",
+    Home = "Home",
+    End = "End",
+    PageUp = "PageUp",
+    PageDown = "PageDown"
+}
+export interface UseDropdownProps {
+    isFocused: string | null;
+    visible: boolean;
+    itemRefs: MutableRefObject<{
+        [key: string]: HTMLElement | null;
+    }>;
+    triggerRef: MutableRefObject<HTMLButtonElement | null>;
+    menuRef: MutableRefObject<HTMLUListElement | null>;
+    triggerProps: Record<string, any>;
+    menuProps: Record<string, any>;
+    itemProps: Record<string, any>;
+    setVisible: Dispatch<SetStateAction<boolean>>;
+}
+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/index.d.ts

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

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

@@ -0,0 +1,34 @@
+import { ChangeEvent } from 'react';
+declare const useDropzone: (props?: {
+    /**
+     * Truthy when the `accept` attribute of the referenced `input[type=file]`
+     * must be force-checked against any added file.
+     */
+    forceFilters: boolean;
+}) => {
+    /** Reference to an `input[type=file]` HTMLElement, null at first. */
+    inputRef: import('react').MutableRefObject<HTMLInputElement | null>;
+    /** Read-only list of File·s  managed by this hook. */
+    files: File[];
+    /** Truthy when a drag event is triggered. */
+    dragging: boolean;
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    handleDragging: <T extends HTMLElement>(event: React.DragEvent<T>) => void;
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    handleDragLeave: <T extends HTMLElement>(event: React.DragEvent<T>) => void;
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    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. */
+    deleteFile: (file: File) => void;
+    /** Add a file to the `files` list. */
+    addFile: (file: File) => void;
+    /** Add many files to the `files` list. */
+    addFiles: (files: File[]) => void;
+    /** Empty the `files` list. */
+    cleanFiles: () => void;
+    /** Callback to attach to your `input[type=file]` HTMLElement. */
+    handleOnChange: (event: ChangeEvent<HTMLInputElement>) => void;
+};
+export default useDropzone;

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/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/index.d.ts

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

package/dist/hooks/useHasWorkflow/useHasWorkflow.d.ts

@@ -0,0 +1 @@
+export default function useHasWorkflow(workflow: string | string[]): (boolean | undefined) | Record<string, boolean>;

package/dist/hooks/useHasWorkflow/useHasWorkflow.js

@@ -0,0 +1,22 @@
+import { useState, useEffect } from "react";
+import { odeServices } from "@edifice.io/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/index.d.ts

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

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

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