opfs-worker 0.2.3 → 0.2.5

package/dist/raw.js

@@ -1,6 +1,6 @@
-import { expose as v } from "comlink";
-import { d as I, O as o, b as f, s as u, P as g, i as p, o as S, F as d, w as E, j as T, e as m, f as y, k as M, r as H, n as F, l as P } from "./helpers-Co-qCBmA.js";
-class $ {
+import { expose as p } from "comlink";
+import { d as S, O as n, b as l, s as w, P as g, i as I, o as v, F as f, w as F, j as T, e as y, f as u, k as M, r as A, n as d, l as $ } from "./helpers-3TGPHd1h.js";
+class O {
   /** Root directory handle for the file system */
   root = null;
   /** Watch event callback */
@@ -15,15 +15,45 @@ class $ {
   scanning = !1;
   /** Promise to prevent concurrent mount operations */
   mountingPromise = null;
+  /** Hash algorithm for file hashing (null means no hashing) */
+  hashAlgorithm = null;
+  /**
+   * Notify about internal changes to the file system
+   * 
+   * This method is called by internal operations to notify clients about
+   * changes, even when no specific paths are being watched.
+   * 
+   * @param path - The path that was changed
+   * @param type - The type of change (create, change, delete)
+   */
+  async notifyChange(t) {
+    if (!this.watchCallback)
+      return;
+    let e;
+    if (this.hashAlgorithm && !t.isDirectory && t.type !== "removed")
+      try {
+        const i = await this.stat(t.path);
+        i.isFile && i.hash && (e = i.hash);
+      } catch (i) {
+        console.warn(`Failed to calculate hash for ${t.path}:`, i);
+      }
+    this.watchCallback({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...t,
+      ...e && { hash: e }
+    });
+  }
   /**
    * Creates a new OPFSFileSystem instance
    * 
    * @param watchCallback - Optional callback for file change events
-   * @param watchOptions - Optional configuration for watching
+   * @param options - Optional configuration options
+   * @param options.watchInterval - Polling interval in milliseconds for file watching
+   * @param options.hashAlgorithm - Hash algorithm for file hashing
    * @throws {OPFSError} If OPFS is not supported in the current browser
    */
   constructor(t, e) {
-    I(), t && (this.watchCallback = t, e?.watchInterval && (this.watchInterval = e.watchInterval)), this.mount("/");
+    S(), t && (this.watchCallback = t), e && this.setOptions(e), this.mount("/");
   }
   /**
    * Initialize the file system within a given directory
@@ -53,7 +83,7 @@ class $ {
         const r = await navigator.storage.getDirectory();
         t === "/" ? this.root = r : this.root = await this.getDirectoryHandle(t, !0, r), e(!0);
       } catch (r) {
-        console.error(r), i(new o("Failed to initialize OPFS", "INIT_FAILED"));
+        console.error(r), i(new n("Failed to initialize OPFS", "INIT_FAILED"));
       } finally {
         this.mountingPromise = null;
       }
@@ -63,10 +93,19 @@ class $ {
    * Set the watch callback for file change events
    * 
    * @param callback - The callback function to invoke when files change
-   * @param options - Optional configuration for watching
    */
-  setWatchCallback(t, e) {
-    this.watchCallback = t, e?.watchInterval && (this.watchInterval = e.watchInterval);
+  setWatchCallback(t) {
+    this.watchCallback = t;
+  }
+  /**
+   * Set configuration options for the file system
+   * 
+   * @param options - Configuration options to update
+   * @param options.watchInterval - Polling interval in milliseconds for file watching
+   * @param options.hashAlgorithm - Hash algorithm for file hashing
+   */
+  setOptions(t) {
+    t.watchInterval !== void 0 && (this.watchInterval = t.watchInterval), t.hashAlgorithm !== void 0 && (this.hashAlgorithm = t.hashAlgorithm);
   }
   /**
    * Automatically mount the OPFS root if not already mounted
@@ -83,7 +122,7 @@ class $ {
         await this.mountingPromise;
         return;
       }
-      throw new o("OPFS not mounted", "NOT_MOUNTED");
+      throw new n("OPFS not mounted", "NOT_MOUNTED");
     }
   }
   /**
@@ -106,11 +145,11 @@ class $ {
    */
   async getDirectoryHandle(t, e = !1, i = this.root) {
     if (!i)
-      throw new f();
-    const r = Array.isArray(t) ? t : u(t);
+      throw new l();
+    const r = Array.isArray(t) ? t : w(t);
     let a = i;
-    for (const n of r)
-      a = await a.getDirectoryHandle(n, { create: e });
+    for (const s of r)
+      a = await a.getDirectoryHandle(s, { create: e });
     return a;
   }
   /**
@@ -134,43 +173,25 @@ class $ {
    */
   async getFileHandle(t, e = !1, i = this.root) {
     if (!i)
-      throw new f();
-    const r = u(t);
+      throw new l();
+    const r = w(t);
     if (r.length === 0)
       throw new g("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
     const a = r.pop();
     return (await this.getDirectoryHandle(r, e, i)).getFileHandle(a, { create: e });
   }
   /**
-   * Recursively list all files and directories with their stats
+   * Get a complete index of all files and directories in the file system
    * 
-   * Traverses the entire file system starting from the root and returns
-   * a Map containing all paths and their corresponding file statistics.
+   * This method recursively traverses the entire file system and returns
+   * a Map containing FileStat objects for every file and directory.
    * 
-   * @param options - Options for indexing
-   * @param options.includeHash - Whether to calculate file hash (default: false)
-   * @param options.hashAlgorithm - Hash algorithm to use (default: 'SHA-1', fastest)
-   * @returns Promise that resolves to a Map of path => FileStat
-   * @throws {OPFSError} If the indexing operation fails
+   * @returns Promise that resolves to a Map of paths to FileStat objects
+   * @throws {OPFSError} If the file system is not mounted
    * 
    * @example
    * ```typescript
-   * // Basic index without hash
    * const index = await fs.index();
-   * 
-   * // Index with file hash
-   * const indexWithHash = await fs.index({ 
-   *   includeHash: true,
-   *   hashAlgorithm: 'SHA-1'
-   * });
-   * 
-   * // Iterate through all files and directories
-   * for (const [path, stat] of index) {
-   *   console.log(`${path}: ${stat.isFile ? 'file' : 'directory'} (${stat.size} bytes)`);
-   *   if (stat.hash) console.log(`  Hash: ${stat.hash}`);
-   * }
-   * 
-   * // Get specific file stats
    * const fileStats = index.get('/data/config.json');
    * if (fileStats) {
    *   console.log(`File size: ${fileStats.size} bytes`);
@@ -178,35 +199,35 @@ class $ {
    * }
    * ```
    */
-  async index(t) {
-    const e = /* @__PURE__ */ new Map(), i = async (r) => {
-      const a = await this.readdir(r, { withFileTypes: !0 });
-      for (const n of a) {
-        const s = `${r === "/" ? "" : r}/${n.name}`;
+  async index() {
+    const t = /* @__PURE__ */ new Map(), e = async (i) => {
+      const r = await this.readdir(i, { withFileTypes: !0 });
+      for (const a of r) {
+        const s = `${i === "/" ? "" : i}/${a.name}`;
         try {
-          const c = await this.stat(s, t);
-          e.set(s, c), c.isDirectory && await i(s);
-        } catch (c) {
-          console.warn(`Skipping broken entry: ${s}`, c);
+          const o = await this.stat(s);
+          t.set(s, o), o.isDirectory && await e(s);
+        } catch (o) {
+          console.warn(`Skipping broken entry: ${s}`, o);
         }
       }
     };
-    return e.set("/", {
+    return t.set("/", {
       kind: "directory",
       size: 0,
       mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
       ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
       isFile: !1,
       isDirectory: !0
-    }), await i("/"), e;
+    }), await e("/"), t;
   }
   async readFile(t, e = "utf-8") {
     await this.ensureMounted();
     try {
-      const i = await this.getFileHandle(t, !1), r = await p(i);
-      return e === "binary" ? r : S(r, e);
+      const i = await this.getFileHandle(t, !1), r = await I(i);
+      return e === "binary" ? r : v(r, e);
     } catch (i) {
-      throw console.error(i), new d(t);
+      throw console.error(i), new f(t);
     }
   }
   /**
@@ -237,7 +258,7 @@ class $ {
   async writeFile(t, e, i) {
     await this.ensureMounted();
     const r = await this.getFileHandle(t, !0);
-    await E(r, e, i, { truncate: !0 });
+    await F(r, e, i, { truncate: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
   }
   /**
    * Append data to a file
@@ -264,7 +285,7 @@ class $ {
   async appendFile(t, e, i) {
     await this.ensureMounted();
     const r = await this.getFileHandle(t, !0);
-    await E(r, e, i, { append: !0 });
+    await F(r, e, i, { append: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
   }
   /**
    * Create a directory
@@ -289,51 +310,45 @@ class $ {
    */
   async mkdir(t, e) {
     if (await this.ensureMounted(), !this.root)
-      throw new f();
-    const i = e?.recursive ?? !1, r = u(t);
+      throw new l();
+    const i = e?.recursive ?? !1, r = w(t);
     let a = this.root;
-    for (let n = 0; n < r.length; n++) {
-      const s = r[n];
+    for (let s = 0; s < r.length; s++) {
+      const o = r[s];
       try {
-        a = await a.getDirectoryHandle(s, { create: i || n === r.length - 1 });
+        a = await a.getDirectoryHandle(o, { create: i || s === r.length - 1 });
       } catch (c) {
-        throw c.name === "NotFoundError" ? new o(
-          `Parent directory does not exist: ${T(r.slice(0, n + 1))}`,
+        throw c.name === "NotFoundError" ? new n(
+          `Parent directory does not exist: ${T(r.slice(0, s + 1))}`,
           "ENOENT"
-        ) : c.name === "TypeMismatchError" ? new o(`Path segment is not a directory: ${s}`, "ENOTDIR") : new o("Failed to create directory", "MKDIR_FAILED");
+        ) : c.name === "TypeMismatchError" ? new n(`Path segment is not a directory: ${o}`, "ENOTDIR") : new n("Failed to create directory", "MKDIR_FAILED");
       }
     }
+    await this.notifyChange({ path: t, type: "added", isDirectory: !0 });
   }
   /**
-   * Get file or directory stats
+   * Get file or directory statistics
    * 
-   * Retrieves metadata about a file or directory, including size, modification time,
-   * type information, and optionally file hashes.
+   * Returns detailed information about a file or directory, including
+   * size, modification time, and optionally a hash of the file content.
    * 
    * @param path - The path to the file or directory
-   * @param options - Options for stat operation
-   * @param options.includeHash - Whether to calculate file hash (default: false, only for files)
-   * @param options.hashAlgorithm - Hash algorithm to use (default: 'SHA-1', fastest)
-   * @returns Promise that resolves to file/directory statistics
-   * @throws {OPFSError} If the file or directory does not exist or cannot be accessed
+   * @returns Promise that resolves to FileStat object
+   * @throws {OPFSError} If the path does not exist or cannot be accessed
    * 
    * @example
    * ```typescript
-   * // Basic stats
-   * const stats = await fs.stat('/config/settings.json');
+   * const stats = await fs.stat('/data/config.json');
    * console.log(`File size: ${stats.size} bytes`);
-   * console.log(`Is file: ${stats.isFile}`);
-   * console.log(`Modified: ${stats.mtime}`);
-   * 
-   * // Stats with hash (SHA-1 is fastest)
-   * const statsWithHash = await fs.stat('/config/settings.json', { 
-   *   includeHash: true,
-   *   hashAlgorithm: 'SHA-1'
-   * });
-   * console.log(`Hash: ${statsWithHash.hash}`);
+   * console.log(`Last modified: ${stats.mtime}`);
+   * 
+   * // If hashing is enabled, hash will be included
+   * if (stats.hash) {
+   *   console.log(`Hash: ${stats.hash}`);
+   * }
    * ```
    */
-  async stat(t, e) {
+  async stat(t) {
     if (await this.ensureMounted(), t === "/")
       return {
         kind: "directory",
@@ -343,30 +358,30 @@ class $ {
         isFile: !1,
         isDirectory: !0
       };
-    const i = m(t), r = await this.getDirectoryHandle(y(t), !1), a = e?.includeHash ?? !1, n = e?.hashAlgorithm ?? "SHA-1";
+    const e = y(t), i = await this.getDirectoryHandle(u(t), !1), r = this.hashAlgorithm !== null;
     try {
-      const c = await (await r.getFileHandle(i, { create: !1 })).getFile(), l = {
+      const s = await (await i.getFileHandle(e, { create: !1 })).getFile(), o = {
         kind: "file",
-        size: c.size,
-        mtime: new Date(c.lastModified).toISOString(),
-        ctime: new Date(c.lastModified).toISOString(),
+        size: s.size,
+        mtime: new Date(s.lastModified).toISOString(),
+        ctime: new Date(s.lastModified).toISOString(),
         isFile: !0,
         isDirectory: !1
       };
-      if (a)
+      if (r && this.hashAlgorithm)
         try {
-          const h = new Uint8Array(await c.arrayBuffer()), w = await M(h, n);
-          l.hash = w;
-        } catch (h) {
-          console.warn(`Failed to calculate hash for ${t}:`, h);
+          const c = await M(s, this.hashAlgorithm);
+          o.hash = c;
+        } catch (c) {
+          console.warn(`Failed to calculate hash for ${t}:`, c);
         }
-      return l;
-    } catch (s) {
-      if (s.name !== "TypeMismatchError" && s.name !== "NotFoundError")
-        throw new o("Failed to stat (file)", "STAT_FAILED");
+      return o;
+    } catch (a) {
+      if (a.name !== "TypeMismatchError" && a.name !== "NotFoundError")
+        throw new n("Failed to stat (file)", "STAT_FAILED");
     }
     try {
-      return await r.getDirectoryHandle(i, { create: !1 }), {
+      return await i.getDirectoryHandle(e, { create: !1 }), {
         kind: "directory",
         size: 0,
         mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
@@ -374,8 +389,8 @@ class $ {
         isFile: !1,
         isDirectory: !0
       };
-    } catch (s) {
-      throw s.name === "NotFoundError" ? new o(`No such file or directory: ${t}`, "ENOENT") : new o("Failed to stat (directory)", "STAT_FAILED");
+    } catch (a) {
+      throw a.name === "NotFoundError" ? new n(`No such file or directory: ${t}`, "ENOENT") : new n("Failed to stat (directory)", "STAT_FAILED");
     }
   }
   async readdir(t, e) {
@@ -383,11 +398,11 @@ class $ {
     const i = e?.withFileTypes ?? !1, r = await this.getDirectoryHandle(t, !1);
     if (i) {
       const a = [];
-      for await (const [n, s] of r.entries()) {
-        const c = s.kind === "file";
+      for await (const [s, o] of r.entries()) {
+        const c = o.kind === "file";
         a.push({
-          name: n,
-          kind: s.kind,
+          name: s,
+          kind: o.kind,
           isFile: c,
           isDirectory: !c
         });
@@ -395,8 +410,8 @@ class $ {
       return a;
     } else {
       const a = [];
-      for await (const [n] of r.entries())
-        a.push(n);
+      for await (const [s] of r.entries())
+        a.push(s);
       return a;
     }
   }
@@ -417,10 +432,10 @@ class $ {
   async exists(t) {
     if (await this.ensureMounted(), t === "/")
       return !0;
-    const e = m(t);
+    const e = y(t);
     let i = null;
     try {
-      i = await this.getDirectoryHandle(y(t), !1);
+      i = await this.getDirectoryHandle(u(t), !1);
     } catch (r) {
       throw (r.name === "NotFoundError" || r.name === "TypeMismatchError") && (i = null), r;
     }
@@ -467,8 +482,9 @@ class $ {
         const r = `${t === "/" ? "" : t}/${i.name}`;
         await this.remove(r, { recursive: !0 });
       }
+      await this.notifyChange({ path: t, type: "changed", isDirectory: !0 });
     } catch (e) {
-      throw e instanceof o ? e : new o(`Failed to clear directory: ${t}`, "CLEAR_FAILED");
+      throw e instanceof n ? e : new n(`Failed to clear directory: ${t}`, "CLEAR_FAILED");
     }
   }
   /**
@@ -499,19 +515,20 @@ class $ {
     await this.ensureMounted();
     const i = e?.recursive ?? !1, r = e?.force ?? !1;
     if (t === "/")
-      throw new o("Cannot remove root directory", "EROOT");
-    const a = m(t);
+      throw new n("Cannot remove root directory", "EROOT");
+    const a = y(t);
     if (!a)
       throw new g("Invalid path", t);
-    const n = await this.getDirectoryHandle(y(t), !1);
+    const s = await this.getDirectoryHandle(u(t), !1);
     try {
-      await n.removeEntry(a, { recursive: i });
-    } catch (s) {
-      if (s.name === "NotFoundError") {
+      await s.removeEntry(a, { recursive: i });
+    } catch (o) {
+      if (o.name === "NotFoundError") {
         if (!r)
-          throw new o(`No such file or directory: ${t}`, "ENOENT");
-      } else throw s.name === "InvalidModificationError" ? new o(`Directory not empty: ${t}. Use recursive option to force removal.`, "ENOTEMPTY") : s.name === "TypeMismatchError" && !i ? new o(`Cannot remove directory without recursive option: ${t}`, "EISDIR") : new o(`Failed to remove path: ${t}`, "RM_FAILED");
+          throw new n(`No such file or directory: ${t}`, "ENOENT");
+      } else throw o.name === "InvalidModificationError" ? new n(`Directory not empty: ${t}. Use recursive option to force removal.`, "ENOTEMPTY") : o.name === "TypeMismatchError" && !i ? new n(`Cannot remove directory without recursive option: ${t}`, "EISDIR") : new n(`Failed to remove path: ${t}`, "RM_FAILED");
     }
+    await this.notifyChange({ path: t, type: "removed", isDirectory: !1 });
   }
   /**
    * Resolve a path to an absolute path
@@ -534,12 +551,12 @@ class $ {
   async realpath(t) {
     await this.ensureMounted();
     try {
-      const e = H(t);
+      const e = A(t);
       if (!await this.exists(e))
-        throw new d(e);
+        throw new f(e);
       return e;
     } catch (e) {
-      throw e instanceof o ? e : new o(`Failed to resolve path: ${t}`, "REALPATH_FAILED");
+      throw e instanceof n ? e : new n(`Failed to resolve path: ${t}`, "REALPATH_FAILED");
     }
   }
   /**
@@ -562,10 +579,10 @@ class $ {
     await this.ensureMounted();
     try {
       if (!await this.exists(t))
-        throw new d(t);
-      await this.copy(t, e, { recursive: !0 }), await this.remove(t, { recursive: !0 });
+        throw new f(t);
+      await this.copy(t, e, { recursive: !0 }), await this.remove(t, { recursive: !0 }), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 }), await this.notifyChange({ path: e, type: "added", isDirectory: !1 });
     } catch (i) {
-      throw i instanceof o ? i : new o(`Failed to rename from ${t} to ${e}`, "RENAME_FAILED");
+      throw i instanceof n ? i : new n(`Failed to rename from ${t} to ${e}`, "RENAME_FAILED");
     }
   }
   /**
@@ -598,24 +615,25 @@ class $ {
     try {
       const r = i?.recursive ?? !1, a = i?.force ?? !0;
       if (!await this.exists(t))
-        throw new o(`Source does not exist: ${t}`, "ENOENT");
+        throw new n(`Source does not exist: ${t}`, "ENOENT");
       if (await this.exists(e) && !a)
-        throw new o(`Destination already exists: ${e}`, "EEXIST");
+        throw new n(`Destination already exists: ${e}`, "EEXIST");
       if ((await this.stat(t)).isFile) {
-        const l = await this.readFile(t, "binary");
-        await this.writeFile(e, l);
+        const h = await this.readFile(t, "binary");
+        await this.writeFile(e, h);
       } else {
         if (!r)
-          throw new o(`Cannot copy directory without recursive option: ${t}`, "EISDIR");
+          throw new n(`Cannot copy directory without recursive option: ${t}`, "EISDIR");
         await this.mkdir(e, { recursive: !0 });
-        const l = await this.readdir(t, { withFileTypes: !0 });
-        for (const h of l) {
-          const w = `${t}/${h.name}`, D = `${e}/${h.name}`;
-          await this.copy(w, D, { recursive: !0, force: a });
+        const h = await this.readdir(t, { withFileTypes: !0 });
+        for (const m of h) {
+          const D = `${t}/${m.name}`, E = `${e}/${m.name}`;
+          await this.copy(D, E, { recursive: !0, force: a });
         }
       }
+      await this.notifyChange({ path: e, type: "added", isDirectory: !1 });
     } catch (r) {
-      throw r instanceof o ? r : new o(`Failed to copy from ${t} to ${e}`, "CP_FAILED");
+      throw r instanceof n ? r : new n(`Failed to copy from ${t} to ${e}`, "CP_FAILED");
     }
   }
   /**
@@ -623,7 +641,7 @@ class $ {
    */
   async watch(t) {
     await this.ensureMounted();
-    const e = F(t), i = await this.buildSnapshot(e);
+    const e = d(t), i = await this.buildSnapshot(e);
     this.watchers.set(e, i), this.watchTimer || (this.watchTimer = setInterval(() => {
       this.scanWatches();
     }, this.watchInterval));
@@ -632,16 +650,16 @@ class $ {
    * Stop watching a previously watched path
    */
   unwatch(t) {
-    const e = F(t);
+    const e = d(t);
     this.watchers.delete(e), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
   }
   async buildSnapshot(t) {
     const e = /* @__PURE__ */ new Map(), i = async (r) => {
       const a = await this.stat(r);
       if (e.set(r, a), a.isDirectory) {
-        const n = await this.readdir(r, { withFileTypes: !0 });
-        for (const s of n) {
-          const c = `${r === "/" ? "" : r}/${s.name}`;
+        const s = await this.readdir(r, { withFileTypes: !0 });
+        for (const o of s) {
+          const c = `${r === "/" ? "" : r}/${o.name}`;
           await i(c);
         }
       }
@@ -660,16 +678,12 @@ class $ {
             } catch {
               i = /* @__PURE__ */ new Map();
             }
-            const r = [];
-            for (const [a, n] of i) {
-              const s = e.get(a);
-              s ? (s.mtime !== n.mtime || s.size !== n.size) && r.push({ path: a, type: "change" }) : r.push({ path: a, type: "create" });
+            for (const [r, a] of i) {
+              const s = e.get(r);
+              s ? (s.mtime !== a.mtime || s.size !== a.size) && await this.notifyChange({ path: r, type: "changed", isDirectory: !1 }) : await this.notifyChange({ path: r, type: "added", isDirectory: !1 });
             }
-            for (const a of e.keys())
-              i.has(a) || r.push({ path: a, type: "delete" });
-            if (r.length && this.watchCallback)
-              for (const a of r)
-                this.watchCallback(a);
+            for (const r of e.keys())
+              i.has(r) || await this.notifyChange({ path: r, type: "removed", isDirectory: !1 });
             this.watchers.set(t, i);
           })
         );
@@ -711,17 +725,18 @@ class $ {
     try {
       (e?.cleanBefore ?? !1) && await this.clear("/");
       for (const [r, a] of t) {
-        const n = F(r);
-        let s;
-        a instanceof Blob ? s = await P(a) : s = a, await this.writeFile(n, s);
+        const s = d(r);
+        let o;
+        a instanceof Blob ? o = await $(a) : o = a, await this.writeFile(s, o);
       }
+      await this.notifyChange({ path: "/", type: "changed", isDirectory: !0 });
     } catch (i) {
-      throw i instanceof o ? i : new o("Failed to sync file system", "SYNC_FAILED");
+      throw i instanceof n ? i : new n("Failed to sync file system", "SYNC_FAILED");
     }
   }
 }
-typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && v(new $());
+typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && p(new O());
 export {
-  $ as OPFSWorker
+  O as OPFSWorker
 };
 //# sourceMappingURL=raw.js.map