Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

9.1 KB
Raw Blame
import { toast } from '@core/component/Toast/Toast';
import { exportAndroidFileWithProgress } from '@core/mobile/exportAndroidFileWithProgress';
import { exportIosFile, hasIosFileExport } from '@core/mobile/iosFiles';
import { isPlatform } from '@core/util/platform';
import type { ResultError } from '@core/util/result';
import { downloadFile } from '@filesystem/download';
import { type Span, Telemetry } from '@macro-inc/observability';
import type { FetchProgress } from '@service-storage/util/fetchPresigned';
import type { Result } from 'neverthrow';
import {
  type Accessor,
  batch,
  createEffect,
  createSignal,
  on,
  onCleanup,
} from 'solid-js';

export type DownloadSource = {
  id: string;
  name: string;
  load: (options: {
    signal: AbortSignal;
    onProgress: (progress: FetchProgress) => void;
    span: Span;
  }) => Promise<Result<{ blob: Blob; name?: string }, ResultError<string>[]>>;
};

export function createFileDownload(
  source: Accessor<DownloadSource | undefined>
) {
  const [phase, setPhase] = createSignal<
    'idle' | 'loading' | 'ready' | 'saving' | 'error'
  >('idle');
  const [action, setAction] = createSignal<'save' | 'share'>('save');
  let nativeIos = false;
  const [file, setFile] = createSignal<File>();
  const [name, setName] = createSignal('');
  const [progress, setProgress] = createSignal<FetchProgress>({
    loaded: 0,
    total: 0,
  });
  let controller: AbortController | undefined;
  const isCurrent = (request: AbortController) =>
    controller === request && !request.signal.aborted;
  let selectedId: string | undefined;
  let trace: Span | undefined;
  const finishTrace = (outcome: string, error?: unknown) => {
    if (error !== undefined) trace?.error(error);
    trace?.setAttr('file.outcome', outcome);
    trace?.end();
    trace = undefined;
  };
  let opener: HTMLElement | undefined;
  const restoreFocus = () => {
    if (opener?.isConnected) opener.focus();
  };

  const cancel = () => {
    finishTrace('canceled');
    controller?.abort();
    controller = undefined;
    setFile(undefined);
    setPhase('idle');
  };
  onCleanup(cancel);
  // Abort the external transfer when the viewer changes file or version.
  createEffect(on(() => source()?.id, cancel, { defer: true }));

  const busy = () => phase() === 'loading' || phase() === 'saving';
  const canOfferShare = () =>
    isPlatform('android') ||
    isPlatform('ios') ||
    typeof navigator.share === 'function';
  const canShare = () => {
    const ready = file();
    return (
      !!ready &&
      (isPlatform('android') ||
        nativeIos ||
        !!navigator.canShare?.({ files: [ready] }))
    );
  };

  // A prepared Web Share file can be handed off from the original control on
  // a fresh tap if loading outlived the browser's user activation.
  const handOff = async (action: 'save' | 'share') => {
    const ready = file();
    const request = controller;
    if (!ready || !request || request.signal.aborted || phase() === 'saving')
      return;
    if (source()?.id !== selectedId) {
      cancel();
      return;
    }
    setPhase('saving');
    // A cancelled chooser can be retried with the already prepared bytes.
    trace ??= Telemetry.span('file.download');
    trace.setAttr('file.id', selectedId ?? '');
    trace.setAttr('file.size', ready.size);
    const span = trace.span(`file.${action}`);
    try {
      await span.run(async () => {
        let canceled = false;
        if (isPlatform('android')) {
          ({ canceled } = await exportAndroidFileWithProgress(
            ready,
            ready.name,
            action,
            request.signal
          ));
        } else if (nativeIos) {
          ({ canceled } = await exportIosFile(ready, action, {
            signal: request.signal,
            onProgress: (fraction) => {
              if (controller === request)
                setProgress({
                  loaded: fraction * ready.size,
                  total: ready.size,
                });
            },
          }));
        } else if (action === 'share' || isPlatform('ios')) {
          await navigator.share({ files: [ready] });
        } else {
          const { saved } = await downloadFile(ready, ready.name);
          if (!saved) {
            span.error('Unable to save file');
            if (controller === request) {
              setPhase('ready');
              finishTrace('failed', 'Unable to save file');
            }
            return;
          }
        }
        span.setAttr('file.outcome', canceled ? 'canceled' : 'handed_off');
        if (controller !== request) return;
        if (canceled) {
          finishTrace('canceled');
          setPhase('ready');
          return;
        }
        if (action === 'save' && (!isPlatform('ios') || nativeIos)) {
          toast.success(
            isPlatform('android') || nativeIos
              ? 'File saved'
              : 'Download started'
          );
        }
        finishTrace('handed_off');
        cancel();
        restoreFocus();
      });
    } catch (error) {
      const canceled =
        request.signal.aborted ||
        (error instanceof Error && error.name === 'AbortError');
      if (canceled) span.setAttr('file.outcome', 'canceled');
      else span.error(error);
      if (controller !== request) return;
      setPhase('ready');
      finishTrace(
        canceled ? 'canceled' : 'failed',
        canceled ? undefined : error
      );
      if (canceled) return;
      Telemetry.error(error, { surface: 'file-download' });
      toast.failure(
        action === 'share' ? 'Unable to share file' : 'Unable to download file',
        {
          subtext: 'Please try again.',
        }
      );
    } finally {
      span.end();
    }
  };

  const handOffWhenReady = async (nextAction: 'save' | 'share') => {
    const usesWebShare =
      !nativeIos &&
      !isPlatform('android') &&
      (nextAction === 'share' || isPlatform('ios'));
    if (usesWebShare) {
      if (!canShare()) {
        setPhase('error');
        finishTrace('unsupported');
        toast.failure('This device can’t share this file');
        return;
      }
      if (!navigator.userActivation?.isActive) {
        toast.custom({
          title:
            nextAction === 'share'
              ? 'File ready — tap Share'
              : 'File ready — tap Save file',
        });
        return;
      }
    }
    await handOff(nextAction);
  };

  const start = async (nextAction: 'save' | 'share' = 'save') => {
    if (busy()) return;
    if (document.activeElement instanceof HTMLElement)
      opener = document.activeElement;
    if (phase() === 'ready' && file() && source()?.id === selectedId) {
      setAction(nextAction);
      await handOff(nextAction);
      return;
    }
    const snapshot = source();
    if (!snapshot) return;
    const request = new AbortController();
    batch(() => {
      cancel();
      selectedId = snapshot.id;
      controller = request;
      setName(snapshot.name);
      setProgress({ loaded: 0, total: 0 });
      setPhase('loading');
      setAction(nextAction);
    });
    trace = Telemetry.span('file.download');
    trace.setAttr('file.id', snapshot.id);
    trace.setAttr('file.action', nextAction);
    const span = trace.span('file.load');
    try {
      nativeIos = isPlatform('ios') && (await hasIosFileExport());
      if (!isCurrent(request)) {
        span.end();
        return;
      }
      const result = await span.run(async () => {
        try {
          const result = await snapshot.load({
            signal: request.signal,
            span,
            onProgress: (next) => {
              if (controller === request) setProgress(next);
            },
          });
          if (result.isErr() && !request.signal.aborted)
            span.error(result.error);
          return result;
        } catch (error) {
          if (request.signal.aborted) span.setAttr('file.outcome', 'canceled');
          else span.error(error);
          throw error;
        } finally {
          span.end();
        }
      });
      if (!isCurrent(request)) return;
      if (source()?.id !== snapshot.id) {
        cancel();
        return;
      }
      if (result.isErr()) {
        setPhase('error');
        finishTrace('failed', result.error);
        toast.failure('Unable to download file', {
          subtext: 'Try again. The file may no longer be available.',
        });
        return;
      }
      const filename = result.value.name || snapshot.name;
      trace?.setAttr('file.size', result.value.blob.size);
      setName(filename);
      setFile(
        new File([result.value.blob], filename, {
          type: result.value.blob.type,
        })
      );
      setPhase('ready');
      await handOffWhenReady(nextAction);
    } catch (error) {
      if (!isCurrent(request)) return;
      setPhase('error');
      finishTrace('failed', error);
      Telemetry.error(error, { surface: 'file-download' });
      toast.failure('Unable to download file', {
        subtext: 'Try again. The file may no longer be available.',
      });
    }
  };

  return {
    start,
    cancel,
    action,
    phase,
    busy,
    file,
    name,
    progress,
    canOfferShare,
  };
}

export type FileDownloadController = ReturnType<typeof createFileDownload>;