Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

3.9 KB
Raw Blame
import { useCallback, type MutableRefObject } from "react";
import { Alert } from "react-native";
import type { createEdgeEverClient } from "@edgeever/client";
import type { LocalTiptapEditorRef } from "../components/LocalTiptapEditor";
import {
  openMobileResource,
  parseMobileResourceTargetJson,
  saveMobileResourceAs,
  type MobileResourceTarget,
} from "../lib/mobile-attachments";
import { loadProtectedResourceDataUrl, type ProtectedResourceLoadFailure } from "../lib/mobile-protected-resources";
import { safeDomCall } from "../lib/safe-dom-call";
import { formatMobileCopy, getMobileCatalog, type MobileLocale } from "../lib/mobile-locale";

type Client = ReturnType<typeof createEdgeEverClient> | null;

type Options = {
  baseUrl: string;
  canMutate: () => boolean;
  client: Client;
  editorRef: MutableRefObject<LocalTiptapEditorRef | null>;
  onLoadFailure: (failure: ProtectedResourceLoadFailure) => void;
  onSelect: (target: MobileResourceTarget) => void;
  resolvedLocale: MobileLocale;
  resourceCacheRef: MutableRefObject<Map<string, Promise<string | null>>>;
  sessionBaseUrl?: string;
  token?: string;
};

export const useMobileEditorResourceActions = ({
  baseUrl,
  canMutate,
  client,
  editorRef,
  onLoadFailure,
  onSelect,
  resolvedLocale,
  resourceCacheRef,
  sessionBaseUrl,
  token,
}: Options) => {
  const loadEditorResource = useCallback((source: string) => {
    if (!client) return Promise.resolve(null);
    return loadProtectedResourceDataUrl(source, {
      baseUrl: sessionBaseUrl ?? baseUrl,
      cache: resourceCacheRef.current,
      getResourceBlob: client.getResourceBlob,
      onFailure: onLoadFailure,
      token,
    });
  }, [baseUrl, client, onLoadFailure, resourceCacheRef, sessionBaseUrl, token]);

  const downloadResource = useCallback(async (target: MobileResourceTarget) => {
    if (!client) throw new Error(getMobileCatalog(resolvedLocale).mobile.resources.attachmentUnavailable);
    await openMobileResource(client, target, { baseUrl: sessionBaseUrl ?? baseUrl, token });
  }, [baseUrl, client, sessionBaseUrl, resolvedLocale, token]);

  const saveResourceAs = useCallback(async (target: MobileResourceTarget) => {
    if (!client) throw new Error(getMobileCatalog(resolvedLocale).mobile.common.resourceUnavailable);
    const result = await saveMobileResourceAs(client, target, { baseUrl: sessionBaseUrl ?? baseUrl, token });
    if (result.kind === "saf") {
      Alert.alert(
        getMobileCatalog(resolvedLocale).mobile.common.downloaded,
        formatMobileCopy(getMobileCatalog(resolvedLocale).mobile.common.savedFile, { filename: result.filename }),
      );
    }
  }, [baseUrl, client, resolvedLocale, sessionBaseUrl, token]);

  const requireMutableClient = useCallback(() => {
    if (!client || !canMutate()) {
      throw new Error(getMobileCatalog(resolvedLocale).mobile.resources.waitForSync);
    }
    return client;
  }, [canMutate, client, resolvedLocale]);

  const renameResource = useCallback(async (target: MobileResourceTarget, filename: string) => {
    const mutableClient = requireMutableClient();
    const { resource } = await mutableClient.renameResource(target.resourceId, filename);
    safeDomCall(() => editorRef.current?.renameResource(JSON.stringify(target), resource.filename || filename));
  }, [editorRef, requireMutableClient]);

  const deleteResource = useCallback(async (target: MobileResourceTarget) => {
    const mutableClient = requireMutableClient();
    await mutableClient.deleteResource(target.resourceId);
    safeDomCall(() => editorRef.current?.removeResource(JSON.stringify(target)));
  }, [editorRef, requireMutableClient]);

  const selectResource = useCallback(async (targetJson: string) => {
    const target = parseMobileResourceTargetJson(targetJson);
    if (target) onSelect(target);
  }, [onSelect]);

  return { deleteResource, downloadResource, loadEditorResource, renameResource, saveResourceAs, selectResource };
};