xitdb 0.11.0 → 0.13.0

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

@@ -6,9 +6,9 @@ export declare class ReadArrayList implements Slotted {
     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-counted-hash-map.d.ts

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

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

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

package/dist/read-cursor.d.ts

@@ -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,9 @@ export declare class CursorIterator {
     private stack;
     private nextCursorMaybe;
     constructor(cursor: ReadCursor);
-    init(): Promise<void>;
+    init(): void;
     private initStack;
-    hasNext(): Promise<boolean>;
-    next(): Promise<ReadCursor | null>;
+    hasNext(): boolean;
+    next(): ReadCursor | null;
     private nextInternal;
 }

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

@@ -7,22 +7,22 @@ export declare class ReadHashMap implements Slotted {
     constructor();
     constructor(cursor: ReadCursor);
     slot(): Slot;
-    iterator(): Promise<CursorIterator>;
-    [Symbol.asyncIterator](): AsyncIterator<ReadCursor>;
-    getCursor(key: string): Promise<ReadCursor | null>;
-    getCursor(key: Bytes): Promise<ReadCursor | null>;
-    getCursor(hash: Uint8Array): Promise<ReadCursor | null>;
-    getSlot(key: string): Promise<Slot | null>;
-    getSlot(key: Bytes): Promise<Slot | null>;
-    getSlot(hash: Uint8Array): Promise<Slot | null>;
-    getKeyCursor(key: string): Promise<ReadCursor | null>;
-    getKeyCursor(key: Bytes): Promise<ReadCursor | null>;
-    getKeyCursor(hash: Uint8Array): Promise<ReadCursor | null>;
-    getKeySlot(key: string): Promise<Slot | null>;
-    getKeySlot(key: Bytes): Promise<Slot | null>;
-    getKeySlot(hash: Uint8Array): Promise<Slot | null>;
-    getKeyValuePair(key: string): Promise<KeyValuePairCursor | null>;
-    getKeyValuePair(key: Bytes): Promise<KeyValuePairCursor | null>;
-    getKeyValuePair(hash: Uint8Array): Promise<KeyValuePairCursor | null>;
-    protected resolveHash(key: string | Bytes | Uint8Array): Promise<Uint8Array>;
+    iterator(): CursorIterator;
+    [Symbol.iterator](): Iterator<ReadCursor>;
+    getCursor(key: string): ReadCursor | null;
+    getCursor(key: Bytes): ReadCursor | null;
+    getCursor(hash: Uint8Array): ReadCursor | null;
+    getSlot(key: string): Slot | null;
+    getSlot(key: Bytes): Slot | null;
+    getSlot(hash: Uint8Array): Slot | null;
+    getKeyCursor(key: string): ReadCursor | null;
+    getKeyCursor(key: Bytes): ReadCursor | null;
+    getKeyCursor(hash: Uint8Array): ReadCursor | null;
+    getKeySlot(key: string): Slot | null;
+    getKeySlot(key: Bytes): Slot | null;
+    getKeySlot(hash: Uint8Array): Slot | null;
+    getKeyValuePair(key: string): KeyValuePairCursor | null;
+    getKeyValuePair(key: Bytes): KeyValuePairCursor | null;
+    getKeyValuePair(hash: Uint8Array): KeyValuePairCursor | null;
+    protected resolveHash(key: string | Bytes | Uint8Array): Uint8Array;
 }

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

@@ -7,13 +7,13 @@ export declare class ReadHashSet implements Slotted {
     constructor();
     constructor(cursor: ReadCursor);
     slot(): Slot;
-    iterator(): Promise<CursorIterator>;
-    [Symbol.asyncIterator](): AsyncIterator<ReadCursor>;
-    getCursor(key: string): Promise<ReadCursor | null>;
-    getCursor(key: Bytes): Promise<ReadCursor | null>;
-    getCursor(hash: Uint8Array): Promise<ReadCursor | null>;
-    getSlot(key: string): Promise<Slot | null>;
-    getSlot(key: Bytes): Promise<Slot | null>;
-    getSlot(hash: Uint8Array): Promise<Slot | null>;
-    protected resolveHash(key: string | Bytes | Uint8Array): Promise<Uint8Array>;
+    iterator(): CursorIterator;
+    [Symbol.iterator](): Iterator<ReadCursor>;
+    getCursor(key: string): ReadCursor | null;
+    getCursor(key: Bytes): ReadCursor | null;
+    getCursor(hash: Uint8Array): ReadCursor | null;
+    getSlot(key: string): Slot | null;
+    getSlot(key: Bytes): Slot | null;
+    getSlot(hash: Uint8Array): Slot | null;
+    protected resolveHash(key: string | Bytes | Uint8Array): Uint8Array;
 }

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

@@ -6,9 +6,9 @@ export declare class ReadLinkedArrayList implements Slotted {
     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/write-array-list.d.ts

@@ -3,14 +3,13 @@ import { WriteCursor, WriteCursorIterator } from './write-cursor';
 import { type ContextFunction } from './database';
 import type { WriteableData } from './writeable-data';
 export declare class WriteArrayList extends ReadArrayList {
-    protected constructor();
-    static create(cursor: WriteCursor): Promise<WriteArrayList>;
-    iterator(): Promise<WriteCursorIterator>;
-    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
-    put(index: number, data: WriteableData): Promise<void>;
-    putCursor(index: number): Promise<WriteCursor>;
-    append(data: WriteableData): Promise<void>;
-    appendCursor(): Promise<WriteCursor>;
-    appendContext(data: WriteableData | null, fn: ContextFunction): Promise<void>;
-    slice(size: number): Promise<void>;
+    constructor(cursor: WriteCursor);
+    iterator(): WriteCursorIterator;
+    [Symbol.iterator](): Iterator<WriteCursor>;
+    put(index: number, data: WriteableData): void;
+    putCursor(index: number): WriteCursor;
+    append(data: WriteableData): void;
+    appendCursor(): WriteCursor;
+    appendContext(data: WriteableData | null, fn: ContextFunction): void;
+    slice(size: number): void;
 }

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

@@ -1,7 +1,6 @@
 import { WriteHashMap } from './write-hash-map';
 import { WriteCursor } from './write-cursor';
 export declare class WriteCountedHashMap extends WriteHashMap {
-    protected constructor();
-    static create(cursor: WriteCursor): Promise<WriteCountedHashMap>;
-    count(): Promise<number>;
+    constructor(cursor: WriteCursor);
+    count(): number;
 }

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

@@ -1,7 +1,6 @@
 import { WriteHashSet } from './write-hash-set';
 import { WriteCursor } from './write-cursor';
 export declare class WriteCountedHashSet extends WriteHashSet {
-    protected constructor();
-    static create(cursor: WriteCursor): Promise<WriteCountedHashSet>;
-    count(): Promise<number>;
+    constructor(cursor: WriteCursor);
+    count(): number;
 }

package/dist/write-cursor.d.ts

@@ -10,13 +10,13 @@ export declare class WriteKeyValuePairCursor extends KeyValuePairCursor {
 }
 export declare class WriteCursor extends ReadCursor {
     constructor(slotPtr: SlotPointer, db: Database);
-    writePath(path: PathPart[]): Promise<WriteCursor>;
-    write(data: WriteableData | null): Promise<void>;
-    writeIfEmpty(data: WriteableData): Promise<void>;
-    readKeyValuePair(): Promise<WriteKeyValuePairCursor>;
-    writer(): Promise<Writer>;
-    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
-    iterator(): Promise<WriteCursorIterator>;
+    writePath(path: PathPart[]): WriteCursor;
+    write(data: WriteableData | null): void;
+    writeIfEmpty(data: WriteableData): void;
+    readKeyValuePair(): WriteKeyValuePairCursor;
+    writer(): Writer;
+    [Symbol.iterator](): Iterator<WriteCursor>;
+    iterator(): WriteCursorIterator;
 }
 export declare class Writer {
     parent: WriteCursor;
@@ -26,11 +26,11 @@ export declare class Writer {
     relativePosition: number;
     formatTag: Uint8Array | null;
     constructor(parent: WriteCursor, size: number, slot: Slot, startPosition: number, relativePosition: number);
-    write(buffer: Uint8Array): Promise<void>;
-    finish(): Promise<void>;
+    write(buffer: Uint8Array): void;
+    finish(): void;
     seek(position: number): void;
 }
 export declare class WriteCursorIterator extends CursorIterator {
     constructor(cursor: WriteCursor);
-    next(): Promise<WriteCursor | null>;
+    next(): WriteCursor | null;
 }

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

@@ -3,25 +3,24 @@ import { WriteCursor, WriteCursorIterator } from './write-cursor';
 import type { WriteableData } from './writeable-data';
 import { Bytes } from './writeable-data';
 export declare class WriteHashMap extends ReadHashMap {
-    protected constructor();
-    static create(cursor: WriteCursor): Promise<WriteHashMap>;
-    iterator(): Promise<WriteCursorIterator>;
-    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
-    put(key: string, data: WriteableData): Promise<void>;
-    put(key: Bytes, data: WriteableData): Promise<void>;
-    put(hash: Uint8Array, data: WriteableData): Promise<void>;
-    putCursor(key: string): Promise<WriteCursor>;
-    putCursor(key: Bytes): Promise<WriteCursor>;
-    putCursor(hash: Uint8Array): Promise<WriteCursor>;
-    putKey(key: string, data: WriteableData): Promise<void>;
-    putKey(key: Bytes, data: WriteableData): Promise<void>;
-    putKey(hash: Uint8Array, data: WriteableData): Promise<void>;
-    putKeyCursor(key: string): Promise<WriteCursor>;
-    putKeyCursor(key: Bytes): Promise<WriteCursor>;
-    putKeyCursor(hash: Uint8Array): Promise<WriteCursor>;
-    remove(key: string): Promise<boolean>;
-    remove(key: Bytes): Promise<boolean>;
-    remove(hash: Uint8Array): Promise<boolean>;
+    constructor(cursor: WriteCursor, counted?: boolean);
+    iterator(): WriteCursorIterator;
+    [Symbol.iterator](): Iterator<WriteCursor>;
+    put(key: string, data: WriteableData): void;
+    put(key: Bytes, data: WriteableData): void;
+    put(hash: Uint8Array, data: WriteableData): void;
+    putCursor(key: string): WriteCursor;
+    putCursor(key: Bytes): WriteCursor;
+    putCursor(hash: Uint8Array): WriteCursor;
+    putKey(key: string, data: WriteableData): void;
+    putKey(key: Bytes, data: WriteableData): void;
+    putKey(hash: Uint8Array, data: WriteableData): void;
+    putKeyCursor(key: string): WriteCursor;
+    putKeyCursor(key: Bytes): WriteCursor;
+    putKeyCursor(hash: Uint8Array): WriteCursor;
+    remove(key: string): boolean;
+    remove(key: Bytes): boolean;
+    remove(hash: Uint8Array): boolean;
     private putInternal;
     private putCursorInternal;
     private putKeyInternal;

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

@@ -3,19 +3,18 @@ import { WriteCursor, WriteCursorIterator } from './write-cursor';
 import type { WriteableData } from './writeable-data';
 import { Bytes } from './writeable-data';
 export declare class WriteHashSet extends ReadHashSet {
-    protected constructor();
-    static create(cursor: WriteCursor): Promise<WriteHashSet>;
-    iterator(): Promise<WriteCursorIterator>;
-    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
-    put(key: string): Promise<void>;
-    put(key: Bytes): Promise<void>;
-    put(hash: Uint8Array, data: WriteableData): Promise<void>;
-    putCursor(key: string): Promise<WriteCursor>;
-    putCursor(key: Bytes): Promise<WriteCursor>;
-    putCursor(hash: Uint8Array): Promise<WriteCursor>;
-    remove(key: string): Promise<boolean>;
-    remove(key: Bytes): Promise<boolean>;
-    remove(hash: Uint8Array): Promise<boolean>;
+    constructor(cursor: WriteCursor, counted?: boolean);
+    iterator(): WriteCursorIterator;
+    [Symbol.iterator](): Iterator<WriteCursor>;
+    put(key: string): void;
+    put(key: Bytes): void;
+    put(hash: Uint8Array, data: WriteableData): void;
+    putCursor(key: string): WriteCursor;
+    putCursor(key: Bytes): WriteCursor;
+    putCursor(hash: Uint8Array): WriteCursor;
+    remove(key: string): boolean;
+    remove(key: Bytes): boolean;
+    remove(hash: Uint8Array): boolean;
     private putInternal;
     private putCursorInternal;
 }

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

@@ -3,17 +3,16 @@ import { ReadLinkedArrayList } from './read-linked-array-list';
 import { WriteCursor, WriteCursorIterator } from './write-cursor';
 import type { WriteableData } from './writeable-data';
 export declare class WriteLinkedArrayList extends ReadLinkedArrayList {
-    protected constructor();
-    static create(cursor: WriteCursor): Promise<WriteLinkedArrayList>;
-    iterator(): Promise<WriteCursorIterator>;
-    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
-    put(index: number, data: WriteableData): Promise<void>;
-    putCursor(index: number): Promise<WriteCursor>;
-    append(data: WriteableData): Promise<void>;
-    appendCursor(): Promise<WriteCursor>;
-    slice(offset: number, size: number): Promise<void>;
-    concat(list: Slot): Promise<void>;
-    insert(index: number, data: WriteableData): Promise<void>;
-    insertCursor(index: number): Promise<WriteCursor>;
-    remove(index: number): Promise<void>;
+    constructor(cursor: WriteCursor);
+    iterator(): WriteCursorIterator;
+    [Symbol.iterator](): Iterator<WriteCursor>;
+    put(index: number, data: WriteableData): void;
+    putCursor(index: number): WriteCursor;
+    append(data: WriteableData): void;
+    appendCursor(): WriteCursor;
+    slice(offset: number, size: number): void;
+    concat(list: Slot): void;
+    insert(index: number, data: WriteableData): void;
+    insertCursor(index: number): WriteCursor;
+    remove(index: number): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xitdb",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "An immutable database",
   "license": "MIT",
   "repository": {