@fireproof/core 0.3.2 → 0.3.3

package/README.md

@@ -18,7 +18,7 @@ Fireproof is alpha software, you should only use it if you are planning to contr
 ## Usage
 
 ```js
-import Fireproof from 'fireproof';
+import { Fireproof } from 'fireproof';
 
 async function main() {
   const database = Fireproof.storage('my-db');

package/dist/src/blockstore.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @typedef {Object} AnyBlock
+ * @property {import('./link').AnyLink} cid - The CID of the block
+ * @property {Uint8Array} bytes - The block's data
+ *
+ * @typedef {Object} Blockstore
+ * @property {function(import('./link').AnyLink): Promise<AnyBlock|undefined>} get - A function to retrieve a block by CID
+ * @property {function(import('./link').AnyLink, Uint8Array): Promise<void>} put - A function to store a block's data and CID
+ *
+ * A blockstore that caches writes to a transaction and only persists them when committed.
+ * @implements {Blockstore}
+ */
+export class TransactionBlockstore implements Blockstore {
+    constructor(name: any, encryptionKey: any);
+    /** @type {Map<string, Uint8Array>} */
+    committedBlocks: Map<string, Uint8Array>;
+    valet: any;
+    instanceId: string;
+    inflightTransactions: Set<any>;
+    /**
+     * Get a block from the store.
+     *
+     * @param {import('./link').AnyLink} cid
+     * @returns {Promise<AnyBlock | undefined>}
+     */
+    get(cid: import('./link').AnyLink): Promise<AnyBlock | undefined>;
+    transactionsGet(key: any): Promise<any>;
+    committedGet(key: any): Promise<any>;
+    clearCommittedCache(): Promise<void>;
+    networkGet(key: any): Promise<any>;
+    /**
+     * Add a block to the store. Usually bound to a transaction by a closure.
+     * It sets the lastCid property to the CID of the block that was put.
+     * This is used by the transaction as the head of the car when written to the valet.
+     * We don't have to worry about which transaction we are when we are here because
+     * we are the transactionBlockstore.
+     *
+     * @param {import('./link').AnyLink} cid
+     * @param {Uint8Array} bytes
+     */
+    put(cid: import('./link').AnyLink, bytes: Uint8Array): void;
+    /**
+     * Iterate over all blocks in the store.
+     *
+     * @yields {AnyBlock}
+     * @returns {AsyncGenerator<AnyBlock>}
+     */
+    /**
+     * Begin a transaction. Ensures the uncommited blocks are empty at the begining.
+     * Returns the blocks to read and write during the transaction.
+     * @returns {InnerBlockstore}
+     * @memberof TransactionBlockstore
+     */
+    begin(label?: string): InnerBlockstore;
+    /**
+     * Commit the transaction. Writes the blocks to the store.
+     * @returns {Promise<void>}
+     * @memberof TransactionBlockstore
+     */
+    commit(innerBlockstore: any): Promise<void>;
+    doCommit: (innerBlockstore: any) => Promise<void>;
+    /**
+     * Retire the transaction. Clears the uncommited blocks.
+     * @returns {void}
+     * @memberof TransactionBlockstore
+     */
+    retire(innerBlockstore: any): void;
+}
+export function doTransaction(label: string, blockstore: TransactionBlockstore, doFun: (innerBlockstore: Blockstore) => Promise<any>): Promise<any>;
+/** @implements {BlockFetcher} */
+export class InnerBlockstore implements BlockFetcher {
+    constructor(label: any, parentBlockstore: any);
+    /** @type {Map<string, Uint8Array>} */
+    blocks: Map<string, Uint8Array>;
+    lastCid: any;
+    label: string;
+    parentBlockstore: any;
+    /**
+     * @param {import('./link').AnyLink} cid
+     * @returns {Promise<AnyBlock | undefined>}
+     */
+    get(cid: import('./link').AnyLink): Promise<AnyBlock | undefined>;
+    /**
+     * @param {import('./link').AnyLink} cid
+     * @param {Uint8Array} bytes
+     */
+    put(cid: import('./link').AnyLink, bytes: Uint8Array): void;
+    entries(): Generator<{
+        cid: import("multiformats").Link<unknown, number, number, import("multiformats").Version>;
+        bytes: Uint8Array;
+    }, void, unknown>;
+}
+export type AnyBlock = {
+    /**
+     * - The CID of the block
+     */
+    cid: import('./link').AnyLink;
+    /**
+     * - The block's data
+     */
+    bytes: Uint8Array;
+};
+export type Blockstore = {
+    /**
+     * - A function to retrieve a block by CID
+     */
+    get: (arg0: import('./link').AnyLink) => Promise<AnyBlock | undefined>;
+    /**
+     * - A function to store a block's data and CID
+     *
+     * A blockstore that caches writes to a transaction and only persists them when committed.
+     */
+    put: (arg0: import('./link').AnyLink, arg1: Uint8Array) => Promise<void>;
+};
+//# sourceMappingURL=blockstore.d.ts.map

package/dist/src/blockstore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockstore.d.ts","sourceRoot":"","sources":["../../src/blockstore.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;AACH;IASE,2CAEC;IAVD,sCAAsC;IACtC,iBADW,IAAI,MAAM,EAAE,UAAU,CAAC,CACP;IAE3B,WAAY;IAEZ,mBAAiE;IACjE,+BAAgC;IAMhC;;;;;OAKG;IACH,SAHW,OAAO,QAAQ,EAAE,OAAO,GACtB,QAAQ,QAAQ,GAAG,SAAS,CAAC,CAWzC;IAID,wCAMC;IAED,qCAOC;IAED,qCAEC;IAED,mCAcC;IAED;;;;;;;;;OASG;IACH,SAHW,OAAO,QAAQ,EAAE,OAAO,SACxB,UAAU,QAIpB;IAED;;;;;OAKG;IAWH;;;;;OAKG;IACH,uBAHa,eAAe,CAO3B;IAED;;;;OAIG;IACH,8BAHa,QAAQ,IAAI,CAAC,CAKzB;IAOD,kDAeC;IAED;;;;OAIG;IACH,8BAHa,IAAI,CAKhB;CACF;AAWM,qCANI,MAAM,cACN,qBAAqB,2BACH,UAAU,KAAK,QAAQ,GAAG,CAAC,GAC3C,QAAQ,GAAG,CAAC,CAgBxB;AAED,iCAAiC;AACjC,wCADiB,YAAY;IAQ3B,+CAGC;IATD,sCAAsC;IACtC,QADW,IAAI,MAAM,EAAE,UAAU,CAAC,CAChB;IAClB,aAAc;IACd,cAAU;IACV,sBAAuB;IAOvB;;;OAGG;IACH,SAHW,OAAO,QAAQ,EAAE,OAAO,GACtB,QAAQ,QAAQ,GAAG,SAAS,CAAC,CAYzC;IAED;;;OAGG;IACH,SAHW,OAAO,QAAQ,EAAE,OAAO,SACxB,UAAU,QAMpB;IAED;;;sBAIC;CACF;;;;;SAtOa,OAAO,QAAQ,EAAE,OAAO;;;;WACxB,UAAU;;;;;;gBAGD,OAAO,QAAQ,EAAE,OAAO,KAAG,QAAQ,QAAQ,GAAC,SAAS,CAAC;;;;;;gBACtD,OAAO,QAAQ,EAAE,OAAO,QAAE,UAAU,KAAG,QAAQ,IAAI,CAAC"}

package/dist/src/clock.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @template T
+ * @typedef {{ parents: EventLink<T>[], data: T }} EventView
+ */
+/**
+ * @template T
+ * @typedef {import('multiformats').BlockView<EventView<T>>} EventBlockView
+ */
+/**
+ * @template T
+ * @typedef {import('multiformats').Link<EventView<T>>} EventLink
+ */
+/**
+ * Advance the clock by adding an event.
+ *
+ * @template T
+ * @param {import('./blockstore').BlockFetcher} blocks Block storage.
+ * @param {EventLink<T>[]} head The head of the clock.
+ * @param {EventLink<T>} event The event to add.
+ * @returns {Promise<EventLink<T>[]>} The new head of the clock.
+ */
+export function advance<T>(blocks: any, head: import("multiformats/dist/types/src").Link<EventView<T>, number, number, 1>[], event: import("multiformats/dist/types/src").Link<EventView<T>, number, number, 1>): Promise<import("multiformats/dist/types/src").Link<EventView<T>, number, number, 1>[]>;
+/**
+ * @template T
+ * @param {EventView<T>} value
+ * @returns {Promise<EventBlockView<T>>}
+ */
+export function encodeEventBlock<T>(value: EventView<T>): Promise<import("multiformats/dist/types/src").BlockView<EventView<T>, number, number, 1>>;
+/**
+ * @template T
+ * @param {Uint8Array} bytes
+ * @returns {Promise<EventBlockView<T>>}
+ */
+export function decodeEventBlock<T>(bytes: Uint8Array): Promise<import("multiformats/dist/types/src").BlockView<EventView<T>, number, number, 1>>;
+/**
+ * @template T
+ * @param {import('./blockstore').BlockFetcher} blocks Block storage.
+ * @param {EventLink<T>[]} head
+ * @param {object} [options]
+ * @param {(b: EventBlockView<T>) => string} [options.renderNodeLabel]
+ */
+export function vis<T>(blocks: any, head: import("multiformats/dist/types/src").Link<EventView<T>, number, number, 1>[], options?: {
+    renderNodeLabel?: (b: import("multiformats/dist/types/src").BlockView<EventView<T>, number, number, 1>) => string;
+}): AsyncGenerator<string, void, unknown>;
+export function findEventsToSync(blocks: any, head: any): Promise<{
+    cids: any;
+    events: any;
+}>;
+export function findCommonAncestorWithSortedEvents(events: any, children: any): Promise<{
+    ancestor: import("multiformats/dist/types/src").Link<EventView<EventData>, number, number, 1>;
+    sorted: import("multiformats/dist/types/src").BlockView<EventView<EventData>, number, number, 1>[];
+}>;
+/**
+ * @template T
+ * @implements {EventBlockView<T>}
+ */
+export class EventBlock<T> extends Block<any, any, any, any> implements EventBlockView<T> {
+    /**
+     * @template T
+     * @param {T} data
+     * @param {EventLink<T>[]} [parents]
+     */
+    static create<T_1>(data: T_1, parents?: import("multiformats/dist/types/src").Link<EventView<T_1>, number, number, 1>[]): Promise<import("multiformats/dist/types/src").BlockView<EventView<T_1>, number, number, 1>>;
+    /**
+     * @param {object} config
+     * @param {EventLink<T>} config.cid
+     * @param {Event} config.value
+     * @param {Uint8Array} config.bytes
+     */
+    constructor({ cid, value, bytes }: {
+        cid: EventLink<T>;
+        value: Event;
+        bytes: Uint8Array;
+    });
+}
+/** @template T */
+export class EventFetcher<T> {
+    /** @param {import('./blockstore').BlockFetcher} blocks */
+    constructor(blocks: any);
+    /** @private */
+    private _blocks;
+    _cids: any;
+    _cache: Map<any, any>;
+    /**
+     * @param {EventLink<T>} link
+     * @returns {Promise<EventBlockView<T>>}
+     */
+    get(link: EventLink<T>): Promise<EventBlockView<T>>;
+    all(): Promise<any>;
+}
+export type EventView<T> = {
+    parents: EventLink<T>[];
+    data: T;
+};
+export type EventBlockView<T> = import('multiformats').BlockView<EventView<T>>;
+export type EventLink<T> = import('multiformats').Link<EventView<T>>;
+import { Block } from 'multiformats/block';
+//# sourceMappingURL=clock.d.ts.map

package/dist/src/clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../../src/clock.js"],"names":[],"mappings":"AAMA;;;GAGG;AAEH;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;;;GAQG;AACH,ySAgCC;AA4DD;;;;GAIG;AACH,oJAKC;AAED;;;;GAIG;AACH,2CAHW,UAAU,6FAOpB;AA0BD;;;;;;GAMG;AACH;+GAFqC,MAAM;0CAgC1C;AAED;;;GAYC;AAKD;;;GAYC;AA7KD;;;GAGG;AACH,uFAF+B,CAAC;IAc9B;;;;OAIG;IACH,sNAEC;IAlBD;;;;;OAKG;IACH;QAJgC,GAAG,EAAxB,UAAU,CAAC,CAAC;QACE,KAAK,EAAnB,KAAK;QACc,KAAK,EAAxB,UAAU;OAKpB;CAUF;AAED,kBAAkB;AAClB;IACE,0DAA0D;IAC1D,yBAKC;IAJC,eAAe;IACf,gBAAqB;IACrB,WAA6B;IAC7B,sBAAuB;IAGzB;;;OAGG;IACH,UAHW,UAAU,CAAC,CAAC,GACV,QAAQ,eAAe,CAAC,CAAC,CAAC,CAYtC;IAED,oBAGC;CACF;2BAhHY;IAAE,OAAO,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE;gCAKpC,OAAO,cAAc,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;2BAK9C,OAAO,cAAc,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;sBAjBhB,oBAAoB"}

package/dist/src/crypto.d.ts

@@ -0,0 +1,18 @@
+export function encrypt({ get, cids, hasher, key, cache, chunker, root }: {
+    get: any;
+    cids: any;
+    hasher: any;
+    key: any;
+    cache: any;
+    chunker: any;
+    root: any;
+}): AsyncGenerator<any, void, unknown>;
+export function decrypt({ root, get, key, cache, chunker, hasher }: {
+    root: any;
+    get: any;
+    key: any;
+    cache: any;
+    chunker: any;
+    hasher: any;
+}): AsyncGenerator<any, void, undefined>;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/src/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/crypto.js"],"names":[],"mappings":"AAaA;;;;;;;;uCAuBC;AAED;;;;;;;yCAsBC"}

package/dist/src/db-index.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Represents an DbIndex for a Fireproof database.
+ *
+ * @class DbIndex
+ * @classdesc An DbIndex can be used to order and filter the documents in a Fireproof database.
+ *
+ * @param {Fireproof} database - The Fireproof database instance to DbIndex.
+ * @param {Function} mapFn - The map function to apply to each entry in the database.
+ *
+ */
+export class DbIndex {
+    static registerWithDatabase(inIndex: any, database: any): void;
+    static fromJSON(database: any, { code, clock, name }: {
+        code: any;
+        clock: any;
+        name: any;
+    }): DbIndex;
+    constructor(database: any, mapFn: any, clock: any, opts?: {});
+    /**
+     * The database instance to DbIndex.
+     * @type {Fireproof}
+     */
+    database: Fireproof;
+    mapFnString: any;
+    mapFn: any;
+    name: any;
+    indexById: {
+        root: any;
+        cid: any;
+    };
+    indexByKey: {
+        root: any;
+        cid: any;
+    };
+    dbHead: any;
+    instanceId: string;
+    updateIndexPromise: Promise<void>;
+    makeName(): any;
+    toJSON(): {
+        name: any;
+        code: any;
+        clock: {
+            db: any;
+            byId: any;
+            byKey: any;
+        };
+    };
+    /**
+     * JSDoc for Query type.
+     * @typedef {Object} DbQuery
+     * @property {string[]} [range] - The range to query.
+     * @memberof DbIndex
+     */
+    /**
+     * Query object can have {range}
+     * @param {DbQuery} query - the query range to use
+     * @returns {Promise<{proof: {}, rows: Array<{id: string, key: string, value: any}>}>}
+     * @memberof DbIndex
+     * @instance
+     */
+    query(query: {
+        /**
+         * - The range to query.
+         */
+        range?: string[];
+    }, update?: boolean): Promise<{
+        proof: {};
+        rows: Array<{
+            id: string;
+            key: string;
+            value: any;
+        }>;
+    }>;
+    /**
+     * Update the DbIndex with the latest changes
+     * @private
+     * @returns {Promise<void>}
+     */
+    private updateIndex;
+    innerUpdateIndex(inBlocks: any): Promise<void>;
+}
+/**
+ * JDoc for the result row type.
+ */
+export type ChangeEvent = {
+    /**
+     * - The key of the document.
+     */
+    key: string;
+    /**
+     * - The new value of the document.
+     */
+    value: any;
+    /**
+     * - Is the row deleted?
+     */
+    del?: boolean;
+};
+/**
+ * JDoc for the result row type.
+ */
+export type DbIndexEntry = {
+    /**
+     * - The key for the DbIndex entry.
+     */
+    key: string[];
+    /**
+     * - The value of the document.
+     */
+    value: any;
+    /**
+     * - Is the row deleted?
+     */
+    del?: boolean;
+};
+//# sourceMappingURL=db-index.d.ts.map

package/dist/src/db-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-index.d.ts","sourceRoot":"","sources":["../../src/db-index.js"],"names":[],"mappings":"AAoFA;;;;;;;;;GASG;AACH;IA0CE,+DAkBC;IAUD;;;;gBAGC;IAxED,8DAiCC;IA/BC;;;OAGG;IACH,oBAAwB;IAUtB,iBAAwB;IAExB,WAAkB;IAGpB,UAAwC;IACxC;;;MAA0C;IAC1C;;;MAA2C;IAC3C,YAAkB;IAMlB,mBAAqG;IACrG,kCAA8B;IAIhC,gBAIC;IAsBD;;;;;;;;MAMC;IAOD;;;;;OAKG;IAEH;;;;;;OAMG;IACH;;;;gBAXc,MAAM,EAAE;0BAOT,QAAQ;QAAC,KAAK,EAAE,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,GAAG,CAAA;SAAC,CAAC,CAAA;KAAC,CAAC,CAoBpF;IAED;;;;OAIG;IAEH,oBAOC;IAED,+CA6CC;CACF;;;;;;;;SAzNa,MAAM;;;;;;;;UAEN,OAAO;;;;;;;;;SAOP,MAAM,EAAE;;;;;;;;UAER,OAAO"}

package/dist/src/fireproof.d.ts

@@ -0,0 +1,167 @@
+export function cidsToProof(cids: any): Promise<any[]>;
+/**
+ * @class Fireproof
+ * @classdesc Fireproof stores data in IndexedDB and provides a Merkle clock.
+ *  This is the main class for saving and loading JSON and other documents with the database. You can find additional examples and
+ *  usage guides in the repository README.
+ *
+ * @param {import('./blockstore.js').TransactionBlockstore} blocks - The block storage instance to use documents and indexes
+ * @param {CID[]} clock - The Merkle clock head to use for the Fireproof instance.
+ * @param {object} [config] - Optional configuration options for the Fireproof instance.
+ * @param {object} [authCtx] - Optional authorization context object to use for any authentication checks.
+ *
+ */
+export class Fireproof {
+    /**
+     * @function storage
+     * @memberof Fireproof
+     * Creates a new Fireproof instance with default storage settings
+     * Most apps should use this and not worry about the details.
+     * @static
+     * @returns {Fireproof} - a new Fireproof instance
+     */
+    static storage: (name?: string) => Fireproof;
+    constructor(blocks: any, clock: any, config: any, authCtx?: {});
+    listeners: Set<any>;
+    name: any;
+    instanceId: string;
+    blocks: any;
+    clock: any;
+    config: any;
+    authCtx: {};
+    indexes: Map<any, any>;
+    /**
+     * Renders the Fireproof instance as a JSON object.
+     * @returns {Object} - The JSON representation of the Fireproof instance. Includes clock heads for the database and its indexes.
+     * @memberof Fireproof
+     * @instance
+     */
+    toJSON(): any;
+    clockToJSON(): any;
+    hydrate({ clock, name, key }: {
+        clock: any;
+        name: any;
+        key: any;
+    }): void;
+    indexBlocks: any;
+    /**
+     * Triggers a notification to all listeners
+     * of the Fireproof instance so they can repaint UI, etc.
+     * @param {CID[] } clock
+     *    Clock to use for the snapshot.
+     * @returns {Promise<void>}
+     * @memberof Fireproof
+     * @instance
+     */
+    notifyReset(): Promise<void>;
+    notifyExternal(source?: string): Promise<void>;
+    /**
+     * Returns the changes made to the Fireproof instance since the specified event.
+     * @function changesSince
+     * @param {CID[]} [event] - The clock head to retrieve changes since. If null or undefined, retrieves all changes.
+     * @returns {Object<{rows : Object[], clock: CID[]}>} An object containing the rows and the head of the instance's clock.
+     * @memberof Fireproof
+     * @instance
+     */
+    changesSince(event?: CID[]): any;
+    allDocuments(): Promise<{
+        rows: {
+            key: any;
+            value: any;
+        }[];
+        clock: any;
+        proof: any[];
+    }>;
+    /**
+     * Runs validation on the specified document using the Fireproof instance's configuration. Throws an error if the document is invalid.
+     *
+     * @param {Object} doc - The document to validate.
+     * @returns {Promise<void>}
+     * @throws {Error} - Throws an error if the document is invalid.
+     * @memberof Fireproof
+     * @instance
+     */
+    runValidation(doc: any): Promise<void>;
+    /**
+     * Retrieves the document with the specified ID from the database
+     *
+     * @param {string} key - the ID of the document to retrieve
+     * @param {Object} [opts] - options
+     * @returns {Promise<{_id: string}>} - the document with the specified ID
+     * @memberof Fireproof
+     * @instance
+     */
+    get(key: string, opts?: any): Promise<{
+        _id: string;
+    }>;
+    /**
+     * Adds a new document to the database, or updates an existing document. Returns the ID of the document and the new clock head.
+     *
+     * @param {Object} doc - the document to be added
+     * @param {string} doc._id - the document ID. If not provided, a random ID will be generated.
+     * @param {CID[]} doc._clock - the document ID. If not provided, a random ID will be generated.
+     * @param {Proof} doc._proof - CIDs referenced by the update
+     * @returns {Promise<{ id: string, clock: CID[]  }>} - The result of adding the document to the database
+     * @memberof Fireproof
+     * @instance
+     */
+    put({ _id, _proof, ...doc }: {
+        _id: string;
+        _clock: CID[];
+        _proof: Proof;
+    }): Promise<{
+        id: string;
+        clock: CID[];
+    }>;
+    /**
+     * Deletes a document from the database
+     * @param {string | any} docOrId - the document ID
+     * @returns {Promise<{ id: string, clock: CID[] }>} - The result of deleting the document from the database
+     * @memberof Fireproof
+     * @instance
+     */
+    del(docOrId: string | any): Promise<{
+        id: string;
+        clock: CID[];
+    }>;
+    /**
+     * Updates the underlying storage with the specified event.
+     * @private
+     * @param {{del?: true, key : string, value?: any}} decodedEvent - the event to add
+     * @returns {Promise<{ proof:{}, id: string, clock: CID[] }>} - The result of adding the event to storage
+     */
+    private putToProllyTree;
+    vis(): AsyncGenerator<any, {
+        cids: any;
+        result: any;
+        vis?: undefined;
+    } | {
+        vis: string;
+        cids: any;
+        result?: undefined;
+    }, unknown>;
+    visTree(): Promise<{
+        cids: any;
+        result: any;
+        vis?: undefined;
+    } | {
+        vis: string;
+        cids: any;
+        result?: undefined;
+    }>;
+    visClock(): Promise<{
+        vis: string;
+    }>;
+    /**
+     * Registers a Listener to be called when the Fireproof instance's clock is updated.
+     * Recieves live changes from the database after they are committed.
+     * @param {Function} listener - The listener to be called when the clock is updated.
+     * @returns {Function} - A function that can be called to unregister the listener.
+     * @memberof Fireproof
+     */
+    registerListener(listener: Function): Function;
+    notifyListeners(changes: any): Promise<void>;
+    setCarUploader(carUploaderFn: any): void;
+    setRemoteBlockReader(remoteBlockReaderFn: any): void;
+}
+//# sourceMappingURL=fireproof.d.ts.map

package/dist/src/fireproof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fireproof.d.ts","sourceRoot":"","sources":["../../src/fireproof.js"],"names":[],"mappings":"AAkUA,uDAIC;AA3TD;;;;;;;;;;;GAWG;AACH;IAGE;;;;;;;OAOG;IACH,mCAFa,SAAS,CAOrB;IAED,gEAQC;IAzBD,oBAAqB;IAkBnB,UAAoC;IACpC,mBAAiF;IACjF,YAAoB;IACpB,WAAkB;IAClB,YAAoB;IACpB,YAAsB;IACtB,uBAAwB;IAG1B;;;;;OAKG;IACH,cAQC;IAED,mBAEC;IAED;;;;aAKC;IADC,iBAAuB;IAGzB;;;;;;;;OAQG;IACH,eAJa,QAAQ,IAAI,CAAC,CAMzB;IAGD,+CAEC;IAED;;;;;;;OAOG;IACH,qBALW,KAAK,OAiCf;IAED;;;;;;;OAQC;IAED;;;;;;;;OAQG;IACH,yBALa,QAAQ,IAAI,CAAC,CAYzB;IAED;;;;;;;;OAQG;IACH,SANW,MAAM,eAEJ,QAAQ;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,CAAC,CAsBlC;IAED;;;;;;;;;;OAUG;IACH;QAPuB,GAAG,EAAf,MAAM;QACK,MAAM,EAAjB,KAAK;QACM,MAAM;;YACD,MAAM;eAAS,KAAK;OAQ9C;IAED;;;;;;OAMG;IACH,aALW,MAAM,GAAG,GAAG;YACI,MAAM;eAAS,KAAK;OAiB9C;IAED;;;;;OAKG;IACH,wBA6BC;IAYD;;;;;;;;gBAEC;IAED;;;;;;;;OAEC;IAED;;OAEC;IAED;;;;;;OAMG;IACH,+CAKC;IAED,6CAKC;IAED,yCAIC;IAED,qDAGC;CACF"}

package/dist/src/hydrator.d.ts

@@ -0,0 +1,6 @@
+export class Hydrator {
+    static fromJSON(json: any, database: any): any;
+    static snapshot(database: any, clock: any): any;
+    static zoom(database: any, clock: any): Promise<any>;
+}
+//# sourceMappingURL=hydrator.d.ts.map

package/dist/src/hydrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrator.d.ts","sourceRoot":"","sources":["../../src/hydrator.js"],"names":[],"mappings":"AAMA;IACE,+CAgBC;IAED,gDAgBC;IAED,qDASC;CACF"}

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+import { Fireproof } from './fireproof';
+import { DbIndex as Index } from './db-index';
+import { Listener } from './listener';
+import { Hydrator } from './hydrator';
+export { Fireproof, Index, Listener, Hydrator };
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":"0BAA0B,aAAa;iCACN,YAAY;yBACpB,YAAY;yBACZ,YAAY"}

package/dist/src/listener.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A Fireproof database Listener allows you to react to events in the database.
+ *
+ * @class Listener
+ * @classdesc An listener attaches to a Fireproof database and runs a routing function on each change, sending the results to subscribers.
+ *
+ * @param {Fireproof} database - The Fireproof database instance to index.
+ * @param {Function} routingFn - The routing function to apply to each entry in the database.
+ */
+export class Listener {
+    constructor(database: any, routingFn: any);
+    subcribers: Map<any, any>;
+    doStopListening: any;
+    /** routingFn
+     * The database instance to index.
+     * @type {Fireproof}
+     */
+    database: Fireproof;
+    /**
+     * The map function to apply to each entry in the database.
+     * @type {Function}
+     */
+    routingFn: Function;
+    dbHead: any;
+    /**
+     * Subscribe to a topic emitted by the event function.
+     * @param {string} topic - The topic to subscribe to.
+     * @param {Function} subscriber - The function to call when the topic is emitted.
+     * @returns {Function} A function to unsubscribe from the topic.
+     * @memberof Listener
+     * @instance
+     */
+    on(topic: string, subscriber: Function, since: any): Function;
+    onChanges(changes: any): void;
+}
+//# sourceMappingURL=listener.d.ts.map

package/dist/src/listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener.d.ts","sourceRoot":"","sources":["../../src/listener.js"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AAGH;IAIE,2CAiBC;IApBD,0BAAsB;IACtB,qBAAsB;IAGpB;;;OAGG;IACH,oBAAwB;IAExB;;;OAGG;IACH,oBAIG;IACH,YAAkB;IAGpB;;;;;;;OAOG;IACH,UANW,MAAM,8CAmBhB;IAED,8BAaC;CACF"}