vfs-kit 1.0.0 → 1.0.2

package/dist/adapters/index.mjs

@@ -0,0 +1,1159 @@
+"use client";
+import {
+  VfsAdapter
+} from "../chunk-ALWOZGZI.mjs";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-7OQI6PNM.mjs";
+
+// src/adapters/InMemoryAdapter.ts
+import { nanoid } from "nanoid";
+var InMemoryAdapter = class extends VfsAdapter {
+  constructor() {
+    super(...arguments);
+    this.supportsHistory = true;
+    this.store = /* @__PURE__ */ new Map();
+    this.orders = /* @__PURE__ */ new Map();
+    this.snapshots = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  generateId() {
+    return nanoid();
+  }
+  mutate(op, nodeIds, fn) {
+    const result = fn();
+    this.notifyChanged({ op, nodeIds, timestamp: Date.now() });
+    return result;
+  }
+  notifyChanged(change) {
+    for (const listener of this.listeners) listener(change);
+  }
+  makeFileNode(params, id) {
+    var _a, _b;
+    const now = Date.now();
+    return {
+      id,
+      name: params.name,
+      kind: "file",
+      parentId: params.parentId,
+      mimeType: (_a = params.mimeType) != null ? _a : "application/octet-stream",
+      size: 0,
+      sortIndex: null,
+      lockedBy: null,
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null,
+      meta: (_b = params.meta) != null ? _b : {}
+    };
+  }
+  makeFolderNode(params, id) {
+    var _a;
+    const now = Date.now();
+    return {
+      id,
+      name: params.name,
+      kind: "folder",
+      parentId: params.parentId,
+      sortIndex: null,
+      lockedBy: null,
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null,
+      meta: (_a = params.meta) != null ? _a : {}
+    };
+  }
+  getNodes(ids) {
+    return __async(this, null, function* () {
+      if (ids.length === 0) {
+        return [...this.store.values()].map((e) => e.node).filter((n) => n.deletedAt === null);
+      }
+      return ids.map((id) => {
+        var _a;
+        return (_a = this.store.get(id)) == null ? void 0 : _a.node;
+      }).filter((n) => !!n);
+    });
+  }
+  getNodeById(id) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      return (_b = (_a = this.store.get(id)) == null ? void 0 : _a.node) != null ? _b : null;
+    });
+  }
+  getNodeByPath(path) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const parts = path.replace(/^\//, "").split("/").filter(Boolean);
+      if (parts.length === 0) return null;
+      let parentId = null;
+      for (const part of parts) {
+        const match = [...this.store.values()].find(
+          (e) => e.node.name === part && e.node.parentId === parentId && e.node.deletedAt === null
+        );
+        if (!match) return null;
+        parentId = match.node.id;
+      }
+      return parentId ? (_b = (_a = this.store.get(parentId)) == null ? void 0 : _a.node) != null ? _b : null : null;
+    });
+  }
+  getChildren(parentId, options) {
+    return __async(this, null, function* () {
+      return [...this.store.values()].map((e) => e.node).filter(
+        (n) => n.parentId === parentId && ((options == null ? void 0 : options.includeTrashed) ? true : n.deletedAt === null)
+      );
+    });
+  }
+  getTrashed() {
+    return __async(this, null, function* () {
+      return [...this.store.values()].map((e) => e.node).filter((n) => n.deletedAt !== null);
+    });
+  }
+  search(query, options) {
+    return __async(this, null, function* () {
+      const lower = query.toLowerCase();
+      return [...this.store.values()].map((e) => e.node).filter((n) => {
+        if (!(options == null ? void 0 : options.includeTrashed) && n.deletedAt !== null) return false;
+        if ((options == null ? void 0 : options.kind) && n.kind !== options.kind) return false;
+        if ((options == null ? void 0 : options.scope) && !this.isDescendantOf(n.id, options.scope)) return false;
+        return n.name.toLowerCase().includes(lower);
+      });
+    });
+  }
+  readFile(id) {
+    return __async(this, null, function* () {
+      const entry = this.store.get(id);
+      if (!entry || entry.node.kind !== "file") {
+        throw new Error(`File not found: ${id}`);
+      }
+      return entry.content;
+    });
+  }
+  writeFile(id, content) {
+    return __async(this, null, function* () {
+      const entry = this.store.get(id);
+      if (!entry || entry.node.kind !== "file") {
+        throw new Error(`File not found: ${id}`);
+      }
+      this.mutate("write", [id], () => {
+        entry.content = content;
+        entry.node.size = content.byteLength;
+        entry.node.updatedAt = Date.now();
+      });
+    });
+  }
+  createFile(params) {
+    return __async(this, null, function* () {
+      const id = this.generateId();
+      const node = this.makeFileNode(params, id);
+      return this.mutate("create", [id], () => {
+        this.store.set(id, { node, content: new Uint8Array() });
+        return node;
+      });
+    });
+  }
+  createFolder(params) {
+    return __async(this, null, function* () {
+      const id = this.generateId();
+      const node = this.makeFolderNode(params, id);
+      return this.mutate("create", [id], () => {
+        this.store.set(id, { node });
+        return node;
+      });
+    });
+  }
+  updateNode(id, updates) {
+    return __async(this, null, function* () {
+      const entry = this.store.get(id);
+      if (!entry) throw new Error(`Node not found: ${id}`);
+      return this.mutate("rename", [id], () => {
+        Object.assign(entry.node, __spreadProps(__spreadValues({}, updates), { updatedAt: Date.now() }));
+        return entry.node;
+      });
+    });
+  }
+  deleteNode(id, permanent = false) {
+    return __async(this, null, function* () {
+      const entry = this.store.get(id);
+      if (!entry) throw new Error(`Node not found: ${id}`);
+      this.mutate("delete", [id], () => {
+        if (permanent) {
+          this.deleteRecursive(id);
+        } else {
+          entry.node.deletedAt = Date.now();
+        }
+      });
+    });
+  }
+  deleteNodes(ids, permanent = false) {
+    return __async(this, null, function* () {
+      this.mutate("delete", ids, () => {
+        for (const id of ids) {
+          const entry = this.store.get(id);
+          if (!entry) continue;
+          if (permanent) {
+            this.deleteRecursive(id);
+          } else {
+            entry.node.deletedAt = Date.now();
+          }
+        }
+      });
+    });
+  }
+  restoreNode(id) {
+    return __async(this, null, function* () {
+      const entry = this.store.get(id);
+      if (!entry) throw new Error(`Node not found: ${id}`);
+      return this.mutate("restore", [id], () => {
+        entry.node.deletedAt = null;
+        entry.node.updatedAt = Date.now();
+        return entry.node;
+      });
+    });
+  }
+  purgeNode(id) {
+    return __async(this, null, function* () {
+      this.mutate("purge", [id], () => this.deleteRecursive(id));
+    });
+  }
+  moveNode(id, newParentId) {
+    return __async(this, null, function* () {
+      const entry = this.store.get(id);
+      if (!entry) throw new Error(`Node not found: ${id}`);
+      return this.mutate("move", [id], () => {
+        entry.node.parentId = newParentId;
+        entry.node.updatedAt = Date.now();
+        return entry.node;
+      });
+    });
+  }
+  moveNodes(ids, newParentId) {
+    return __async(this, null, function* () {
+      return this.mutate("move", ids, () => {
+        const moved = [];
+        for (const id of ids) {
+          const entry = this.store.get(id);
+          if (!entry) continue;
+          const before = __spreadValues({}, entry.node);
+          entry.node.parentId = newParentId;
+          entry.node.updatedAt = Date.now();
+          moved.push(before);
+        }
+        return moved;
+      });
+    });
+  }
+  lockNode(id, sessionId) {
+    return __async(this, null, function* () {
+      const entry = this.store.get(id);
+      if (!entry) throw new Error(`Node not found: ${id}`);
+      if (entry.node.lockedBy && entry.node.lockedBy !== sessionId) {
+        throw new Error(`Node ${id} is locked by another session`);
+      }
+      return this.mutate("lock", [id], () => {
+        entry.node.lockedBy = sessionId;
+        entry.node.updatedAt = Date.now();
+        return entry.node;
+      });
+    });
+  }
+  unlockNode(id, sessionId) {
+    return __async(this, null, function* () {
+      const entry = this.store.get(id);
+      if (!entry) throw new Error(`Node not found: ${id}`);
+      if (entry.node.lockedBy !== sessionId) {
+        throw new Error(`Cannot unlock node ${id} \u2014 session mismatch`);
+      }
+      return this.mutate("unlock", [id], () => {
+        entry.node.lockedBy = null;
+        entry.node.updatedAt = Date.now();
+        return entry.node;
+      });
+    });
+  }
+  getOrder(parentId) {
+    return __async(this, null, function* () {
+      var _a;
+      return (_a = this.orders.get(parentId != null ? parentId : "root")) != null ? _a : null;
+    });
+  }
+  setOrder(parentId, orderedIds) {
+    return __async(this, null, function* () {
+      this.mutate("reorder", [], () => {
+        this.orders.set(parentId != null ? parentId : "root", { parentId, orderedIds });
+      });
+    });
+  }
+  getSnapshots(fileId) {
+    return __async(this, null, function* () {
+      var _a;
+      return (_a = this.snapshots.get(fileId)) != null ? _a : [];
+    });
+  }
+  saveSnapshot(fileId, content, label) {
+    return __async(this, null, function* () {
+      var _a;
+      const existing = (_a = this.snapshots.get(fileId)) != null ? _a : [];
+      const snapshot = {
+        id: this.generateId(),
+        fileId,
+        index: existing.length,
+        content,
+        createdAt: Date.now(),
+        label
+      };
+      return this.mutate("snapshot", [fileId], () => {
+        const updated = [...existing, snapshot];
+        this.snapshots.set(fileId, updated);
+        return snapshot;
+      });
+    });
+  }
+  restoreSnapshot(fileId, index) {
+    return __async(this, null, function* () {
+      const snaps = this.snapshots.get(fileId);
+      if (!snaps) throw new Error(`No snapshots for file: ${fileId}`);
+      const snap = snaps.find((s) => s.index === index);
+      if (!snap) throw new Error(`Snapshot ${index} not found for file: ${fileId}`);
+      yield this.writeFile(fileId, snap.content);
+    });
+  }
+  deleteSnapshot(fileId, index) {
+    return __async(this, null, function* () {
+      const snaps = this.snapshots.get(fileId);
+      if (!snaps) throw new Error(`No snapshots for file: ${fileId}`);
+      this.mutate("snapshot", [fileId], () => {
+        this.snapshots.set(
+          fileId,
+          snaps.filter((s) => s.index !== index)
+        );
+      });
+    });
+  }
+  onChanged(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  deleteRecursive(id) {
+    for (const entry of this.store.values()) {
+      if (entry.node.parentId === id) {
+        this.deleteRecursive(entry.node.id);
+      }
+    }
+    this.store.delete(id);
+    this.snapshots.delete(id);
+  }
+  isDescendantOf(id, ancestorId) {
+    var _a, _b;
+    let current = (_a = this.store.get(id)) == null ? void 0 : _a.node;
+    while (current == null ? void 0 : current.parentId) {
+      if (current.parentId === ancestorId) return true;
+      current = (_b = this.store.get(current.parentId)) == null ? void 0 : _b.node;
+    }
+    return false;
+  }
+  seed(nodes) {
+    for (const { node, content } of nodes) {
+      if (node.kind === "file") {
+        this.store.set(node.id, {
+          node,
+          content: content != null ? content : new Uint8Array()
+        });
+      } else {
+        this.store.set(node.id, { node });
+      }
+    }
+  }
+  clear() {
+    this.store.clear();
+    this.orders.clear();
+    this.snapshots.clear();
+  }
+  snapshot() {
+    return new Map(this.store);
+  }
+};
+
+// src/adapters/IndexedDBAdapter.ts
+import { openDB } from "idb";
+import { nanoid as nanoid2 } from "nanoid";
+var DB_VERSION = 1;
+var IndexedDBAdapter = class extends VfsAdapter {
+  constructor(options) {
+    var _a, _b;
+    super();
+    this.supportsHistory = true;
+    this.db = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.channel = null;
+    this.options = {
+      dbName: options.dbName,
+      dbVersion: (_a = options.dbVersion) != null ? _a : DB_VERSION,
+      isolation: (_b = options.isolation) != null ? _b : "private"
+    };
+  }
+  open() {
+    return __async(this, null, function* () {
+      this.db = yield openDB(
+        this.options.dbName,
+        this.options.dbVersion,
+        {
+          upgrade(db) {
+            if (!db.objectStoreNames.contains("nodes")) {
+              const nodeStore = db.createObjectStore("nodes", { keyPath: "id" });
+              nodeStore.createIndex("by_parent", "parentId", { unique: false });
+              nodeStore.createIndex("by_deleted", "deletedAt", { unique: false });
+              nodeStore.createIndex("by_name", "name", { unique: false });
+            }
+            if (!db.objectStoreNames.contains("content")) {
+              db.createObjectStore("content", { keyPath: "id" });
+            }
+            if (!db.objectStoreNames.contains("orders")) {
+              db.createObjectStore("orders", { keyPath: "key" });
+            }
+            if (!db.objectStoreNames.contains("snapshots")) {
+              const snapStore = db.createObjectStore("snapshots", { keyPath: "id" });
+              snapStore.createIndex("by_file", "fileId", { unique: false });
+            }
+            if (!db.objectStoreNames.contains("meta")) {
+              db.createObjectStore("meta", { keyPath: "key" });
+            }
+          }
+        }
+      );
+      if (this.options.isolation === "shared") {
+        this.channel = new BroadcastChannel(`vfs-kit:${this.options.dbName}`);
+        this.channel.onmessage = (e) => {
+          this.notifyListeners(e.data);
+        };
+      }
+    });
+  }
+  close() {
+    var _a, _b;
+    (_a = this.db) == null ? void 0 : _a.close();
+    (_b = this.channel) == null ? void 0 : _b.close();
+    this.db = null;
+    this.channel = null;
+  }
+  get idb() {
+    if (!this.db) throw new Error(
+      `IndexedDBAdapter: call open() before using the adapter`
+    );
+    return this.db;
+  }
+  generateId() {
+    return nanoid2();
+  }
+  mutate(op, nodeIds, fn) {
+    return __async(this, null, function* () {
+      var _a;
+      const result = yield fn();
+      const change = { op, nodeIds, timestamp: Date.now() };
+      this.notifyListeners(change);
+      (_a = this.channel) == null ? void 0 : _a.postMessage(change);
+      return result;
+    });
+  }
+  notifyListeners(change) {
+    for (const listener of this.listeners) listener(change);
+  }
+  makeFileNode(params, id) {
+    var _a, _b;
+    const now = Date.now();
+    return {
+      id,
+      name: params.name,
+      kind: "file",
+      parentId: params.parentId,
+      mimeType: (_a = params.mimeType) != null ? _a : "application/octet-stream",
+      size: 0,
+      sortIndex: null,
+      lockedBy: null,
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null,
+      meta: (_b = params.meta) != null ? _b : {}
+    };
+  }
+  makeFolderNode(params, id) {
+    var _a;
+    const now = Date.now();
+    return {
+      id,
+      name: params.name,
+      kind: "folder",
+      parentId: params.parentId,
+      sortIndex: null,
+      lockedBy: null,
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null,
+      meta: (_a = params.meta) != null ? _a : {}
+    };
+  }
+  getNodes(ids) {
+    return __async(this, null, function* () {
+      if (ids.length === 0) {
+        return this.idb.getAll("nodes");
+      }
+      const tx = this.idb.transaction("nodes", "readonly");
+      const results = yield Promise.all(ids.map((id) => tx.store.get(id)));
+      return results.filter((n) => !!n);
+    });
+  }
+  getNodeById(id) {
+    return __async(this, null, function* () {
+      var _a;
+      return (_a = yield this.idb.get("nodes", id)) != null ? _a : null;
+    });
+  }
+  getNodeByPath(path) {
+    return __async(this, null, function* () {
+      const parts = path.replace(/^\//, "").split("/").filter(Boolean);
+      if (parts.length === 0) return null;
+      let parentId = null;
+      for (const part of parts) {
+        const all = yield this.idb.getAllFromIndex(
+          "nodes",
+          "by_parent",
+          parentId
+        );
+        const match = all.find(
+          (n) => n.name === part && n.deletedAt === null
+        );
+        if (!match) return null;
+        parentId = match.id;
+      }
+      return parentId ? this.getNodeById(parentId) : null;
+    });
+  }
+  getChildren(parentId, options) {
+    return __async(this, null, function* () {
+      const nodes = yield this.idb.getAllFromIndex(
+        "nodes",
+        "by_parent",
+        parentId
+      );
+      return (options == null ? void 0 : options.includeTrashed) ? nodes : nodes.filter((n) => n.deletedAt === null);
+    });
+  }
+  getTrashed() {
+    return __async(this, null, function* () {
+      const all = yield this.idb.getAll("nodes");
+      return all.filter((n) => n.deletedAt !== null);
+    });
+  }
+  search(query, options) {
+    return __async(this, null, function* () {
+      const lower = query.toLowerCase();
+      const all = yield this.idb.getAllFromIndex(
+        "nodes",
+        "by_name"
+      );
+      return all.filter((n) => {
+        if (!(options == null ? void 0 : options.includeTrashed) && n.deletedAt !== null) return false;
+        if ((options == null ? void 0 : options.kind) && n.kind !== options.kind) return false;
+        if (!n.name.toLowerCase().includes(lower)) return false;
+        if (options == null ? void 0 : options.scope) {
+          return this.isDescendantOf(n, options.scope, all);
+        }
+        return true;
+      });
+    });
+  }
+  readFile(id) {
+    return __async(this, null, function* () {
+      const entry = yield this.idb.get("content", id);
+      if (!entry) throw new Error(`Content not found for file: ${id}`);
+      return entry.data;
+    });
+  }
+  writeFile(id, content) {
+    return __async(this, null, function* () {
+      yield this.mutate("write", [id], () => __async(this, null, function* () {
+        const tx = this.idb.transaction(["content", "nodes"], "readwrite");
+        const node = yield tx.objectStore("nodes").get(id);
+        if (!node || node.kind !== "file") {
+          throw new Error(`File not found: ${id}`);
+        }
+        node.size = content.byteLength;
+        node.updatedAt = Date.now();
+        yield tx.objectStore("content").put({ id, data: content });
+        yield tx.objectStore("nodes").put(node);
+        yield tx.done;
+      }));
+    });
+  }
+  createFile(params) {
+    return __async(this, null, function* () {
+      const id = this.generateId();
+      const node = this.makeFileNode(params, id);
+      return this.mutate("create", [id], () => __async(this, null, function* () {
+        const tx = this.idb.transaction(["nodes", "content"], "readwrite");
+        yield tx.objectStore("nodes").put(node);
+        yield tx.objectStore("content").put({ id, data: new Uint8Array() });
+        yield tx.done;
+        return node;
+      }));
+    });
+  }
+  createFolder(params) {
+    return __async(this, null, function* () {
+      const id = this.generateId();
+      const node = this.makeFolderNode(params, id);
+      return this.mutate("create", [id], () => __async(this, null, function* () {
+        yield this.idb.put("nodes", node);
+        return node;
+      }));
+    });
+  }
+  updateNode(id, updates) {
+    return __async(this, null, function* () {
+      return this.mutate("rename", [id], () => __async(this, null, function* () {
+        const node = yield this.idb.get("nodes", id);
+        if (!node) throw new Error(`Node not found: ${id}`);
+        const updated = __spreadProps(__spreadValues(__spreadValues({}, node), updates), { updatedAt: Date.now() });
+        yield this.idb.put("nodes", updated);
+        return updated;
+      }));
+    });
+  }
+  deleteNode(id, permanent = false) {
+    return __async(this, null, function* () {
+      yield this.mutate("delete", [id], () => __async(this, null, function* () {
+        if (permanent) {
+          yield this.deleteRecursive(id);
+        } else {
+          const node = yield this.idb.get("nodes", id);
+          if (!node) throw new Error(`Node not found: ${id}`);
+          yield this.idb.put("nodes", __spreadProps(__spreadValues({}, node), {
+            deletedAt: Date.now()
+          }));
+        }
+      }));
+    });
+  }
+  deleteNodes(ids, permanent = false) {
+    return __async(this, null, function* () {
+      yield this.mutate("delete", ids, () => __async(this, null, function* () {
+        const tx = this.idb.transaction("nodes", "readwrite");
+        for (const id of ids) {
+          if (permanent) {
+            yield this.deleteRecursive(id);
+          } else {
+            const node = yield tx.store.get(id);
+            if (!node) continue;
+            yield tx.store.put(__spreadProps(__spreadValues({}, node), { deletedAt: Date.now() }));
+          }
+        }
+        yield tx.done;
+      }));
+    });
+  }
+  restoreNode(id) {
+    return __async(this, null, function* () {
+      return this.mutate("restore", [id], () => __async(this, null, function* () {
+        const node = yield this.idb.get("nodes", id);
+        if (!node) throw new Error(`Node not found: ${id}`);
+        const restored = __spreadProps(__spreadValues({}, node), { deletedAt: null, updatedAt: Date.now() });
+        yield this.idb.put("nodes", restored);
+        return restored;
+      }));
+    });
+  }
+  purgeNode(id) {
+    return __async(this, null, function* () {
+      yield this.mutate("purge", [id], () => this.deleteRecursive(id));
+    });
+  }
+  moveNode(id, newParentId) {
+    return __async(this, null, function* () {
+      return this.mutate("move", [id], () => __async(this, null, function* () {
+        const node = yield this.idb.get("nodes", id);
+        if (!node) throw new Error(`Node not found: ${id}`);
+        const moved = __spreadProps(__spreadValues({}, node), { parentId: newParentId, updatedAt: Date.now() });
+        yield this.idb.put("nodes", moved);
+        return moved;
+      }));
+    });
+  }
+  moveNodes(ids, newParentId) {
+    return __async(this, null, function* () {
+      return this.mutate("move", ids, () => __async(this, null, function* () {
+        const tx = this.idb.transaction("nodes", "readwrite");
+        const moved = [];
+        for (const id of ids) {
+          const node = yield tx.store.get(id);
+          if (!node) continue;
+          const updated = __spreadProps(__spreadValues({}, node), { parentId: newParentId, updatedAt: Date.now() });
+          yield tx.store.put(updated);
+          moved.push(updated);
+        }
+        yield tx.done;
+        return moved;
+      }));
+    });
+  }
+  lockNode(id, sessionId) {
+    return __async(this, null, function* () {
+      return this.mutate("lock", [id], () => __async(this, null, function* () {
+        const node = yield this.idb.get("nodes", id);
+        if (!node) throw new Error(`Node not found: ${id}`);
+        if (node.lockedBy && node.lockedBy !== sessionId) {
+          throw new Error(`Node ${id} is locked by another session`);
+        }
+        const locked = __spreadProps(__spreadValues({}, node), { lockedBy: sessionId, updatedAt: Date.now() });
+        yield this.idb.put("nodes", locked);
+        return locked;
+      }));
+    });
+  }
+  unlockNode(id, sessionId) {
+    return __async(this, null, function* () {
+      return this.mutate("unlock", [id], () => __async(this, null, function* () {
+        const node = yield this.idb.get("nodes", id);
+        if (!node) throw new Error(`Node not found: ${id}`);
+        if (node.lockedBy !== sessionId) {
+          throw new Error(`Cannot unlock node ${id} \u2014 session mismatch`);
+        }
+        const unlocked = __spreadProps(__spreadValues({}, node), { lockedBy: null, updatedAt: Date.now() });
+        yield this.idb.put("nodes", unlocked);
+        return unlocked;
+      }));
+    });
+  }
+  getOrder(parentId) {
+    return __async(this, null, function* () {
+      const key = parentId != null ? parentId : "root";
+      const record = yield this.idb.get("orders", key);
+      return record ? { parentId: record.parentId, orderedIds: record.orderedIds } : null;
+    });
+  }
+  setOrder(parentId, orderedIds) {
+    return __async(this, null, function* () {
+      yield this.mutate("reorder", [], () => __async(this, null, function* () {
+        const key = parentId != null ? parentId : "root";
+        yield this.idb.put("orders", { key, parentId, orderedIds });
+      }));
+    });
+  }
+  getSnapshots(fileId) {
+    return __async(this, null, function* () {
+      return this.idb.getAllFromIndex("snapshots", "by_file", fileId);
+    });
+  }
+  saveSnapshot(fileId, content, label) {
+    return __async(this, null, function* () {
+      return this.mutate("snapshot", [fileId], () => __async(this, null, function* () {
+        const existing = yield this.idb.getAllFromIndex(
+          "snapshots",
+          "by_file",
+          fileId
+        );
+        if (existing.length >= 50) {
+          const oldest = existing.sort((a, b) => a.index - b.index)[0];
+          yield this.idb.delete("snapshots", oldest.id);
+        }
+        const snapshot = {
+          id: this.generateId(),
+          fileId,
+          index: existing.length,
+          content,
+          createdAt: Date.now(),
+          label
+        };
+        yield this.idb.put("snapshots", snapshot);
+        return snapshot;
+      }));
+    });
+  }
+  restoreSnapshot(fileId, index) {
+    return __async(this, null, function* () {
+      const all = yield this.idb.getAllFromIndex("snapshots", "by_file", fileId);
+      const snap = all.find((s) => s.index === index);
+      if (!snap) throw new Error(`Snapshot ${index} not found for file: ${fileId}`);
+      yield this.writeFile(fileId, snap.content);
+    });
+  }
+  deleteSnapshot(fileId, index) {
+    return __async(this, null, function* () {
+      yield this.mutate("snapshot", [fileId], () => __async(this, null, function* () {
+        const all = yield this.idb.getAllFromIndex("snapshots", "by_file", fileId);
+        const snap = all.find((s) => s.index === index);
+        if (!snap) throw new Error(`Snapshot ${index} not found`);
+        yield this.idb.delete("snapshots", snap.id);
+      }));
+    });
+  }
+  onChanged(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  // ── Private helpers ────────────────────────────────────────────────────
+  deleteRecursive(id) {
+    return __async(this, null, function* () {
+      const children = yield this.idb.getAllFromIndex(
+        "nodes",
+        "by_parent",
+        id
+      );
+      for (const child of children) {
+        yield this.deleteRecursive(child.id);
+      }
+      yield this.idb.delete("nodes", id);
+      yield this.idb.delete("content", id);
+      yield this.idb.delete("snapshots", id);
+    });
+  }
+  isDescendantOf(node, ancestorId, allNodes) {
+    const index = new Map(allNodes.map((n) => [n.id, n]));
+    let current = node;
+    while (current == null ? void 0 : current.parentId) {
+      if (current.parentId === ancestorId) return true;
+      current = index.get(current.parentId);
+    }
+    return false;
+  }
+};
+
+// src/adapters/RestAdapter.ts
+import { nanoid as nanoid3 } from "nanoid";
+var defaultEndpoints = (base) => ({
+  getNode: (id) => `${base}/nodes/${id}`,
+  getNodes: (ids) => `${base}/nodes?ids=${ids.join(",")}`,
+  getNodeByPath: (path) => `${base}/nodes/by-path?path=${encodeURIComponent(path)}`,
+  getChildren: (parentId) => `${base}/nodes/${parentId != null ? parentId : "root"}/children`,
+  getTrashed: () => `${base}/nodes/trashed`,
+  search: (query) => `${base}/nodes/search?q=${encodeURIComponent(query)}`,
+  readFile: (id) => `${base}/content/${id}`,
+  writeFile: (id) => `${base}/content/${id}`,
+  createFile: () => `${base}/nodes/file`,
+  createFolder: () => `${base}/nodes/folder`,
+  updateNode: (id) => `${base}/nodes/${id}`,
+  deleteNode: (id) => `${base}/nodes/${id}`,
+  deleteNodes: () => `${base}/nodes/batch/delete`,
+  restoreNode: (id) => `${base}/nodes/${id}/restore`,
+  purgeNode: (id) => `${base}/nodes/${id}/purge`,
+  moveNode: (id) => `${base}/nodes/${id}/move`,
+  moveNodes: () => `${base}/nodes/batch/move`,
+  lockNode: (id) => `${base}/nodes/${id}/lock`,
+  unlockNode: (id) => `${base}/nodes/${id}/unlock`,
+  getOrder: (parentId) => `${base}/orders/${parentId != null ? parentId : "root"}`,
+  setOrder: (parentId) => `${base}/orders/${parentId != null ? parentId : "root"}`,
+  getSnapshots: (fileId) => `${base}/snapshots/${fileId}`,
+  saveSnapshot: (fileId) => `${base}/snapshots/${fileId}`,
+  restoreSnapshot: (fileId, index) => `${base}/snapshots/${fileId}/${index}/restore`,
+  deleteSnapshot: (fileId, index) => `${base}/snapshots/${fileId}/${index}`,
+  subscribe: () => `${base}/events`
+});
+var RestAdapter = class extends VfsAdapter {
+  constructor(options) {
+    var _a, _b;
+    super();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.eventSource = null;
+    this.options = options;
+    this.supportsHistory = (_a = options.supportsHistory) != null ? _a : true;
+    this.fetch = (_b = options.fetch) != null ? _b : globalThis.fetch.bind(globalThis);
+    this.endpoints = __spreadValues(__spreadValues({}, defaultEndpoints(options.baseUrl)), options.endpoints);
+  }
+  open() {
+    return __async(this, null, function* () {
+      yield this.connectRealtime();
+    });
+  }
+  close() {
+    var _a;
+    (_a = this.eventSource) == null ? void 0 : _a.close();
+    this.eventSource = null;
+  }
+  connectRealtime() {
+    return __async(this, null, function* () {
+      try {
+        const url = this.endpoints.subscribe();
+        const es = new EventSource(url);
+        es.onmessage = (e) => {
+          try {
+            const change = JSON.parse(e.data);
+            this.notifyListeners(change);
+          } catch (e2) {
+          }
+        };
+        es.onerror = () => {
+          es.close();
+          this.eventSource = null;
+          this.fallbackRealtime();
+        };
+        this.eventSource = es;
+      } catch (e) {
+        this.fallbackRealtime();
+      }
+    });
+  }
+  fallbackRealtime() {
+    if (!this.options.realtimeFallback) return;
+    this.options.realtimeFallback(
+      (change) => this.notifyListeners(change),
+      (err) => console.error("[RestAdapter] realtime fallback error:", err)
+    );
+  }
+  notifyListeners(change) {
+    for (const listener of this.listeners) listener(change);
+  }
+  generateId() {
+    return nanoid3();
+  }
+  get(url) {
+    return __async(this, null, function* () {
+      const res = yield this.fetch(url, { method: "GET" });
+      if (!res.ok) throw new Error(`GET ${url} failed: ${res.status}`);
+      return res.json();
+    });
+  }
+  post(url, body) {
+    return __async(this, null, function* () {
+      const res = yield this.fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (!res.ok) throw new Error(`POST ${url} failed: ${res.status}`);
+      return res.json();
+    });
+  }
+  patch(url, body) {
+    return __async(this, null, function* () {
+      const res = yield this.fetch(url, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) throw new Error(`PATCH ${url} failed: ${res.status}`);
+      return res.json();
+    });
+  }
+  delete(url, body) {
+    return __async(this, null, function* () {
+      const res = yield this.fetch(url, {
+        method: "DELETE",
+        headers: body ? { "Content-Type": "application/json" } : {},
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (!res.ok) throw new Error(`DELETE ${url} failed: ${res.status}`);
+    });
+  }
+  postBinary(url, content) {
+    return __async(this, null, function* () {
+      const res = yield this.fetch(url, {
+        method: "PUT",
+        headers: { "Content-Type": "application/octet-stream" },
+        body: content.buffer
+      });
+      if (!res.ok) throw new Error(`PUT ${url} failed: ${res.status}`);
+    });
+  }
+  mutate(fn) {
+    return __async(this, null, function* () {
+      return fn();
+    });
+  }
+  getNodes(ids) {
+    return __async(this, null, function* () {
+      if (ids.length === 0) return this.get(this.endpoints.getNodes([]));
+      return this.get(this.endpoints.getNodes(ids));
+    });
+  }
+  getNodeById(id) {
+    return __async(this, null, function* () {
+      try {
+        return yield this.get(this.endpoints.getNode(id));
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  getNodeByPath(path) {
+    return __async(this, null, function* () {
+      try {
+        return yield this.get(this.endpoints.getNodeByPath(path));
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  getChildren(parentId, options) {
+    return __async(this, null, function* () {
+      const url = this.endpoints.getChildren(parentId);
+      const fullUrl = (options == null ? void 0 : options.includeTrashed) ? `${url}?includeTrashed=true` : url;
+      return this.get(fullUrl);
+    });
+  }
+  getTrashed() {
+    return __async(this, null, function* () {
+      return this.get(this.endpoints.getTrashed());
+    });
+  }
+  search(query, options) {
+    return __async(this, null, function* () {
+      const params = new URLSearchParams({ q: query });
+      if (options == null ? void 0 : options.kind) params.set("kind", options.kind);
+      if (options == null ? void 0 : options.scope) params.set("scope", options.scope);
+      if (options == null ? void 0 : options.includeTrashed) params.set("includeTrashed", "true");
+      return this.get(`${this.endpoints.search(query)}?${params}`);
+    });
+  }
+  readFile(id) {
+    return __async(this, null, function* () {
+      const res = yield this.fetch(
+        this.endpoints.readFile(id),
+        { method: "GET" }
+      );
+      if (!res.ok) throw new Error(`readFile ${id} failed: ${res.status}`);
+      return new Uint8Array(yield res.arrayBuffer());
+    });
+  }
+  writeFile(id, content) {
+    return __async(this, null, function* () {
+      yield this.mutate(
+        () => this.postBinary(this.endpoints.writeFile(id), content)
+      );
+    });
+  }
+  createFile(params) {
+    return __async(this, null, function* () {
+      return this.mutate(
+        () => this.post(this.endpoints.createFile(), params)
+      );
+    });
+  }
+  createFolder(params) {
+    return __async(this, null, function* () {
+      return this.mutate(
+        () => this.post(this.endpoints.createFolder(), params)
+      );
+    });
+  }
+  updateNode(id, updates) {
+    return __async(this, null, function* () {
+      return this.mutate(
+        () => this.patch(this.endpoints.updateNode(id), updates)
+      );
+    });
+  }
+  deleteNode(id, permanent = false) {
+    return __async(this, null, function* () {
+      return this.mutate(
+        () => this.delete(this.endpoints.deleteNode(id), { permanent })
+      );
+    });
+  }
+  deleteNodes(ids, permanent = false) {
+    return __async(this, null, function* () {
+      return this.mutate(
+        () => this.delete(this.endpoints.deleteNodes(), { ids, permanent })
+      );
+    });
+  }
+  restoreNode(id) {
+    return __async(this, null, function* () {
+      return this.mutate(
+        () => this.post(this.endpoints.restoreNode(id))
+      );
+    });
+  }
+  purgeNode(id) {
+    return __async(this, null, function* () {
+      return this.mutate(
+        () => this.delete(this.endpoints.purgeNode(id))
+      );
+    });
+  }
+  moveNode(id, newParentId) {
+    return __async(this, null, function* () {
+      return this.mutate(
+        () => this.post(this.endpoints.moveNode(id), { newParentId })
+      );
+    });
+  }
+  moveNodes(ids, newParentId) {
+    return __async(this, null, function* () {
+      return this.mutate(
+        () => this.post(this.endpoints.moveNodes(), { ids, newParentId })
+      );
+    });
+  }
+  lockNode(id, sessionId) {
+    return __async(this, null, function* () {
+      return this.mutate(
+        () => this.post(this.endpoints.lockNode(id), { sessionId })
+      );
+    });
+  }
+  unlockNode(id, sessionId) {
+    return __async(this, null, function* () {
+      return this.mutate(
+        () => this.post(this.endpoints.unlockNode(id), { sessionId })
+      );
+    });
+  }
+  getOrder(parentId) {
+    return __async(this, null, function* () {
+      try {
+        return yield this.get(this.endpoints.getOrder(parentId));
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  setOrder(parentId, orderedIds) {
+    return __async(this, null, function* () {
+      yield this.mutate(
+        () => this.post(this.endpoints.setOrder(parentId), { orderedIds })
+      );
+    });
+  }
+  getSnapshots(fileId) {
+    return __async(this, null, function* () {
+      return this.get(this.endpoints.getSnapshots(fileId));
+    });
+  }
+  saveSnapshot(fileId, content, label) {
+    return __async(this, null, function* () {
+      const res = yield this.fetch(
+        this.endpoints.saveSnapshot(fileId),
+        {
+          method: "POST",
+          headers: __spreadValues({ "Content-Type": "application/octet-stream" }, label ? { "x-snapshot-label": label } : {}),
+          body: content.buffer
+        }
+      );
+      if (!res.ok) throw new Error(`saveSnapshot failed: ${res.status}`);
+      return res.json();
+    });
+  }
+  restoreSnapshot(fileId, index) {
+    return __async(this, null, function* () {
+      yield this.mutate(
+        () => this.post(this.endpoints.restoreSnapshot(fileId, index))
+      );
+    });
+  }
+  deleteSnapshot(fileId, index) {
+    return __async(this, null, function* () {
+      yield this.mutate(
+        () => this.delete(this.endpoints.deleteSnapshot(fileId, index))
+      );
+    });
+  }
+  onChanged(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+};
+export {
+  InMemoryAdapter,
+  IndexedDBAdapter,
+  RestAdapter
+};
+//# sourceMappingURL=index.mjs.map