xitdb 0.1.0 → 0.2.0

package/dist/core-buffered-file.d.ts

@@ -0,0 +1,41 @@
+import type { Core, DataReader, DataWriter } from './core';
+import { CoreFile } from './core-file';
+export declare class CoreBufferedFile implements Core {
+    file: RandomAccessBufferedFile;
+    constructor(file: RandomAccessBufferedFile);
+    static create(filePath: string, bufferSize?: number): Promise<CoreBufferedFile>;
+    reader(): DataReader;
+    writer(): DataWriter;
+    length(): Promise<number>;
+    seek(pos: number): Promise<void>;
+    position(): number;
+    setLength(len: number): Promise<void>;
+    flush(): Promise<void>;
+    sync(): Promise<void>;
+    [Symbol.dispose](): void;
+}
+declare class RandomAccessBufferedFile implements DataReader, DataWriter {
+    file: CoreFile;
+    private memory;
+    private bufferSize;
+    private filePos;
+    private memoryPos;
+    private constructor();
+    static create(filePath: string, bufferSize?: number): Promise<RandomAccessBufferedFile>;
+    seek(pos: number): Promise<void>;
+    length(): Promise<number>;
+    position(): number;
+    setLength(len: number): Promise<void>;
+    flush(): Promise<void>;
+    sync(): Promise<void>;
+    write(buffer: Uint8Array): Promise<void>;
+    writeByte(v: number): Promise<void>;
+    writeShort(v: number): Promise<void>;
+    writeLong(v: number): Promise<void>;
+    readFully(buffer: Uint8Array): Promise<void>;
+    readByte(): Promise<number>;
+    readShort(): Promise<number>;
+    readInt(): Promise<number>;
+    readLong(): Promise<number>;
+}
+export {};

package/dist/core-file.d.ts

@@ -0,0 +1,18 @@
+import type { Core, DataReader, DataWriter } from './core';
+import type { FileHandle } from 'fs/promises';
+export declare class CoreFile implements Core {
+    filePath: string;
+    private _position;
+    fileHandle: FileHandle;
+    private constructor();
+    static create(filePath: string): Promise<CoreFile>;
+    reader(): DataReader;
+    writer(): DataWriter;
+    length(): Promise<number>;
+    seek(pos: number): Promise<void>;
+    position(): number;
+    setLength(len: number): Promise<void>;
+    flush(): Promise<void>;
+    sync(): Promise<void>;
+    [Symbol.dispose](): void;
+}

package/dist/core-memory.d.ts

@@ -0,0 +1,36 @@
+import type { Core, DataReader, DataWriter } from './core';
+export declare class CoreMemory implements Core {
+    memory: RandomAccessMemory;
+    constructor();
+    reader(): DataReader;
+    writer(): DataWriter;
+    length(): Promise<number>;
+    seek(pos: number): Promise<void>;
+    position(): number;
+    setLength(len: number): Promise<void>;
+    flush(): Promise<void>;
+    sync(): Promise<void>;
+}
+declare class RandomAccessMemory implements DataReader, DataWriter {
+    private buffer;
+    private _position;
+    private _count;
+    constructor(initialSize?: number);
+    private ensureCapacity;
+    size(): number;
+    seek(pos: number): void;
+    getPosition(): number;
+    setLength(len: number): void;
+    reset(): void;
+    toByteArray(): Uint8Array;
+    write(data: Uint8Array): Promise<void>;
+    writeByte(v: number): Promise<void>;
+    writeShort(v: number): Promise<void>;
+    writeLong(v: number): Promise<void>;
+    readFully(b: Uint8Array): Promise<void>;
+    readByte(): Promise<number>;
+    readShort(): Promise<number>;
+    readInt(): Promise<number>;
+    readLong(): Promise<number>;
+}
+export {};

package/dist/core.d.ts

@@ -0,0 +1,23 @@
+export interface DataReader {
+    readFully(buffer: Uint8Array): Promise<void>;
+    readByte(): Promise<number>;
+    readShort(): Promise<number>;
+    readInt(): Promise<number>;
+    readLong(): Promise<number>;
+}
+export interface DataWriter {
+    write(buffer: Uint8Array): Promise<void>;
+    writeByte(v: number): Promise<void>;
+    writeShort(v: number): Promise<void>;
+    writeLong(v: number): Promise<void>;
+}
+export interface Core {
+    reader(): DataReader;
+    writer(): DataWriter;
+    length(): Promise<number>;
+    seek(pos: number): Promise<void>;
+    position(): number;
+    setLength(len: number): Promise<void>;
+    flush(): Promise<void>;
+    sync(): Promise<void>;
+}

package/dist/database.d.ts

@@ -0,0 +1,244 @@
+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';
+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): Promise<Header>;
+    write(core: Core): Promise<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): Promise<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) => Promise<void>;
+export declare class ArrayListInit implements PathPartBase {
+    readonly kind = "ArrayListInit";
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<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): Promise<SlotPointer>;
+}
+export declare class ArrayListAppend implements PathPartBase {
+    readonly kind = "ArrayListAppend";
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<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): Promise<SlotPointer>;
+}
+export declare class LinkedArrayListInit implements PathPartBase {
+    readonly kind = "LinkedArrayListInit";
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<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): Promise<SlotPointer>;
+}
+export declare class LinkedArrayListAppend implements PathPartBase {
+    readonly kind = "LinkedArrayListAppend";
+    readSlotPointer(db: Database, isTopLevel: boolean, writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<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): Promise<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): Promise<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): Promise<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): Promise<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): Promise<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): Promise<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): Promise<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): Promise<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): Promise<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;
+    private constructor();
+    static create(core: Core, hasher: Hasher): Promise<Database>;
+    rootCursor(): Promise<any>;
+    freeze(): Promise<void>;
+    truncate(): Promise<void>;
+    checkHashBytes(hash: Uint8Array): Uint8Array;
+    checkHash(target: HashMapGetTarget): Uint8Array;
+    readSlotPointer(writeMode: WriteMode, path: PathPart[], pathI: number, slotPtr: SlotPointer): Promise<SlotPointer>;
+    readMapSlot(indexPos: number, keyHash: Uint8Array, keyOffset: number, writeMode: WriteMode, isTopLevel: boolean, target: HashMapGetTarget): Promise<HashMapGetResult>;
+    removeMapSlot(indexPos: number, keyHash: Uint8Array, keyOffset: number, isTopLevel: boolean): Promise<Slot>;
+    readArrayListSlotAppend(header: ArrayListHeader, writeMode: WriteMode, isTopLevel: boolean): Promise<ArrayListAppendResult>;
+    readArrayListSlot(indexPos: number, key: number, shift: number, writeMode: WriteMode, isTopLevel: boolean): Promise<SlotPointer>;
+    readArrayListSlice(header: ArrayListHeader, size: number): Promise<ArrayListHeader>;
+    readLinkedArrayListSlotAppend(header: LinkedArrayListHeader, writeMode: WriteMode, isTopLevel: boolean): Promise<LinkedArrayListAppendResult>;
+    private static blockLeafCount;
+    private static slotLeafCount;
+    private static keyAndIndexForLinkedArrayList;
+    readLinkedArrayListSlot(indexPos: number, key: number, shift: number, writeMode: WriteMode, isTopLevel: boolean): Promise<LinkedArrayListSlotPointer>;
+    readLinkedArrayListBlocks(indexPos: number, key: number, shift: number, blocks: LinkedArrayListBlockInfo[]): Promise<void>;
+    private populateArray;
+    readLinkedArrayListSlice(header: LinkedArrayListHeader, offset: number, size: number): Promise<LinkedArrayListHeader>;
+    readLinkedArrayListConcat(headerA: LinkedArrayListHeader, headerB: LinkedArrayListHeader): Promise<LinkedArrayListHeader>;
+}
+export {};

package/dist/exceptions.d.ts

@@ -0,0 +1,51 @@
+export declare class DatabaseException extends Error {
+    constructor(message?: string);
+}
+export declare class NotImplementedException extends DatabaseException {
+}
+export declare class UnreachableException extends DatabaseException {
+}
+export declare class InvalidDatabaseException extends DatabaseException {
+}
+export declare class InvalidVersionException extends DatabaseException {
+}
+export declare class InvalidHashSizeException extends DatabaseException {
+}
+export declare class KeyNotFoundException extends DatabaseException {
+}
+export declare class WriteNotAllowedException extends DatabaseException {
+}
+export declare class UnexpectedTagException extends DatabaseException {
+}
+export declare class CursorNotWriteableException extends DatabaseException {
+}
+export declare class ExpectedTxStartException extends DatabaseException {
+}
+export declare class KeyOffsetExceededException extends DatabaseException {
+}
+export declare class PathPartMustBeAtEndException extends DatabaseException {
+}
+export declare class StreamTooLongException extends DatabaseException {
+}
+export declare class EndOfStreamException extends DatabaseException {
+}
+export declare class InvalidOffsetException extends DatabaseException {
+}
+export declare class InvalidTopLevelTypeException extends DatabaseException {
+}
+export declare class ExpectedUnsignedLongException extends DatabaseException {
+}
+export declare class NoAvailableSlotsException extends DatabaseException {
+}
+export declare class MustSetNewSlotsToFullException extends DatabaseException {
+}
+export declare class EmptySlotException extends DatabaseException {
+}
+export declare class ExpectedRootNodeException extends DatabaseException {
+}
+export declare class InvalidFormatTagSizeException extends DatabaseException {
+}
+export declare class UnexpectedWriterPositionException extends DatabaseException {
+}
+export declare class MaxShiftExceededException extends DatabaseException {
+}

package/dist/hasher.d.ts

@@ -0,0 +1,9 @@
+export declare class Hasher {
+    readonly algorithm: string;
+    readonly id: number;
+    readonly digestLength: number;
+    constructor(algorithm: string, id?: number);
+    digest(data: Uint8Array): Promise<Uint8Array>;
+    static stringToId(hashIdName: string): number;
+    static idToString(id: number): string;
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+export { Tag, tagValueOf } from './tag';
+export { Slot } from './slot';
+export { SlotPointer } from './slot-pointer';
+export type { Slotted } from './slotted';
+export { Uint, Int, Float, Bytes, type WriteableData } from './writeable-data';
+export { DatabaseException, NotImplementedException, UnreachableException, InvalidDatabaseException, InvalidVersionException, InvalidHashSizeException, KeyNotFoundException, WriteNotAllowedException, UnexpectedTagException, CursorNotWriteableException, ExpectedTxStartException, KeyOffsetExceededException, PathPartMustBeAtEndException, StreamTooLongException, EndOfStreamException, InvalidOffsetException, InvalidTopLevelTypeException, ExpectedUnsignedLongException, NoAvailableSlotsException, MustSetNewSlotsToFullException, EmptySlotException, ExpectedRootNodeException, InvalidFormatTagSizeException, UnexpectedWriterPositionException, MaxShiftExceededException, } from './exceptions';
+export type { Core, DataReader, DataWriter } from './core';
+export { CoreMemory } from './core-memory';
+export { CoreFile } from './core-file';
+export { CoreBufferedFile } from './core-buffered-file';
+export { Hasher } from './hasher';
+export { Database, WriteMode, Header, ArrayListHeader, TopLevelArrayListHeader, LinkedArrayListHeader, KeyValuePair, LinkedArrayListSlot, LinkedArrayListSlotPointer, LinkedArrayListBlockInfo, VERSION, MAGIC_NUMBER, BIT_COUNT, SLOT_COUNT, MASK, INDEX_BLOCK_SIZE, LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE, MAX_BRANCH_LENGTH, type PathPart, ArrayListInit, ArrayListGet, ArrayListAppend, ArrayListSlice, LinkedArrayListInit, LinkedArrayListGet, LinkedArrayListAppend, LinkedArrayListSlice, LinkedArrayListConcat, LinkedArrayListInsert, LinkedArrayListRemove, HashMapInit, HashMapGet, HashMapRemove, WriteData, Context, type HashMapGetTarget, HashMapGetKVPair, HashMapGetKey, HashMapGetValue, type ContextFunction, } from './database';
+export { ReadCursor, Reader, CursorIterator, KeyValuePairCursor } from './read-cursor';
+export { WriteCursor, Writer, WriteCursorIterator, WriteKeyValuePairCursor } from './write-cursor';
+export { ReadArrayList } from './read-array-list';
+export { WriteArrayList } from './write-array-list';
+export { ReadHashMap } from './read-hash-map';
+export { WriteHashMap } from './write-hash-map';
+export { ReadHashSet } from './read-hash-set';
+export { WriteHashSet } from './write-hash-set';
+export { ReadLinkedArrayList } from './read-linked-array-list';
+export { WriteLinkedArrayList } from './write-linked-array-list';
+export { ReadCountedHashMap } from './read-counted-hash-map';
+export { WriteCountedHashMap } from './write-counted-hash-map';
+export { ReadCountedHashSet } from './read-counted-hash-set';
+export { WriteCountedHashSet } from './write-counted-hash-set';