Skip to content

Papermark is the open-source DocSend alternative and secure data rooms with built-in analytics and custom domains.

12.9 KB
Raw Blame
import {
  createContext,
  useCallback,
  useContext,
  useMemo,
  useRef,
  useState,
} from "react";

import { UploadNotificationDrawer } from "@/components/upload-notification";
// Type-only import so adding the reverse runtime dependency (UploadZone
// importing this context) doesn't create a runtime circular import.
import type {
  RejectedFile,
  UploadBatchState,
  UploadItemState,
} from "@/components/upload-zone";

/**
 * Imperative triggers exposed by a mounted `UploadZone` so that callers
 * elsewhere in the tree (e.g. the +Add dropdown rendered in the page
 * toolbar) can open the file/folder picker without reaching into the DOM
 * via `document.getElementById`. `null` when no zone is currently mounted
 * — callers should fall back gracefully (e.g. open the single-file modal).
 */
export interface UploadZoneTriggers {
  openFilesPicker: () => void;
  openFolderPicker: () => void;
}

interface UploadProgressContextType {
  uploadBatch: UploadBatchState | null;
  setUploadBatch: React.Dispatch<
    React.SetStateAction<UploadBatchState | null>
  >;
  rejectedFiles: RejectedFile[];
  setRejectedFiles: React.Dispatch<React.SetStateAction<RejectedFile[]>>;
  showDrawer: boolean;
  setShowDrawer: (show: boolean) => void;
  cancelUpload: (() => void) | null;
  addCancelFn: (fn: () => void) => void;
  cancelItem: (itemId: string) => void;
  cancelledItemIds: Set<string>;
  cancelledItemIdsRef: React.RefObject<Set<string>>;
  /**
   * Triggers registered by the currently-mounted `UploadZone`, or `null`
   * if none is mounted in the visible tree (e.g. while the dataroom search
   * results are showing instead of the items list).
   */
  uploadTriggers: UploadZoneTriggers | null;
  /**
   * Registers the given triggers and returns an unregister function.
   * Last-mount-wins; the unregister fn only clears state if the currently
   * registered object is still the same one we registered (so a late
   * unmount can't wipe out a newer registration).
   */
  registerUploadTriggers: (triggers: UploadZoneTriggers) => () => void;
}

const UploadProgressContext = createContext<UploadProgressContextType | null>(
  null,
);

function getActiveUploadByteTotals(items: UploadItemState[]) {
  let bytesUploaded = 0;
  let bytesTotal = 0;

  for (const item of items) {
    if (item.cancelled) continue;
    bytesUploaded += item.bytesUploaded ?? 0;
    bytesTotal += item.bytesTotal ?? 0;
  }

  return { bytesUploaded, bytesTotal };
}

export function UploadProgressProvider({
  children,
}: {
  children: React.ReactNode;
}) {
  const [uploadBatch, setUploadBatch] = useState<UploadBatchState | null>(null);
  const [rejectedFiles, setRejectedFiles] = useState<RejectedFile[]>([]);
  const [showDrawer, setShowDrawer] = useState(false);
  const [hasCancelFns, setHasCancelFns] = useState(false);
  const cancelFnsRef = useRef<(() => void)[]>([]);
  const [cancelledItemIds, setCancelledItemIds] = useState<Set<string>>(
    new Set(),
  );
  const cancelledItemIdsRef = useRef(cancelledItemIds);
  cancelledItemIdsRef.current = cancelledItemIds;

  const [uploadTriggers, setUploadTriggers] =
    useState<UploadZoneTriggers | null>(null);

  const registerUploadTriggers = useCallback(
    (triggers: UploadZoneTriggers) => {
      setUploadTriggers(triggers);
      return () => {
        // Identity guard: only clear if the same object is still registered.
        // Prevents a late unmount from wiping out a newer registration.
        setUploadTriggers((current) =>
          current === triggers ? null : current,
        );
      };
    },
    [],
  );

  const addCancelFn = useCallback((fn: () => void) => {
    cancelFnsRef.current.push(fn);
    setHasCancelFns(true);
  }, []);

  const cancelUpload = useCallback(() => {
    cancelFnsRef.current.forEach((fn) => fn());
    cancelFnsRef.current = [];
    setHasCancelFns(false);
    setUploadBatch((prev) => {
      if (!prev) return prev;
      let addedCompleted = 0;
      const updatedItems = prev.items.map((it) => {
        if (it.cancelled) return it;
        const remaining =
          it.totalEntries - it.completedEntries - it.failedEntries;
        if (remaining > 0) {
          addedCompleted += remaining;
          return {
            ...it,
            cancelled: true,
            completedEntries: it.totalEntries - it.failedEntries,
          } as UploadItemState;
        }
        return it;
      });
      const { bytesUploaded, bytesTotal } =
        getActiveUploadByteTotals(updatedItems);
      return {
        ...prev,
        cancelled: true,
        completedEntries: prev.completedEntries + addedCompleted,
        bytesUploaded,
        bytesTotal,
        items: updatedItems,
      };
    });
  }, []);

  const cancelItem = useCallback((itemId: string) => {
    setCancelledItemIds((prev) => {
      const next = new Set(prev);
      next.add(itemId);
      return next;
    });
    setUploadBatch((prev) => {
      if (!prev) return prev;
      const target = prev.items.find((it) => it.itemId === itemId);
      if (!target || target.cancelled) return prev;
      const remaining =
        target.totalEntries - target.completedEntries - target.failedEntries;
      const updatedItems = prev.items.map((it) =>
        it.itemId === itemId
          ? ({
              ...it,
              cancelled: true,
              completedEntries: it.totalEntries - it.failedEntries,
            } as UploadItemState)
          : it,
      );
      const { bytesUploaded, bytesTotal } =
        getActiveUploadByteTotals(updatedItems);
      return {
        ...prev,
        completedEntries: prev.completedEntries + remaining,
        bytesUploaded,
        bytesTotal,
        items: updatedItems,
      };
    });
  }, []);

  const handleCloseDrawer = useCallback(() => {
    setShowDrawer(false);
    setUploadBatch(null);
    setRejectedFiles([]);
    setCancelledItemIds(new Set());
    cancelFnsRef.current = [];
    setHasCancelFns(false);
  }, []);

  const handleOpenChange = useCallback((open: boolean) => {
    setShowDrawer(open);
    if (!open) {
      setUploadBatch(null);
      setRejectedFiles([]);
      setCancelledItemIds(new Set());
      cancelFnsRef.current = [];
      setHasCancelFns(false);
    }
  }, []);

  const value = useMemo<UploadProgressContextType>(
    () => ({
      uploadBatch,
      setUploadBatch,
      rejectedFiles,
      setRejectedFiles,
      showDrawer,
      setShowDrawer,
      cancelUpload: hasCancelFns ? cancelUpload : null,
      addCancelFn,
      cancelItem,
      cancelledItemIds,
      cancelledItemIdsRef,
      uploadTriggers,
      registerUploadTriggers,
    }),
    [
      uploadBatch,
      rejectedFiles,
      showDrawer,
      hasCancelFns,
      cancelUpload,
      addCancelFn,
      cancelItem,
      cancelledItemIds,
      uploadTriggers,
      registerUploadTriggers,
    ],
  );

  return (
    <UploadProgressContext.Provider value={value}>
      {children}
      {showDrawer ? (
        <UploadNotificationDrawer
          open={showDrawer}
          onOpenChange={handleOpenChange}
          batch={uploadBatch}
          setBatch={setUploadBatch}
          rejectedFiles={rejectedFiles}
          setRejectedFiles={setRejectedFiles}
          handleCloseDrawer={handleCloseDrawer}
          onCancel={hasCancelFns ? cancelUpload : undefined}
          onCancelItem={cancelItem}
        />
      ) : null}
    </UploadProgressContext.Provider>
  );
}

export function useUploadProgress() {
  const ctx = useContext(UploadProgressContext);
  if (!ctx) {
    throw new Error(
      "useUploadProgress must be used within UploadProgressProvider",
    );
  }
  return ctx;
}

/** Stable callbacks for wiring UploadZone to the shared upload-progress context. */
export function useUploadCallbacks() {
  const { setUploadBatch, setRejectedFiles, setShowDrawer, addCancelFn } =
    useUploadProgress();

  const onTraversalStart = useCallback(
    (preliminaryItems?: { name: string; isFolder: boolean }[]) => {
      setUploadBatch((prev) => {
        const isDone =
          prev &&
          (prev.cancelled ||
            (prev.totalEntries > 0 &&
              prev.completedEntries + prev.failedEntries >=
                prev.totalEntries));
        const baseBatch = isDone ? null : prev;
        if (!preliminaryItems?.length) return baseBatch;
        const newItems = preliminaryItems.map((pi) => ({
          itemId: crypto.randomUUID(),
          name: pi.name,
          type: (pi.isFolder ? "folder" : "file") as "folder" | "file",
          totalEntries: 0,
          completedEntries: 0,
          failedEntries: 0,
        }));
        if (!baseBatch) {
          return {
            batchId: crypto.randomUUID(),
            items: newItems,
            startedAt: Date.now(),
            totalEntries: 0,
            completedEntries: 0,
            failedEntries: 0,
          };
        }
        return {
          ...baseBatch,
          items: [...baseBatch.items, ...newItems],
        };
      });
      setShowDrawer(true);
    },
    [setUploadBatch, setShowDrawer],
  );

  const onUploadBatchStart = useCallback(
    (batch: UploadBatchState, cancelFn: () => void) => {
      addCancelFn(cancelFn);
      setUploadBatch((prev) => {
        if (!prev || prev.cancelled) return batch;
        const isPreliminary = prev.totalEntries === 0;
        if (isPreliminary) {
          const realNames = new Set(batch.items.map((it) => it.name));
          const kept = prev.items
            .filter((it) => !realNames.has(it.name))
            .map((it) => ({ ...it, cancelled: true }));
          return {
            ...batch,
            items: [...batch.items, ...kept],
            totalEntries: batch.totalEntries,
            completedEntries: batch.completedEntries,
            failedEntries: batch.failedEntries,
          };
        }
        const isActive =
          prev.completedEntries + prev.failedEntries < prev.totalEntries;
        if (isActive) {
          return {
            ...prev,
            items: [...prev.items, ...batch.items],
            totalEntries: prev.totalEntries + batch.totalEntries,
            completedEntries:
              prev.completedEntries + batch.completedEntries,
            failedEntries: prev.failedEntries + batch.failedEntries,
            bytesUploaded: (prev.bytesUploaded ?? 0) + (batch.bytesUploaded ?? 0),
            bytesTotal: (prev.bytesTotal ?? 0) + (batch.bytesTotal ?? 0),
          };
        }
        return batch;
      });
      setShowDrawer(true);
    },
    [addCancelFn, setUploadBatch, setShowDrawer],
  );

  const onUploadBatchUpdate = useCallback(
    (_batchId: string, update: Partial<UploadBatchState>) => {
      setUploadBatch((prev) => {
        if (!prev || prev.cancelled) return prev;
        const mergedItems = [...prev.items];
        if (update.items) {
          const indexMap = new Map<string, number>();
          for (let i = 0; i < mergedItems.length; i++) {
            indexMap.set(mergedItems[i].itemId, i);
          }
          for (const incoming of update.items) {
            const idx = indexMap.get(incoming.itemId);
            if (idx !== undefined && !mergedItems[idx].cancelled) {
              mergedItems[idx] = incoming;
            }
          }
        }
        let totalEntries = 0;
        let completedEntries = 0;
        let failedEntries = 0;
        for (const it of mergedItems) {
          totalEntries += it.totalEntries;
          completedEntries += it.completedEntries;
          failedEntries += it.failedEntries;
        }
        const { bytesUploaded, bytesTotal } =
          getActiveUploadByteTotals(mergedItems);
        return {
          ...prev,
          items: mergedItems,
          totalEntries,
          completedEntries,
          failedEntries,
          bytesUploaded,
          bytesTotal,
        };
      });
    },
    [setUploadBatch],
  );

  const onUploadRejected = useCallback(
    (rejected: RejectedFile[]) => {
      setRejectedFiles((prevRejected) => [...prevRejected, ...rejected]);
      const rejectedNames = new Set(rejected.map((r) => r.fileName));
      setUploadBatch((prev) => {
        if (!prev) return prev;
        let changed = false;
        const updatedItems = prev.items.map((it) => {
          if (
            it.totalEntries === 0 &&
            !it.cancelled &&
            rejectedNames.has(it.name)
          ) {
            changed = true;
            return { ...it, cancelled: true };
          }
          return it;
        });
        return changed ? { ...prev, items: updatedItems } : prev;
      });
      setShowDrawer(true);
    },
    [setRejectedFiles, setUploadBatch, setShowDrawer],
  );

  const onUploadAborted = useCallback(() => {
    setUploadBatch((prev) => {
      if (!prev) return prev;
      const updatedItems = prev.items.map((it) =>
        it.totalEntries === 0 && !it.cancelled
          ? { ...it, cancelled: true }
          : it,
      );
      return { ...prev, items: updatedItems };
    });
  }, [setUploadBatch]);

  return {
    onTraversalStart,
    onUploadBatchStart,
    onUploadBatchUpdate,
    onUploadRejected,
    onUploadAborted,
  };
}