xitdb 0.12.0 → 0.14.0

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

@@ -1,14 +1,14 @@
-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 ReadArrayList implements Slotted {
     cursor: ReadCursor;
     constructor();
     constructor(cursor: ReadCursor);
     slot(): Slot;
-    count(): Promise<number>;
-    iterator(): Promise<CursorIterator>;
-    [Symbol.asyncIterator](): AsyncIterator<ReadCursor>;
-    getCursor(index: number): Promise<ReadCursor | null>;
-    getSlot(index: number): Promise<Slot | null>;
+    count(): number;
+    iterator(): CursorIterator;
+    [Symbol.iterator](): Iterator<ReadCursor>;
+    getCursor(index: number): ReadCursor | null;
+    getSlot(index: number): Slot | null;
 }

package/dist/read-array-list.js

@@ -0,0 +1,35 @@
+import { ArrayListGet } from './database.js';
+import { UnexpectedTagException } from './exceptions.js';
+export class ReadArrayList {
+    cursor;
+    constructor(cursor) {
+        if (cursor) {
+            switch (cursor.slotPtr.slot.tag) {
+                case 0 /* Tag.NONE */:
+                case 2 /* Tag.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();
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    getCursor(index) {
+        return this.cursor.readPath([new ArrayListGet(index)]);
+    }
+    getSlot(index) {
+        return this.cursor.readPathSlot([new ArrayListGet(index)]);
+    }
+}

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

@@ -1,6 +1,6 @@
-import { ReadHashMap } from './read-hash-map';
-import { ReadCursor } from './read-cursor';
+import { ReadHashMap } from './read-hash-map.js';
+import { ReadCursor } from './read-cursor.js';
 export declare class ReadCountedHashMap extends ReadHashMap {
     constructor(cursor: ReadCursor);
-    count(): Promise<number>;
+    count(): number;
 }

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

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

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

@@ -1,6 +1,6 @@
-import { ReadHashSet } from './read-hash-set';
-import { ReadCursor } from './read-cursor';
+import { ReadHashSet } from './read-hash-set.js';
+import { ReadCursor } from './read-cursor.js';
 export declare class ReadCountedHashSet extends ReadHashSet {
     constructor(cursor: ReadCursor);
-    count(): Promise<number>;
+    count(): number;
 }

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

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

package/dist/read-cursor.d.ts

@@ -1,8 +1,8 @@
-import { Slot } from './slot';
-import { SlotPointer } from './slot-pointer';
-import type { Slotted } from './slotted';
-import { Database, type PathPart } from './database';
-import { Bytes } from './writeable-data';
+import { Slot } from './slot.js';
+import { SlotPointer } from './slot-pointer.js';
+import type { Slotted } from './slotted.js';
+import { Database, type PathPart } from './database.js';
+import { Bytes } from './writeable-data.js';
 export declare class KeyValuePairCursor {
     valueCursor: ReadCursor;
     keyCursor: ReadCursor;
@@ -14,18 +14,18 @@ export declare class ReadCursor implements Slotted {
     db: Database;
     constructor(slotPtr: SlotPointer, db: Database);
     slot(): Slot;
-    readPath(path: PathPart[]): Promise<ReadCursor | null>;
-    readPathSlot(path: PathPart[]): Promise<Slot | null>;
+    readPath(path: PathPart[]): ReadCursor | null;
+    readPathSlot(path: PathPart[]): Slot | null;
     readUint(): number;
     readInt(): number;
     readFloat(): number;
-    readBytes(maxSizeMaybe?: number | null): Promise<Uint8Array>;
-    readBytesObject(maxSizeMaybe?: number | null): Promise<Bytes>;
-    readKeyValuePair(): Promise<KeyValuePairCursor>;
-    reader(): Promise<Reader>;
-    count(): Promise<number>;
-    [Symbol.asyncIterator](): AsyncIterator<ReadCursor>;
-    iterator(): Promise<CursorIterator>;
+    readBytes(maxSizeMaybe?: number | null): Uint8Array;
+    readBytesObject(maxSizeMaybe?: number | null): Bytes;
+    readKeyValuePair(): KeyValuePairCursor;
+    reader(): Reader;
+    count(): number;
+    [Symbol.iterator](): Iterator<ReadCursor>;
+    iterator(): CursorIterator;
 }
 export declare class Reader {
     parent: ReadCursor;
@@ -33,12 +33,12 @@ export declare class Reader {
     startPosition: number;
     relativePosition: number;
     constructor(parent: ReadCursor, size: number, startPosition: number, relativePosition: number);
-    read(buffer: Uint8Array): Promise<number>;
-    readFully(buffer: Uint8Array): Promise<void>;
-    readByte(): Promise<number>;
-    readShort(): Promise<number>;
-    readInt(): Promise<number>;
-    readLong(): Promise<number>;
+    read(buffer: Uint8Array): number;
+    readFully(buffer: Uint8Array): void;
+    readByte(): number;
+    readShort(): number;
+    readInt(): number;
+    readLong(): number;
     seek(position: number): void;
 }
 export declare class CursorIterator {
@@ -48,9 +48,15 @@ export declare class CursorIterator {
     private stack;
     private nextCursorMaybe;
     constructor(cursor: ReadCursor);
-    init(): Promise<void>;
+    static initSortedFromIndex(cursor: ReadCursor, startIndex: number): CursorIterator;
+    static initSortedFromKey(cursor: ReadCursor, startKey: Uint8Array): CursorIterator;
+    private static sortedRootPtr;
+    private static sortedStackFromIndex;
+    private static sortedStackFromKey;
+    init(): void;
+    private readSlotBlock;
     private initStack;
-    hasNext(): Promise<boolean>;
-    next(): Promise<ReadCursor | null>;
+    hasNext(): boolean;
+    next(): ReadCursor | null;
     private nextInternal;
 }