Source

// Where a file being received is kept until the person saves it. Where the browser allows, it goes
// straight to the site's private storage on disk (so a file can be as big as the free space the
// browser gives the site); otherwise it is kept in memory, which limits very large files.

export interface Sink {
  /** Disk: written to this device's storage. Memory: held in the browser's memory. */
  readonly kind: "disk" | "memory";
  write(part: Blob): Promise<void>;
  finish(): Promise<Blob>;
  discard(): Promise<void>;
}

const DIR = "drop-received";
const HOUR = 3600_000;
let dirHandle: Promise<FileSystemDirectoryHandle | null> | null = null;

function storageDir(): Promise<FileSystemDirectoryHandle | null> {
  dirHandle ??= (async () => {
    try {
      if (typeof FileSystemFileHandle === "undefined" || !("createWritable" in FileSystemFileHandle.prototype)) return null;
      const root = await navigator.storage.getDirectory();
      const dir = await root.getDirectoryHandle(DIR, { create: true });
      // Files kept from an earlier visit are removed once they are an hour old.
      for await (const name of dir.keys()) {
        const t = Number(name.split("-")[0]);
        if (!t || Date.now() - t > HOUR) await dir.removeEntry(name).catch(() => null);
      }
      return dir;
    } catch {
      return null; // private windows and older browsers
    }
  })();
  return dirHandle;
}

/** Free space the browser lets this site use, in bytes, or null when it does not say. */
export async function freeSpace(): Promise<number | null> {
  try {
    const e = await navigator.storage.estimate();
    return typeof e.quota === "number" ? Math.max(0, e.quota - (e.usage || 0)) : null;
  } catch {
    return null;
  }
}

export async function openSink(size: number, label: string): Promise<Sink> {
  const dir = await storageDir();
  const free = dir ? await freeSpace() : null;
  if (dir && (free === null || free > size + 16 * 1024 * 1024)) {
    try {
      const name = `${Date.now()}-${label}`;
      const handle = await dir.getFileHandle(name, { create: true });
      const writable = await handle.createWritable({ keepExistingData: false });
      return new DiskSink(dir, name, handle, writable);
    } catch {
      // fall back to memory
    }
  }
  return new MemorySink();
}

class DiskSink implements Sink {
  readonly kind = "disk";
  constructor(
    private dir: FileSystemDirectoryHandle,
    private name: string,
    private handle: FileSystemFileHandle,
    private writable: FileSystemWritableFileStream,
  ) {}

  write(part: Blob) { return this.writable.write(part); }

  async finish() {
    await this.writable.close();
    return this.handle.getFile();
  }

  async discard() {
    await this.writable.abort().catch(() => null);
    await this.dir.removeEntry(this.name).catch(() => null);
  }
}

class MemorySink implements Sink {
  readonly kind = "memory";
  private parts: Blob[] = [];
  async write(part: Blob) { this.parts.push(part); }
  async finish() { return new Blob(this.parts); }
  async discard() { this.parts = []; }
}