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.

6.8 KB
Raw Blame
import { toast } from '@core/component/Toast/Toast';
import { fireAndForget } from '@core/util/fireAndForget';
import { convertFileSrc, invoke } from '@tauri-apps/api/core';
import { listen } from '@tauri-apps/api/event';
import type { OsType } from '@tauri-apps/plugin-os';
import {
  type Accessor,
  createContext,
  createSignal,
  type JSX,
  onCleanup,
  onMount,
  useContext,
} from 'solid-js';
import { useAndroidShares } from './androidShares';

interface StagedSharedFileData {
  token: string;
  name: string;
  mime_type: string;
  size: number;
  preview_path?: string | null;
}

export interface PendingShareFile {
  token: string;
  name: string;
  mimeType: string;
  size: number;
  previewSrc?: string;
  isSharedText?: boolean;
  sharedText?: string;
  sha256?: string;
}

export interface UploadPendingShareFileArgs {
  token: string;
  uploadUrl: string;
  mimeType: string;
}

interface ShareFilesReadyPayload {
  filenames: string[];
}

function isSharedTextMimeType(mimeType: string): boolean {
  return mimeType === 'text/uri-list' || mimeType === 'text/plain';
}

function shareFileNamesMatch(
  left: readonly string[],
  right: readonly string[]
): boolean {
  return (
    left.length === right.length &&
    left.every((name, index) => name === right[index])
  );
}

async function getPendingShareFilenames(): Promise<string[]> {
  return invoke<string[]>('get_pending_share_filenames');
}

async function popSharedFiles(
  filenames: string[]
): Promise<PendingShareFile[]> {
  const results = await invoke<StagedSharedFileData[]>('pop_shared_files', {
    filenames,
  });
  return Promise.all(
    results.map(async ({ token, name, mime_type, size, preview_path }) => {
      const isSharedText = isSharedTextMimeType(mime_type);
      const sharedText = isSharedText
        ? await readSharedFileText(token).catch((error) => {
            console.error('failed to read shared text', { token, error });
            return undefined;
          })
        : undefined;

      return {
        token,
        name,
        mimeType: mime_type,
        size,
        previewSrc: preview_path ? convertFileSrc(preview_path) : undefined,
        isSharedText,
        sharedText,
      };
    })
  );
}

async function readSharedFileText(token: string): Promise<string> {
  return invoke<string>('read_shared_file_text', { token });
}

async function clearSharedFiles(tokens: readonly string[]): Promise<void> {
  await invoke('clear_shared_files', { tokens });
}

async function uploadPendingShareFile(
  args: UploadPendingShareFileArgs
): Promise<void> {
  await invoke('upload_staged_file_to_presigned_url', {
    source: 'share',
    token: args.token,
    uploadUrl: args.uploadUrl,
    mimeType: args.mimeType,
  });
}

interface ShareTargetContextValue {
  pendingShareFiles: Accessor<PendingShareFile[]>;
  uploadPendingShareFile: (args: UploadPendingShareFileArgs) => Promise<void>;
  clearPendingShareFiles: (tokens?: readonly string[]) => Promise<void>;
}

const ShareTargetContext = createContext<ShareTargetContextValue | undefined>(
  undefined
);

export function ShareTargetProvider(props: {
  os: OsType;
  children: JSX.Element;
}) {
  const [pendingShareFiles, setPendingShareFiles] = createSignal<
    PendingShareFile[]
  >([]);
  const [pendingShareFileNames, setPendingShareFileNames] = createSignal<
    string[]
  >([]);

  const clearPendingShareFiles = async (
    tokens: readonly string[] = pendingShareFiles().map((file) => file.token)
  ) => {
    if (tokens.length === 0) return;

    const clearMatchingFiles = () => {
      setPendingShareFiles((current) =>
        current.filter((file) => !tokens.includes(file.token))
      );
      if (pendingShareFiles().length === 0) setPendingShareFileNames([]);
    };
    if (props.os !== 'android') clearMatchingFiles();

    try {
      if (props.os === 'android') {
        await invoke('plugin:android-mobile|clearShares', { tokens });
        // A queue notification may already have loaded the next batch.
        clearMatchingFiles();
      } else {
        await clearSharedFiles(tokens);
      }
    } catch (error) {
      console.error('failed to clear shared files', error);
      if (props.os === 'android')
        toast.failure('Unable to clear this share. Please try again.');
    }
  };

  if (props.os === 'android') useAndroidShares(setPendingShareFiles);

  const clearLoadedPendingShare = (files: readonly PendingShareFile[]) => {
    setPendingShareFiles([]);
    setPendingShareFileNames([]);

    if (files.length > 0) {
      void clearSharedFiles(files.map((file) => file.token)).catch(() => {});
    }
  };

  onMount(() => {
    if (props.os !== 'ios') {
      return;
    }

    let nextRequestId = 0;

    const loadPendingShareFiles = async (filenames: string[]) => {
      if (filenames.length === 0) return;

      const requestId = ++nextRequestId;

      const previousFilenames = pendingShareFileNames();
      const previousFiles = pendingShareFiles();
      const isSamePendingShare = shareFileNamesMatch(
        previousFilenames,
        filenames
      );

      if (isSamePendingShare && pendingShareFiles().length > 0) {
        return;
      }

      try {
        const files = await popSharedFiles(filenames);

        if (requestId !== nextRequestId) return;

        if (files.length === 0) {
          clearLoadedPendingShare(previousFiles);
          return;
        }

        setPendingShareFiles(files);
        setPendingShareFileNames(filenames);
        if (previousFiles.length > 0 && !isSamePendingShare) {
          void clearSharedFiles(previousFiles.map((file) => file.token)).catch(
            () => {}
          );
        }
      } catch (error) {
        if (requestId !== nextRequestId) return;
        clearLoadedPendingShare(previousFiles);
        console.error('failed to load pending share files', error);
      }
    };

    const unlisten = listen<ShareFilesReadyPayload>(
      'share-files-ready',
      (event) =>
        fireAndForget(
          loadPendingShareFiles(event.payload.filenames),
          'share-target'
        )
    );

    fireAndForget(
      (async () => {
        try {
          await unlisten;
          const filenames = await getPendingShareFilenames();
          await loadPendingShareFiles(filenames);
        } catch (error) {
          console.error('failed to initialize iOS share target', error);
        }
      })(),
      'share-target'
    );

    onCleanup(() =>
      fireAndForget(
        unlisten.then((fn) => fn()),
        'share-target'
      )
    );
  });

  const value: ShareTargetContextValue = {
    pendingShareFiles,
    uploadPendingShareFile,
    clearPendingShareFiles,
  };

  return (
    <ShareTargetContext.Provider value={value}>
      {props.children}
    </ShareTargetContext.Provider>
  );
}

export function useShareTarget() {
  return useContext(ShareTargetContext);
}