xitdb/dist/database.d.ts

An immutable database

import type { Core } from './core';
import { Hasher } from './hasher';
import { Tag } from './tag';
import { Slot } from './slot';
import { SlotPointer } from './slot-pointer';
import { type WriteableData } from './writeable-data';
import { WriteCursor } from './write-cursor';
export declare const VERSION = 0;
export declare const MAGIC_NUMBER: Uint8Array<ArrayBuffer>;
export declare const BIT_COUNT = 4;
export declare const SLOT_COUNT: number;
export declare const MASK: bigint;
export declare const INDEX_BLOCK_SIZE: number;
export declare const LINKED_ARRAY_LIST_SLOT_LENGTH: number;
export declare const LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE: number;
export declare const MAX_BRANCH_LENGTH = 16;
export declare enum WriteMode {
    READ_ONLY = 0,
    READ_WRITE = 1
}
export declare class Header {
    hashId: number;
    hashSize: number;
    version: number;
    tag: Tag;
    magicNumber: Uint8Array;
    static readonly LENGTH = 12;
    constructor(hashId: number, hashSize: number, version: number, tag: Tag, magicNumber: Uint8Array);
    toBytes(): Uint8Array;
    static read(core: Core): Header;
    write(core: Core): void;
    validate(): void;
    withTag(tag: Tag): Header;
}
export declare class ArrayListHeader {
    ptr: number;
    size: number;
    static readonly LENGTH = 16;
    constructor(ptr: number, size: number);
    toBytes(): Uint8Array;
    static fromBytes(bytes: Uint8Array): ArrayListHeader;
    withPtr(ptr: number): ArrayListHeader;
}
export declare class TopLevelArrayListHeader {
    fileSize: number;
    parent: ArrayListHeader;
    static readonly LENGTH: number;
    constructor(fileSize: number, parent: ArrayListHeader);
    toBytes(): Uint8Array;
}
export declare class LinkedArrayListHeader {
    shift: number;
    ptr: number;
    size: number;
    static readonly LENGTH = 17;
    constructor(shift: number, ptr: number, size: number);
    toBytes(): Uint8Array;
    static fromBytes(bytes: Uint8Array): LinkedArrayListHeader;
    withPtr(ptr: number): LinkedArrayListHeader;
}
export declare class KeyValuePair {
    valueSlot: Slot;
    keySlot: Slot;
    hash: Uint8Array;
    constructor(valueSlot: Slot, keySlot: Slot, hash: Uint8Array);
    static length(hashSize: number): number;
    toBytes(): Uint8Array;
    static fromBytes(bytes: Uint8Array, hashSize: number): KeyValuePair;
}
export declare class LinkedArrayListSlot {
    size: number;
    slot: Slot;
    static readonly LENGTH: number;
    constructor(size: number, slot: Slot);
    withSize(size: number): LinkedArrayListSlot;
    toBytes(): Uint8Array;
    static fromBytes(bytes: Uint8Array): LinkedArrayListSlot;
}
export declare class LinkedArrayListSlotPointer {
    slotPtr: SlotPointer;
    leafCount: number;
    constructor(slotPtr: SlotPointer, leafCount: number);
    withSlotPointer(slotPtr: SlotPointer): LinkedArrayListSlotPointer;
}
export declare class LinkedArrayListBlockInfo {
    block: LinkedArrayListSlot[];
    i: number;
    parentSlot: LinkedArrayListSlot;
    constructor(block: LinkedArrayListSlot[], i: number, parentSlot: LinkedArrayListSlot);
}
export type PathPart = ArrayListInit | ArrayListGet | ArrayListAppend | ArrayListSlice | LinkedArrayListInit | LinkedArrayListGet | LinkedArrayListAppend | LinkedArrayListSlice | LinkedArrayListConcat | LinkedArrayListInsert | LinkedArrayListRemove | HashMapInit | HashMapGet | HashMapRemove | WriteData | Context;
export interface PathPartBase {
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export type HashMapGetTarget = HashMapGetKVPair | HashMapGetKey | HashMapGetValue;
export declare class HashMapGetKVPair {
    hash: Uint8Array;
    readonly kind = "kv_pair";
    constructor(hash: Uint8Array);
}
export declare class HashMapGetKey {
    hash: Uint8Array;
    readonly kind = "key";
    constructor(hash: Uint8Array);
}
export declare class HashMapGetValue {
    hash: Uint8Array;
    readonly kind = "value";
    constructor(hash: Uint8Array);
}
export type ContextFunction = (cursor: any) => void;
export declare class ArrayListInit implements PathPartBase {
    readonly kind = "ArrayListInit";
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class ArrayListGet implements PathPartBase {
    index: number;
    readonly kind = "ArrayListGet";
    constructor(index: number);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class ArrayListAppend implements PathPartBase {
    readonly kind = "ArrayListAppend";
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class ArrayListSlice implements PathPartBase {
    size: number;
    readonly kind = "ArrayListSlice";
    constructor(size: number);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class LinkedArrayListInit implements PathPartBase {
    readonly kind = "LinkedArrayListInit";
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class LinkedArrayListGet implements PathPartBase {
    index: number;
    readonly kind = "LinkedArrayListGet";
    constructor(index: number);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class LinkedArrayListAppend implements PathPartBase {
    readonly kind = "LinkedArrayListAppend";
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class LinkedArrayListSlice implements PathPartBase {
    offset: number;
    size: number;
    readonly kind = "LinkedArrayListSlice";
    constructor(offset: number, size: number);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class LinkedArrayListConcat implements PathPartBase {
    list: Slot;
    readonly kind = "LinkedArrayListConcat";
    constructor(list: Slot);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class LinkedArrayListInsert implements PathPartBase {
    index: number;
    readonly kind = "LinkedArrayListInsert";
    constructor(index: number);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class LinkedArrayListRemove implements PathPartBase {
    index: number;
    readonly kind = "LinkedArrayListRemove";
    constructor(index: number);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class HashMapInit implements PathPartBase {
    counted: boolean;
    set: boolean;
    readonly kind = "HashMapInit";
    constructor(counted?: boolean, set?: boolean);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class HashMapGet implements PathPartBase {
    target: HashMapGetTarget;
    readonly kind = "HashMapGet";
    constructor(target: HashMapGetTarget);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class HashMapRemove implements PathPartBase {
    hash: Uint8Array;
    readonly kind = "HashMapRemove";
    constructor(hash: Uint8Array);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class WriteData implements PathPartBase {
    data: WriteableData | null;
    readonly kind = "WriteData";
    constructor(data: WriteableData | null);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
export declare class Context implements PathPartBase {
    fn: ContextFunction;
    readonly kind = "Context";
    constructor(fn: ContextFunction);
    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
}
declare class HashMapGetResult {
    slotPtr: SlotPointer;
    isEmpty: boolean;
    constructor(slotPtr: SlotPointer, isEmpty: boolean);
}
declare class ArrayListAppendResult {
    header: ArrayListHeader;
    slotPtr: SlotPointer;
    constructor(header: ArrayListHeader, slotPtr: SlotPointer);
}
declare class LinkedArrayListAppendResult {
    header: LinkedArrayListHeader;
    slotPtr: LinkedArrayListSlotPointer;
    constructor(header: LinkedArrayListHeader, slotPtr: LinkedArrayListSlotPointer);
}
export declare class Database {
    core: Core;
    hasher: Hasher;
    header: Header;
    txStart: number | null;
    constructor(core: Core, hasher: Hasher);
    rootCursor(): WriteCursor;
    freeze(): void;
    compact(targetCore: Core): Database;
    truncate(): void;
    checkHashBytes(hash: Uint8Array): Uint8Array;
    checkHash(target: HashMapGetTarget): Uint8Array;
    readSlotPointer(writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): SlotPointer;
    readMapSlot(indexPos: number, keyHash: Uint8Array, keyOffset: number, writeMode: WriteMode, isTopLevel: boolean, target: HashMapGetTarget): HashMapGetResult;
    removeMapSlot(indexPos: number, keyHash: Uint8Array, keyOffset: number, isTopLevel: boolean): Slot;
    readArrayListSlotAppend(header: ArrayListHeader, writeMode: WriteMode, isTopLevel: boolean): ArrayListAppendResult;
    readArrayListSlot(indexPos: number, key: number, shift: number, writeMode: WriteMode, isTopLevel: boolean): SlotPointer;
    readArrayListSlice(header: ArrayListHeader, size: number): ArrayListHeader;
    readLinkedArrayListSlotAppend(header: LinkedArrayListHeader, writeMode: WriteMode, isTopLevel: boolean): LinkedArrayListAppendResult;
    private static blockLeafCount;
    private static slotLeafCount;
    private static keyAndIndexForLinkedArrayList;
    readLinkedArrayListSlot(indexPos: number, key: number, shift: number, writeMode: WriteMode, isTopLevel: boolean): LinkedArrayListSlotPointer;
    readLinkedArrayListBlocks(indexPos: number, key: number, shift: number, blocks: LinkedArrayListBlockInfo[]): void;
    private populateArray;
    readLinkedArrayListSlice(header: LinkedArrayListHeader, offset: number, size: number): LinkedArrayListHeader;
    readLinkedArrayListConcat(headerA: LinkedArrayListHeader, headerB: LinkedArrayListHeader): LinkedArrayListHeader;
}
export {};