@edifice.io/react 2.0.0-develop-rc.13 → 2.0.0-develop-rc.15

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
+};

package/dist/hooks/useLibraryUrl/useLibraryUrl.js

@@ -0,0 +1,21 @@
+import { libraryMaps } from "@edifice.io/utilities";
+import { useEdificeClient } from "../../providers/EdificeClientProvider/EdificeClientProvider.hook.js";
+const useLibraryUrl = () => {
+  var _a;
+  const {
+    user,
+    appCode
+  } = useEdificeClient(), appName = libraryMaps[appCode], libraryApp = user == null ? void 0 : user.apps.find((app) => app.isExternal && app.address.includes("library"));
+  if (!libraryApp)
+    return null;
+  const libraryUrlSplit = (_a = libraryApp.address) == null ? void 0 : _a.split("?");
+  if (!libraryUrlSplit || libraryUrlSplit.length < 2)
+    return null;
+  let libraryHost = libraryUrlSplit[0];
+  libraryHost.endsWith("/") || (libraryHost = `${libraryHost}/`);
+  const platformURLParam = libraryUrlSplit == null ? void 0 : libraryUrlSplit[1], searchParams = `application%5B0%5D=${appName}&page=1&sort_field=views&sort_order=desc`;
+  return `${libraryHost}search/?${platformURLParam}&${searchParams}`;
+};
+export {
+  useLibraryUrl as default
+};

package/dist/hooks/useMediaLibrary/useMediaLibrary.d.ts

@@ -0,0 +1,12 @@
+import { WorkspaceElement } from '@edifice.io/ts-client';
+import { TabsItemProps } from '../../components';
+import { MediaLibraryRef, MediaLibraryResult } from '../../modules/multimedia';
+declare const useMediaLibrary: () => {
+    ref: import('react').RefObject<MediaLibraryRef>;
+    libraryMedia: any;
+    setLibraryMedia: import('react').Dispatch<any>;
+    onCancel: (uploads?: WorkspaceElement[]) => Promise<void>;
+    onSuccess: (result: MediaLibraryResult) => void;
+    onTabChange: (_tab: TabsItemProps, uploads?: WorkspaceElement[]) => Promise<void>;
+};
+export default useMediaLibrary;

package/dist/hooks/useMediaLibrary/useMediaLibrary.js

@@ -0,0 +1,58 @@
+import { useRef, useState } from "react";
+import useWorkspaceFile from "../useWorkspaceFile/useWorkspaceFile.js";
+const useMediaLibrary = () => {
+  const mediaLibraryRef = useRef(null), [libraryMedia, setLibraryMedia] = useState(), {
+    remove
+  } = useWorkspaceFile();
+  return {
+    ref: mediaLibraryRef,
+    libraryMedia,
+    setLibraryMedia,
+    onCancel: async (uploads) => {
+      var _a, _b;
+      (_a = mediaLibraryRef.current) != null && _a.type && uploads && uploads.length > 0 && await remove(uploads), (_b = mediaLibraryRef.current) == null || _b.hide();
+    },
+    onSuccess: (result) => {
+      var _a, _b, _c, _d;
+      let updatedMedia;
+      switch ((_a = mediaLibraryRef.current) == null ? void 0 : _a.type) {
+        case "video": {
+          if (typeof result == "object")
+            updatedMedia = result[0];
+          else {
+            const element = new DOMParser().parseFromString(result, "text/html").body.firstChild, href = element == null ? void 0 : element.getAttribute("src");
+            (_b = mediaLibraryRef.current) == null || _b.hide(), updatedMedia = href;
+          }
+          break;
+        }
+        case "embedder": {
+          const element = new DOMParser().parseFromString(result, "text/html").body.firstChild, href = element == null ? void 0 : element.getAttribute("src");
+          (_c = mediaLibraryRef.current) == null || _c.hide(), updatedMedia = href;
+          break;
+        }
+        case "audio": {
+          result.length === void 0 ? updatedMedia = result : updatedMedia = result[0];
+          break;
+        }
+        case "hyperlink": {
+          updatedMedia = result;
+          break;
+        }
+        case "image": {
+          updatedMedia = `/workspace/document/${result[0]._id}`;
+          break;
+        }
+        default:
+          updatedMedia = result[0];
+      }
+      (_d = mediaLibraryRef.current) == null || _d.hide(), setLibraryMedia(updatedMedia);
+    },
+    onTabChange: async (_tab, uploads) => {
+      var _a;
+      (_a = mediaLibraryRef.current) != null && _a.type && uploads && uploads.length > 0 && await remove(uploads);
+    }
+  };
+};
+export {
+  useMediaLibrary as default
+};

package/dist/hooks/usePaths/usePaths.js

@@ -0,0 +1,7 @@
+function usePaths() {
+  const base = "/", imagePath = `${base}assets/themes/edifice-bootstrap/images`, iconPath = `${base}assets/themes/edifice-bootstrap/icons`, fontPath = `${base}assets/themes/edifice-bootstrap/fonts`;
+  return [imagePath, iconPath, fontPath];
+}
+export {
+  usePaths as default
+};

package/dist/hooks/usePreferences/usePreferences.js

@@ -0,0 +1,10 @@
+import { odeServices } from "@edifice.io/ts-client";
+function usePreferences(name) {
+  return {
+    getPreference: async () => await odeServices.conf().getPreference(name),
+    savePreference: async (value) => await odeServices.conf().savePreference(name, JSON.stringify(value))
+  };
+}
+export {
+  usePreferences as default
+};

package/dist/hooks/useResource/useResource.d.ts

@@ -0,0 +1,3 @@
+import { IResource } from '@edifice.io/ts-client';
+declare const useResource: (application: string, id: string) => IResource;
+export default useResource;

package/dist/hooks/useResource/useResource.js

@@ -0,0 +1,25 @@
+import { useState, useEffect } from "react";
+import { odeServices } from "@edifice.io/ts-client";
+const useResource = (application, id) => {
+  const [resource, setResource] = useState(null);
+  return useEffect(() => {
+    if (id === "") {
+      console.warn("resourceId must be an assetId and not an empty string");
+      return;
+    }
+    (async () => {
+      try {
+        const response = await odeServices.resource(application).searchResource({
+          application,
+          id
+        });
+        setResource(response);
+      } catch (error) {
+        console.error(error);
+      }
+    })();
+  }, []), resource;
+};
+export {
+  useResource as default
+};

package/dist/hooks/useResourceSearch/useResourceSearch.d.ts

@@ -0,0 +1,18 @@
+import { App, GetContextParameters, ILinkedResource } from '@edifice.io/ts-client';
+/**
+ * A hook to search for resources produced by applications.
+ *
+ * @param appCode Currently running application.
+ * @returns An object with 2 fields :
+ *
+ * `resourceApplications: Array<App>`
+ * Resources-producing applications the user can use.
+ *
+ * `loadResources: (filters:GetContextParameters) => Promise<ILinkedResource[]>`
+ * A search method with filters.
+ *
+ */
+export declare const useResourceSearch: (appCode: App) => {
+    resourceApplications: Array<App>;
+    loadResources: (filters: GetContextParameters) => Promise<ILinkedResource[]>;
+};

package/dist/hooks/useResourceSearch/useResourceSearch.js

@@ -0,0 +1,19 @@
+import { useState, useEffect, useCallback } from "react";
+import { SnipletsService, odeServices } from "@edifice.io/ts-client";
+const useResourceSearch = (appCode) => {
+  const [resourceApplications, setResourceApplications] = useState([]);
+  useEffect(() => {
+    (async () => (await SnipletsService.initialize(odeServices, appCode), await SnipletsService.registerBehaviours(appCode), setResourceApplications(SnipletsService.resourceProducingApps)))();
+  }, []);
+  const loadResources = useCallback(async (filters) => {
+    const [resourceType] = filters.types;
+    return await odeServices.behaviour(appCode, resourceType).loadResources(filters);
+  }, [appCode]);
+  return {
+    resourceApplications,
+    loadResources
+  };
+};
+export {
+  useResourceSearch
+};

package/dist/hooks/useSession/useSession.js

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

package/dist/hooks/useToast/useToast.d.ts

@@ -11,7 +11,7 @@ export default function useToast(): {
     error: (message: string | ReactNode, options?: CustomToastOptions) => string;
     info: (message: string | ReactNode, options?: CustomToastOptions) => string;
     warning: (message: string | ReactNode, options?: CustomToastOptions) => string;
-    loading: (message: import('react-hot-toast').Renderable | import('react-hot-toast').ValueFunction<import('react-hot-toast').Renderable, import('react-hot-toast').Toast>, options?: Partial<Pick<import('react-hot-toast').Toast, "style" | "className" | "id" | "icon" | "position" | "duration" | "ariaProps" | "iconTheme">> | undefined) => string;
+    loading: (message: import('react-hot-toast').Renderable | import('react-hot-toast').ValueFunction<import('react-hot-toast').Renderable, import('react-hot-toast').Toast>, options?: import('react-hot-toast').ToastOptions) => string;
     dismiss: (id: string) => void;
     remove: (id: string) => void;
 };

package/dist/hooks/useTrapFocus/useTrapFocus.d.ts

@@ -1,2 +1 @@
-/// <reference types="react" />
 export default function useTrapFocus(): import('react').MutableRefObject<HTMLElement | null>;

package/dist/hooks/useTrashedResource/useTrashedResource.js

@@ -0,0 +1,27 @@
+import { useState, useEffect } from "react";
+import { odeServices } from "@edifice.io/ts-client";
+import { useEdificeClient } from "../../providers/EdificeClientProvider/EdificeClientProvider.hook.js";
+import useUser from "../useUser/useUser.js";
+const useTrashedResource = (id) => {
+  const {
+    appCode
+  } = useEdificeClient(), {
+    user
+  } = useUser(), [trashed, setTrashed] = useState(!1);
+  useEffect(() => {
+    (async () => {
+      var _a, _b;
+      const explorerData = await odeServices.http().get(`/explorer/resources?application=${appCode}&resource_type=${appCode}&asset_id[]=${id}`), resource = (_a = explorerData == null ? void 0 : explorerData.resources) == null ? void 0 : _a.find((resource2) => resource2.assetId === id);
+      (resource != null && resource.trashed || (_b = resource == null ? void 0 : resource.trashedBy) != null && _b.includes(user == null ? void 0 : user.userId)) && setTrashed(!0);
+    })();
+  }, []), useEffect(() => {
+    if (trashed)
+      throw new Response("", {
+        status: 404,
+        statusText: "Not Found"
+      });
+  }, [trashed]);
+};
+export {
+  useTrashedResource as default
+};

package/dist/hooks/useUpload/useUpload.d.ts

@@ -0,0 +1,18 @@
+import { WorkspaceElement, WorkspaceVisibility } from '@edifice.io/ts-client';
+import { Status } from '../../types';
+declare const useUpload: (visibility?: WorkspaceVisibility, application?: string) => {
+    getUploadStatus: (upload: File | Blob) => Status | undefined;
+    setUploadStatus: (blob: File | Blob, status: Status) => void;
+    clearUploadStatus: (blob: File | Blob) => void;
+    uploadFile: (file: File, metadata?: {
+        duration: number;
+    }) => Promise<WorkspaceElement | null>;
+    uploadAlternateFile: (original: File, replacement: File, metadata?: {
+        duration: number;
+    }) => Promise<WorkspaceElement | null>;
+    uploadBlob: (blob: Blob, metadata?: {
+        filename?: string;
+        duration?: number;
+    }) => Promise<WorkspaceElement | null>;
+};
+export default useUpload;

package/dist/hooks/useUpload/useUpload.js

@@ -0,0 +1,106 @@
+import { useState, useCallback } from "react";
+import { ERROR_CODE, odeServices } from "@edifice.io/ts-client";
+import { getOrGenerateBlobId } from "@edifice.io/utilities";
+import useBrowserInfo from "../useBrowserInfo/useBrowserInfo.js";
+import useWorkspaceFile from "../useWorkspaceFile/useWorkspaceFile.js";
+const useUpload = (visibility, application = "media-library") => {
+  const [status, setStatus] = useState({}), {
+    browser,
+    device
+  } = useBrowserInfo(navigator.userAgent), {
+    create
+  } = useWorkspaceFile(), getUploadStatus = useCallback((upload) => status[getOrGenerateBlobId(upload)], [status]), setUploadStatus = (blob, status2) => {
+    setStatus((prevStatus) => {
+      const key = getOrGenerateBlobId(blob);
+      return {
+        ...prevStatus,
+        [key]: status2
+      };
+    });
+  }, clearUploadStatus = (blob) => {
+    setStatus((prevStatus) => {
+      const key = getOrGenerateBlobId(blob), {
+        [key]: unused,
+        ...rest
+      } = prevStatus;
+      return rest;
+    });
+  };
+  async function uploadFile(file, metadata) {
+    setUploadStatus(file, "loading");
+    try {
+      let resource;
+      return application === "media-library" && file.type.includes("video") ? resource = await uploadVideo(file, {
+        filename: file.name,
+        ...metadata
+      }) : resource = await create(file, {
+        application,
+        visibility
+      }), setUploadStatus(file, "success"), resource;
+    } catch {
+      return setUploadStatus(file, "error"), null;
+    }
+  }
+  async function uploadBlob(blob, metadata) {
+    setUploadStatus(blob, "loading");
+    try {
+      let resource;
+      if (blob.type.includes("video"))
+        resource = await uploadVideo(blob, metadata);
+      else
+        throw new Error(ERROR_CODE.NOT_SUPPORTED);
+      return setUploadStatus(blob, "success"), resource;
+    } catch {
+      return setUploadStatus(blob, "error"), null;
+    }
+  }
+  const uploadVideo = async (blob, metadata) => {
+    const params = {
+      data: {
+        device: device.type,
+        browser: {
+          name: browser.name,
+          version: browser.version
+        },
+        url: window.location.hostname,
+        file: blob,
+        filename: (metadata == null ? void 0 : metadata.filename) ?? "filename",
+        weight: blob.size
+      },
+      appCode: application,
+      captation: !(blob instanceof File),
+      duration: (metadata == null ? void 0 : metadata.duration) ?? 0
+    }, uploadResponse = await odeServices.video().upload(params);
+    if (uploadResponse.state === "succeed")
+      return {
+        _id: uploadResponse.videoworkspaceid,
+        file: uploadResponse.videoid,
+        name: params.data.filename,
+        eType: "file",
+        eParent: "",
+        children: [],
+        created: /* @__PURE__ */ new Date(),
+        _shared: [],
+        _isShared: !1,
+        owner: {
+          userId: "",
+          displayName: ""
+        }
+      };
+    throw uploadResponse.state === "error" ? new Error(uploadResponse.code || "Error while uploading video") : new Error("Video encoding is still running");
+  };
+  function uploadAlternateFile(original, replacement, metadata) {
+    return getOrGenerateBlobId(replacement, getOrGenerateBlobId(original)), uploadFile(replacement, metadata);
+  }
+  return {
+    getUploadStatus,
+    setUploadStatus,
+    clearUploadStatus,
+    uploadFile,
+    uploadAlternateFile,
+    uploadBlob
+  };
+};
+export {
+  useUpload as default
+};

package/dist/hooks/useUploadFiles/useUploadFiles.d.ts

@@ -0,0 +1,25 @@
+import { WorkspaceElement, WorkspaceVisibility } from '@edifice.io/ts-client';
+declare const useUploadFiles: ({ handleOnChange, visibility, application, }: {
+    handleOnChange: (uploadedFiles: WorkspaceElement[]) => void;
+    visibility?: WorkspaceVisibility;
+    application?: string;
+}) => {
+    /** List of files added from device */
+    files: File[];
+    getUploadStatus: (upload: File | Blob) => import('../..').Status | undefined;
+    clearUploadStatus: (blob: File | Blob) => void;
+    uploadedFiles: WorkspaceElement[];
+    editingImage: WorkspaceElement | undefined;
+    setEditingImage: import('react').Dispatch<import('react').SetStateAction<WorkspaceElement | undefined>>;
+    getUrl: (resource?: WorkspaceElement, timestamp?: boolean) => string;
+    updateImage: ({ blob, legend, altText: alt, }: {
+        blob: Blob;
+        legend: string;
+        altText: string;
+    }) => Promise<void>;
+    uploadFile: (file: File, metadata?: {
+        duration: number;
+    }) => Promise<WorkspaceElement | null>;
+    removeFile: (file: File) => Promise<void>;
+};
+export default useUploadFiles;