@fireproof/core 0.8.0 → 0.10.1-dev

package/dist/src/fireproof.d.ts

@@ -1,472 +0,0 @@
-import * as multiformats from 'multiformats';
-import { Link, CID } from 'multiformats';
-
-type AnyLink = Link<unknown, number, number, 1|0>
-
-declare class Valet {
-    constructor(name?: string, config?: {});
-    idb: any;
-    name: any;
-    uploadQueue: any;
-    alreadyEnqueued: Set<any>;
-    instanceId: string;
-    primary: any;
-    secondary: any;
-    ready: Promise<any[]>;
-    saveHeader(header: any): Promise<any>;
-    compact(clock: any): Promise<void>;
-    /**
-     * Group the blocks into a car and write it to the valet.
-     * @param {import('./blockstore.js').InnerBlockstore} innerBlockstore
-     * @param {Set<string>} cids
-     * @returns {Promise<void>}
-     * @memberof Valet
-     */
-    writeTransaction(innerBlockstore: InnerBlockstore, cids: Set<string>): Promise<void>;
-    /**
-     * Iterate over all blocks in the store.
-     *
-     * @yields {{cid: string, value: Uint8Array}}
-     * @returns {AsyncGenerator<any, any, any>}
-     */
-    cids(): AsyncGenerator<any, any, any>;
-    remoteBlockFunction: any;
-    getValetBlock(dataCID: any): Promise<any>;
-}
-
-/**
- * @typedef {{ get: (link: import('../src/link').AnyLink) => Promise<AnyBlock | undefined> }} BlockFetcher
- */
-/**
- * @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.
-*/
-declare class TransactionBlockstore {
-    constructor(name: any, config: any);
-    /** @type {Map<string, Uint8Array>} */
-    committedBlocks: Map<string, Uint8Array>;
-    /** @type {Valet} */
-    valet: Valet;
-    instanceId: string;
-    inflightTransactions: Set<any>;
-    syncs: Set<any>;
-    ready: Promise<void> | Promise<any[]>;
-    remoteBlockFunction: any;
-    /**
-     * Get a block from the store.
-     *
-     * @param {import('./link').AnyLink} cid
-     * @returns {Promise<AnyBlock | undefined>}
-     */
-    get(cid: 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: AnyLink, bytes: Uint8Array): void;
-    /**
-     * Iterate over all blocks in the store.
-     *
-     * @yields {{cid: string, bytes: Uint8Array}}
-     * @returns {AsyncGenerator<any, any, any>}
-     */
-    entries(): AsyncGenerator<any, any, any>;
-    /**
-     * 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, doSync?: boolean): Promise<void>;
-    doCommit: (innerBlockstore: any) => Promise<void>;
-    /**
-     * Retire the transaction. Clears the uncommited blocks.
-     * @returns {void}
-     * @memberof TransactionBlockstore
-     */
-    retire(innerBlockstore: any): void;
-}
-declare class InnerBlockstore {
-    constructor(label: any, parentBlockstore: any);
-    /** @type {Map<string, Uint8Array>} */
-    blocks: Map<string, Uint8Array>;
-    head: any[];
-    lastCid: any;
-    label: string;
-    parentBlockstore: any;
-    /**
-     * @param {import('./link').AnyLink} cid
-     * @returns {Promise<AnyBlock | undefined>}
-     */
-    get(cid: AnyLink): Promise<AnyBlock | undefined>;
-    /**
-     * @param {import('./link').AnyLink} cid
-     * @param {Uint8Array} bytes
-     */
-    put(cid: AnyLink, bytes: Uint8Array): Promise<void>;
-    entries(): Generator<{
-        cid: multiformats.Link<unknown, number, number, multiformats.Version>;
-        bytes: Uint8Array;
-    }, void, unknown>;
-}
-type AnyBlock = {
-    /**
-     * - The CID of the block
-     */
-    cid: AnyLink;
-    /**
-     * - The block's data
-     */
-    bytes: Uint8Array;
-};
-
-/**
- * @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 {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.
- *
- */
-declare class Database {
-    constructor(name: any, config?: {});
-    listeners: Set<any>;
-    indexes: Map<any, any>;
-    rootCache: any;
-    eventsCache: Map<any, any>;
-    remote: any;
-    name: string;
-    clock: any[];
-    instanceId: string;
-    blocks: TransactionBlockstore;
-    indexBlocks: TransactionBlockstore;
-    config: {};
-    ready: Promise<void>;
-    /**
-     * 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;
-    toHeader(): {
-        name: string;
-        index: {
-            key: any;
-            car: any;
-        };
-        indexes: any[];
-    };
-    /**
-     * Returns the Merkle clock heads for the Fireproof instance.
-     * @returns {string[]} - The Merkle clock heads for the Fireproof instance.
-     * @memberof Fireproof
-     * @instance
-     */
-    clockToJSON(clock?: any): string[];
-    maybeSaveClock(): Promise<void>;
-    index(name: any): any;
-    /**
-     * Triggers a notification to all listeners
-     * of the Fireproof instance so they can repaint UI, etc.
-     * @returns {Promise<void>}
-     * @memberof Fireproof
-     * @instance
-     */
-    notifyReset(): Promise<void>;
-    compact(): 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 {Promise<{rows : Object[], clock: CID[], proof: {}}>} An object containing the rows and the head of the instance's clock.
-     * @memberof Fireproof
-     * @instance
-     */
-    changesSince(aClock: any): Promise<{
-        rows: any[];
-        clock: CID[];
-        proof: {};
-    }>;
-    allDocuments(): Promise<{
-        rows: {
-            key: any;
-            value: any;
-        }[];
-        clock: string[];
-        proof: any[];
-    }>;
-    allCIDs(): Promise<any[]>;
-    allStoredCIDs(): Promise<any[]>;
-    /**
-     * 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;
-    }>;
-    /**
-     * @typedef {any} Document
-     * @property {string} _id - The ID of the document (required)
-     * @property {string} [_proof] - The proof of the document (optional)
-     * @property {string} [_clock] - The clock of the document (optional)
-     * @property {Object.<string, any>} [unknown: string] - Any other unknown properties (optional)
-     */
-    /**
-     * Adds a new document to the database, or updates an existing document. Returns the ID of the document and the new clock head.
-     *
-     * @param {Document} doc - the document to be added
-     * @returns {Promise<{ id: string, clock: CID[]  }>} - The result of adding the document to the database
-     * @memberof Fireproof
-     * @instance
-     */
-    put({ _id, _proof, _clock, ...doc }: any): 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[];
-    }>;
-    /**
-     * 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>;
-    /**
-     * 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;
-    applyClock(prevClock: any, newClock: any): void;
-    vis(): AsyncGenerator<any, {
-        cids: any;
-        result: any;
-        vis?: undefined;
-    } | {
-        vis: string;
-        cids: any;
-        result?: undefined;
-    }, unknown>;
-    visTree(): Promise<{
-        vis: string;
-        cids: any;
-    }>;
-    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
-     */
-    subscribe(listener: Function): Function;
-    /**
-     * @deprecated 0.7.0 - renamed subscribe(listener)
-     * @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>;
-    setRemoteBlockReader(remoteBlockReaderFn: any): void;
-}
-
-/**
- * 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 {Database} database - The Fireproof database instance to DbIndex.
- * @param {Function} mapFn - The map function to apply to each entry in the database.
- *
- */
-declare class DbIndex {
-    static registerWithDatabase(inIndex: any, database: any): void;
-    static fromJSON(database: any, { code, clock, name }: {
-        code: any;
-        clock: any;
-        name: any;
-    }): DbIndex;
-    /**
-     * @param {Database} database
-     */
-    constructor(database: Database, name: any, mapFn: any, clock?: any, opts?: {});
-    database: Database;
-    indexById: {
-        root: any;
-        cid: any;
-    };
-    indexByKey: {
-        root: any;
-        cid: any;
-    };
-    dbHead: any;
-    instanceId: string;
-    updateIndexPromise: Promise<any>;
-    applyMapFn(mapFn: any, name: any): void;
-    mapFnString: any;
-    mapFn: any;
-    includeDocsDefault: any;
-    name: any;
-    makeName(): any;
-    toJSON(): {
-        name: any;
-        code: any;
-        clock: {
-            db: any;
-            byId: any;
-            byKey: any;
-        };
-    };
-    visKeyTree(): Promise<{
-        vis: string;
-        cids: any;
-    }>;
-    visIdTree(): Promise<{
-        vis: string;
-        cids: 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, doc?: any}>}>}
-     * @memberof DbIndex
-     * @instance
-     */
-    query(query?: {
-        /**
-         * - The range to query.
-         */
-        range?: string[];
-    }, update?: boolean): Promise<{
-        proof: {};
-        rows: Array<{
-            id: string;
-            key: string;
-            value: any;
-            doc?: any;
-        }>;
-    }>;
-    /**
-     *
-     * @param {any} resp
-     * @param {any} query
-     * @returns
-     */
-    applyQuery(resp: any, query: any): Promise<any>;
-    doIndexQuery(query?: {}): Promise<any>;
-    /**
-     * Update the DbIndex with the latest changes
-     * @private
-     * @returns {Promise<void>}
-     */
-    private updateIndex;
-    innerUpdateIndex(inBlocks: any): Promise<any>;
-}
-
-/**
- * @typedef {import('./database.js').Database} Database
- */
-declare class Sync {
-    /**
-     * @param {import("./database.js").Database} database
-     * @param {string} key
-     */
-    static makeCar(database: Database, key: string, skip?: any[]): Promise<multiformats.BlockView<Uint8Array, 85, 18, 1>>;
-    constructor(database: any, PeerClass?: any);
-    /**
-     * @param {Database} database
-     * @param {typeof SimplePeer} [PeerClass]
-     * @memberof Sync
-     * @static
-     */
-    status: string;
-    database: any;
-    PeerClass: any;
-    pushBacklog: Promise<any>;
-    pushBacklogResolve: (value: any) => void;
-    pushBacklogReject: (reason?: any) => void;
-    isReady: boolean;
-    offer(): Promise<string>;
-    accept(base64offer: any): Promise<string>;
-    connect(base64accept: any): void;
-    setupPeer(initiator?: boolean): Promise<string>;
-    peer: any;
-    backlog(): Promise<any>;
-    gotData(data: any): Promise<void>;
-    destroy(): void;
-    sendUpdate(blockstore: any): Promise<void>;
-    startSync(): Promise<void>;
-}
-
-declare 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 {Database} - a new Fireproof instance
-     */
-    static storage: (name?: any, opts?: {}) => Database;
-    static fromJSON(primary: any, secondary: any, database: any): any;
-    static snapshot(database: any, clock: any): any;
-    static zoom(database: any, clock: any): Promise<any>;
-}
-
-export { Database, Fireproof, DbIndex as Index, Sync };