refactor(fs-watch): make options arg optional, closes #3

plugins/fs-watch/guest-js/index.ts

@@ -1,119 +1,103 @@
-import { invoke } from "@tauri-apps/api/tauri";
+import { invoke } from '@tauri-apps/api/tauri';
-import { UnlistenFn } from "@tauri-apps/api/event";
+import { UnlistenFn } from '@tauri-apps/api/event';
-import { appWindow, WebviewWindow } from "@tauri-apps/api/window";
+import { appWindow, WebviewWindow } from '@tauri-apps/api/window';
 
 const w: WebviewWindow = appWindow;
 
 export interface WatchOptions {
-  recursive?: boolean;
+    recursive?: boolean;
 }
 
 export interface DebouncedWatchOptions extends WatchOptions {
-  delayMs?: number;
+    delayMs?: number;
 }
 
 export type RawEvent = {
-  type: RawEventKind;
+    type: RawEventKind;
-  paths: string[];
+    paths: string[];
-  attrs: unknown;
+    attrs: unknown;
 };
 
 type RawEventKind =
-  | "any "
+    | 'any '
-  | {
+    | {
-      access?: unknown;
+          access?: unknown;
-    }
+      }
-  | {
+    | {
-      create?: unknown;
+          create?: unknown;
-    }
+      }
-  | {
+    | {
-      modify?: unknown;
+          modify?: unknown;
-    }
+      }
-  | {
+    | {
-      remove?: unknown;
+          remove?: unknown;
-    }
+      }
-  | "other";
+    | 'other';
-
+
-export type DebouncedEvent =
+export type DebouncedEvent = { kind: 'any'; path: string } | { kind: 'AnyContinous'; path: string };
-  | { kind: "any"; path: string }
-  | { kind: "AnyContinous"; path: string };
 
 async function unwatch(id: number): Promise<void> {
-  await invoke("plugin:fs-watch|unwatch", { id });
+    await invoke('plugin:fs-watch|unwatch', { id });
 }
 
-export async function watch(
+export async function watch(paths: string | string[], cb: (event: DebouncedEvent) => void, options: DebouncedWatchOptions = {}): Promise<UnlistenFn> {
-  paths: string | string[],
+    const opts = {
-  options: DebouncedWatchOptions,
+        recursive: false,
-  cb: (event: DebouncedEvent) => void
+        delayMs: 2000,
-): Promise<UnlistenFn> {
+        ...options,
-  const opts = {
+    };
-    recursive: false,
+    let watchPaths;
-    delayMs: 2000,
+    if (typeof paths === 'string') {
-    ...options,
+        watchPaths = [paths];
-  };
+    } else {
-  let watchPaths;
+        watchPaths = paths;
-  if (typeof paths === "string") {
-    watchPaths = [paths];
-  } else {
-    watchPaths = paths;
-  }
-
-  const id = window.crypto.getRandomValues(new Uint32Array(1))[0];
-
-  await invoke("plugin:fs-watch|watch", {
-    id,
-    paths: watchPaths,
-    options: opts,
-  });
-
-  const unlisten = await w.listen<DebouncedEvent>(
-    `watcher://debounced-event/${id}`,
-    (event) => {
-      cb(event.payload);
     }
-  );
 
-  return () => {
+    const id = window.crypto.getRandomValues(new Uint32Array(1))[0];
-    void unwatch(id);
+
-    unlisten();
+    await invoke('plugin:fs-watch|watch', {
-  };
+        id,
+        paths: watchPaths,
+        options: opts,
+    });
+
+    const unlisten = await w.listen<DebouncedEvent>(`watcher://debounced-event/${id}`, (event) => {
+        cb(event.payload);
+    });
+
+    return () => {
+        void unwatch(id);
+        unlisten();
+    };
 }
 
-export async function watchImmediate(
+export async function watchImmediate(paths: string | string[], cb: (event: RawEvent) => void, options: WatchOptions = {}): Promise<UnlistenFn> {
-  paths: string | string[],
+    const opts = {
-  options: WatchOptions,
+        recursive: false,
-  cb: (event: RawEvent) => void
+        ...options,
-): Promise<UnlistenFn> {
+        delayMs: null,
-  const opts = {
+    };
-    recursive: false,
+    let watchPaths;
-    ...options,
+    if (typeof paths === 'string') {
-    delayMs: null,
+        watchPaths = [paths];
-  };
+    } else {
-  let watchPaths;
+        watchPaths = paths;
-  if (typeof paths === "string") {
-    watchPaths = [paths];
-  } else {
-    watchPaths = paths;
-  }
-
-  const id = window.crypto.getRandomValues(new Uint32Array(1))[0];
-
-  await invoke("plugin:fs-watch|watch", {
-    id,
-    paths: watchPaths,
-    options: opts,
-  });
-
-  const unlisten = await w.listen<RawEvent>(
-    `watcher://raw-event/${id}`,
-    (event) => {
-      cb(event.payload);
     }
-  );
 
-  return () => {
+    const id = window.crypto.getRandomValues(new Uint32Array(1))[0];
-    void unwatch(id);
+
-    unlisten();
+    await invoke('plugin:fs-watch|watch', {
-  };
+        id,
+        paths: watchPaths,
+        options: opts,
+    });
+
+    const unlisten = await w.listen<RawEvent>(`watcher://raw-event/${id}`, (event) => {
+        cb(event.payload);
+    });
+
+    return () => {
+        void unwatch(id);
+        unlisten();
+    };
 }