@maas/payload-plugin-media-cloud 0.0.31 → 0.0.33

package/dist/components/{upload-handler/upload-handler.mjs → uploadHandler/uploadHandler.mjs}

@@ -1,17 +1,15 @@
 'use client';
 
 import { MediaCloudErrors, MediaCloudLogs } from "../../types/errors.mjs";
+import { useMagicError } from "../../error-handler/dist/index.mjs";
 import { useErrorHandler } from "../../hooks/useErrorHandler.mjs";
-import { generateUniqueFilename, getFileType, isVideo } from "../../utils/file.mjs";
+import { generateUniqueFilename, getMimeType, isVideo, sanitizeFilename } from "../../utils/file.mjs";
 import { useMediaCloudEmitter } from "../../hooks/useMediaCloudEmitter.mjs";
 import * as upchunk from "@mux/upchunk";
 import * as tus from "tus-js-client";
-import { toast } from "@payloadcms/ui";
 import { createClientUploadHandler } from "@payloadcms/plugin-cloud-storage/client";
 
-//#region src/components/upload-handler/upload-handler.tsx
-const { logError, throwError } = useErrorHandler();
-const emitter = useMediaCloudEmitter();
+//#region src/components/uploadHandler/uploadHandler.tsx
 const MUX_CHUNK_SIZE = 30720;
 const TUS_CHUNK_SIZE = 1024 * 1024;
 const TUS_RETRY_DELAYS = [
@@ -20,6 +18,9 @@ const TUS_RETRY_DELAYS = [
 	2e3,
 	5e3
 ];
+const magicError = useMagicError({ prefix: "PLUGIN-MEDIA-CLOUD" });
+const { throwError } = magicError;
+const emitter = useMediaCloudEmitter();
 /**
 * Handles Mux video upload with progress tracking
 * @param args - The upload arguments including file, server URL, and callbacks
@@ -27,9 +28,10 @@ const TUS_RETRY_DELAYS = [
 */
 async function muxUpload(args) {
 	const { file, serverURL, apiRoute, mimeType } = args;
+	const endpoint = `${serverURL}${apiRoute}`;
 	const filename = file.name;
 	try {
-		const { url, uploadId } = await (await fetch(`${serverURL}${apiRoute}/mux/upload`, {
+		const { url, uploadId } = await (await fetch(`${endpoint}/mux/upload`, {
 			body: JSON.stringify({
 				filename,
 				mimeType
@@ -47,12 +49,11 @@ async function muxUpload(args) {
 			filename,
 			uploadId,
 			polling: false,
-			pollingUrl: `${serverURL}${apiRoute}/mux/asset`
+			pollingUrl: `${endpoint}/mux/asset`
 		});
 		uploader.on("error", function() {
-			logError(MediaCloudErrors.MUX_UPLOAD_ERROR.message);
-			toast.error("Video upload failed");
 			emitter.emit("removeUpload", { uploadId });
+			throwError(MediaCloudErrors.MUX_UPLOAD_ERROR);
 		});
 		uploader.on("progress", function(progress) {
 			emitter.emit("updateUpload", {
@@ -69,9 +70,12 @@ async function muxUpload(args) {
 			mimeType,
 			storage: "mux"
 		};
-	} catch (_error) {
-		logError(MediaCloudErrors.MUX_DIRECT_UPLOAD_ERROR.message);
-		toast.error("Video upload failed");
+	} catch {
+		throwError(MediaCloudErrors.MUX_DIRECT_UPLOAD_ERROR);
+		emitter.emit("uploadError", {
+			filename,
+			error: "Video upload failed"
+		});
 		return null;
 	}
 }
@@ -81,10 +85,11 @@ async function muxUpload(args) {
 * @returns Promise that resolves to upload result or null if upload fails
 */
 async function tusUpload(args) {
-	const { apiRoute, serverURL, file, mimeType } = args;
+	const { apiRoute, serverURL, file, prefix = "", mimeType } = args;
 	const filename = file.name;
 	const filetype = file.type;
 	const filesize = file.size.toString();
+	const endpoint = `${serverURL}${apiRoute}/uploads`;
 	Object.keys(localStorage).filter((key) => key.startsWith("tus::")).forEach((key) => localStorage.removeItem(key));
 	let uploadUrlAvailable = false;
 	let eventListenerAdded = false;
@@ -94,11 +99,11 @@ async function tusUpload(args) {
 	}
 	function onPageUnload() {
 		window.removeEventListener("unload", onPageUnload);
-		navigator.sendBeacon(`${serverURL}${apiRoute}/uploads/cleanup`, JSON.stringify({ filename }));
+		navigator.sendBeacon(`${endpoint}/cleanup`, JSON.stringify({ filename }));
 	}
 	return new Promise((resolve) => {
 		new tus.Upload(file, {
-			endpoint: `${serverURL}${apiRoute}/uploads`,
+			endpoint,
 			retryDelays: TUS_RETRY_DELAYS,
 			chunkSize: TUS_CHUNK_SIZE,
 			storeFingerprintForResuming: false,
@@ -106,16 +111,22 @@ async function tusUpload(args) {
 				filetype,
 				filesize,
 				filename,
+				prefix,
 				contentType: filetype,
 				contentLength: filesize,
 				contentDisposition: "inline"
 			},
 			onError(error) {
-				logError(MediaCloudErrors.TUS_UPLOAD_ERROR.message);
-				logError(error.message);
-				navigator.sendBeacon(`${serverURL}${apiRoute}/uploads/cleanup`, JSON.stringify({ filename }));
+				navigator.sendBeacon(`${endpoint}/cleanup`, JSON.stringify({ filename }));
+				emitter.emit("uploadError", {
+					filename,
+					error: error.message
+				});
 				emitter.emit("removeUpload", { filename });
-				toast.error("File upload failed");
+				throwError({
+					...MediaCloudErrors.TUS_UPLOAD_ERROR,
+					cause: error
+				});
 				resolve(null);
 			},
 			onBeforeRequest() {
@@ -132,11 +143,12 @@ async function tusUpload(args) {
 					progress: percentage
 				});
 			},
-			onSuccess() {
+			async onSuccess() {
 				window.removeEventListener("beforeunload", onBeforeUnload);
 				window.removeEventListener("unload", onPageUnload);
 				emitter.emit("uploadComplete", { filename });
-				fetch(`${serverURL}${apiRoute}/uploads/${filename}/process`);
+				await fetch(`${endpoint}/${filename}/process`);
+				await fetch(`${endpoint}/${filename}/folder`);
 			},
 			onUploadUrlAvailable: async function() {
 				if (uploadUrlAvailable) return;
@@ -152,42 +164,60 @@ async function tusUpload(args) {
 	});
 }
 const { log } = useErrorHandler();
-const UploadHandler = createClientUploadHandler({ handler: async function(args) {
-	const { serverURL, apiRoute, file, updateFilename } = args;
-	try {
-		const mimeType = await getFileType(file) || file.type || "application/octet-stream";
-		if (!mimeType) {
-			throwError(MediaCloudErrors.FILE_TYPE_UNKNOWN);
+function UploadHandler(props) {
+	return createClientUploadHandler({ handler: async function(args) {
+		const { serverURL, apiRoute, file, prefix, updateFilename, extra } = args;
+		const { pluginOptions } = extra;
+		const mimeType = await getMimeType(file);
+		magicError.assert(mimeType, MediaCloudErrors.FILE_TYPE_UNKNOWN);
+		if (!(pluginOptions.limits?.mimeTypes ?? []).some((allowed) => allowed.endsWith("/*") ? mimeType?.startsWith(allowed.replace("/*", "/")) : mimeType === allowed)) {
+			throwError(MediaCloudErrors.FILE_TYPE_NOT_ALLOWED);
+			return null;
+		}
+		if (file.size > (pluginOptions.limits?.fileSize ?? Infinity)) {
+			throwError(MediaCloudErrors.FILE_SIZE_EXCEEDED);
 			return null;
 		}
-		const isVideoFile = await isVideo(file);
 		let mappedFile = file;
-		if (!isVideoFile) try {
-			if ((await fetch(`${serverURL}${apiRoute}/uploads/${file.name}/exists`).catch(() => {}))?.status === 200) {
-				log(MediaCloudLogs.S3_STORE_FILE_FOUND);
-				const newFilename = generateUniqueFilename(file.name);
-				mappedFile = new File([file], newFilename, { type: file.type });
-				await updateFilename(newFilename);
+		try {
+			const endpoint = `${serverURL}${apiRoute}/uploads`;
+			const response = await fetch(`${endpoint}/${file.name}/exists`);
+			if (response?.status === 200) log(MediaCloudLogs.S3_STORE_FILE_FOUND);
+			const newFilename = response?.status === 200 ? generateUniqueFilename(file.name) : sanitizeFilename(file.name);
+			mappedFile = new File([file], newFilename, { type: file.type });
+			await updateFilename(newFilename);
+		} catch (error) {
+			throwError({
+				...MediaCloudErrors.NAMING_FUNCTION_ERROR,
+				cause: error
+			});
+			return null;
+		}
+		try {
+			const uploadArgs = {
+				file: mappedFile,
+				serverURL,
+				apiRoute,
+				mimeType,
+				prefix
+			};
+			const storageForMimeType = pluginOptions.storage && Object.prototype.hasOwnProperty.call(pluginOptions.storage, mimeType) ? pluginOptions.storage[mimeType] : void 0;
+			const isVideoFile = await isVideo(file);
+			const storeOnMux = pluginOptions.storage?.["video/*"] === "mux" || storageForMimeType === "mux";
+			switch (true) {
+				case storeOnMux && isVideoFile: return await muxUpload(uploadArgs);
+				default: return await tusUpload(uploadArgs);
 			}
-		} catch (_error) {
-			logError(MediaCloudErrors.NAMING_FUNCTION_ERROR.message);
+		} catch (error) {
+			throwError({
+				...MediaCloudErrors.UPLOAD_HANDLER_ERROR,
+				cause: error
+			});
+			return null;
 		}
-		const uploadArgs = {
-			file: mappedFile,
-			serverURL,
-			apiRoute,
-			mimeType
-		};
-		if (isVideoFile) return await muxUpload(uploadArgs);
-		else return await tusUpload(uploadArgs);
-	} catch (error) {
-		console.error("[PLUGIN-MEDIA-CLOUD] Upload handler detailed error:", error);
-		logError(MediaCloudErrors.UPLOAD_HANDLER_ERROR.message);
-		toast.error(`Upload failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-		return null;
-	}
-} });
+	} })(props);
+}
 
 //#endregion
 export { UploadHandler };
-//# sourceMappingURL=upload-handler.mjs.map
+//# sourceMappingURL=uploadHandler.mjs.map

package/dist/components/uploadHandler/uploadHandler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadHandler.mjs","names":["upchunk","tus","createClientUploadHandler","MediaCloudErrors","MediaCloudLogs","useMediaCloudEmitter","useErrorHandler","isVideo","getMimeType","generateUniqueFilename","sanitizeFilename","MediaCloudPluginOptions","Storage","MimeType","ReactNode","UploadCollectionSlug","useMagicError","UseMagicErrorReturn","UploadArgs","serverURL","apiRoute","file","File","mimeType","prefix","UploadResult","storage","filename","uploadId","MuxCreateUploadResponse","url","MUX_CHUNK_SIZE","TUS_CHUNK_SIZE","TUS_RETRY_DELAYS","magicError","throwError","emitter","muxUpload","args","Promise","endpoint","name","response","fetch","body","JSON","stringify","credentials","method","headers","json","uploader","createUpload","chunkSize","emit","polling","pollingUrl","on","MUX_UPLOAD_ERROR","progress","detail","MUX_DIRECT_UPLOAD_ERROR","error","tusUpload","filetype","type","filesize","size","toString","Object","keys","localStorage","filter","key","startsWith","forEach","removeItem","uploadUrlAvailable","eventListenerAdded","onBeforeUnload","e","BeforeUnloadEvent","window","removeEventListener","preventDefault","onPageUnload","navigator","sendBeacon","resolve","upload","Upload","retryDelays","storeFingerprintForResuming","metadata","contentType","contentLength","contentDisposition","onError","message","TUS_UPLOAD_ERROR","cause","onBeforeRequest","addEventListener","onProgress","bytesUploaded","bytesTotal","percentage","Math","round","onSuccess","onUploadUrlAvailable","start","log","Extra","pluginOptions","ClientUploadHandlerProps","Record","children","collectionSlug","enabled","extra","T","serverHandlerPath","UploadHandler","props","handler","updateFilename","assert","FILE_TYPE_UNKNOWN","allowedMimeTypes","limits","mimeTypes","mimeTypeMatches","some","allowed","endsWith","replace","FILE_TYPE_NOT_ALLOWED","fileSize","Infinity","FILE_SIZE_EXCEEDED","mappedFile","status","S3_STORE_FILE_FOUND","newFilename","NAMING_FUNCTION_ERROR","uploadArgs","StorageMap","NonNullable","storageForMimeType","prototype","hasOwnProperty","call","undefined","isVideoFile","storeOnMux","UPLOAD_HANDLER_ERROR"],"sources":["../../../src/components/uploadHandler/uploadHandler.tsx"],"sourcesContent":["'use client'\n\nimport * as upchunk from '@mux/upchunk'\nimport * as tus from 'tus-js-client'\n\nimport { createClientUploadHandler } from '@payloadcms/plugin-cloud-storage/client'\n\nimport { MediaCloudErrors, MediaCloudLogs } from '../../types/errors'\nimport { useMediaCloudEmitter } from '../../hooks/useMediaCloudEmitter'\nimport { useErrorHandler } from '../../hooks/useErrorHandler'\nimport {\n  isVideo,\n  getMimeType,\n  generateUniqueFilename,\n  sanitizeFilename,\n} from '../../utils/file'\n\nimport type {\n  MediaCloudPluginOptions,\n  Storage,\n  MimeType,\n} from '../../types/index'\nimport type { ReactNode } from 'react'\nimport type { UploadCollectionSlug } from 'payload'\nimport { useMagicError, UseMagicErrorReturn } from '@maas/error-handler'\n\ninterface UploadArgs {\n  serverURL: string\n  apiRoute: string\n  file: File\n  mimeType: MimeType\n  prefix?: string\n}\n\ninterface UploadResult {\n  storage: Storage\n  mimeType: MimeType\n  filename: string\n  uploadId?: string\n}\n\ninterface MuxCreateUploadResponse {\n  url: string\n  uploadId: string\n  filename: string\n}\n\nconst MUX_CHUNK_SIZE = 30720\nconst TUS_CHUNK_SIZE = 1024 * 1024\nconst TUS_RETRY_DELAYS = [0, 1000, 2000, 5000]\n\nconst magicError: UseMagicErrorReturn = useMagicError({\n  prefix: 'PLUGIN-MEDIA-CLOUD',\n})\n\nconst { throwError } = magicError\nconst emitter = useMediaCloudEmitter()\n\n/**\n * Handles Mux video upload with progress tracking\n * @param args - The upload arguments including file, server URL, and callbacks\n * @returns Promise that resolves to upload result or null if upload fails\n */\nasync function muxUpload(args: UploadArgs): Promise<UploadResult | null> {\n  const { file, serverURL, apiRoute, mimeType } = args\n\n  const endpoint = `${serverURL}${apiRoute}`\n  const filename = file.name\n\n  try {\n    // Request upload URL from Mux\n    const response = await fetch(`${endpoint}/mux/upload`, {\n      body: JSON.stringify({ filename, mimeType }),\n      credentials: 'include',\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n    })\n\n    const { url, uploadId } = (await response.json()) as MuxCreateUploadResponse\n\n    // Create upchunk uploader\n    const uploader = await upchunk.createUpload({\n      endpoint: url,\n      file,\n      chunkSize: MUX_CHUNK_SIZE,\n    })\n\n    // Add upload to tracker\n    emitter.emit('addUpload', {\n      filename,\n      uploadId,\n      polling: false,\n      pollingUrl: `${endpoint}/mux/asset`,\n    })\n\n    // Set up event handlers\n    uploader.on('error', function () {\n      emitter.emit('removeUpload', { uploadId })\n      throwError(MediaCloudErrors.MUX_UPLOAD_ERROR)\n    })\n\n    uploader.on('progress', function (progress) {\n      emitter.emit('updateUpload', {\n        filename,\n        progress: progress.detail,\n      })\n    })\n\n    uploader.on('success', function () {\n      emitter.emit('uploadComplete', { filename })\n    })\n\n    // Update collection entry\n    // with filename, uploadId, mimeType, and storage\n    return {\n      filename,\n      uploadId,\n      mimeType,\n      storage: 'mux',\n    }\n  } catch {\n    throwError(MediaCloudErrors.MUX_DIRECT_UPLOAD_ERROR)\n    emitter.emit('uploadError', { filename, error: 'Video upload failed' })\n    return null\n  }\n}\n\n/**\n * Handles TUS file upload with resumable capabilities\n * @param args - The upload arguments including file, server URL, and callbacks\n * @returns Promise that resolves to upload result or null if upload fails\n */\nasync function tusUpload(args: UploadArgs): Promise<UploadResult | null> {\n  const { apiRoute, serverURL, file, prefix = '', mimeType } = args\n\n  const filename = file.name\n  const filetype = file.type\n  const filesize = file.size.toString()\n\n  const endpoint = `${serverURL}${apiRoute}/uploads`\n\n  // Clear any stale TUS uploads from localStorage\n  Object.keys(localStorage)\n    .filter((key) => key.startsWith('tus::'))\n    .forEach((key) => localStorage.removeItem(key))\n\n  // Flag to prevent multiple onUploadUrlAvailable calls\n  let uploadUrlAvailable = false\n  let eventListenerAdded = false\n\n  function onBeforeUnload(e: BeforeUnloadEvent) {\n    window.removeEventListener('beforeunload', onBeforeUnload)\n    e.preventDefault()\n  }\n\n  function onPageUnload() {\n    window.removeEventListener('unload', onPageUnload)\n    navigator.sendBeacon(`${endpoint}/cleanup`, JSON.stringify({ filename }))\n  }\n\n  return new Promise((resolve) => {\n    const upload = new tus.Upload(file, {\n      endpoint,\n      retryDelays: TUS_RETRY_DELAYS,\n      chunkSize: TUS_CHUNK_SIZE,\n      storeFingerprintForResuming: false,\n      metadata: {\n        filetype,\n        filesize,\n        filename,\n        prefix,\n        contentType: filetype,\n        contentLength: filesize,\n        contentDisposition: 'inline',\n      },\n      onError(error) {\n        // Clean up\n        navigator.sendBeacon(\n          `${endpoint}/cleanup`,\n          JSON.stringify({ filename })\n        )\n\n        // Inform user\n        emitter.emit('uploadError', { filename, error: error.message })\n        emitter.emit('removeUpload', { filename })\n        throwError({ ...MediaCloudErrors.TUS_UPLOAD_ERROR, cause: error })\n        resolve(null)\n      },\n      onBeforeRequest() {\n        if (!eventListenerAdded) {\n          window.addEventListener('beforeunload', onBeforeUnload)\n          window.addEventListener('unload', onPageUnload)\n          eventListenerAdded = true\n        }\n      },\n      onProgress: function (bytesUploaded, bytesTotal) {\n        const percentage = Math.round((bytesUploaded / bytesTotal) * 100)\n        emitter.emit('updateUpload', {\n          filename,\n          progress: percentage,\n        })\n      },\n      async onSuccess() {\n        // Clean up beforeunload listener\n        window.removeEventListener('beforeunload', onBeforeUnload)\n        window.removeEventListener('unload', onPageUnload)\n\n        // Mark upload as complete in UI\n        emitter.emit('uploadComplete', { filename })\n\n        // Trigger post upload processing\n        await fetch(`${endpoint}/${filename}/process`)\n\n        // Move file to correct folder\n        await fetch(`${endpoint}/${filename}/folder`)\n      },\n      onUploadUrlAvailable: async function () {\n        // Prevent multiple callbacks\n        if (uploadUrlAvailable) {\n          return\n        }\n\n        // Update flag\n        uploadUrlAvailable = true\n\n        // Add upload to UI\n        emitter.emit('addUpload', { filename })\n\n        // Update collection entry\n        // with filename, mimeType, and storage\n        resolve({\n          filename,\n          mimeType,\n          storage: 's3',\n        })\n      },\n    })\n\n    upload.start()\n  })\n}\n\nconst { log } = useErrorHandler()\n\ninterface Extra {\n  pluginOptions: MediaCloudPluginOptions\n}\n\ntype ClientUploadHandlerProps<T extends Record<string, unknown>> = {\n  children: ReactNode\n  collectionSlug: UploadCollectionSlug\n  enabled?: boolean\n  extra: T\n  prefix?: string\n  serverHandlerPath: `/${string}`\n}\n\nexport function UploadHandler(\n  props: ClientUploadHandlerProps<{ pluginOptions: MediaCloudPluginOptions }>\n) {\n  return createClientUploadHandler({\n    handler: async function (args) {\n      const { serverURL, apiRoute, file, prefix, updateFilename, extra } = args\n      const { pluginOptions } = extra as unknown as Extra\n\n      // Check mime type\n      const mimeType = await getMimeType(file)\n\n      magicError.assert(mimeType, MediaCloudErrors.FILE_TYPE_UNKNOWN)\n\n      const allowedMimeTypes = pluginOptions.limits?.mimeTypes ?? []\n      const mimeTypeMatches = allowedMimeTypes.some((allowed) =>\n        allowed.endsWith('/*')\n          ? mimeType?.startsWith(allowed.replace('/*', '/'))\n          : mimeType === allowed\n      )\n\n      if (!mimeTypeMatches) {\n        throwError(MediaCloudErrors.FILE_TYPE_NOT_ALLOWED)\n        return null\n      }\n\n      // Check file size limit\n      if (file.size > (pluginOptions.limits?.fileSize ?? Infinity)) {\n        throwError(MediaCloudErrors.FILE_SIZE_EXCEEDED)\n        return null\n      }\n\n      // Clone file\n      let mappedFile = file\n\n      try {\n        // Check if file with same name exists\n        const endpoint = `${serverURL}${apiRoute}/uploads`\n        const response = await fetch(`${endpoint}/${file.name}/exists`)\n\n        if (response?.status === 200) {\n          log(MediaCloudLogs.S3_STORE_FILE_FOUND)\n        }\n\n        // If file exists, generate a cloned file with a unique filename\n        // If not, generate a cloned file with a sanitized filename\n        const newFilename =\n          response?.status === 200\n            ? generateUniqueFilename(file.name)\n            : sanitizeFilename(file.name)\n\n        mappedFile = new File([file], newFilename, {\n          type: file.type,\n        })\n\n        await updateFilename(newFilename)\n      } catch (error) {\n        throwError({\n          ...MediaCloudErrors.NAMING_FUNCTION_ERROR,\n          cause: error,\n        })\n        return null\n      }\n\n      try {\n        const uploadArgs: UploadArgs = {\n          file: mappedFile,\n          serverURL,\n          apiRoute,\n          mimeType,\n          prefix,\n        }\n\n        // Check storage mapping for mime type\n        type StorageMap = NonNullable<typeof pluginOptions.storage>\n\n        const storageForMimeType =\n          pluginOptions.storage &&\n          Object.prototype.hasOwnProperty.call(pluginOptions.storage, mimeType)\n            ? pluginOptions.storage[mimeType as keyof StorageMap]\n            : undefined\n\n        const isVideoFile = await isVideo(file)\n        const storeOnMux =\n          pluginOptions.storage?.['video/*'] === 'mux' ||\n          storageForMimeType === 'mux'\n\n        switch (true) {\n          case storeOnMux && isVideoFile:\n            return await muxUpload(uploadArgs)\n          default:\n            return await tusUpload(uploadArgs)\n        }\n      } catch (error) {\n        throwError({ ...MediaCloudErrors.UPLOAD_HANDLER_ERROR, cause: error })\n        return null\n      }\n    },\n  })(props)\n}\n"],"mappings":"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"}

package/dist/components/uploadManager/index.d.mts

@@ -0,0 +1,2 @@
+import { UploadManagerProvider, useUploadManagerContext } from "./uploadManager.mjs";
+export { UploadManagerProvider, useUploadManagerContext };

package/dist/components/uploadManager/index.mjs

@@ -0,0 +1,3 @@
+import { UploadManagerProvider, useUploadManagerContext } from "./uploadManager.mjs";
+
+export { UploadManagerProvider, useUploadManagerContext };

package/dist/components/{upload-manager/upload-manager.d.mts → uploadManager/uploadManager.d.mts}

@@ -1,8 +1,8 @@
 import { MediaCloudEmitterEvents } from "../../types/index.mjs";
 import React from "react";
-import "./upload-manager.css";
+import "./uploadManager.css";
 
-//#region src/components/upload-manager/upload-manager.d.ts
+//#region src/components/uploadManager/uploadManager.d.ts
 interface Upload {
   filename: string;
   progress: number;
@@ -30,4 +30,4 @@ declare function UploadManagerProvider(args: UploadManagerProviderArgs): React.J
 declare const useUploadManagerContext: () => UploadManagerContextType;
 //#endregion
 export { UploadManagerProvider, useUploadManagerContext };
-//# sourceMappingURL=upload-manager.d.mts.map
+//# sourceMappingURL=uploadManager.d.mts.map

package/dist/components/uploadManager/uploadManager.mjs

@@ -0,0 +1,363 @@
+'use client';
+
+import { MediaCloudErrors } from "../../types/errors.mjs";
+import { useErrorHandler } from "../../hooks/useErrorHandler.mjs";
+import { useMediaCloudEmitter } from "../../hooks/useMediaCloudEmitter.mjs";
+import { c } from "react/compiler-runtime";
+import { createContext, use, useEffect, useRef, useState } from "react";
+import { Button } from "@payloadcms/ui";
+import "./uploadManager.css";
+
+//#region src/components/uploadManager/uploadManager.tsx
+const UploadManagerContext = createContext({
+	showUploadManager: false,
+	activeUploads: [],
+	addUpload: () => {},
+	updateUpload: () => {}
+});
+/**
+* Provider component for upload management context
+* @param args - Arguments including children to wrap
+* @returns JSX element providing upload management context
+*/
+function UploadManagerProvider(args) {
+	const $ = c(40);
+	const { children } = args;
+	const [showUploadManager, setShowUploadManager] = useState(false);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = [];
+		$[0] = t0;
+	} else t0 = $[0];
+	const [activeUploads, setActiveUploads] = useState(t0);
+	const [activeTab, setActiveTab] = useState("uploading");
+	const emitter = useMediaCloudEmitter();
+	const activeTabRef = useRef(activeTab);
+	const activeUploadsRef = useRef(activeUploads);
+	const { logError } = useErrorHandler();
+	let t1;
+	let t2;
+	if ($[1] !== activeTab) {
+		t1 = () => {
+			activeTabRef.current = activeTab;
+		};
+		t2 = [activeTab];
+		$[1] = activeTab;
+		$[2] = t1;
+		$[3] = t2;
+	} else {
+		t1 = $[2];
+		t2 = $[3];
+	}
+	useEffect(t1, t2);
+	let t3;
+	let t4;
+	if ($[4] !== activeUploads) {
+		t3 = () => {
+			activeUploadsRef.current = activeUploads;
+		};
+		t4 = [activeUploads];
+		$[4] = activeUploads;
+		$[5] = t3;
+		$[6] = t4;
+	} else {
+		t3 = $[5];
+		t4 = $[6];
+	}
+	useEffect(t3, t4);
+	let t5;
+	if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+		t5 = (uploads) => {
+			const hasActiveUploads = uploads.some(_temp);
+			const hasProcessingUploads = uploads.some(_temp2);
+			const hasCompletedUploads = uploads.some(_temp3);
+			if (!hasActiveUploads && !hasProcessingUploads && hasCompletedUploads && activeTabRef.current !== "completed") setActiveTab("completed");
+		};
+		$[7] = t5;
+	} else t5 = $[7];
+	const checkAutoSwitchToCompleted = t5;
+	let t6;
+	let t7;
+	if ($[8] !== activeUploads || $[9] !== logError) {
+		t6 = () => {
+			const pollingUploads = activeUploads.filter(_temp4);
+			if (pollingUploads.length === 0) return;
+			const pollAssets = async () => {
+				for (const pollingUpload of pollingUploads) try {
+					const response = await fetch(`${pollingUpload.pollingUrl}?upload_id=${pollingUpload.uploadId}`, {
+						method: "GET",
+						credentials: "include"
+					});
+					if (response.ok) {
+						if ((await response.json()).ready) setActiveUploads((prev) => {
+							const updatedUploads = prev.map((upload_3) => upload_3.uploadId === pollingUpload.uploadId ? {
+								...upload_3,
+								polling: false,
+								progress: 100,
+								status: "completed"
+							} : upload_3);
+							setTimeout(() => checkAutoSwitchToCompleted(updatedUploads), 0);
+							return updatedUploads;
+						});
+					}
+				} catch (t8$1) {
+					logError(MediaCloudErrors.UPLOAD_POLLING_ERROR.message);
+				}
+			};
+			const intervalId = setInterval(pollAssets, 2e3);
+			return () => clearInterval(intervalId);
+		};
+		t7 = [
+			activeUploads,
+			checkAutoSwitchToCompleted,
+			logError
+		];
+		$[8] = activeUploads;
+		$[9] = logError;
+		$[10] = t6;
+		$[11] = t7;
+	} else {
+		t6 = $[10];
+		t7 = $[11];
+	}
+	useEffect(t6, t7);
+	let t8;
+	if ($[12] !== logError) {
+		t8 = (event) => {
+			const { filename, error } = event;
+			logError(MediaCloudErrors.TUS_UPLOAD_ERROR.message);
+			setActiveUploads((prev_0) => prev_0.map((upload_4) => upload_4.filename === filename ? {
+				...upload_4,
+				error,
+				status: "completed"
+			} : upload_4));
+		};
+		$[12] = logError;
+		$[13] = t8;
+	} else t8 = $[13];
+	const onUploadError = t8;
+	let t9;
+	if ($[14] === Symbol.for("react.memo_cache_sentinel")) {
+		t9 = (event_0) => {
+			const upload_5 = {
+				filename: event_0.filename,
+				uploadId: event_0.uploadId,
+				progress: 0,
+				polling: event_0.polling,
+				pollingUrl: event_0.pollingUrl,
+				status: "uploading"
+			};
+			setActiveUploads((prev_1) => [...prev_1, upload_5]);
+			setShowUploadManager(true);
+			if (activeTabRef.current !== "uploading") setActiveTab("uploading");
+		};
+		$[14] = t9;
+	} else t9 = $[14];
+	const onAddUpload = t9;
+	let t10;
+	if ($[15] === Symbol.for("react.memo_cache_sentinel")) {
+		t10 = (event_1) => {
+			const { filename: filename_0, progress, polling } = event_1;
+			setActiveUploads((prev_2) => prev_2.map((upload_6) => upload_6.filename === filename_0 ? {
+				...upload_6,
+				progress,
+				...polling !== void 0 && { polling },
+				status: polling ? "processing" : progress >= 100 ? "completed" : "uploading"
+			} : upload_6));
+		};
+		$[15] = t10;
+	} else t10 = $[15];
+	const onUpdateUpload = t10;
+	let t11;
+	if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+		t11 = (event_2) => {
+			setActiveUploads((prev_3) => prev_3.filter((upload_7) => upload_7.filename !== event_2.filename));
+		};
+		$[16] = t11;
+	} else t11 = $[16];
+	const onRemoveUpload = t11;
+	let t12;
+	if ($[17] === Symbol.for("react.memo_cache_sentinel")) {
+		t12 = (event_3) => {
+			if (activeUploadsRef.current.find((upload_8) => upload_8.filename === event_3.filename)?.pollingUrl) setActiveUploads((prev_4) => prev_4.map((upload_10) => upload_10.filename === event_3.filename ? {
+				...upload_10,
+				polling: true,
+				progress: 100,
+				status: "processing"
+			} : upload_10));
+			else setActiveUploads((prev_5) => {
+				const updatedUploads_0 = prev_5.map((upload_11) => upload_11.filename === event_3.filename ? {
+					...upload_11,
+					progress: 100,
+					status: "completed"
+				} : upload_11);
+				setTimeout(() => checkAutoSwitchToCompleted(updatedUploads_0), 0);
+				return updatedUploads_0;
+			});
+		};
+		$[17] = t12;
+	} else t12 = $[17];
+	const onUploadComplete = t12;
+	let t13;
+	let t14;
+	if ($[18] !== emitter || $[19] !== onUploadError) {
+		t13 = () => {
+			emitter.on("addUpload", onAddUpload);
+			emitter.on("updateUpload", onUpdateUpload);
+			emitter.on("removeUpload", onRemoveUpload);
+			emitter.on("uploadError", onUploadError);
+			emitter.on("uploadComplete", onUploadComplete);
+			return () => {
+				emitter.off("addUpload", onAddUpload);
+				emitter.off("updateUpload", onUpdateUpload);
+				emitter.off("removeUpload", onRemoveUpload);
+				emitter.off("uploadError", onUploadError);
+				emitter.off("uploadComplete", onUploadComplete);
+			};
+		};
+		t14 = [
+			emitter,
+			onAddUpload,
+			onUpdateUpload,
+			onRemoveUpload,
+			onUploadError,
+			onUploadComplete
+		];
+		$[18] = emitter;
+		$[19] = onUploadError;
+		$[20] = t13;
+		$[21] = t14;
+	} else {
+		t13 = $[20];
+		t14 = $[21];
+	}
+	useEffect(t13, t14);
+	let t15;
+	if ($[22] === Symbol.for("react.memo_cache_sentinel")) {
+		t15 = (args_0) => {
+			const { filename: filename_1, polling: t16$1, pollingUrl } = args_0;
+			const upload_12 = {
+				filename: filename_1,
+				progress: 0,
+				polling: t16$1 === void 0 ? false : t16$1,
+				pollingUrl,
+				status: "uploading"
+			};
+			setActiveUploads((prev_6) => [...prev_6, upload_12]);
+		};
+		$[22] = t15;
+	} else t15 = $[22];
+	const addUpload = t15;
+	let t16;
+	if ($[23] === Symbol.for("react.memo_cache_sentinel")) {
+		t16 = (args_1) => {
+			const { filename: filename_2, progress: progress_0, polling: polling_1 } = args_1;
+			setActiveUploads((prev_7) => prev_7.map((upload_13) => upload_13.filename === filename_2 ? {
+				...upload_13,
+				progress: progress_0,
+				...polling_1 !== void 0 && { polling: polling_1 },
+				status: polling_1 ? "processing" : progress_0 >= 100 ? "completed" : "uploading"
+			} : upload_13));
+		};
+		$[23] = t16;
+	} else t16 = $[23];
+	const updateUpload = t16;
+	let T0;
+	let t17;
+	let t18;
+	if ($[24] !== activeTab || $[25] !== activeUploads || $[26] !== showUploadManager) {
+		const uploadingFiles = activeUploads.filter(_temp5);
+		const processingFiles = activeUploads.filter(_temp6);
+		const completedFiles = activeUploads.filter(_temp7);
+		let t19$1;
+		if ($[30] === Symbol.for("react.memo_cache_sentinel")) {
+			t19$1 = function renderUploadList$1(args_2) {
+				const { uploads: uploads_0 } = args_2;
+				return <ul>{uploads_0.map(_temp8)}</ul>;
+			};
+			$[30] = t19$1;
+		} else t19$1 = $[30];
+		const renderUploadList = t19$1;
+		let t20;
+		if ($[31] !== activeUploads) {
+			t20 = function closeUploadManager$1() {
+				if (!activeUploads.some(_temp9)) {
+					setActiveUploads([]);
+					setShowUploadManager(false);
+				}
+			};
+			$[31] = activeUploads;
+			$[32] = t20;
+		} else t20 = $[32];
+		const closeUploadManager = t20;
+		let t21;
+		if ($[33] !== activeUploads) {
+			t21 = {
+				activeUploads,
+				addUpload,
+				updateUpload
+			};
+			$[33] = activeUploads;
+			$[34] = t21;
+		} else t21 = $[34];
+		const value = t21;
+		T0 = UploadManagerContext.Provider;
+		t17 = value;
+		t18 = showUploadManager && <div className="upload-manager"><div className="upload-manager__header"><h4>Uploads</h4><Button buttonStyle="icon-label" icon="x" margin={false} onClick={closeUploadManager} /></div><div className="upload-manager__tabs"><button data-active={activeTab === "uploading"} className="upload-tab" onClick={() => setActiveTab("uploading")}>Uploading ({uploadingFiles.length})</button><button data-active={activeTab === "processing"} className="upload-tab" onClick={() => setActiveTab("processing")}>Processing ({processingFiles.length})</button><button data-active={activeTab === "completed"} className="upload-tab" onClick={() => setActiveTab("completed")}>Completed ({completedFiles.length})</button></div><div className="upload-manager__content">{activeTab === "uploading" && uploadingFiles.length > 0 && <div>{renderUploadList({ uploads: uploadingFiles })}</div>}{activeTab === "processing" && processingFiles.length > 0 && <div>{renderUploadList({ uploads: processingFiles })}</div>}{activeTab === "completed" && completedFiles.length > 0 && <div>{renderUploadList({ uploads: completedFiles })}<div className="upload-manager__footer"><Button buttonStyle="subtle" size="small" margin={false} onClick={_temp0}>Refresh</Button></div></div>}{(activeTab === "uploading" && uploadingFiles.length === 0 || activeTab === "processing" && processingFiles.length === 0 || activeTab === "completed" && completedFiles.length === 0) && <p className="upload-empty-state">No {activeTab} files</p>}</div></div>;
+		$[24] = activeTab;
+		$[25] = activeUploads;
+		$[26] = showUploadManager;
+		$[27] = T0;
+		$[28] = t17;
+		$[29] = t18;
+	} else {
+		T0 = $[27];
+		t17 = $[28];
+		t18 = $[29];
+	}
+	let t19;
+	if ($[35] !== T0 || $[36] !== children || $[37] !== t17 || $[38] !== t18) {
+		t19 = <T0 value={t17}>{t18}{children}</T0>;
+		$[35] = T0;
+		$[36] = children;
+		$[37] = t17;
+		$[38] = t18;
+		$[39] = t19;
+	} else t19 = $[39];
+	return t19;
+}
+function _temp0() {
+	return window?.location?.reload();
+}
+function _temp9(upload_18) {
+	return upload_18.polling;
+}
+function _temp8(upload_17) {
+	return <li key={upload_17.filename} data-status={upload_17.status}><div className="upload-info"><span className="upload-filename">{upload_17.filename}</span><span className="upload-meta">{upload_17.status === "processing" ? "Processing..." : upload_17.progress < 100 ? `${Math.ceil(upload_17.progress)}%` : "Completed"}</span></div><div className="upload-progress-bar" style={{ "--progress": upload_17.status === "processing" ? "1" : `${upload_17.progress / 100}` }}><div data-active={upload_17.status === "processing"} className="upload-progress" /></div></li>;
+}
+function _temp7(upload_16) {
+	return upload_16.status === "completed";
+}
+function _temp6(upload_15) {
+	return upload_15.status === "processing";
+}
+function _temp5(upload_14) {
+	return upload_14.status === "uploading";
+}
+function _temp4(upload_2) {
+	return upload_2.polling && upload_2.pollingUrl;
+}
+function _temp3(upload_1) {
+	return upload_1.status === "completed";
+}
+function _temp2(upload_0) {
+	return upload_0.status === "processing";
+}
+function _temp(upload) {
+	return upload.status === "uploading";
+}
+const useUploadManagerContext = () => use(UploadManagerContext);
+
+//#endregion
+export { UploadManagerProvider, useUploadManagerContext };
+//# sourceMappingURL=uploadManager.mjs.map