opfs-worker 0.3.3 → 0.4.2

package/dist/raw.js

@@ -1,9 +1,9 @@
-import { expose as p } from "comlink";
-import { d as S, O as n, b as l, s as w, P as g, i as v, o as I, F as f, w as D, j as C, e as d, f as y, k as M, r as T, n as u, l as b } from "./helpers-DxFcNkZe.js";
-class A {
+import { expose as v } from "comlink";
+import { d as S, n as f, O as n, b as m, s as u, P as E, k as I, p as C, F as g, w as p, j as b, e as D, f as F, l as T, r as x, i as d, m as A } from "./helpers-BgMlBRWa.js";
+class $ {
   /** Root directory handle for the file system */
   root = null;
-  /** Map of watched paths to their last known state */
+  /** Map of watched paths to their last known state and options */
   watchers = /* @__PURE__ */ new Map();
   /** Interval handle for polling watched paths */
   watchTimer = null;
@@ -15,6 +15,7 @@ class A {
   broadcastChannel = null;
   /** Configuration options */
   options = {
+    root: "/",
     watchInterval: 1e3,
     maxFileSize: 50 * 1024 * 1024,
     hashAlgorithm: null,
@@ -43,7 +44,7 @@ class A {
     try {
       this.broadcastChannel || (this.broadcastChannel = new BroadcastChannel(this.options.broadcastChannel));
       const i = {
-        root: this.root.name,
+        root: this.options.root,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         ...t,
         ...e && { hash: e }
@@ -57,13 +58,14 @@ class A {
    * Creates a new OPFSFileSystem instance
    * 
    * @param options - Optional configuration options
+   * @param options.root - Root path for the file system (default: '/')
    * @param options.watchInterval - Polling interval in milliseconds for file watching
    * @param options.hashAlgorithm - Hash algorithm for file hashing
    * @param options.maxFileSize - Maximum file size for hashing in bytes (default: 50MB)
    * @throws {OPFSError} If OPFS is not supported in the current browser
    */
   constructor(t) {
-    S(), t && this.setOptions(t), this.mount("/");
+    S(), t && this.setOptions(t);
   }
   /**
    * Initialize the file system within a given directory
@@ -86,8 +88,8 @@ class A {
    * await fs.mount('/my-app');
    * ```
    */
-  async mount(t = "/") {
-    return this.mountingPromise && await this.mountingPromise, this.mountingPromise = new Promise(async (e, i) => {
+  async mount(t = this.options.root) {
+    return this.mountingPromise && await this.mountingPromise, t = f(t), this.mountingPromise = new Promise(async (e, i) => {
       this.root = null;
       try {
         const a = await navigator.storage.getDirectory();
@@ -103,31 +105,14 @@ class A {
    * Update configuration options
    * 
    * @param options - Configuration options to update
+   * @param options.root - Root path for the file system
    * @param options.watchInterval - Polling interval in milliseconds for file watching
    * @param options.hashAlgorithm - Hash algorithm for file hashing
    * @param options.maxFileSize - Maximum file size for hashing in bytes
    * @param options.broadcastChannel - Custom name for the broadcast channel
    */
-  setOptions(t) {
-    t.watchInterval !== void 0 && (this.options.watchInterval = t.watchInterval), t.hashAlgorithm !== void 0 && (this.options.hashAlgorithm = t.hashAlgorithm), t.maxFileSize !== void 0 && (this.options.maxFileSize = t.maxFileSize), t.broadcastChannel !== void 0 && (this.broadcastChannel && this.options.broadcastChannel !== t.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.options.broadcastChannel = t.broadcastChannel);
-  }
-  /**
-   * Automatically mount the OPFS root if not already mounted
-   * 
-   * This method is called internally when file operations are performed
-   * without explicitly mounting first.
-   * 
-   * @returns Promise that resolves when auto-mount is complete
-   * @throws {OPFSError} If auto-mount fails
-   */
-  async ensureMounted() {
-    if (!this.root) {
-      if (this.mountingPromise) {
-        await this.mountingPromise;
-        return;
-      }
-      throw new n("OPFS not mounted", "NOT_MOUNTED");
-    }
+  async setOptions(t) {
+    t.watchInterval !== void 0 && (this.options.watchInterval = t.watchInterval), t.hashAlgorithm !== void 0 && (this.options.hashAlgorithm = t.hashAlgorithm), t.maxFileSize !== void 0 && (this.options.maxFileSize = t.maxFileSize), t.broadcastChannel !== void 0 && (this.broadcastChannel && this.options.broadcastChannel !== t.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.options.broadcastChannel = t.broadcastChannel), t.root !== void 0 && (this.options.root = t.root, await this.mount(this.options.root));
   }
   /**
    * Get a directory handle from a path
@@ -149,8 +134,8 @@ class A {
    */
   async getDirectoryHandle(t, e = !1, i = this.root) {
     if (!i)
-      throw new l();
-    const a = Array.isArray(t) ? t : w(t);
+      throw new m();
+    const a = Array.isArray(t) ? t : u(t);
     let r = i;
     for (const s of a)
       r = await r.getDirectoryHandle(s, { create: e });
@@ -177,10 +162,10 @@ class A {
    */
   async getFileHandle(t, e = !1, i = this.root) {
     if (!i)
-      throw new l();
-    const a = w(t);
+      throw new m();
+    const a = u(t);
     if (a.length === 0)
-      throw new g("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
+      throw new E("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
     const r = a.pop();
     return (await this.getDirectoryHandle(a, e, i)).getFileHandle(r, { create: e });
   }
@@ -226,12 +211,12 @@ class A {
     }), await e("/"), t;
   }
   async readFile(t, e = "utf-8") {
-    await this.ensureMounted();
+    await this.mount();
     try {
-      const i = await this.getFileHandle(t, !1), a = await v(i);
-      return e === "binary" ? a : I(a, e);
+      const i = await this.getFileHandle(t, !1), a = await I(i);
+      return e === "binary" ? a : C(a, e);
     } catch (i) {
-      throw console.error(i), new f(t);
+      throw console.error(i), new g(t);
     }
   }
   /**
@@ -260,9 +245,9 @@ class A {
    * ```
    */
   async writeFile(t, e, i) {
-    await this.ensureMounted();
+    await this.mount();
     const a = await this.getFileHandle(t, !0);
-    await D(a, e, i, { truncate: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
+    await p(a, e, i, { truncate: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
   }
   /**
    * Append data to a file
@@ -287,9 +272,9 @@ class A {
    * ```
    */
   async appendFile(t, e, i) {
-    await this.ensureMounted();
+    await this.mount();
     const a = await this.getFileHandle(t, !0);
-    await D(a, e, i, { append: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
+    await p(a, e, i, { append: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
   }
   /**
    * Create a directory
@@ -313,9 +298,9 @@ class A {
    * ```
    */
   async mkdir(t, e) {
-    if (await this.ensureMounted(), !this.root)
-      throw new l();
-    const i = e?.recursive ?? !1, a = w(t);
+    if (await this.mount(), !this.root)
+      throw new m();
+    const i = e?.recursive ?? !1, a = u(t);
     let r = this.root;
     for (let s = 0; s < a.length; s++) {
       const o = a[s];
@@ -323,7 +308,7 @@ class A {
         r = await r.getDirectoryHandle(o, { create: i || s === a.length - 1 });
       } catch (c) {
         throw c.name === "NotFoundError" ? new n(
-          `Parent directory does not exist: ${C(a.slice(0, s + 1))}`,
+          `Parent directory does not exist: ${b(a.slice(0, s + 1))}`,
           "ENOENT"
         ) : c.name === "TypeMismatchError" ? new n(`Path segment is not a directory: ${o}`, "ENOTDIR") : new n("Failed to create directory", "MKDIR_FAILED");
       }
@@ -353,7 +338,7 @@ class A {
    * ```
    */
   async stat(t) {
-    if (await this.ensureMounted(), t === "/")
+    if (await this.mount(), t === "/")
       return {
         kind: "directory",
         size: 0,
@@ -362,7 +347,7 @@ class A {
         isFile: !1,
         isDirectory: !0
       };
-    const e = d(t), i = await this.getDirectoryHandle(y(t), !1), a = this.options.hashAlgorithm !== null;
+    const e = D(t), i = await this.getDirectoryHandle(F(t), !1), a = this.options.hashAlgorithm !== null;
     try {
       const s = await (await i.getFileHandle(e, { create: !1 })).getFile(), o = {
         kind: "file",
@@ -374,7 +359,7 @@ class A {
       };
       if (a && this.options.hashAlgorithm)
         try {
-          const c = await M(s, this.options.hashAlgorithm, this.options.maxFileSize);
+          const c = await T(s, this.options.hashAlgorithm, this.options.maxFileSize);
           o.hash = c;
         } catch (c) {
           console.warn(`Failed to calculate hash for ${t}:`, c);
@@ -416,7 +401,7 @@ class A {
    * ```
    */
   async readDir(t) {
-    await this.ensureMounted();
+    await this.mount();
     const e = await this.getDirectoryHandle(t, !1), i = [];
     for await (const [a, r] of e.entries()) {
       const s = r.kind === "file";
@@ -444,12 +429,12 @@ class A {
    * ```
    */
   async exists(t) {
-    if (await this.ensureMounted(), t === "/")
+    if (await this.mount(), t === "/")
       return !0;
-    const e = d(t);
+    const e = D(t);
     let i = null;
     try {
-      i = await this.getDirectoryHandle(y(t), !1);
+      i = await this.getDirectoryHandle(F(t), !1);
     } catch (a) {
       throw (a.name === "NotFoundError" || a.name === "TypeMismatchError") && (i = null), a;
     }
@@ -489,7 +474,7 @@ class A {
    * ```
    */
   async clear(t = "/") {
-    await this.ensureMounted();
+    await this.mount();
     try {
       const e = await this.readDir(t);
       for (const i of e) {
@@ -526,14 +511,14 @@ class A {
    * ```
    */
   async remove(t, e) {
-    await this.ensureMounted();
+    await this.mount();
     const i = e?.recursive ?? !1, a = e?.force ?? !1;
     if (t === "/")
       throw new n("Cannot remove root directory", "EROOT");
-    const r = d(t);
+    const r = D(t);
     if (!r)
-      throw new g("Invalid path", t);
-    const s = await this.getDirectoryHandle(y(t), !1);
+      throw new E("Invalid path", t);
+    const s = await this.getDirectoryHandle(F(t), !1);
     try {
       await s.removeEntry(r, { recursive: i });
     } catch (o) {
@@ -563,11 +548,11 @@ class A {
    * ```
    */
   async realpath(t) {
-    await this.ensureMounted();
+    await this.mount();
     try {
-      const e = T(t);
+      const e = x(t);
       if (!await this.exists(e))
-        throw new f(e);
+        throw new g(e);
       return e;
     } catch (e) {
       throw e instanceof n ? e : new n(`Failed to resolve path: ${t}`, "REALPATH_FAILED");
@@ -590,10 +575,10 @@ class A {
    * ```
    */
   async rename(t, e) {
-    await this.ensureMounted();
+    await this.mount();
     try {
       if (!await this.exists(t))
-        throw new f(t);
+        throw new g(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 n ? i : new n(`Failed to rename from ${t} to ${e}`, "RENAME_FAILED");
@@ -625,7 +610,7 @@ class A {
    * ```
    */
   async copy(t, e, i) {
-    await this.ensureMounted();
+    await this.mount();
     try {
       const a = i?.recursive ?? !1, r = i?.force ?? !0;
       if (!await this.exists(t))
@@ -640,9 +625,9 @@ class A {
           throw new n(`Cannot copy directory without recursive option: ${t}`, "EISDIR");
         await this.mkdir(e, { recursive: !0 });
         const h = await this.readDir(t);
-        for (const m of h) {
-          const F = `${t}/${m.name}`, E = `${e}/${m.name}`;
-          await this.copy(F, E, { recursive: !0, force: r });
+        for (const w of h) {
+          const y = `${t}/${w.name}`, l = `${e}/${w.name}`;
+          await this.copy(y, l, { recursive: !0, force: r });
         }
       }
       await this.notifyChange({ path: e, type: "added", isDirectory: !1 });
@@ -652,11 +637,29 @@ class A {
   }
   /**
    * Start watching a file or directory for changes
+   * 
+   * @param path - The path to watch
+   * @param options - Watch options
+   * @param options.recursive - Whether to watch recursively (default: true)
+   * @param options.excludes - Glob pattern(s) to exclude (minimatch).
+   * @returns Promise that resolves when watching starts
+   * 
+   * @example
+   * ```typescript
+   * // Watch entire directory tree recursively (default)
+   * await fs.watch('/data');
+   * 
+   * // Watch only immediate children (shallow)
+   * await fs.watch('/data', { recursive: false });
+   * 
+   * // Watch a single file
+   * await fs.watch('/config.json', { recursive: false });
+   * ```
    */
-  async watch(t) {
-    await this.ensureMounted();
-    const e = u(t), i = await this.buildSnapshot(e);
-    this.watchers.set(e, i), this.watchTimer || (this.watchTimer = setInterval(() => {
+  async watch(t, e) {
+    await this.mount();
+    const i = f(t), a = { recursive: !0, ...e }, r = await this.buildSnapshot(i, a);
+    this.watchers.set(i, { snapshot: r, options: a }), this.watchTimer || (this.watchTimer = setInterval(() => {
       this.scanWatches();
     }, this.options.watchInterval));
   }
@@ -664,7 +667,7 @@ class A {
    * Stop watching a previously watched path
    */
   unwatch(t) {
-    const e = u(t);
+    const e = f(t);
     this.watchers.delete(e), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
   }
   /**
@@ -676,41 +679,45 @@ class A {
   dispose() {
     this.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null), this.watchers.clear();
   }
-  async buildSnapshot(t) {
-    const e = /* @__PURE__ */ new Map(), i = async (a) => {
-      const r = await this.stat(a);
-      if (e.set(a, r), r.isDirectory) {
-        const s = await this.readDir(a);
-        for (const o of s) {
-          const c = `${a === "/" ? "" : a}/${o.name}`;
-          await i(c);
+  async buildSnapshot(t, e) {
+    const i = /* @__PURE__ */ new Map(), a = e?.recursive ?? !0, r = e?.excludes, s = async (c) => {
+      const h = await this.stat(c);
+      return i.set(c, h), h;
+    }, o = async (c) => {
+      if (d(c, r))
+        return;
+      if ((await s(c)).isDirectory) {
+        const w = await this.readDir(c);
+        for (const y of w) {
+          const l = `${c === "/" ? "" : c}/${y.name}`;
+          a ? await o(l) : d(l, r) || await s(l);
         }
       }
     };
-    return await i(t), e;
+    return await o(t), i;
   }
   async scanWatches() {
     if (!this.scanning) {
       this.scanning = !0;
       try {
         await Promise.all(
-          [...this.watchers.entries()].map(async ([t, e]) => {
-            let i;
+          [...this.watchers.entries()].map(async ([t, { snapshot: e, options: i }]) => {
+            let a;
             try {
-              i = await this.buildSnapshot(t);
+              a = await this.buildSnapshot(t, i);
             } catch {
-              i = /* @__PURE__ */ new Map();
+              a = /* @__PURE__ */ new Map();
             }
-            for (const [a, r] of i) {
-              const s = e.get(a);
-              s ? (s.mtime !== r.mtime || s.size !== r.size) && await this.notifyChange({ path: a, type: "changed", isDirectory: r.isDirectory }) : await this.notifyChange({ path: a, type: "added", isDirectory: r.isDirectory });
+            for (const [r, s] of a) {
+              const o = e.get(r);
+              d(r, i.excludes) || (o ? (o.mtime !== s.mtime || o.size !== s.size) && await this.notifyChange({ path: r, type: "changed", isDirectory: s.isDirectory }) : await this.notifyChange({ path: r, type: "added", isDirectory: s.isDirectory }));
             }
-            for (const a of e.keys())
-              if (!i.has(a)) {
-                const r = e.get(a);
-                await this.notifyChange({ path: a, type: "removed", isDirectory: r?.isDirectory ?? !1 });
+            for (const r of e.keys())
+              if (!d(r, i.excludes) && !a.has(r)) {
+                const s = e.get(r);
+                await this.notifyChange({ path: r, type: "removed", isDirectory: s?.isDirectory ?? !1 });
               }
-            this.watchers.set(t, i);
+            this.watchers.set(t, { snapshot: a, options: i });
           })
         );
       } finally {
@@ -747,13 +754,13 @@ class A {
    * ```
    */
   async sync(t, e) {
-    await this.ensureMounted();
+    await this.mount();
     try {
       (e?.cleanBefore ?? !1) && await this.clear("/");
       for (const [a, r] of t) {
-        const s = u(a);
+        const s = f(a);
         let o;
-        r instanceof Blob ? o = await b(r) : o = r, await this.writeFile(s, o);
+        r instanceof Blob ? o = await A(r) : o = r, await this.writeFile(s, o);
       }
       await this.notifyChange({ path: "/", type: "changed", isDirectory: !0 });
     } catch (i) {
@@ -761,8 +768,8 @@ class A {
     }
   }
 }
-typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && p(new A());
+typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && v(new $());
 export {
-  A as OPFSWorker
+  $ as OPFSWorker
 };
 //# sourceMappingURL=raw.js.map