xitdb 0.13.0 → 0.15.0

package/dist/read-hash-map.js

@@ -0,0 +1,65 @@
+import { HashMapGet, HashMapGetValue, HashMapGetKey, HashMapGetKVPair } from './database.js';
+import { UnexpectedTagException } from './exceptions.js';
+export class ReadHashMap {
+    cursor;
+    constructor(cursor) {
+        if (cursor) {
+            switch (cursor.slotPtr.slot.tag) {
+                case 0 /* Tag.NONE */:
+                case 4 /* Tag.HASH_MAP */:
+                case 11 /* Tag.HASH_SET */:
+                    this.cursor = cursor;
+                    break;
+                default:
+                    throw new UnexpectedTagException();
+            }
+        }
+    }
+    slot() {
+        return this.cursor.slot();
+    }
+    iterator() {
+        return this.cursor.iterator();
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    getCursor(key) {
+        const hash = this.resolveHash(key);
+        return this.cursor.readPath([new HashMapGet(new HashMapGetValue(hash))]);
+    }
+    getSlot(key) {
+        const hash = this.resolveHash(key);
+        return this.cursor.readPathSlot([new HashMapGet(new HashMapGetValue(hash))]);
+    }
+    getKeyCursor(key) {
+        const hash = this.resolveHash(key);
+        return this.cursor.readPath([new HashMapGet(new HashMapGetKey(hash))]);
+    }
+    getKeySlot(key) {
+        const hash = this.resolveHash(key);
+        return this.cursor.readPathSlot([new HashMapGet(new HashMapGetKey(hash))]);
+    }
+    getKeyValuePair(key) {
+        const hash = this.resolveHash(key);
+        const cursor = this.cursor.readPath([new HashMapGet(new HashMapGetKVPair(hash))]);
+        if (cursor === null) {
+            return null;
+        }
+        else {
+            return cursor.readKeyValuePair();
+        }
+    }
+    // Helper to resolve key to hash
+    resolveHash(key) {
+        if (key instanceof Uint8Array) {
+            return key;
+        }
+        else if (typeof key === 'string') {
+            return this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+        }
+        else {
+            return this.cursor.db.hasher.digest(key.value);
+        }
+    }
+}

package/dist/read-hash-set.d.ts

@@ -1,7 +1,7 @@
-import { Slot } from './slot';
-import type { Slotted } from './slotted';
-import { ReadCursor, CursorIterator } from './read-cursor';
-import { Bytes } from './writeable-data';
+import { Slot } from './slot.js';
+import type { Slotted } from './slotted.js';
+import { ReadCursor, CursorIterator } from './read-cursor.js';
+import { Bytes } from './writeable-data.js';
 export declare class ReadHashSet implements Slotted {
     cursor: ReadCursor;
     constructor();

package/dist/read-hash-set.js

@@ -0,0 +1,47 @@
+import { HashMapGet, HashMapGetKey } from './database.js';
+import { UnexpectedTagException } from './exceptions.js';
+export class ReadHashSet {
+    cursor;
+    constructor(cursor) {
+        if (cursor) {
+            switch (cursor.slotPtr.slot.tag) {
+                case 0 /* Tag.NONE */:
+                case 4 /* Tag.HASH_MAP */:
+                case 11 /* Tag.HASH_SET */:
+                    this.cursor = cursor;
+                    break;
+                default:
+                    throw new UnexpectedTagException();
+            }
+        }
+    }
+    slot() {
+        return this.cursor.slot();
+    }
+    iterator() {
+        return this.cursor.iterator();
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    getCursor(key) {
+        const hash = this.resolveHash(key);
+        return this.cursor.readPath([new HashMapGet(new HashMapGetKey(hash))]);
+    }
+    getSlot(key) {
+        const hash = this.resolveHash(key);
+        return this.cursor.readPathSlot([new HashMapGet(new HashMapGetKey(hash))]);
+    }
+    // Helper to resolve key to hash
+    resolveHash(key) {
+        if (key instanceof Uint8Array) {
+            return key;
+        }
+        else if (typeof key === 'string') {
+            return this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+        }
+        else {
+            return this.cursor.db.hasher.digest(key.value);
+        }
+    }
+}

package/dist/read-linked-array-list.d.ts

@@ -1,6 +1,6 @@
-import { Slot } from './slot';
-import type { Slotted } from './slotted';
-import { ReadCursor, CursorIterator } from './read-cursor';
+import { Slot } from './slot.js';
+import type { Slotted } from './slotted.js';
+import { ReadCursor, CursorIterator } from './read-cursor.js';
 export declare class ReadLinkedArrayList implements Slotted {
     cursor: ReadCursor;
     constructor();
@@ -8,6 +8,7 @@ export declare class ReadLinkedArrayList implements Slotted {
     slot(): Slot;
     count(): number;
     iterator(): CursorIterator;
+    iteratorFrom(index: number): CursorIterator;
     [Symbol.iterator](): Iterator<ReadCursor>;
     getCursor(index: number): ReadCursor | null;
     getSlot(index: number): Slot | null;

package/dist/read-linked-array-list.js

@@ -0,0 +1,41 @@
+import { CursorIterator } from './read-cursor.js';
+import { LinkedArrayListGet } from './database.js';
+import { UnexpectedTagException } from './exceptions.js';
+export class ReadLinkedArrayList {
+    cursor;
+    constructor(cursor) {
+        if (cursor) {
+            switch (cursor.slotPtr.slot.tag) {
+                case 0 /* Tag.NONE */:
+                case 3 /* Tag.LINKED_ARRAY_LIST */:
+                    this.cursor = cursor;
+                    break;
+                default:
+                    throw new UnexpectedTagException();
+            }
+        }
+    }
+    slot() {
+        return this.cursor.slot();
+    }
+    count() {
+        return this.cursor.count();
+    }
+    iterator() {
+        return this.cursor.iterator();
+    }
+    // iterate starting at the given index, seeking straight to it instead of
+    // walking from the front. negative indexes count from the end.
+    iteratorFrom(index) {
+        return CursorIterator.initLinkedArrayListFromIndex(this.cursor, index);
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    getCursor(index) {
+        return this.cursor.readPath([new LinkedArrayListGet(index)]);
+    }
+    getSlot(index) {
+        return this.cursor.readPathSlot([new LinkedArrayListGet(index)]);
+    }
+}

package/dist/read-sorted-map.d.ts

@@ -0,0 +1,21 @@
+import { Slot } from './slot.js';
+import type { Slotted } from './slotted.js';
+import { ReadCursor, CursorIterator, KeyValuePairCursor } from './read-cursor.js';
+import { Bytes } from './writeable-data.js';
+export declare class ReadSortedMap implements Slotted {
+    cursor: ReadCursor;
+    constructor();
+    constructor(cursor: ReadCursor);
+    slot(): Slot;
+    count(): number;
+    iterator(): CursorIterator;
+    [Symbol.iterator](): Iterator<ReadCursor>;
+    iteratorFrom(key: string | Bytes | Uint8Array): CursorIterator;
+    iteratorFromIndex(startIndex: number): CursorIterator;
+    getCursor(key: string | Bytes | Uint8Array): ReadCursor | null;
+    getSlot(key: string | Bytes | Uint8Array): Slot | null;
+    getKeyValuePair(key: string | Bytes | Uint8Array): KeyValuePairCursor | null;
+    getIndexKeyValuePair(index: number): KeyValuePairCursor | null;
+    rank(key: string | Bytes | Uint8Array): number;
+    protected resolveKey(key: string | Bytes | Uint8Array): Uint8Array;
+}

package/dist/read-sorted-map.js

@@ -0,0 +1,73 @@
+import { CursorIterator } from './read-cursor.js';
+import { SortedMapGet, SortedMapGetValue, SortedMapGetKVPair, SortedMapGetIndex, BTreeHeader, } from './database.js';
+import { UnexpectedTagException } from './exceptions.js';
+export class ReadSortedMap {
+    cursor;
+    constructor(cursor) {
+        if (cursor) {
+            switch (cursor.slotPtr.slot.tag) {
+                case 0 /* Tag.NONE */:
+                case 14 /* Tag.SORTED_MAP */:
+                case 15 /* Tag.SORTED_SET */:
+                    this.cursor = cursor;
+                    break;
+                default:
+                    throw new UnexpectedTagException();
+            }
+        }
+    }
+    slot() {
+        return this.cursor.slot();
+    }
+    count() {
+        return this.cursor.count();
+    }
+    iterator() {
+        return this.cursor.iterator();
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    // iterate in key order starting at the first entry with key >= startKey
+    iteratorFrom(key) {
+        return CursorIterator.initSortedFromKey(this.cursor, this.resolveKey(key));
+    }
+    // iterate in key order starting at the entry with rank startIndex
+    iteratorFromIndex(startIndex) {
+        return CursorIterator.initSortedFromIndex(this.cursor, startIndex);
+    }
+    getCursor(key) {
+        return this.cursor.readPath([new SortedMapGet(new SortedMapGetValue(this.resolveKey(key)))]);
+    }
+    getSlot(key) {
+        return this.cursor.readPathSlot([new SortedMapGet(new SortedMapGetValue(this.resolveKey(key)))]);
+    }
+    getKeyValuePair(key) {
+        const cursor = this.cursor.readPath([new SortedMapGet(new SortedMapGetKVPair(this.resolveKey(key)))]);
+        return cursor === null ? null : cursor.readKeyValuePair();
+    }
+    // the key/value pair at the given rank (negative counts from the end)
+    getIndexKeyValuePair(index) {
+        const cursor = this.cursor.readPath([new SortedMapGetIndex(index)]);
+        return cursor === null ? null : cursor.readKeyValuePair();
+    }
+    // number of keys strictly less than key (the inverse of getIndexKeyValuePair)
+    rank(key) {
+        if (this.cursor.slotPtr.slot.tag === 0 /* Tag.NONE */)
+            return 0;
+        this.cursor.db.core.seek(Number(this.cursor.slotPtr.slot.value));
+        const reader = this.cursor.db.core.reader();
+        const headerBytes = new Uint8Array(BTreeHeader.LENGTH);
+        reader.readFully(headerBytes);
+        const header = BTreeHeader.fromBytes(headerBytes);
+        return this.cursor.db.sortedRank(header.rootPtr, this.resolveKey(key));
+    }
+    // sorted-map keys are byte strings, not hashes
+    resolveKey(key) {
+        if (key instanceof Uint8Array)
+            return key;
+        if (typeof key === 'string')
+            return new TextEncoder().encode(key);
+        return key.value;
+    }
+}

package/dist/read-sorted-set.d.ts

@@ -0,0 +1,19 @@
+import { Slot } from './slot.js';
+import type { Slotted } from './slotted.js';
+import { ReadCursor, CursorIterator, KeyValuePairCursor } from './read-cursor.js';
+import { Bytes } from './writeable-data.js';
+export declare class ReadSortedSet implements Slotted {
+    cursor: ReadCursor;
+    constructor();
+    constructor(cursor: ReadCursor);
+    slot(): Slot;
+    count(): number;
+    iterator(): CursorIterator;
+    [Symbol.iterator](): Iterator<ReadCursor>;
+    iteratorFrom(key: string | Bytes | Uint8Array): CursorIterator;
+    iteratorFromIndex(startIndex: number): CursorIterator;
+    getIndexKeyValuePair(index: number): KeyValuePairCursor | null;
+    contains(key: string | Bytes | Uint8Array): boolean;
+    rank(key: string | Bytes | Uint8Array): number;
+    protected resolveKey(key: string | Bytes | Uint8Array): Uint8Array;
+}

package/dist/read-sorted-set.js

@@ -0,0 +1,65 @@
+import { CursorIterator } from './read-cursor.js';
+import { SortedMapGet, SortedMapGetKey, SortedMapGetIndex, BTreeHeader } from './database.js';
+import { UnexpectedTagException } from './exceptions.js';
+// a sorted set of byte-string keys (a SortedMap with no values).
+export class ReadSortedSet {
+    cursor;
+    constructor(cursor) {
+        if (cursor) {
+            switch (cursor.slotPtr.slot.tag) {
+                case 0 /* Tag.NONE */:
+                case 14 /* Tag.SORTED_MAP */:
+                case 15 /* Tag.SORTED_SET */:
+                    this.cursor = cursor;
+                    break;
+                default:
+                    throw new UnexpectedTagException();
+            }
+        }
+    }
+    slot() {
+        return this.cursor.slot();
+    }
+    count() {
+        return this.cursor.count();
+    }
+    iterator() {
+        return this.cursor.iterator();
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    iteratorFrom(key) {
+        return CursorIterator.initSortedFromKey(this.cursor, this.resolveKey(key));
+    }
+    iteratorFromIndex(startIndex) {
+        return CursorIterator.initSortedFromIndex(this.cursor, startIndex);
+    }
+    // the key/value pair at the given rank (negative counts from the end)
+    getIndexKeyValuePair(index) {
+        const cursor = this.cursor.readPath([new SortedMapGetIndex(index)]);
+        return cursor === null ? null : cursor.readKeyValuePair();
+    }
+    contains(key) {
+        return this.cursor.readPath([new SortedMapGet(new SortedMapGetKey(this.resolveKey(key)))]) !== null;
+    }
+    // number of keys strictly less than key
+    rank(key) {
+        if (this.cursor.slotPtr.slot.tag === 0 /* Tag.NONE */)
+            return 0;
+        this.cursor.db.core.seek(Number(this.cursor.slotPtr.slot.value));
+        const reader = this.cursor.db.core.reader();
+        const headerBytes = new Uint8Array(BTreeHeader.LENGTH);
+        reader.readFully(headerBytes);
+        const header = BTreeHeader.fromBytes(headerBytes);
+        return this.cursor.db.sortedRank(header.rootPtr, this.resolveKey(key));
+    }
+    // sorted-set keys are byte strings, not hashes
+    resolveKey(key) {
+        if (key instanceof Uint8Array)
+            return key;
+        if (typeof key === 'string')
+            return new TextEncoder().encode(key);
+        return key.value;
+    }
+}

package/dist/slot-pointer.d.ts

@@ -1,4 +1,4 @@
-import { Slot } from './slot';
+import { Slot } from './slot.js';
 export declare class SlotPointer {
     readonly position: number | null;
     readonly slot: Slot;

package/dist/slot-pointer.js

@@ -0,0 +1,11 @@
+export class SlotPointer {
+    position;
+    slot;
+    constructor(position, slot) {
+        this.position = position;
+        this.slot = slot;
+    }
+    withSlot(slot) {
+        return new SlotPointer(this.position, slot);
+    }
+}

package/dist/slot.d.ts

@@ -1,5 +1,5 @@
-import { Tag } from './tag';
-import type { WriteableData } from './writeable-data';
+import { Tag } from './tag.js';
+import type { WriteableData } from './writeable-data.js';
 export declare class Slot implements WriteableData {
     static readonly LENGTH = 9;
     readonly value: bigint;

package/dist/slot.js

@@ -0,0 +1,41 @@
+import { tagValueOf } from './tag.js';
+export class Slot {
+    static LENGTH = 9;
+    value;
+    tag;
+    full;
+    constructor(value = 0n, tag = 0 /* Tag.NONE */, full = false) {
+        this.value = typeof value === 'bigint' ? value : BigInt(value);
+        this.tag = tag;
+        this.full = full;
+    }
+    withTag(tag) {
+        return new Slot(this.value, tag, this.full);
+    }
+    withFull(full) {
+        return new Slot(this.value, this.tag, full);
+    }
+    empty() {
+        return this.tag === 0 /* Tag.NONE */ && !this.full;
+    }
+    toBytes() {
+        const buffer = new ArrayBuffer(Slot.LENGTH);
+        const view = new DataView(buffer);
+        let tagInt = this.full ? 0b1000_0000 : 0;
+        tagInt = tagInt | this.tag;
+        view.setUint8(0, tagInt);
+        view.setBigInt64(1, this.value, false);
+        return new Uint8Array(buffer);
+    }
+    static fromBytes(bytes) {
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        const tagByte = view.getUint8(0);
+        const full = (tagByte & 0b1000_0000) !== 0;
+        const tag = tagValueOf(tagByte & 0b0111_1111);
+        const value = view.getBigInt64(1, false);
+        return new Slot(value, tag, full);
+    }
+    equals(other) {
+        return this.value === other.value && this.tag === other.tag && this.full === other.full;
+    }
+}

package/dist/slotted.d.ts

@@ -1,4 +1,4 @@
-import type { Slot } from './slot';
+import type { Slot } from './slot.js';
 export interface Slotted {
     slot(): Slot;
 }

package/dist/slotted.js

@@ -0,0 +1 @@
+export {};

package/dist/tag.d.ts

@@ -12,6 +12,8 @@ export declare const enum Tag {
     FLOAT = 10,
     HASH_SET = 11,
     COUNTED_HASH_MAP = 12,
-    COUNTED_HASH_SET = 13
+    COUNTED_HASH_SET = 13,
+    SORTED_MAP = 14,
+    SORTED_SET = 15
 }
 export declare function tagValueOf(n: number): Tag;

package/dist/tag.js

@@ -0,0 +1,25 @@
+export var Tag;
+(function (Tag) {
+    Tag[Tag["NONE"] = 0] = "NONE";
+    Tag[Tag["INDEX"] = 1] = "INDEX";
+    Tag[Tag["ARRAY_LIST"] = 2] = "ARRAY_LIST";
+    Tag[Tag["LINKED_ARRAY_LIST"] = 3] = "LINKED_ARRAY_LIST";
+    Tag[Tag["HASH_MAP"] = 4] = "HASH_MAP";
+    Tag[Tag["KV_PAIR"] = 5] = "KV_PAIR";
+    Tag[Tag["BYTES"] = 6] = "BYTES";
+    Tag[Tag["SHORT_BYTES"] = 7] = "SHORT_BYTES";
+    Tag[Tag["UINT"] = 8] = "UINT";
+    Tag[Tag["INT"] = 9] = "INT";
+    Tag[Tag["FLOAT"] = 10] = "FLOAT";
+    Tag[Tag["HASH_SET"] = 11] = "HASH_SET";
+    Tag[Tag["COUNTED_HASH_MAP"] = 12] = "COUNTED_HASH_MAP";
+    Tag[Tag["COUNTED_HASH_SET"] = 13] = "COUNTED_HASH_SET";
+    Tag[Tag["SORTED_MAP"] = 14] = "SORTED_MAP";
+    Tag[Tag["SORTED_SET"] = 15] = "SORTED_SET";
+})(Tag || (Tag = {}));
+export function tagValueOf(n) {
+    if (n < 0 || n > 15) {
+        throw new Error(`Invalid tag value: ${n}`);
+    }
+    return n;
+}

package/dist/write-array-list.d.ts

@@ -1,7 +1,7 @@
-import { ReadArrayList } from './read-array-list';
-import { WriteCursor, WriteCursorIterator } from './write-cursor';
-import { type ContextFunction } from './database';
-import type { WriteableData } from './writeable-data';
+import { ReadArrayList } from './read-array-list.js';
+import { WriteCursor, WriteCursorIterator } from './write-cursor.js';
+import { type ContextFunction } from './database.js';
+import type { WriteableData } from './writeable-data.js';
 export declare class WriteArrayList extends ReadArrayList {
     constructor(cursor: WriteCursor);
     iterator(): WriteCursorIterator;

package/dist/write-array-list.js

@@ -0,0 +1,42 @@
+import { ReadArrayList } from './read-array-list.js';
+import { ArrayListInit, ArrayListGet, ArrayListAppend, ArrayListSlice, WriteData, Context, } from './database.js';
+export class WriteArrayList extends ReadArrayList {
+    constructor(cursor) {
+        super();
+        this.cursor = cursor.writePath([new ArrayListInit()]);
+    }
+    iterator() {
+        return this.cursor.iterator();
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    put(index, data) {
+        this.cursor.writePath([
+            new ArrayListGet(index),
+            new WriteData(data),
+        ]);
+    }
+    putCursor(index) {
+        return this.cursor.writePath([new ArrayListGet(index)]);
+    }
+    append(data) {
+        this.cursor.writePath([
+            new ArrayListAppend(),
+            new WriteData(data),
+        ]);
+    }
+    appendCursor() {
+        return this.cursor.writePath([new ArrayListAppend()]);
+    }
+    appendContext(data, fn) {
+        this.cursor.writePath([
+            new ArrayListAppend(),
+            new WriteData(data),
+            new Context(fn),
+        ]);
+    }
+    slice(size) {
+        this.cursor.writePath([new ArrayListSlice(size)]);
+    }
+}

package/dist/write-counted-hash-map.d.ts

@@ -1,5 +1,5 @@
-import { WriteHashMap } from './write-hash-map';
-import { WriteCursor } from './write-cursor';
+import { WriteHashMap } from './write-hash-map.js';
+import { WriteCursor } from './write-cursor.js';
 export declare class WriteCountedHashMap extends WriteHashMap {
     constructor(cursor: WriteCursor);
     count(): number;

package/dist/write-counted-hash-map.js

@@ -0,0 +1,18 @@
+import { WriteHashMap } from './write-hash-map.js';
+import { UnexpectedTagException } from './exceptions.js';
+export class WriteCountedHashMap extends WriteHashMap {
+    constructor(cursor) {
+        switch (cursor.slotPtr.slot.tag) {
+            case 0 /* Tag.NONE */:
+            case 12 /* Tag.COUNTED_HASH_MAP */:
+            case 13 /* Tag.COUNTED_HASH_SET */:
+                super(cursor, true);
+                break;
+            default:
+                throw new UnexpectedTagException();
+        }
+    }
+    count() {
+        return this.cursor.count();
+    }
+}

package/dist/write-counted-hash-set.d.ts

@@ -1,5 +1,5 @@
-import { WriteHashSet } from './write-hash-set';
-import { WriteCursor } from './write-cursor';
+import { WriteHashSet } from './write-hash-set.js';
+import { WriteCursor } from './write-cursor.js';
 export declare class WriteCountedHashSet extends WriteHashSet {
     constructor(cursor: WriteCursor);
     count(): number;

package/dist/write-counted-hash-set.js

@@ -0,0 +1,18 @@
+import { WriteHashSet } from './write-hash-set.js';
+import { UnexpectedTagException } from './exceptions.js';
+export class WriteCountedHashSet extends WriteHashSet {
+    constructor(cursor) {
+        switch (cursor.slotPtr.slot.tag) {
+            case 0 /* Tag.NONE */:
+            case 12 /* Tag.COUNTED_HASH_MAP */:
+            case 13 /* Tag.COUNTED_HASH_SET */:
+                super(cursor, true);
+                break;
+            default:
+                throw new UnexpectedTagException();
+        }
+    }
+    count() {
+        return this.cursor.count();
+    }
+}

package/dist/write-cursor.d.ts

@@ -1,8 +1,8 @@
-import { Slot } from './slot';
-import { SlotPointer } from './slot-pointer';
-import { Database, type PathPart } from './database';
-import { ReadCursor, KeyValuePairCursor, CursorIterator } from './read-cursor';
-import type { WriteableData } from './writeable-data';
+import { Slot } from './slot.js';
+import { SlotPointer } from './slot-pointer.js';
+import { Database, type PathPart } from './database.js';
+import { ReadCursor, KeyValuePairCursor, CursorIterator } from './read-cursor.js';
+import type { WriteableData } from './writeable-data.js';
 export declare class WriteKeyValuePairCursor extends KeyValuePairCursor {
     valueCursor: WriteCursor;
     keyCursor: WriteCursor;