File size: 3,036 Bytes
50fe3c9 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 | import { invoke } from "@tauri-apps/api/core";
import { useCallback, useEffect, useRef, useState } from "react";
type ReadResult =
| { kind: "text"; content: string; size: number }
| { kind: "binary"; size: number }
| { kind: "toolarge"; size: number; limit: number };
export type DocumentState =
| { status: "loading" }
| { status: "ready"; content: string; size: number }
| { status: "binary"; size: number }
| { status: "toolarge"; size: number; limit: number }
| { status: "error"; message: string };
type Options = {
path: string;
onDirtyChange?: (dirty: boolean) => void;
};
export function useDocument({ path, onDirtyChange }: Options) {
const [doc, setDoc] = useState<DocumentState>({ status: "loading" });
const [dirty, setDirty] = useState(false);
const [reloadCounter, setReloadCounter] = useState(0);
// Track the saved buffer so we can detect changes cheaply.
const savedRef = useRef<string>("");
const bufferRef = useRef<string>("");
const dirtyRef = useRef(false);
useEffect(() => {
dirtyRef.current = dirty;
}, [dirty]);
// Notify parent of dirty transitions.
const onDirtyChangeRef = useRef(onDirtyChange);
useEffect(() => {
onDirtyChangeRef.current = onDirtyChange;
}, [onDirtyChange]);
useEffect(() => {
onDirtyChangeRef.current?.(dirty);
}, [dirty]);
// Load on path change or explicit reload.
useEffect(() => {
let cancelled = false;
setDoc({ status: "loading" });
setDirty(false);
invoke<ReadResult>("fs_read_file", { path })
.then((res) => {
if (cancelled) return;
if (res.kind === "text") {
savedRef.current = res.content;
bufferRef.current = res.content;
setDoc({
status: "ready",
content: res.content,
size: res.size,
});
} else if (res.kind === "binary") {
setDoc({ status: "binary", size: res.size });
} else if (res.kind === "toolarge") {
setDoc({
status: "toolarge",
size: res.size,
limit: res.limit,
});
}
})
.catch((e) => {
if (!cancelled) setDoc({ status: "error", message: String(e) });
});
return () => {
cancelled = true;
};
}, [path, reloadCounter]);
/** Re-read the file from disk. No-op (silent) if the buffer is dirty —
* callers shouldn't clobber unsaved user edits. Returns whether reload ran. */
const reload = useCallback((): boolean => {
if (dirtyRef.current) return false;
setReloadCounter((n) => n + 1);
return true;
}, []);
const onChange = useCallback((next: string) => {
bufferRef.current = next;
setDirty(next !== savedRef.current);
}, []);
const save = useCallback(async () => {
if (!dirty) return;
const content = bufferRef.current;
await invoke("fs_write_file", { path, content });
savedRef.current = content;
setDirty(false);
}, [path, dirty]);
return { doc, dirty, onChange, save, reload };
}
|