@fireproof/core 0.19.112-dev-web → 0.19.112-dev-dyn

package/index.cjs

@@ -294,95 +294,44 @@ var init_utils = __esm({
   }
 });
 
-// src/runtime/gateways/file/mem-filesystem@skip-iife.ts
-var mem_filesystem_skip_iife_exports = {};
-__export(mem_filesystem_skip_iife_exports, {
-  MemFileSystem: () => MemFileSystem
-});
-var import_memfs, MemFileSystem;
-var init_mem_filesystem_skip_iife = __esm({
-  "src/runtime/gateways/file/mem-filesystem@skip-iife.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/get-file-system-dynamic.ts
+async function getFileSystem(url) {
+  const name = url.getParam("fs", "node");
+  let fs;
+  switch (name) {
+    case "mem":
+      fs = await externalLoaders.get(name).once(async () => {
+        const memjs = "./node/mem-filesystem.js";
+        const { MemFileSystem } = await import(
+          /* @vite-ignore */
+          memjs
+        );
+        return new MemFileSystem();
+      });
+      break;
+    // case 'deno': {
+    //   const { DenoFileSystem } = await import("./deno-filesystem.js");
+    //   fs = new DenoFileSystem();
+    //   break;
+    // }
+    default:
+      fs = await externalLoaders.get(name).once(async () => {
+        const nodejs = "./node/node-filesystem.js";
+        const { NodeFileSystem } = await import(
+          /* @vite-ignore */
+          nodejs
+        );
+        return new NodeFileSystem();
+      });
   }
-});
-
-// src/runtime/gateways/file/node-filesystem@skip-iife.ts
-var node_filesystem_skip_iife_exports = {};
-__export(node_filesystem_skip_iife_exports, {
-  NodeFileSystem: () => NodeFileSystem
-});
-var import_cement4, NodeFileSystem;
-var init_node_filesystem_skip_iife = __esm({
-  "src/runtime/gateways/file/node-filesystem@skip-iife.ts"() {
+  return fs.start();
+}
+var import_cement4, externalLoaders;
+var init_get_file_system_dynamic = __esm({
+  "src/runtime/gateways/file/get-file-system-dynamic.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));
-      }
-    };
+    externalLoaders = new import_cement4.KeyedResolvOnce();
   }
 });
 
@@ -391,36 +340,8 @@ 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;
-  switch (name) {
-    case "mem":
-      {
-        const { MemFileSystem: MemFileSystem2 } = await Promise.resolve().then(() => (init_mem_filesystem_skip_iife(), mem_filesystem_skip_iife_exports));
-        fs2 = new MemFileSystem2();
-      }
-      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_skip_iife(), node_filesystem_skip_iife_exports));
-      fs2 = new NodeFileSystem2();
-      break;
-    }
-    case "sys":
-    default: {
-      return getFileSystem(url.build().setParam("fs", "node").URI());
-    }
-  }
-  return fs2.start();
-}
 function getPath(url, sthis) {
   const basePath = url.pathname;
   const name = url.getParam("name");
@@ -445,21 +366,11 @@ 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 init_utils2 = __esm({
   "src/runtime/gateways/file/utils.ts"() {
     "use strict";
     init_utils();
+    init_get_file_system_dynamic();
   }
 });
 
@@ -583,15 +494,15 @@ var init_version = __esm({
   }
 });
 
-// src/runtime/gateways/file/gateway@skip-iife.ts
-var gateway_skip_iife_exports = {};
-__export(gateway_skip_iife_exports, {
+// src/runtime/gateways/file/gateway.ts
+var gateway_exports = {};
+__export(gateway_exports, {
   FileGateway: () => FileGateway,
   FileTestStore: () => FileTestStore
 });
 var import_cement11, versionFiles, FileGateway, FileTestStore;
-var init_gateway_skip_iife = __esm({
-  "src/runtime/gateways/file/gateway@skip-iife.ts"() {
+var init_gateway = __esm({
+  "src/runtime/gateways/file/gateway.ts"() {
     "use strict";
     init_version();
     import_cement11 = require("@adviser/cement");
@@ -722,173 +633,80 @@ var init_gateway_skip_iife = __esm({
   }
 });
 
-// src/runtime/gateways/indexdb/version.ts
-var INDEXDB_VERSION;
-var init_version2 = __esm({
-  "src/runtime/gateways/indexdb/version.ts"() {
+// src/runtime/gateways/indexdb/gateway-import-dynamic.ts
+function gatewayImport() {
+  const gwimpl = "./web/gateway-impl.js";
+  return import(
+    /* @vite-ignore */
+    gwimpl
+  );
+}
+var init_gateway_import_dynamic = __esm({
+  "src/runtime/gateways/indexdb/gateway-import-dynamic.ts"() {
     "use strict";
-    INDEXDB_VERSION = "v0.19-indexdb";
   }
 });
 
-// src/runtime/gateways/indexdb/gateway@skip-esm.ts
-var gateway_skip_esm_exports = {};
-__export(gateway_skip_esm_exports, {
+// 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 init_gateway_skip_esm = __esm({
-  "src/runtime/gateways/indexdb/gateway@skip-esm.ts"() {
+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();
+    init_gateway_import_dynamic();
+    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 gatewayImport().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 gatewayImport().then(({ IndexDBTestStore: IndexDBTestStore2 }) => new IndexDBTestStore2(this.sthis));
+        });
+      }
+      get(url, key) {
+        return this.getGateway().then((gw) => gw.get(url, key));
       }
     };
   }
@@ -3129,22 +2947,22 @@ function toStoreRuntime(opts, sthis) {
 registerStoreProtocol({
   protocol: "file:",
   gateway: async (sthis) => {
-    const { FileGateway: FileGateway2 } = await Promise.resolve().then(() => (init_gateway_skip_iife(), gateway_skip_iife_exports));
+    const { FileGateway: FileGateway2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
     return new FileGateway2(sthis);
   },
   test: async (sthis) => {
-    const { FileTestStore: FileTestStore2 } = await Promise.resolve().then(() => (init_gateway_skip_iife(), gateway_skip_iife_exports));
+    const { FileTestStore: FileTestStore2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
     return new FileTestStore2(sthis);
   }
 });
 registerStoreProtocol({
   protocol: "indexdb:",
   gateway: async (sthis) => {
-    const { IndexDBGateway: IndexDBGateway2 } = await Promise.resolve().then(() => (init_gateway_skip_esm(), gateway_skip_esm_exports));
+    const { IndexDBGateway: IndexDBGateway2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
     return new IndexDBGateway2(sthis);
   },
   test: async (sthis) => {
-    const { IndexDBTestStore: IndexDBTestStore2 } = await Promise.resolve().then(() => (init_gateway_skip_esm(), gateway_skip_esm_exports));
+    const { IndexDBTestStore: IndexDBTestStore2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
     return new IndexDBTestStore2(sthis);
   }
 });
@@ -3522,7 +3340,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 {
 };
@@ -3530,17 +3348,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 }) => {
@@ -4331,8 +4149,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();
 
@@ -4349,13 +4166,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.112-dev-web": "xxxx"
+  "0.19.112-dev-dyn": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map