@fireproof/core-test 0.0.0-smoke-1b31059-1752074105

package/gateway/file/loader-config.test.ts

@@ -0,0 +1,309 @@
+import { BuildURI, CoerceURI, runtimeFn, URI } from "@adviser/cement";
+import { fireproof, PARAM, SuperThis } from "@fireproof/core";
+import { mockSuperThis } from "../../helpers.js";
+import { describe, beforeAll, it, expect } from "vitest";
+import { FILESTORE_VERSION, sysFileSystemFactory } from "@fireproof/core-gateways-file";
+
+function dataDir(sthis: SuperThis, name?: string, base?: CoerceURI): URI {
+  if (!base) {
+    const home = sthis.env.get("HOME") || "./";
+    base =
+      sthis.env.get("FP_STORAGE_URL") ||
+      `file://${sthis.pathOps.join(home, ".fireproof", FILESTORE_VERSION.replace(/-.*$/, ""))}?${PARAM.URL_GEN}=default`;
+  }
+  return URI.from(base.toString())
+    .build()
+    .setParam(PARAM.NAME, name || "")
+    .URI();
+}
+
+const _my_app = "my-app";
+function my_app() {
+  return _my_app;
+}
+
+describe("config file gateway", () => {
+  const sthis = mockSuperThis();
+  // const isMemFS: { fs?: string } = {};
+
+  beforeAll(async () => {
+    await sthis.start();
+    // const url = URI.from(sthis.env.get("FP_STORAGE_URL"));
+    // if (url.getParam("fs") === "mem") {
+    //   isMemFS.fs = "mem";
+    // }
+  });
+
+  it("loader", async () => {
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.ledger.name).toBe(my_app());
+
+    const fileStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.file;
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "file",
+        storekey: "@my-app-data@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+
+    const dataStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.car;
+    expect(dataStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "car",
+        suffix: ".car",
+        storekey: "@my-app-data@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    const metaStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.meta;
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "meta",
+        storekey: "@my-app-meta@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    const WALStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.wal;
+    expect(WALStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "wal",
+        storekey: "@my-app-wal@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    await db.close();
+  });
+
+  it("file path", async () => {
+    let baseDir = "./dist/data".replace(/\?.*$/, "").replace(/^file:\/\//, "");
+    baseDir = sthis.pathOps.join(baseDir, /* testCfg(sthis, "data").version, */ my_app());
+    const base = BuildURI.from("./dist/data");
+    // if (isMemFS.fs) {
+    //   base.setParam("fs", isMemFS.fs);
+    // }
+    const sysfs = await sysFileSystemFactory(base.URI());
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app(), { storeUrls: { base } });
+    // console.log(`>>>>>>>>>>>>>>>file-path`)
+    await db.put({ name: "my-app" });
+    expect(db.ledger.name).toBe(my_app());
+    const carStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.car;
+    expect(carStore?.url().asObj()).toEqual({
+      pathname: "./dist/data",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "car",
+        storekey: "@my-app-data@",
+        suffix: ".car",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    const fileStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.file;
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: "./dist/data",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "file",
+        storekey: "@my-app-data@",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const metaStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.meta;
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: "./dist/data",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "meta",
+        storekey: "@my-app-meta@",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+  });
+
+  it("homedir default", async () => {
+    const old = sthis.env.get("FP_STORAGE_URL");
+    sthis.env.delete("FP_STORAGE_URL");
+    // this switches file: protocol not memory:
+    let baseDir = dataDir(sthis, my_app()).pathname;
+    baseDir = sthis.pathOps.join(baseDir, my_app());
+
+    const base = BuildURI.from(baseDir);
+    // if (isMemFS.fs) {
+    //   base.setParam("fs", isMemFS.fs);
+    // }
+    const sysfs = await sysFileSystemFactory(base.URI());
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    expect(baseDir).toMatch(new RegExp(`/\\.fireproof/${FILESTORE_VERSION.replace(/-file/, "")}/${my_app()}`));
+
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.ledger.name).toBe(my_app());
+    const carStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.car;
+
+    expect(carStore?.url().asObj()).toEqual({
+      pathname: `${sthis.env.get("HOME")}/.fireproof/v0.19`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        suffix: ".car",
+        runtime: runtimeFn().isDeno ? "deno" : "node",
+        urlGen: "default",
+        store: "car",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: FILESTORE_VERSION,
+      },
+    });
+
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+
+    const fileStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.file;
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: `${sthis.env.get("HOME")}/.fireproof/v0.19`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        runtime: runtimeFn().isDeno ? "deno" : "node",
+        urlGen: "default",
+        store: "file",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: FILESTORE_VERSION,
+      },
+    });
+    const metaStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.meta;
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: `${sthis.env.get("HOME")}/.fireproof/v0.19`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        runtime: runtimeFn().isDeno ? "deno" : "node",
+        urlGen: "default",
+        store: "meta",
+        name: my_app(),
+        storekey: `@${my_app()}-meta@`,
+        version: FILESTORE_VERSION,
+      },
+    });
+
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    sthis.env.set("FP_STORAGE_URL", old);
+    await db.close();
+  });
+
+  it("set by env", async () => {
+    const old = sthis.env.get("FP_STORAGE_URL");
+    // assert(!old, "FP_STORAGE_URL must set")
+    const testUrl = BuildURI.from(old);
+    // sthis.env.set("FP_STORAGE_URL", testUrl.toString());
+
+    let baseDir = dataDir(sthis, my_app()).pathname;
+    baseDir = sthis.pathOps.join(baseDir, /* testCfg(sthis, "data").version, */ my_app());
+
+    const sysfs = await sysFileSystemFactory(testUrl.URI());
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.ledger.name).toBe(my_app());
+    const carStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.car;
+    expect(carStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        urlGen: "fromEnv",
+        store: "car",
+        // runtime: "node",
+        suffix: ".car",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: FILESTORE_VERSION,
+      },
+    });
+
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const fileStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.file;
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: `./dist/fp-dir-file`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        urlGen: "fromEnv",
+        store: "file",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: FILESTORE_VERSION,
+      },
+    });
+
+    const metaStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.meta;
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: `./dist/fp-dir-file`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        urlGen: "fromEnv",
+        store: "meta",
+        name: my_app(),
+        storekey: `@${my_app()}-meta@`,
+        version: FILESTORE_VERSION,
+      },
+    });
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+    sthis.env.set("FP_STORAGE_URL", old);
+  });
+});

package/gateway/indexeddb/loader-config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/gateway/indexeddb/loader-config.test.js

@@ -0,0 +1,77 @@
+import { fireproof } from "@fireproof/core";
+import { mockSuperThis } from "../../helpers.js";
+import { describe, beforeAll, it, expect } from "vitest";
+describe("fireproof config indexeddb", () => {
+    const _my_app = "my-app";
+    function my_app() {
+        return _my_app;
+    }
+    const sthis = mockSuperThis();
+    beforeAll(async () => {
+        await sthis.start();
+    });
+    it("indexeddb-loader", async () => {
+        const db = fireproof(my_app());
+        await db.put({ name: "my-app" });
+        expect(db.ledger.name).toBe(my_app());
+        const fileStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.file;
+        expect(fileStore?.url().asObj()).toEqual({
+            pathname: "fp",
+            protocol: "indexeddb:",
+            searchParams: {
+                name: "my-app",
+                store: "file",
+                runtime: "browser",
+                storekey: "@my-app-data@",
+                urlGen: "default",
+                version: "v0.19-indexeddb",
+            },
+            style: "path",
+        });
+        const dataStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.car;
+        expect(dataStore?.url().asObj()).toEqual({
+            pathname: "fp",
+            protocol: "indexeddb:",
+            searchParams: {
+                name: "my-app",
+                store: "car",
+                runtime: "browser",
+                storekey: "@my-app-data@",
+                suffix: ".car",
+                urlGen: "default",
+                version: "v0.19-indexeddb",
+            },
+            style: "path",
+        });
+        const metaStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.meta;
+        expect(metaStore?.url().asObj()).toEqual({
+            pathname: "fp",
+            protocol: "indexeddb:",
+            searchParams: {
+                name: "my-app",
+                store: "meta",
+                runtime: "browser",
+                storekey: "@my-app-meta@",
+                urlGen: "default",
+                version: "v0.19-indexeddb",
+            },
+            style: "path",
+        });
+        const WALStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.wal;
+        expect(WALStore?.url().asObj()).toEqual({
+            pathname: "fp",
+            protocol: "indexeddb:",
+            searchParams: {
+                name: "my-app",
+                store: "wal",
+                runtime: "browser",
+                storekey: "@my-app-wal@",
+                urlGen: "default",
+                version: "v0.19-indexeddb",
+            },
+            style: "path",
+        });
+        await db.close();
+    });
+});
+//# sourceMappingURL=loader-config.test.js.map

package/gateway/indexeddb/loader-config.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader-config.test.js","sourceRoot":"","sources":["loader-config.test.ts"],"names":[],"mappings":"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"}

package/gateway/indexeddb/loader-config.test.ts

@@ -0,0 +1,80 @@
+import { fireproof } from "@fireproof/core";
+import { mockSuperThis } from "../../helpers.js";
+import { describe, beforeAll, it, expect } from "vitest";
+
+describe("fireproof config indexeddb", () => {
+  const _my_app = "my-app";
+  function my_app() {
+    return _my_app;
+  }
+  const sthis = mockSuperThis();
+  beforeAll(async () => {
+    await sthis.start();
+  });
+
+  it("indexeddb-loader", async () => {
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.ledger.name).toBe(my_app());
+
+    const fileStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.file;
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: "fp",
+      protocol: "indexeddb:",
+      searchParams: {
+        name: "my-app",
+        store: "file",
+        runtime: "browser",
+        storekey: "@my-app-data@",
+        urlGen: "default",
+        version: "v0.19-indexeddb",
+      },
+      style: "path",
+    });
+
+    const dataStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.car;
+    expect(dataStore?.url().asObj()).toEqual({
+      pathname: "fp",
+      protocol: "indexeddb:",
+      searchParams: {
+        name: "my-app",
+        store: "car",
+        runtime: "browser",
+        storekey: "@my-app-data@",
+        suffix: ".car",
+        urlGen: "default",
+        version: "v0.19-indexeddb",
+      },
+      style: "path",
+    });
+    const metaStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.meta;
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: "fp",
+      protocol: "indexeddb:",
+      searchParams: {
+        name: "my-app",
+        store: "meta",
+        runtime: "browser",
+        storekey: "@my-app-meta@",
+        urlGen: "default",
+        version: "v0.19-indexeddb",
+      },
+      style: "path",
+    });
+    const WALStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.wal;
+    expect(WALStore?.url().asObj()).toEqual({
+      pathname: "fp",
+      protocol: "indexeddb:",
+      searchParams: {
+        name: "my-app",
+        store: "wal",
+        runtime: "browser",
+        storekey: "@my-app-wal@",
+        urlGen: "default",
+        version: "v0.19-indexeddb",
+      },
+      style: "path",
+    });
+    await db.close();
+  });
+});

package/global-setup.d.ts

@@ -0,0 +1,2 @@
+import type { TestProject } from "vitest/node";
+export declare function setup(project: TestProject): Promise<() => void>;

package/global-setup.js

@@ -0,0 +1,9 @@
+import { cd, $ } from "zx";
+export async function setup(project) {
+    const root = project.toJSON().serializedConfig.root;
+    $.verbose = true;
+    cd(root);
+    return () => {
+    };
+}
+//# sourceMappingURL=global-setup.js.map

package/global-setup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-setup.js","sourceRoot":"","sources":["global-setup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,IAAI,CAAC;AAG3B,MAAM,CAAC,KAAK,UAAU,KAAK,CAAC,OAAoB;IAC9C,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC;IACpD,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC;IACjB,EAAE,CAAC,IAAI,CAAC,CAAC;IACT,OAAO,GAAG,EAAE;IAEZ,CAAC,CAAC;AACJ,CAAC"}

package/global-setup.ts

@@ -0,0 +1,11 @@
+import { cd, $ } from "zx";
+import type { TestProject } from "vitest/node";
+
+export async function setup(project: TestProject) {
+  const root = project.toJSON().serializedConfig.root;
+  $.verbose = true;
+  cd(root);
+  return () => {
+    /* no-op */
+  };
+}

package/helpers.d.ts

@@ -0,0 +1,31 @@
+import { URI, LogCollector } from "@adviser/cement";
+import { SuperThis, SuperThisOpts } from "@fireproof/core";
+import { CID } from "multiformats";
+import { Loadable } from "@fireproof/core-types-blockstore";
+export declare function tracer(): void;
+export interface FileWithCid {
+    file: File;
+    cid: string;
+}
+export declare function buildBlobFiles(): Promise<FileWithCid[]>;
+export declare function storageURL(sthis: SuperThis): URI;
+export type MockSuperThis = SuperThis & {
+    ctx: {
+        readonly logCollector: LogCollector;
+    };
+};
+export declare function mockSuperThis(sthis?: Partial<SuperThisOpts>): MockSuperThis;
+export declare function noopUrl(name?: string): URI;
+export declare function simpleBlockOpts(sthis: SuperThis, name?: string): {
+    keyBag: import("@fireproof/core").KeyBagRuntime;
+    storeRuntime: import("@fireproof/core-types-blockstore").StoreRuntime;
+    storeUrls: {
+        file: URI;
+        wal: URI;
+        meta: URI;
+        car: URI;
+    };
+    tracer: typeof tracer;
+};
+export declare function simpleCID(sthis: SuperThis): Promise<CID<unknown, 512, 18, 1>>;
+export declare function mockLoader(sthis: SuperThis): Loadable;

package/helpers.js

@@ -0,0 +1,140 @@
+import { BuildURI, MockLogger, runtimeFn, toCryptoRuntime, URI, utils, AppContext } from "@adviser/cement";
+import { PARAM } from "@fireproof/core";
+import { CID } from "multiformats";
+import { sha256 } from "multiformats/hashes/sha2";
+import * as json from "multiformats/codecs/json";
+import { CommitQueue, encodeFile, ensureSuperThis, TaskManager } from "@fireproof/core-runtime";
+import { defaultKeyBagOpts, getKeyBag } from "@fireproof/core-keybag";
+import { AttachedRemotesImpl, toStoreRuntime } from "@fireproof/core-blockstore";
+import { CarLog, } from "@fireproof/core-types-blockstore";
+export function tracer() { }
+async function toFileWithCid(buffer, name, opts) {
+    return {
+        file: new File([new Blob([buffer])], name, opts),
+        cid: (await encodeFile(new File([new Blob([buffer])], name, opts))).cid.toString(),
+    };
+}
+export async function buildBlobFiles() {
+    const cp = toCryptoRuntime();
+    return [
+        await toFileWithCid(cp.randomBytes(Math.random() * 51283), `image.jpg`, { type: "image/jpeg" }),
+        await toFileWithCid(cp.randomBytes(Math.random() * 51283), `fireproof.png`, { type: "image/png" }),
+    ];
+}
+export function storageURL(sthis) {
+    const old = sthis.env.get("FP_STORAGE_URL");
+    let merged;
+    if (runtimeFn().isBrowser) {
+        merged = URI.merge(`indexeddb://fp`, old, "indexeddb:");
+    }
+    else {
+        merged = URI.merge(`./dist/env`, old);
+    }
+    return merged;
+}
+export function mockSuperThis(sthis) {
+    const mockLog = MockLogger({
+        pass: new utils.ConsoleWriterStreamDefaultWriter(new utils.ConsoleWriterStream()),
+    });
+    return ensureSuperThis({
+        ...sthis,
+        logger: mockLog.logger,
+        ctx: AppContext.merge({
+            logCollector: mockLog.logCollector,
+        }),
+    });
+}
+export function noopUrl(name) {
+    const burl = BuildURI.from("memory://noop");
+    burl.setParam(PARAM.NAME, name || "test");
+    return burl.URI();
+}
+export function simpleBlockOpts(sthis, name) {
+    const url = noopUrl(name);
+    return {
+        keyBag: defaultKeyBagOpts(sthis),
+        storeRuntime: toStoreRuntime(sthis),
+        storeUrls: {
+            file: url,
+            wal: url,
+            meta: url,
+            car: url,
+        },
+        tracer,
+    };
+}
+export async function simpleCID(sthis) {
+    const bytes = json.encode({ hello: sthis.nextId().str });
+    const hash = await sha256.digest(bytes);
+    return CID.create(1, json.code, hash);
+}
+class MockLoader {
+    sthis;
+    logger;
+    ebOpts;
+    carLog;
+    attachedStores;
+    taskManager;
+    commitQueue;
+    constructor(sthis) {
+        this.sthis = sthis;
+        this.logger = sthis.logger;
+        this.ebOpts = {
+            storeUrls: {
+                file: noopUrl("test"),
+                wal: noopUrl("test"),
+                meta: noopUrl("test"),
+                car: noopUrl("test"),
+            },
+        };
+        this.carLog = new CarLog();
+        this.taskManager = new TaskManager(sthis, () => Promise.resolve(), {
+            removeAfter: 3,
+            retryTimeout: 50,
+        });
+        this.attachedStores = new AttachedRemotesImpl(this);
+        this.commitQueue = new CommitQueue({
+            tracer,
+        });
+    }
+    attach(attached) {
+        throw new Error("Method not implemented.");
+    }
+    ready() {
+        throw new Error("Method not implemented.");
+    }
+    close() {
+        throw new Error("Method not implemented.");
+    }
+    keyBag() {
+        return getKeyBag(this.sthis, {});
+    }
+    handleDbMetasFromStore(metas, store) {
+        return Promise.resolve([]);
+    }
+    commit(t, done, opts) {
+        throw new Error("Method not implemented.");
+    }
+    destroy() {
+        throw new Error("Method not implemented.");
+    }
+    getBlock(cid, store) {
+        throw new Error("Method not implemented.");
+    }
+    loadFileCar(cid, store) {
+        throw new Error("Method not implemented.");
+    }
+    loadCar(cid, store) {
+        throw new Error("Method not implemented.");
+    }
+    commitFiles(t, done) {
+        throw new Error("Method not implemented.");
+    }
+    entries(cache) {
+        throw new Error("Method not implemented.");
+    }
+}
+export function mockLoader(sthis) {
+    return new MockLoader(sthis);
+}
+//# sourceMappingURL=helpers.js.map