@fireproof/core 0.15.1 → 0.16.3

package/dist/types/apply-head-queue.d.ts

@@ -1,15 +0,0 @@
-import { ClockHead, DocUpdate } from './types';
-type ApplyHeadWorkerFunction = (newHead: ClockHead, prevHead: ClockHead) => Promise<void>;
-type ApplyHeadTask = {
-    newHead: ClockHead;
-    prevHead: ClockHead;
-    updates: DocUpdate[] | null;
-};
-export type ApplyHeadQueue = {
-    push(task: ApplyHeadTask): AsyncGenerator<{
-        updates: DocUpdate[];
-        all: boolean;
-    }, void, unknown>;
-};
-export declare function applyHeadQueue(worker: ApplyHeadWorkerFunction): ApplyHeadQueue;
-export {};

package/dist/types/commit-queue.d.ts

@@ -1,6 +0,0 @@
-export declare class CommitQueue<T = void> {
-    private queue;
-    private processing;
-    enqueue(fn: () => Promise<T>): Promise<T>;
-    private processNext;
-}

package/dist/types/crdt-clock.d.ts

@@ -1,20 +0,0 @@
-import { TransactionBlockstore } from './transaction';
-import type { DocUpdate, ClockHead } from './types';
-import { ApplyHeadQueue } from './apply-head-queue';
-export declare class CRDTClock {
-    head: ClockHead;
-    zoomers: Set<() => void>;
-    watchers: Set<(updates: DocUpdate[]) => void>;
-    emptyWatchers: Set<() => void>;
-    blocks: TransactionBlockstore | null;
-    applyHeadQueue: ApplyHeadQueue;
-    constructor();
-    setHead(head: ClockHead): void;
-    applyHead(newHead: ClockHead, prevHead: ClockHead, updates?: DocUpdate[] | null): Promise<void>;
-    processUpdates(updatesAcc: DocUpdate[], all: boolean, prevHead: ClockHead): Promise<void>;
-    notifyWatchers(updates: DocUpdate[]): void;
-    onTick(fn: (updates: DocUpdate[]) => void): void;
-    onTock(fn: () => void): void;
-    onZoom(fn: () => void): void;
-    int_applyHead(newHead: ClockHead, prevHead: ClockHead): Promise<void>;
-}

package/dist/types/crdt-helpers.d.ts

@@ -1,19 +0,0 @@
-import { Block } from 'multiformats/block';
-import { LoggingFetcher, Transaction } from './transaction';
-import type { TransactionBlockstore } from './transaction';
-import type { DocUpdate, ClockHead, AnyLink, DocValue, BulkResult, ChangesOptions, BlockFetcher } from './types';
-export declare function applyBulkUpdateToCrdt(tblocks: Transaction, head: ClockHead, updates: DocUpdate[], options?: object): Promise<BulkResult>;
-export declare function getValueFromCrdt(blocks: TransactionBlockstore, head: ClockHead, key: string): Promise<DocValue>;
-export declare function readFiles(blocks: TransactionBlockstore | LoggingFetcher, { doc }: DocValue): void;
-export declare function clockChangesSince(blocks: TransactionBlockstore | LoggingFetcher, head: ClockHead, since: ClockHead, opts: ChangesOptions): Promise<{
-    result: DocUpdate[];
-    head: ClockHead;
-}>;
-export declare function getAllEntries(blocks: TransactionBlockstore | LoggingFetcher, head: ClockHead): AsyncGenerator<DocUpdate, void, unknown>;
-export declare function clockVis(blocks: TransactionBlockstore, head: ClockHead): AsyncGenerator<string, void, unknown>;
-export declare function doCompact(blocks: TransactionBlockstore, head: ClockHead): Promise<AnyLink | undefined>;
-export declare function getThatBlock({ bytes }: {
-    cid: string;
-    bytes: string;
-}): Promise<Block<unknown, 113, 18, 1>>;
-export declare function getBlock(blocks: BlockFetcher, cidString: string): Promise<Block<unknown, 113, 18, 1>>;

package/dist/types/crdt.d.ts

@@ -1,28 +0,0 @@
-import { TransactionBlockstore, IndexBlockstore } from './transaction';
-import type { DocUpdate, BulkResult, ClockHead, FireproofOptions, ChangesOptions } from './types';
-import type { Index } from './index';
-import { CRDTClock } from './crdt-clock';
-export declare class CRDT {
-    name: string | null;
-    opts: FireproofOptions;
-    ready: Promise<void>;
-    blocks: TransactionBlockstore;
-    indexBlocks: IndexBlockstore;
-    indexers: Map<string, Index>;
-    clock: CRDTClock;
-    constructor(name?: string, opts?: FireproofOptions);
-    bulk(updates: DocUpdate[], options?: object): Promise<BulkResult>;
-    allDocs(): Promise<{
-        result: DocUpdate[];
-        head: ClockHead;
-    }>;
-    vis(): Promise<string>;
-    getBlock(cidString: string): Promise<import("multiformats/dist/types/src/block").Block<unknown, 113, 18, 1>>;
-    getThatBlock(): Promise<import("multiformats/dist/types/src/block").Block<unknown, 113, 18, 1>>;
-    get(key: string): Promise<import("./types").DocValue | null>;
-    changes(since?: ClockHead, opts?: ChangesOptions): Promise<{
-        result: DocUpdate[];
-        head: ClockHead;
-    }>;
-    compact(): Promise<void>;
-}

package/dist/types/crypto-ipld.d.ts

@@ -1,20 +0,0 @@
-import type { AnyBlock, AnyLink } from './types.js';
-import type { MultihashHasher } from 'multiformats';
-declare const encrypt: ({ get, cids, hasher, key, cache, chunker, root }: {
-    get: (cid: AnyLink) => Promise<AnyBlock | undefined>;
-    key: ArrayBuffer;
-    cids: AnyLink[];
-    hasher: MultihashHasher<number>;
-    chunker: (bytes: Uint8Array) => AsyncGenerator<Uint8Array>;
-    cache: (cid: AnyLink) => Promise<AnyBlock>;
-    root: AnyLink;
-}) => AsyncGenerator<any, void, unknown>;
-declare const decrypt: ({ root, get, key, cache, chunker, hasher }: {
-    root: AnyLink;
-    get: (cid: AnyLink) => Promise<AnyBlock | undefined>;
-    key: ArrayBuffer;
-    cache: (cid: AnyLink) => Promise<AnyBlock>;
-    chunker: (bytes: Uint8Array) => AsyncGenerator<Uint8Array>;
-    hasher: MultihashHasher<number>;
-}) => AsyncGenerator<AnyBlock, void, undefined>;
-export { encrypt, decrypt };

package/dist/types/crypto-node.d.ts

@@ -1,4 +0,0 @@
-import { Crypto } from '@peculiar/webcrypto';
-export declare function getCrypto(): Crypto | null;
-export declare const crypto: Crypto | null;
-export declare function randomBytes(size: number): Uint8Array;

package/dist/types/crypto-web.d.ts

@@ -1,4 +0,0 @@
-export declare function getCrypto(): Crypto | null;
-declare const gotCrypto: Crypto | null;
-export { gotCrypto as crypto };
-export declare function randomBytes(size: number): Uint8Array;

package/dist/types/database.d.ts

@@ -1,48 +0,0 @@
-import { WriteQueue } from './write-queue';
-import { CRDT } from './crdt';
-import type { DocUpdate, ClockHead, Doc, FireproofOptions, MapFn, QueryOpts, ChangesOptions } from './types';
-import { DbResponse, ChangesResponse } from './types';
-type DbName = string | null;
-export declare class Database {
-    static databases: Map<string, Database>;
-    name: DbName;
-    opts: FireproofOptions;
-    _listening: boolean;
-    _listeners: Set<ListenerFn>;
-    _noupdate_listeners: Set<ListenerFn>;
-    _crdt: CRDT;
-    _writeQueue: WriteQueue;
-    constructor(name?: string, opts?: FireproofOptions);
-    get(id: string): Promise<Doc>;
-    put(doc: Doc): Promise<DbResponse>;
-    del(id: string): Promise<DbResponse>;
-    changes(since?: ClockHead, opts?: ChangesOptions): Promise<ChangesResponse>;
-    allDocs(): Promise<{
-        rows: {
-            key: string;
-            value: Doc;
-        }[];
-        clock: ClockHead;
-    }>;
-    allDocuments(): Promise<{
-        rows: {
-            key: string;
-            value: Doc;
-        }[];
-        clock: ClockHead;
-    }>;
-    subscribe(listener: ListenerFn | NoUpdateListenerFn, updates?: boolean): () => void;
-    query(field: string | MapFn, opts?: QueryOpts): Promise<{
-        rows: import("./types").IndexRow[];
-    }>;
-    compact(): Promise<void>;
-    getDashboardURL(compact?: boolean): Promise<URL>;
-    openDashboard(): void;
-    _notify(updates: DocUpdate[]): Promise<void>;
-    _no_update_notify(): Promise<void>;
-}
-type UpdateListenerFn = (docs: Doc[]) => Promise<void> | void;
-type NoUpdateListenerFn = () => Promise<void> | void;
-type ListenerFn = UpdateListenerFn | NoUpdateListenerFn;
-export declare function fireproof(name: string, opts?: FireproofOptions): Database;
-export {};

package/dist/types/encrypt-helpers.d.ts

@@ -1,8 +0,0 @@
-import type { CarReader } from '@ipld/car';
-import type { AnyBlock, CarMakeable, AnyLink } from './types';
-import { MemoryBlockstore } from '@alanshaw/pail/block';
-export declare function encryptedEncodeCarFile(key: string, rootCid: AnyLink, t: CarMakeable): Promise<AnyBlock>;
-export declare function decodeEncryptedCar(key: string, reader: CarReader): Promise<{
-    blocks: MemoryBlockstore;
-    root: AnyLink;
-}>;

package/dist/types/encrypted-block.d.ts

@@ -1,44 +0,0 @@
-import type { AnyLink } from './types';
-declare const encode: ({ iv, bytes }: {
-    iv: Uint8Array;
-    bytes: Uint8Array;
-}) => Uint8Array;
-declare const decode: (bytes: Uint8Array) => {
-    iv: Uint8Array;
-    bytes: Uint8Array;
-};
-declare const code: number;
-declare const decrypt: ({ key, value }: {
-    key: ArrayBuffer;
-    value: {
-        bytes: Uint8Array;
-        iv: Uint8Array;
-    };
-}) => Promise<{
-    cid: AnyLink;
-    bytes: Uint8Array;
-}>;
-declare const encrypt: ({ key, cid, bytes }: {
-    key: ArrayBuffer;
-    cid: AnyLink;
-    bytes: Uint8Array;
-}) => Promise<{
-    value: {
-        bytes: Uint8Array;
-        iv: Uint8Array;
-    };
-}>;
-declare const cryptoFn: (key: Uint8Array) => {
-    encrypt: (opts: any) => Promise<{
-        value: {
-            bytes: Uint8Array;
-            iv: Uint8Array;
-        };
-    }>;
-    decrypt: (opts: any) => Promise<{
-        cid: AnyLink;
-        bytes: Uint8Array;
-    }>;
-};
-declare const name = "jchris@encrypted-block:aes-gcm";
-export { encode, decode, code, name, encrypt, decrypt, cryptoFn as crypto };

package/dist/types/files.d.ts

@@ -1,12 +0,0 @@
-import { AnyBlock, AnyLink, DocFileMeta } from './types';
-export declare function encodeFile(blob: BlobLike): Promise<{
-    cid: AnyLink;
-    blocks: AnyBlock[];
-}>;
-export declare function decodeFile(blocks: unknown, cid: AnyLink, meta: DocFileMeta): Promise<File>;
-export interface BlobLike {
-    /**
-     * Returns a ReadableStream which yields the Blob data.
-     */
-    stream: () => ReadableStream;
-}

package/dist/types/fireproof.d.ts

@@ -1,7 +0,0 @@
-export * from './database';
-export * from './index';
-export * from './loader-helpers';
-export * from './store';
-export * from './loader';
-
-export * from './types';

package/dist/types/index.d.ts

@@ -1,31 +0,0 @@
-import type { ClockHead, MapFn, QueryOpts, IdxMeta } from './types';
-import { IndexBlockstore } from './transaction';
-import { IndexTree } from './indexer-helpers';
-import { CRDT } from './crdt';
-export declare function index({ _crdt }: {
-    _crdt: CRDT;
-}, name: string, mapFn?: MapFn, meta?: IdxMeta): Index;
-export declare class Index {
-    blocks: IndexBlockstore;
-    crdt: CRDT;
-    name: string | null;
-    mapFn: MapFn | null;
-    mapFnString: string;
-    byKey: IndexTree;
-    byId: IndexTree;
-    indexHead: ClockHead | undefined;
-    includeDocsDefault: boolean;
-    initError: Error | null;
-    ready: Promise<void>;
-    constructor(crdt: CRDT, name: string, mapFn?: MapFn, meta?: IdxMeta);
-    applyMapFn(name: string, mapFn?: MapFn, meta?: IdxMeta): void;
-    query(opts?: QueryOpts): Promise<{
-        rows: import("./types").IndexRow[];
-    }>;
-    _resetIndex(): void;
-    _hydrateIndex(): Promise<void>;
-    _updateIndex(): Promise<(IdxMeta & import("./types").CarCommit) | {
-        byId: IndexTree;
-        byKey: IndexTree;
-    }>;
-}

package/dist/types/indexer-helpers.d.ts

@@ -1,57 +0,0 @@
-import type { Block, Link } from 'multiformats';
-import { ProllyNode as BaseNode } from 'prolly-trees/base';
-import { AnyLink, DocUpdate, MapFn, DocFragment, BlockFetcher, IndexKey, IndexUpdate, QueryOpts, IndexRow } from './types';
-import { Transaction } from './transaction';
-import { CRDT } from './crdt';
-export declare class IndexTree {
-    cid: AnyLink | null;
-    root: ProllyNode | null;
-}
-export declare const byKeyOpts: StaticProllyOptions;
-export declare const byIdOpts: StaticProllyOptions;
-export declare function indexEntriesForChanges(changes: DocUpdate[], mapFn: MapFn): {
-    key: [string, string];
-    value: DocFragment;
-}[];
-export declare function bulkIndex(tblocks: Transaction, inIndex: IndexTree, indexEntries: IndexUpdate[], opts: StaticProllyOptions): Promise<IndexTree>;
-export declare function loadIndex(tblocks: BlockFetcher, cid: AnyLink, opts: StaticProllyOptions): Promise<ProllyNode>;
-export declare function applyQuery(crdt: CRDT, resp: {
-    result: IndexRow[];
-}, query: QueryOpts): Promise<{
-    rows: IndexRow[];
-}>;
-export declare function encodeRange(range: [DocFragment, DocFragment]): [IndexKey, IndexKey];
-export declare function encodeKey(key: DocFragment): string;
-interface ProllyNode extends BaseNode {
-    getAllEntries(): PromiseLike<{
-        [x: string]: any;
-        result: IndexRow[];
-    }>;
-    getMany(removeIds: string[]): Promise<{
-        [x: string]: any;
-        result: IndexKey[];
-    }>;
-    range(a: IndexKey, b: IndexKey): Promise<{
-        result: IndexRow[];
-    }>;
-    get(key: string): Promise<{
-        result: IndexRow[];
-    }>;
-    bulk(bulk: IndexUpdate[]): PromiseLike<{
-        root: ProllyNode | null;
-        blocks: Block[];
-    }>;
-    address: Promise<Link>;
-    distance: number;
-    compare: (a: any, b: any) => number;
-    cache: any;
-    block: Promise<Block>;
-}
-interface StaticProllyOptions {
-    cache: any;
-    chunker: (entry: any, distance: number) => boolean;
-    codec: any;
-    hasher: any;
-    compare: (a: any, b: any) => number;
-}
-export {};

package/dist/types/loader-helpers.d.ts

@@ -1,5 +0,0 @@
-import { CarReader } from '@ipld/car';
-import { AnyBlock, AnyCarHeader, AnyLink, CarMakeable } from './types';
-export declare function encodeCarFile(roots: AnyLink[], t: CarMakeable): Promise<AnyBlock>;
-export declare function encodeCarHeader(fp: AnyCarHeader): Promise<AnyBlock>;
-export declare function parseCarFile(reader: CarReader): Promise<AnyCarHeader>;

package/dist/types/loader.d.ts

@@ -1,62 +0,0 @@
-import { CarReader } from '@ipld/car';
-import { DataStore, MetaStore, RemoteWAL } from './store-browser';
-import { DataStore as AbstractDataStore, MetaStore as AbstractMetaStore } from './store';
-import type { Transaction } from './transaction';
-import type { AnyBlock, AnyCarHeader, AnyLink, BulkResult, CarLoaderHeader, CommitOpts, DbMeta, FileCarHeader, FileResult, FireproofOptions } from './types';
-import { type IndexerResult } from './loaders';
-import { CommitQueue } from './commit-queue';
-export declare function cidListIncludes(list: AnyLink[], cid: AnyLink): boolean;
-export declare function uniqueCids(list: AnyLink[], remove?: Set<string>): AnyLink[];
-export declare function toHexString(byteArray: Uint8Array): string;
-declare abstract class AbstractRemoteMetaStore extends AbstractMetaStore {
-    abstract handleByteHeads(byteHeads: Uint8Array[], branch?: string): Promise<DbMeta[]>;
-}
-export declare abstract class Loader {
-    name: string;
-    opts: FireproofOptions;
-    commitQueue: CommitQueue<AnyLink>;
-    isCompacting: boolean;
-    isWriting: boolean;
-    remoteMetaLoading: Promise<void> | undefined;
-    remoteMetaStore: AbstractRemoteMetaStore | undefined;
-    remoteCarStore: AbstractDataStore | undefined;
-    remoteWAL: RemoteWAL;
-    metaStore: MetaStore;
-    carStore: DataStore;
-    carLog: AnyLink[];
-    carReaders: Map<string, Promise<CarReader>>;
-    ready: Promise<void>;
-    key: string | undefined;
-    keyId: string | undefined;
-    seenCompacted: Set<string>;
-    private getBlockCache;
-    private seenMeta;
-    static defaultHeader: AnyCarHeader;
-    abstract defaultHeader: AnyCarHeader;
-    constructor(name: string, opts?: FireproofOptions);
-    snapToCar(carCid: AnyLink | string): Promise<void>;
-    _readyForMerge(): Promise<void>;
-    _setWaitForWrite(_writing: () => Promise<void>): Promise<void>;
-    handleDbMetasFromStore(metas: DbMeta[]): Promise<void>;
-    mergeDbMetaIntoClock(meta: DbMeta): Promise<void>;
-    protected ingestKeyFromMeta(meta: DbMeta): Promise<void>;
-    loadCarHeaderFromMeta({ car: cid }: DbMeta): Promise<CarLoaderHeader>;
-    protected abstract _applyCarHeader(_carHeader: CarLoaderHeader, snap?: boolean): Promise<void>;
-    _getKey(): Promise<string | undefined>;
-    commit(t: Transaction, done: IndexerResult | BulkResult | FileResult, opts?: CommitOpts): Promise<AnyLink>;
-    _commitInternal(t: Transaction, done: IndexerResult | BulkResult | FileResult, opts?: CommitOpts): Promise<AnyLink>;
-    flushCars(): Promise<void>;
-    entries(): AsyncIterableIterator<AnyBlock>;
-    getBlock(cid: AnyLink): Promise<AnyBlock | undefined>;
-    protected abstract makeCarHeader(_result: BulkResult | IndexerResult | FileResult, _cars: AnyLink[], _compact: boolean): AnyCarHeader | FileCarHeader;
-    protected loadCar(cid: AnyLink): Promise<CarReader>;
-    protected storesLoadCar(cid: AnyLink, local: AbstractDataStore, remote?: AbstractDataStore, publicFiles?: boolean): Promise<CarReader>;
-    protected ensureDecryptedReader(reader: CarReader): Promise<CarReader>;
-    protected setKey(key: string): Promise<void>;
-    protected getMoreReaders(cids: AnyLink[]): Promise<void>;
-}
-export interface Connection {
-    loader: Loader;
-    loaded: Promise<void>;
-}
-export {};

package/dist/types/loaders.d.ts

@@ -1,51 +0,0 @@
-import type { CarReader } from '@ipld/car';
-import type { AnyLink, BulkResult, CarCommit, DbCarHeader, FileCarHeader, FileResult, FireproofOptions, IdxCarHeader, IdxMeta, IdxMetaMap } from './types';
-import type { CRDT } from './crdt';
-import type { CRDTClock } from './crdt-clock';
-import { Loader } from './loader';
-import type { DataStore as AbstractDataStore } from './store';
-import { DataStore } from './store-browser';
-import { TransactionBlockstore } from './transaction';
-export declare class IdxLoader extends Loader {
-    crdt: CRDT;
-    static defaultHeader: {
-        cars: never[];
-        compact: never[];
-        indexes: Map<string, IdxMeta>;
-    };
-    defaultHeader: {
-        cars: never[];
-        compact: never[];
-        indexes: Map<string, IdxMeta>;
-    };
-    constructor(name: string, crdt: CRDT, opts?: FireproofOptions);
-    _applyCarHeader(header: IdxCarHeader): Promise<void>;
-    protected makeCarHeader({ indexes }: IndexerResult, cars: AnyLink[], compact?: boolean): IdxCarHeader;
-}
-export type IndexerResult = CarCommit & IdxMetaMap;
-export declare class DbLoader extends Loader {
-    static defaultHeader: {
-        cars: never[];
-        compact: never[];
-        head: never[];
-    };
-    defaultHeader: {
-        cars: never[];
-        compact: never[];
-        head: never[];
-    };
-    clock: CRDTClock;
-    awaitingCompact: boolean;
-    compacting: Promise<AnyLink | void>;
-    writing: Promise<BulkResult | void>;
-    remoteFileStore: AbstractDataStore | undefined;
-    fileStore: DataStore;
-    constructor(name: string, clock: CRDTClock, opts?: FireproofOptions);
-    _readyForMerge(): Promise<void>;
-    _setWaitForWrite(_writingFn: () => Promise<any>): Promise<void>;
-    compact(blocks: TransactionBlockstore): Promise<void>;
-    loadFileCar(cid: AnyLink, isPublic?: boolean): Promise<CarReader>;
-    protected _applyCarHeader(carHeader: DbCarHeader, snap?: boolean): Promise<void>;
-    protected makeCarHeader(result: BulkResult | FileResult, cars: AnyLink[], compact?: boolean): DbCarHeader | FileCarHeader;
-}
-export declare function isFileResult(result: IndexerResult | BulkResult | FileResult): result is FileResult;

package/dist/types/remote-wal.d.ts

@@ -1,26 +0,0 @@
-import { AnyLink, CommitOpts, DbMeta } from './types';
-import { type Loader } from './loader';
-export type WALState = {
-    operations: DbMeta[];
-    noLoaderOps: DbMeta[];
-    fileOperations: {
-        cid: AnyLink;
-        public: boolean;
-    }[];
-};
-export declare abstract class RemoteWAL {
-    tag: string;
-    STORAGE_VERSION: string;
-    loader: Loader;
-    ready: Promise<void>;
-    walState: WALState;
-    processing: Promise<void> | undefined;
-    private processQueue;
-    constructor(loader: Loader);
-    enqueue(dbMeta: DbMeta, opts: CommitOpts): Promise<void>;
-    enqueueFile(fileCid: AnyLink, publicFile?: boolean): Promise<void>;
-    _process(): Promise<void>;
-    _doProcess(): Promise<void>;
-    abstract load(branch?: string): Promise<WALState | null>;
-    abstract save(state: WALState, branch?: string): Promise<void>;
-}

package/dist/types/store-browser.d.ts

@@ -1,24 +0,0 @@
-import { IDBPDatabase } from 'idb';
-import { AnyBlock, AnyLink, DbMeta } from './types';
-import { DataStore as DataStoreBase, MetaStore as MetaStoreBase } from './store';
-import { RemoteWAL as RemoteWALBase, WALState } from './remote-wal';
-export declare class DataStore extends DataStoreBase {
-    tag: string;
-    idb: IDBPDatabase<unknown> | null;
-    _withDB(dbWorkFun: (arg0: any) => any): Promise<any>;
-    load(cid: AnyLink): Promise<AnyBlock>;
-    save(car: AnyBlock): Promise<void>;
-    remove(cid: AnyLink): Promise<void>;
-}
-export declare class RemoteWAL extends RemoteWALBase {
-    tag: string;
-    headerKey(branch: string): string;
-    load(branch?: string): Promise<WALState | null>;
-    save(state: WALState, branch?: string): Promise<void>;
-}
-export declare class MetaStore extends MetaStoreBase {
-    tag: string;
-    headerKey(branch: string): string;
-    load(branch?: string): Promise<DbMeta[] | null>;
-    save(meta: DbMeta, branch?: string): Promise<null>;
-}

package/dist/types/store-fs.d.ts

@@ -1,26 +0,0 @@
-import type { AnyBlock, AnyLink, DbMeta } from './types';
-import { MetaStore as MetaStoreBase, DataStore as DataStoreBase } from './store';
-import { RemoteWAL as RemoteWALBase, WALState } from './remote-wal';
-export declare class RemoteWAL extends RemoteWALBase {
-    filePathForBranch(branch: string): string;
-    load(branch?: string): Promise<WALState | null>;
-    save(state: WALState, branch?: string): Promise<void>;
-}
-export declare class MetaStore extends MetaStoreBase {
-    tag: string;
-    static dataDir: string;
-    filePathForBranch(branch: string): string;
-    load(branch?: string): Promise<DbMeta[] | null>;
-    save(meta: DbMeta, branch?: string): Promise<null>;
-}
-export declare const testConfig: {
-    dataDir: string;
-};
-export declare class DataStore extends DataStoreBase {
-    tag: string;
-    static dataDir: string;
-    save(car: AnyBlock): Promise<void>;
-    private cidPath;
-    load(cid: AnyLink): Promise<AnyBlock>;
-    remove(cid: AnyLink): Promise<void>;
-}

package/dist/types/store-memory.d.ts

@@ -1,24 +0,0 @@
-import { AnyBlock, AnyLink, DbMeta } from './types';
-import { DataStore as DataStoreBase, MetaStore as MetaStoreBase } from './store';
-import { RemoteWAL as RemoteWALBase, WALState } from './remote-wal';
-export declare class DataStore extends DataStoreBase {
-    tag: string;
-    store: Map<string, Uint8Array>;
-    load(cid: AnyLink): Promise<AnyBlock>;
-    save(car: AnyBlock): Promise<void>;
-    remove(cid: AnyLink): Promise<void>;
-}
-export declare class MetaStore extends MetaStoreBase {
-    tag: string;
-    store: Map<string, string>;
-    headerKey(branch: string): string;
-    load(branch?: string): Promise<DbMeta[] | null>;
-    save(meta: DbMeta, branch?: string): Promise<null>;
-}
-export declare class RemoteWAL extends RemoteWALBase {
-    tag: string;
-    store: Map<string, string>;
-    headerKey(branch: string): string;
-    load(branch?: string): Promise<WALState | null>;
-    save(state: WALState, branch?: string): Promise<void>;
-}

package/dist/types/store.d.ts

@@ -1,28 +0,0 @@
-import { ToString } from '@ipld/dag-json';
-import { AnyBlock, AnyLink, DbMeta } from './types';
-export declare const STORAGE_VERSION: string;
-declare abstract class VersionedStore {
-    STORAGE_VERSION: string;
-    name: string;
-    constructor(name: string);
-}
-export declare abstract class MetaStore extends VersionedStore {
-    tag: string;
-    makeHeader({ car, key }: DbMeta): ToString<DbMeta>;
-    parseHeader(headerData: ToString<DbMeta>): DbMeta;
-    abstract load(branch?: string): Promise<DbMeta[] | null>;
-    abstract save(dbMeta: DbMeta, branch?: string): Promise<DbMeta[] | null>;
-}
-type DataSaveOpts = {
-    public?: boolean;
-};
-export declare abstract class DataStore {
-    tag: string;
-    STORAGE_VERSION: string;
-    name: string;
-    constructor(name: string);
-    abstract load(cid: AnyLink): Promise<AnyBlock>;
-    abstract save(car: AnyBlock, opts?: DataSaveOpts): Promise<void | AnyLink>;
-    abstract remove(cid: AnyLink): Promise<void>;
-}
-export {};

package/dist/types/transaction.d.ts

@@ -1,50 +0,0 @@
-import { MemoryBlockstore } from '@alanshaw/pail/block';
-import { BlockFetcher, AnyBlock, AnyLink, BulkResult, ClockHead, IdxMeta, CarCommit, CarMakeable, FireproofOptions } from './types';
-import { DbLoader, IdxLoader } from './loaders';
-import { CRDT } from './crdt';
-import { CRDTClock } from './crdt-clock';
-export declare class Transaction extends MemoryBlockstore implements CarMakeable {
-    parent: FireproofBlockstore;
-    constructor(parent: FireproofBlockstore);
-    get(cid: AnyLink): Promise<AnyBlock | undefined>;
-    superGet(cid: AnyLink): Promise<AnyBlock | undefined>;
-}
-declare abstract class FireproofBlockstore implements BlockFetcher {
-    ready: Promise<void>;
-    name: string | null;
-    loader: DbLoader | IdxLoader | null;
-    opts: FireproofOptions;
-    transactions: Set<Transaction>;
-    constructor(name: string | null, loader?: DbLoader | IdxLoader, opts?: FireproofOptions);
-    abstract transaction(fn: (t: Transaction) => Promise<IdxMeta | BulkResult>, indexes?: Map<string, IdxMeta>, opts?: {
-        noLoader: boolean;
-    }): Promise<BulkResultCar | IdxMetaCar>;
-    put(): Promise<void>;
-    get(cid: AnyLink): Promise<AnyBlock | undefined>;
-    commitCompaction(t: Transaction, head: ClockHead): Promise<AnyLink>;
-    entries(): AsyncIterableIterator<AnyBlock>;
-    protected executeTransaction<T, R>(fn: (t: Transaction) => Promise<T>, commitHandler: (t: Transaction, done: T) => Promise<{
-        car?: AnyLink;
-        done: R;
-    }>): Promise<R>;
-}
-export declare class IndexBlockstore extends FireproofBlockstore {
-    constructor(name: string | null, crdt: CRDT, opts?: FireproofOptions);
-    transaction(fn: (t: Transaction) => Promise<IdxMeta>, indexes: Map<string, IdxMeta>): Promise<IdxMetaCar>;
-}
-export declare class TransactionBlockstore extends FireproofBlockstore {
-    constructor(name: string | null, clock: CRDTClock, opts?: FireproofOptions);
-    transaction(fn: (t: Transaction) => Promise<BulkResult>, _indexes?: undefined, opts?: {
-        noLoader: boolean;
-    }): Promise<BulkResultCar>;
-}
-type IdxMetaCar = IdxMeta & CarCommit;
-type BulkResultCar = BulkResult & CarCommit;
-export declare class LoggingFetcher implements BlockFetcher {
-    blocks: TransactionBlockstore;
-    loader: DbLoader | IdxLoader | null;
-    loggedBlocks: Transaction;
-    constructor(blocks: TransactionBlockstore);
-    get(cid: AnyLink): Promise<AnyBlock | undefined>;
-}
-export {};