@dxos/random-access-storage 0.4.9 → 0.4.10-main.05b9ab6

package/dist/lib/browser/index.mjs

@@ -1,19 +1,287 @@
 import "@dxos/node-std/globals";
+import import$random_access_storage from 'random-access-storage';
+import import$inherits from 'inherits';
+import import$next_tick from 'next-tick';
+import import$once from 'once';
+import import$buffer_from from 'buffer-from';
+import import$buffer_alloc from 'buffer-alloc';
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // inject-globals:@inject-globals
 import {
   global,
-  Buffer,
+  Buffer as Buffer2,
   process
 } from "@dxos/node-std/inject-globals";
+var init_inject_globals = __esm({
+  "inject-globals:@inject-globals"() {
+  }
+});
+
+// node_modules/.pnpm/random-access-idb@1.2.2_patch_hash=mqfhtwnltd5kq5s4kb4gk7k2k4/node_modules/random-access-idb/lib/blocks.js
+var require_blocks = __commonJS({
+  "node_modules/.pnpm/random-access-idb@1.2.2_patch_hash=mqfhtwnltd5kq5s4kb4gk7k2k4/node_modules/random-access-idb/lib/blocks.js"(exports, module) {
+    init_inject_globals();
+    module.exports = function(size, start, end) {
+      var result = [];
+      for (var n = Math.floor(start / size) * size; n < end; n += size) {
+        result.push({
+          block: Math.floor(n / size),
+          start: Math.max(n, start) % size,
+          end: Math.min(n + size, end) % size || size
+        });
+      }
+      return result;
+    };
+  }
+});
+
+// node_modules/.pnpm/random-access-idb@1.2.2_patch_hash=mqfhtwnltd5kq5s4kb4gk7k2k4/node_modules/random-access-idb/index.js
+var require_random_access_idb = __commonJS({
+  "node_modules/.pnpm/random-access-idb@1.2.2_patch_hash=mqfhtwnltd5kq5s4kb4gk7k2k4/node_modules/random-access-idb/index.js"(exports, module) {
+    init_inject_globals();
+    var RandomAccess = import$random_access_storage;
+    var inherits = import$inherits;
+    var nextTick = import$next_tick;
+    var once = import$once;
+    var blocks = require_blocks();
+    var bufferFrom = import$buffer_from;
+    var bufferAlloc = import$buffer_alloc;
+    var DELIM2 = "\0";
+    var win = typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {};
+    module.exports = function(dbname, xopts) {
+      if (!xopts)
+        xopts = {};
+      var idb2 = xopts.idb || (typeof win !== "undefined" ? win.indexedDB || win.mozIndexedDB || win.webkitIndexedDB || win.msIndexedDB : null);
+      if (!idb2)
+        throw new Error("indexedDB not present and not given");
+      var db = null, dbqueue = [];
+      if (typeof idb2.open === "function") {
+        var req = idb2.open(dbname);
+        req.addEventListener("upgradeneeded", function() {
+          db = req.result;
+          db.createObjectStore("data");
+        });
+        req.addEventListener("success", function() {
+          db = req.result;
+          dbqueue.forEach(function(cb) {
+            cb(db);
+          });
+          dbqueue = null;
+        });
+      } else {
+        db = idb2;
+      }
+      function getdb(cb) {
+        if (db)
+          nextTick(function() {
+            cb(db);
+          });
+        else
+          dbqueue.push(cb);
+      }
+      return {
+        create: function(name, opts) {
+          if (typeof name === "object") {
+            opts = name;
+            name = opts.name;
+          }
+          if (!opts)
+            opts = {};
+          opts.name = name;
+          return new Store(Object.assign({ db: getdb }, xopts, opts));
+        },
+        getdb
+      };
+    };
+    function Store(opts) {
+      if (!(this instanceof Store))
+        return new Store(opts);
+      RandomAccess.call(this);
+      if (!opts)
+        opts = {};
+      if (typeof opts === "string")
+        opts = { name: opts };
+      this.size = opts.size || 4096;
+      this.name = opts.name;
+      this.length = opts.length || 0;
+      this._getdb = opts.db;
+    }
+    inherits(Store, RandomAccess);
+    Store.prototype._blocks = function(i, j) {
+      return blocks(this.size, i, j);
+    };
+    Store.prototype._read = function(req) {
+      var self2 = this;
+      var buffers = [];
+      self2._store("readonly", function(err, store) {
+        if ((self2.length || 0) < req.offset + req.size) {
+          return req.callback(new Error("Could not satisfy length"));
+        }
+        if (err)
+          return req.callback(err);
+        var offsets = self2._blocks(req.offset, req.offset + req.size);
+        var pending = offsets.length + 1;
+        var firstBlock = offsets.length > 0 ? offsets[0].block : 0;
+        var j = 0;
+        for (var i = 0; i < offsets.length; i++)
+          (function(o) {
+            var key = self2.name + DELIM2 + o.block;
+            backify(store.get(key), function(err2, ev) {
+              if (err2)
+                return req.callback(err2);
+              buffers[o.block - firstBlock] = ev.target.result ? bufferFrom(ev.target.result.subarray(o.start, o.end)) : bufferAlloc(o.end - o.start);
+              if (--pending === 0)
+                req.callback(null, Buffer2.concat(buffers));
+            });
+          })(offsets[i]);
+        if (--pending === 0)
+          req.callback(null, Buffer2.concat(buffers));
+      });
+    };
+    Store.prototype._write = function(req) {
+      var self2 = this;
+      self2._store("readwrite", function(err, store) {
+        if (err)
+          return req.callback(err);
+        var offsets = self2._blocks(req.offset, req.offset + req.data.length);
+        var pending = 1;
+        var buffers = {};
+        for (var i = 0; i < offsets.length; i++)
+          (function(o, i2) {
+            if (o.end - o.start === self2.size)
+              return;
+            pending++;
+            var key = self2.name + DELIM2 + o.block;
+            backify(store.get(key), function(err2, ev) {
+              if (err2)
+                return req.callback(err2);
+              buffers[i2] = bufferFrom(ev.target.result || bufferAlloc(self2.size));
+              if (--pending === 0)
+                write(store, offsets, buffers);
+            });
+          })(offsets[i], i);
+        if (--pending === 0)
+          write(store, offsets, buffers);
+      });
+      function write(store, offsets, buffers) {
+        var block;
+        for (var i = 0, j = 0; i < offsets.length; i++) {
+          var o = offsets[i];
+          var len = o.end - o.start;
+          if (len === self2.size) {
+            block = bufferFrom(req.data.slice(j, j + len));
+          } else {
+            block = buffers[i];
+            req.data.copy(block, o.start, j, j + len);
+          }
+          store.put(block, self2.name + DELIM2 + o.block);
+          j += len;
+        }
+        var length = Math.max(self2.length || 0, req.offset + req.data.length);
+        store.put(length, self2.name + DELIM2 + "length");
+        store.transaction.addEventListener("complete", function() {
+          self2.length = length;
+          req.callback(null);
+        });
+        store.transaction.addEventListener("error", function(err) {
+          req.callback(err);
+        });
+      }
+    };
+    Store.prototype._store = function(mode, cb) {
+      cb = once(cb);
+      var self2 = this;
+      self2._getdb(function(db) {
+        var tx = db.transaction(["data"], mode);
+        var store = tx.objectStore("data");
+        tx.addEventListener("error", cb);
+        cb(null, store);
+      });
+    };
+    Store.prototype._open = function(req) {
+      var self2 = this;
+      this._getdb(function(db) {
+        self2._store("readonly", function(err, store) {
+          backify(store.get(self2.name + DELIM2 + "length"), function(err2, ev) {
+            self2.length = ev.target.result || 0;
+            req.callback(null);
+          });
+        });
+      });
+    };
+    Store.prototype._close = function(req) {
+      this._getdb(function(db) {
+        req.callback();
+      });
+    };
+    Store.prototype._stat = function(req) {
+      var self2 = this;
+      nextTick(function() {
+        req.callback(null, { size: self2.length });
+      });
+    };
+    function backify(r, cb) {
+      r.addEventListener("success", function(ev) {
+        cb(null, ev);
+      });
+      r.addEventListener("error", cb);
+    }
+  }
+});
+
+// packages/common/random-access-storage/src/browser/index.ts
+init_inject_globals();
+
+// packages/common/random-access-storage/src/common/index.ts
+init_inject_globals();
 
 // packages/common/random-access-storage/src/common/abstract-storage.ts
+init_inject_globals();
 import { join as join2 } from "@dxos/node-std/path";
 import { inspect } from "@dxos/node-std/util";
 import { inspectObject } from "@dxos/debug";
 import { log as log2 } from "@dxos/log";
 
+// packages/common/random-access-storage/src/common/directory.ts
+init_inject_globals();
+
 // packages/common/random-access-storage/src/common/utils.ts
+init_inject_globals();
 import { join } from "@dxos/node-std/path";
 var stringDiff = (first, second) => first.split(second).join("");
 var getFullPath = (root, path) => join(root, stringDiff(path, root));
@@ -70,6 +338,7 @@ var Directory = class _Directory {
 };
 
 // packages/common/random-access-storage/src/common/file.ts
+init_inject_globals();
 import pify from "pify";
 import { log } from "@dxos/log";
 var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/random-access-storage/src/common/file.ts";
@@ -154,7 +423,7 @@ var AbstractStorage = class {
     try {
       log2.info("Erasing all data...", void 0, {
         F: __dxlog_file2,
-        L: 59,
+        L: 60,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -163,14 +432,14 @@ var AbstractStorage = class {
       await this._destroy();
       log2("Erased...", void 0, {
         F: __dxlog_file2,
-        L: 63,
+        L: 64,
         S: this,
         C: (f, a) => f(...a)
       });
     } catch (err) {
       log2.catch(err, void 0, {
         F: __dxlog_file2,
-        L: 65,
+        L: 66,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -228,7 +497,7 @@ var AbstractStorage = class {
   async _closeFilesInPath(path) {
     await Promise.all(Array.from((await this._getFiles(path)).values()).map((file) => file.close().catch((err) => log2.catch(err, void 0, {
       F: __dxlog_file2,
-      L: 133,
+      L: 134,
       S: this,
       C: (f, a) => f(...a)
     }))));
@@ -241,7 +510,7 @@ var AbstractStorage = class {
     await Promise.all(Array.from(await this._getFiles(path)).map(([path2, file]) => {
       return file.destroy().then(() => this._files.delete(path2)).catch((err) => log2.error(err.message, void 0, {
         F: __dxlog_file2,
-        L: 148,
+        L: 149,
         S: this,
         C: (f, a) => f(...a)
       }));
@@ -250,10 +519,12 @@ var AbstractStorage = class {
 };
 
 // packages/common/random-access-storage/src/common/memory-storage.ts
+init_inject_globals();
 import ram from "random-access-memory";
 import { arrayToBuffer } from "@dxos/util";
 
 // packages/common/random-access-storage/src/common/storage.ts
+init_inject_globals();
 var StorageType;
 (function(StorageType2) {
   StorageType2["RAM"] = "ram";
@@ -301,65 +572,25 @@ var MemoryStorage = class extends AbstractStorage {
   }
 };
 
-// packages/common/random-access-storage/src/browser/firefox-storage.ts
-import raw from "random-access-web/mutable-file-wrapper.js";
-
-// packages/common/random-access-storage/src/browser/browser-storage.ts
-var BrowserStorage = class extends AbstractStorage {
-  constructor(path) {
-    super(path);
-    this._fileStorage = this._createFileStorage(path);
-  }
-  _createFile(path, filename) {
-    const fullPath = getFullPath(path, filename);
-    return this._fileStorage(fullPath);
-  }
-  async _destroy() {
-    return new Promise((resolve, reject) => {
-      const request = indexedDB.deleteDatabase(this.path);
-      request.onsuccess = () => {
-        resolve();
-      };
-      request.onupgradeneeded = () => {
-        reject(new Error("Upgrade needed."));
-      };
-      request.onblocked = () => {
-        reject(new Error("Blocked."));
-      };
-      request.onerror = (err) => {
-        reject(err);
-      };
-    });
-  }
-};
-
-// packages/common/random-access-storage/src/browser/firefox-storage.ts
-var FirefoxStorage = class extends BrowserStorage {
-  constructor() {
-    super(...arguments);
-    this.type = StorageType.FIREFOX;
-  }
-  _createFileStorage(path) {
-    return raw({
-      name: path
-    });
-  }
-};
+// packages/common/random-access-storage/src/browser/storage.ts
+init_inject_globals();
 
 // packages/common/random-access-storage/src/browser/idb-storage.ts
-import idb from "random-access-idb";
+init_inject_globals();
+var import_random_access_idb = __toESM(require_random_access_idb());
 import { invariant } from "@dxos/invariant";
 var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/common/random-access-storage/src/browser/idb-storage.ts";
 var DELIM = "\0";
-var IDbStorage = class extends BrowserStorage {
-  constructor() {
-    super(...arguments);
+var IDbStorage = class extends AbstractStorage {
+  constructor(path) {
+    super(path);
     this.type = StorageType.IDB;
     this._store = "data";
     this._initialized = false;
+    this._fileStorage = this._createFileStorage(path);
   }
   _createFileStorage(path) {
-    const database = idb(path);
+    const database = (0, import_random_access_idb.default)(path);
     let res;
     this._db = new Promise((resolve) => {
       res = resolve;
@@ -367,6 +598,16 @@ var IDbStorage = class extends BrowserStorage {
     database.getdb(res);
     return database.create;
   }
+  async close() {
+    await this._closeFilesInPath("");
+  }
+  async reset() {
+    await this._closeFilesInPath("");
+    await this._remove("");
+  }
+  async _destroy() {
+    throw new Error("Unreachable");
+  }
   _createFile(path, filename) {
     const file = this._fileStorage(getFullPath(path, filename));
     file.destroy = (cb) => {
@@ -393,7 +634,7 @@ var IDbStorage = class extends BrowserStorage {
     const db = await this._db;
     invariant(db, "Database is not initialized.", {
       F: __dxlog_file3,
-      L: 63,
+      L: 85,
       S: this,
       A: [
         "db",
@@ -435,6 +676,7 @@ var IDbStorage = class extends BrowserStorage {
 };
 
 // packages/common/random-access-storage/src/browser/web-fs.ts
+init_inject_globals();
 import { EventEmitter } from "@dxos/node-std/events";
 import { callbackify } from "@dxos/node-std/util";
 import { synchronized } from "@dxos/async";
@@ -749,7 +991,7 @@ var WebFile = class extends EventEmitter {
     if (offset + size > this._buffer.length) {
       throw new Error("Read out of bounds");
     }
-    return Buffer.from(this._buffer.slice(offset, offset + size));
+    return Buffer2.from(this._buffer.slice(offset, offset + size));
   }
   async write(offset, data) {
     this.assertNotDestroyed("Write");
@@ -898,22 +1140,16 @@ _ts_decorate([
 // packages/common/random-access-storage/src/browser/storage.ts
 var createStorage = ({ type, root = "" } = {}) => {
   if (type === void 0) {
-    if (navigator && navigator.storage && typeof navigator.storage.getDirectory === "function" && FileSystemFileHandle && typeof FileSystemFileHandle.prototype.createWritable === "function") {
-      return new WebFS(root);
-    } else {
-      return new IDbStorage(root);
-    }
+    return new IDbStorage(root);
   }
   switch (type) {
     case StorageType.RAM: {
       return new MemoryStorage(root);
     }
     case StorageType.IDB:
-    case StorageType.CHROME: {
-      return new IDbStorage(root);
-    }
+    case StorageType.CHROME:
     case StorageType.FIREFOX: {
-      return new FirefoxStorage(root);
+      return new IDbStorage(root);
     }
     case StorageType.WEBFS: {
       return new WebFS(root);