@fireproof/core 0.19.111 → 0.19.112-dev-iife

package/index.cjs

@@ -280,7 +280,9 @@ var init_utils = __esm({
     };
     pathOps = new pathOpsImpl();
     txtOps = {
+      // eslint-disable-next-line no-restricted-globals
       encode: (input) => new TextEncoder().encode(input),
+      // eslint-disable-next-line no-restricted-globals
       decode: (input) => new TextDecoder().decode(input)
     };
     NotFoundError = class extends Error {
@@ -292,132 +294,35 @@ var init_utils = __esm({
   }
 });
 
-// src/runtime/gateways/file/mem-filesystem.ts
-var mem_filesystem_exports = {};
-__export(mem_filesystem_exports, {
-  MemFileSystem: () => MemFileSystem
-});
-var import_memfs, MemFileSystem;
-var init_mem_filesystem = __esm({
-  "src/runtime/gateways/file/mem-filesystem.ts"() {
-    "use strict";
-    import_memfs = require("memfs");
-    init_utils2();
-    MemFileSystem = class {
-      async start() {
-        return this;
-      }
-      mkdir(path, options) {
-        return import_memfs.fs.promises.mkdir(path, options);
-      }
-      readdir(path, options) {
-        return import_memfs.fs.promises.readdir(path, options);
-      }
-      rm(path, options) {
-        return import_memfs.fs.promises.rm(path, options);
-      }
-      copyFile(source, destination) {
-        return import_memfs.fs.promises.copyFile(source, destination);
-      }
-      async readfile(path, options) {
-        const ret = await import_memfs.fs.promises.readFile(path, options);
-        return toArrayBuffer(ret);
-      }
-      stat(path) {
-        return import_memfs.fs.promises.stat(path);
-      }
-      unlink(path) {
-        return import_memfs.fs.promises.unlink(path);
-      }
-      writefile(path, data) {
-        return import_memfs.fs.promises.writeFile(path, Buffer.from(data));
-      }
-    };
-  }
-});
-
-// src/runtime/gateways/file/node-filesystem.ts
-var node_filesystem_exports = {};
-__export(node_filesystem_exports, {
-  NodeFileSystem: () => NodeFileSystem
-});
-var import_cement4, NodeFileSystem;
-var init_node_filesystem = __esm({
-  "src/runtime/gateways/file/node-filesystem.ts"() {
-    "use strict";
-    init_utils2();
-    import_cement4 = require("@adviser/cement");
-    NodeFileSystem = class {
-      async start() {
-        this.fs = await import("fs/promises");
-        return this;
-      }
-      async mkdir(path, options) {
-        return this.fs?.mkdir(path, options);
-      }
-      async readdir(path, options) {
-        return this.fs?.readdir(path, options);
-      }
-      async rm(path, options) {
-        return this.fs?.rm(path, options);
-      }
-      async copyFile(source, destination) {
-        return this.fs?.copyFile(source, destination);
-      }
-      async readfile(path, options) {
-        const ret = await this.fs?.readFile(path, options);
-        return toArrayBuffer(ret);
-      }
-      stat(path) {
-        return this.fs?.stat(path);
-      }
-      async unlink(path) {
-        return this.fs?.unlink(path);
-      }
-      async writefile(path, data) {
-        if ((0, import_cement4.runtimeFn)().isDeno) {
-          return this.fs?.writeFile(path, data);
-        }
-        return this.fs?.writeFile(path, Buffer.from(data));
-      }
-    };
-  }
-});
-
 // src/runtime/gateways/file/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
   getFileName: () => getFileName,
   getFileSystem: () => getFileSystem,
-  getPath: () => getPath,
-  toArrayBuffer: () => toArrayBuffer
+  getPath: () => getPath
 });
 async function getFileSystem(url) {
-  const name = url.getParam("fs");
-  let fs2;
+  const name = url.getParam("fs", "node");
+  let fs;
   switch (name) {
     case "mem":
-      {
-        const { MemFileSystem: MemFileSystem2 } = await Promise.resolve().then(() => (init_mem_filesystem(), mem_filesystem_exports));
-        fs2 = new MemFileSystem2();
-      }
+      fs = await externalLoaders.get(name).once(async () => {
+        const { MemFileSystem } = await import("./node/mem-filesystem.js");
+        return new MemFileSystem();
+      });
       break;
     // case 'deno': {
     //   const { DenoFileSystem } = await import("./deno-filesystem.js");
     //   fs = new DenoFileSystem();
     //   break;
     // }
-    case "node": {
-      const { NodeFileSystem: NodeFileSystem2 } = await Promise.resolve().then(() => (init_node_filesystem(), node_filesystem_exports));
-      fs2 = new NodeFileSystem2();
-      break;
-    }
-    case "sys":
-    default: {
-      return getFileSystem(url.build().setParam("fs", "node").URI());
-    }
+    default:
+      fs = await externalLoaders.get(name).once(async () => {
+        const { NodeFileSystem } = await import("./node/node-filesystem.js");
+        return new NodeFileSystem();
+      });
   }
-  return fs2.start();
+  return fs.start();
 }
 function getPath(url, sthis) {
   const basePath = url.pathname;
@@ -443,21 +348,13 @@ function getFileName(url, sthis) {
       throw sthis.logger.Error().Url(url).Msg(`unsupported store type`).AsError();
   }
 }
-function toArrayBuffer(buffer) {
-  if (typeof buffer === "string") {
-    buffer = Buffer.from(buffer);
-  }
-  const ab = new ArrayBuffer(buffer.length);
-  const view = new Uint8Array(ab);
-  for (let i = 0; i < buffer.length; ++i) {
-    view[i] = buffer[i];
-  }
-  return view;
-}
+var import_cement4, externalLoaders;
 var init_utils2 = __esm({
   "src/runtime/gateways/file/utils.ts"() {
     "use strict";
+    import_cement4 = require("@adviser/cement");
     init_utils();
+    externalLoaders = new import_cement4.KeyedResolvOnce();
   }
 });
 
@@ -617,7 +514,7 @@ var init_gateway = __esm({
             throw logger.Error().Str("file", vFile).Msg(`version file is a directory`).AsError();
           }
           const v = await this.fs.readfile(vFile);
-          const vStr = new TextDecoder().decode(v);
+          const vStr = this.sthis.txt.decode(v);
           if (vStr !== FILESTORE_VERSION) {
             logger.Warn().Str("file", vFile).Str("from", vStr).Str("expected", FILESTORE_VERSION).Msg(`version mismatch`);
           }
@@ -720,173 +617,65 @@ var init_gateway = __esm({
   }
 });
 
-// src/runtime/gateways/indexdb/version.ts
-var INDEXDB_VERSION;
-var init_version2 = __esm({
-  "src/runtime/gateways/indexdb/version.ts"() {
-    "use strict";
-    INDEXDB_VERSION = "v0.19-indexdb";
-  }
-});
-
 // src/runtime/gateways/indexdb/gateway.ts
 var gateway_exports2 = {};
 __export(gateway_exports2, {
   IndexDBGateway: () => IndexDBGateway,
-  IndexDBTestStore: () => IndexDBTestStore,
-  getIndexDBName: () => getIndexDBName
+  IndexDBTestStore: () => IndexDBTestStore
 });
-function ensureVersion(url) {
-  return url.build().defParam("version", INDEXDB_VERSION).URI();
-}
-function sanitzeKey(key) {
-  if (key.length === 1) {
-    key = key[0];
-  }
-  return key;
-}
-async function connectIdb(url, sthis) {
-  const dbName = getIndexDBName(url, sthis);
-  const once = await onceIndexDB.get(dbName.fullDb).once(async () => {
-    const db = await (0, import_idb2.openDB)(dbName.fullDb, 1, {
-      upgrade(db2) {
-        ["version", "data", "wal", "meta", "idx.data", "idx.wal", "idx.meta"].map((store) => {
-          db2.createObjectStore(store, {
-            autoIncrement: false
-          });
-        });
-      }
-    });
-    const found = await db.get("version", "version");
-    const version = ensureVersion(url).getParam("version");
-    if (!found) {
-      await db.put("version", { version }, "version");
-    } else if (found.version !== version) {
-      sthis.logger.Warn().Str("url", url.toString()).Str("version", version).Str("found", found.version).Msg("version mismatch");
-    }
-    return { db, dbName, version, url };
-  });
-  return {
-    ...once,
-    url: url.build().setParam("version", once.version).URI()
-  };
-}
-function joinDBName(...names) {
-  return names.map((i) => i.replace(/^[^a-zA-Z0-9]+/g, "").replace(/[^a-zA-Z0-9]+/g, "_")).filter((i) => i.length).join(".");
-}
-function getIndexDBName(iurl, sthis) {
-  const url = ensureVersion(iurl);
-  const fullDb = url.pathname.replace(/^\/+/, "").replace(/\?.*$/, "");
-  const dbName = url.getParam("name");
-  if (!dbName) throw sthis.logger.Error().Str("url", url.toString()).Msg(`name not found`).AsError();
-  const result = joinDBName(fullDb, dbName);
-  const objStore = getStore(url, sthis, joinDBName).name;
-  const connectionKey = [result, objStore].join(":");
-  return {
-    fullDb: result,
-    objStore,
-    connectionKey,
-    dbName
-  };
-}
-var import_idb2, import_cement12, onceIndexDB, IndexDBGateway, IndexDBTestStore;
+var import_cement12, loadExternal, IndexDBGateway, IndexDBTestStore;
 var init_gateway2 = __esm({
   "src/runtime/gateways/indexdb/gateway.ts"() {
     "use strict";
-    import_idb2 = require("idb");
     import_cement12 = require("@adviser/cement");
-    init_version2();
-    init_utils();
-    onceIndexDB = new import_cement12.KeyedResolvOnce();
+    loadExternal = new import_cement12.ResolveOnce();
     IndexDBGateway = class {
       constructor(sthis) {
-        this._db = {};
-        this.logger = ensureLogger(sthis, "IndexDBGateway");
         this.sthis = sthis;
       }
-      async start(baseURL) {
-        return (0, import_cement12.exception2Result)(async () => {
-          this.logger.Debug().Url(baseURL).Msg("starting");
-          await this.sthis.start();
-          const ic = await connectIdb(baseURL, this.sthis);
-          this._db = ic.db;
-          this.logger.Debug().Url(ic.url).Msg("started");
-          return ic.url;
+      getGateway() {
+        return loadExternal.once(() => {
+          return import("./web/gateway-impl.js").then(({ IndexDBGatewayImpl }) => new IndexDBGatewayImpl(this.sthis));
         });
       }
-      async close() {
-        return import_cement12.Result.Ok(void 0);
+      buildUrl(baseUrl, key) {
+        return this.getGateway().then((gw) => gw.buildUrl(baseUrl, key));
       }
-      async destroy(baseUrl) {
-        return (0, import_cement12.exception2Result)(async () => {
-          const type = getStore(baseUrl, this.sthis, joinDBName).name;
-          const idb = this._db;
-          const trans = idb.transaction(type, "readwrite");
-          const object_store = trans.objectStore(type);
-          const toDelete = [];
-          for (let cursor = await object_store.openCursor(); cursor; cursor = await cursor.continue()) {
-            toDelete.push(cursor.primaryKey);
-          }
-          for (const key of toDelete) {
-            await trans.db.delete(type, key);
-          }
-          await trans.done;
-        });
+      start(baseUrl) {
+        return this.getGateway().then((gw) => gw.start(baseUrl));
       }
-      buildUrl(baseUrl, key) {
-        return Promise.resolve(import_cement12.Result.Ok(baseUrl.build().setParam("key", key).URI()));
+      close(baseUrl) {
+        return this.getGateway().then((gw) => gw.close(baseUrl));
       }
-      async get(url) {
-        return exceptionWrapper(async () => {
-          const key = getKey(url, this.logger);
-          const store = getStore(url, this.sthis, joinDBName).name;
-          this.logger.Debug().Url(url).Str("key", key).Str("store", store).Msg("getting");
-          const tx = this._db.transaction([store], "readonly");
-          const bytes = await tx.objectStore(store).get(sanitzeKey(key));
-          await tx.done;
-          if (!bytes) {
-            return import_cement12.Result.Err(new NotFoundError(`missing ${key}`));
-          }
-          return import_cement12.Result.Ok(bytes);
-        });
+      destroy(baseUrl) {
+        return this.getGateway().then((gw) => gw.destroy(baseUrl));
       }
-      async put(url, value) {
-        return (0, import_cement12.exception2Result)(async () => {
-          const key = getKey(url, this.logger);
-          const store = getStore(url, this.sthis, joinDBName).name;
-          this.logger.Debug().Url(url).Str("key", key).Str("store", store).Msg("putting");
-          const tx = this._db.transaction([store], "readwrite");
-          await tx.objectStore(store).put(value, sanitzeKey(key));
-          await tx.done;
-        });
+      put(url, body) {
+        return this.getGateway().then((gw) => gw.put(url, body));
       }
-      async delete(url) {
-        return (0, import_cement12.exception2Result)(async () => {
-          const key = getKey(url, this.logger);
-          const store = getStore(url, this.sthis, joinDBName).name;
-          this.logger.Debug().Url(url).Str("key", key).Str("store", store).Msg("deleting");
-          const tx = this._db.transaction([store], "readwrite");
-          await tx.objectStore(store).delete(sanitzeKey(key));
-          await tx.done;
-          return import_cement12.Result.Ok(void 0);
-        });
+      get(url) {
+        return this.getGateway().then((gw) => gw.get(url));
+      }
+      delete(url) {
+        return this.getGateway().then((gw) => gw.delete(url));
       }
+      // subscribe?(url: URI, callback: (meta: Uint8Array) => void): Promise<UnsubscribeResult> {
+      //     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      //     return this.getGateway().then(gw => gw.subscribe!(url, callback));
+      // }
     };
     IndexDBTestStore = class {
       constructor(sthis) {
+        this.loadExternal = new import_cement12.ResolveOnce();
         this.sthis = sthis;
-        this.logger = ensureLogger(sthis, "IndexDBTestStore", {});
       }
-      async get(url, key) {
-        const ic = await connectIdb(url, this.sthis);
-        const store = getStore(ic.url, this.sthis, joinDBName).name;
-        this.logger.Debug().Str("key", key).Str("store", store).Msg("getting");
-        let bytes = await ic.db.get(store, sanitzeKey(key));
-        this.logger.Debug().Str("key", key).Str("store", store).Int("len", bytes.length).Msg("got");
-        if (typeof bytes === "string") {
-          bytes = this.sthis.txt.encode(bytes);
-        }
-        return bytes;
+      getGateway() {
+        return this.loadExternal.once(() => {
+          return import("./web/gateway-impl.js").then(({ IndexDBTestStore: IndexDBTestStore2 }) => new IndexDBTestStore2(this.sthis));
+        });
+      }
+      get(url, key) {
+        return this.getGateway().then((gw) => gw.get(url, key));
       }
     };
   }
@@ -2481,7 +2270,7 @@ var import_cement9 = require("@adviser/cement");
 async function decodeGatewayMetaBytesToDbMeta(sthis, byteHeads) {
   const crdtEntries = JSON.parse(sthis.txt.decode(byteHeads));
   if (!crdtEntries.length) {
-    sthis.logger.Debug().Str("byteHeads", new TextDecoder().decode(byteHeads)).Msg("No CRDT entries found");
+    sthis.logger.Debug().Any("byteHeads", byteHeads).Msg("No CRDT entries found");
     return [];
   }
   if (!crdtEntries.map) {
@@ -2518,7 +2307,7 @@ async function setCryptoKeyFromGatewayMetaPayload(uri, sthis, data) {
       sthis.logger.Debug().Str("dbMeta.key", dbMeta.key).Str("uri", uri.toString()).Msg("Set crypto key from gateway meta payload");
       return import_cement9.Result.Ok(dbMeta);
     }
-    sthis.logger.Debug().Str("data", new TextDecoder().decode(data)).Msg("No crypto in gateway meta payload");
+    sthis.logger.Debug().Any("data", data).Msg("No crypto in gateway meta payload");
     return import_cement9.Result.Ok(void 0);
   } catch (error) {
     sthis.logger.Debug().Err(error).Msg("Failed to set crypto key from gateway meta payload");
@@ -3520,7 +3309,7 @@ var import_sha26 = require("multiformats/hashes/sha2");
 var codec2 = __toESM(require("@ipld/dag-cbor"), 1);
 var import_charwise = __toESM(require("charwise"), 1);
 var DbIndex = __toESM(require("prolly-trees/db-index"), 1);
-var import_utils16 = require("prolly-trees/utils");
+var import_utils13 = require("prolly-trees/utils");
 var import_cache = require("prolly-trees/cache");
 var IndexTree = class {
 };
@@ -3528,17 +3317,17 @@ function refCompare(aRef, bRef) {
   if (Number.isNaN(aRef)) return -1;
   if (Number.isNaN(bRef)) throw new Error("ref may not be Infinity or NaN");
   if (aRef === Infinity) return 1;
-  return (0, import_utils16.simpleCompare)(aRef, bRef);
+  return (0, import_utils13.simpleCompare)(aRef, bRef);
 }
 function compare(a, b) {
   const [aKey, aRef] = a;
   const [bKey, bRef] = b;
-  const comp = (0, import_utils16.simpleCompare)(aKey, bKey);
+  const comp = (0, import_utils13.simpleCompare)(aKey, bKey);
   if (comp !== 0) return comp;
   return refCompare(aRef, bRef);
 }
-var byKeyOpts = { cache: import_cache.nocache, chunker: (0, import_utils16.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare };
-var byIdOpts = { cache: import_cache.nocache, chunker: (0, import_utils16.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare: import_utils16.simpleCompare };
+var byKeyOpts = { cache: import_cache.nocache, chunker: (0, import_utils13.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare };
+var byIdOpts = { cache: import_cache.nocache, chunker: (0, import_utils13.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare: import_utils13.simpleCompare };
 function indexEntriesForChanges(changes, mapFn) {
   const indexEntries = [];
   changes.forEach(({ id: key, value, del }) => {
@@ -4329,8 +4118,7 @@ __export(runtime_exports, {
   kb: () => key_bag_exports,
   kc: () => keyed_crypto_exports,
   mf: () => wait_pr_multiformats_exports,
-  runtimeFn: () => import_cement17.runtimeFn,
-  toArrayBuffer: () => toArrayBuffer
+  runtimeFn: () => import_cement17.runtimeFn
 });
 init_utils2();
 
@@ -4347,13 +4135,15 @@ var codec_interface_exports = {};
 // src/runtime/index.ts
 var import_cement17 = require("@adviser/cement");
 init_version();
-init_version2();
+
+// src/runtime/gateways/indexdb/version.ts
+var INDEXDB_VERSION = "v0.19-indexdb";
 
 // src/index.ts
 init_utils();
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.19.111": "xxxx"
+  "0.19.112-dev-iife": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map