xitdb 0.1.0 → 0.3.0

package/src/write-hash-set.ts

@@ -1,86 +0,0 @@
-import { ReadHashSet } from './read-hash-set';
-import { WriteCursor, WriteCursorIterator } from './write-cursor';
-import { HashMapInit, HashMapGet, HashMapGetKey, HashMapRemove } from './database';
-import type { WriteableData } from './writeable-data';
-import { Bytes } from './writeable-data';
-import { KeyNotFoundException } from './exceptions';
-
-export class WriteHashSet extends ReadHashSet {
-  protected constructor() {
-    super();
-  }
-
-  static async create(cursor: WriteCursor): Promise<WriteHashSet> {
-    const set = new WriteHashSet();
-    const newCursor = await cursor.writePath([new HashMapInit(false, true)]);
-    set.cursor = newCursor;
-    return set;
-  }
-
-  override iterator(): WriteCursorIterator {
-    return (this.cursor as WriteCursor).iterator();
-  }
-
-  override async *[Symbol.asyncIterator](): AsyncIterator<WriteCursor> {
-    yield* this.cursor as WriteCursor;
-  }
-
-  // Methods that take a string key and hash it
-  async putByString(key: string): Promise<void> {
-    const bytes = new TextEncoder().encode(key);
-    const hash = await this.cursor.db.hasher.digest(bytes);
-    await this.put(hash, new Bytes(bytes));
-  }
-
-  async putCursorByString(key: string): Promise<WriteCursor> {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.putCursor(hash);
-  }
-
-  async removeByString(key: string): Promise<boolean> {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.remove(hash);
-  }
-
-  // Methods that take Bytes key and hash it
-  async putByBytes(key: Bytes): Promise<void> {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    await this.put(hash, key);
-  }
-
-  async putCursorByBytes(key: Bytes): Promise<WriteCursor> {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.putCursor(hash);
-  }
-
-  async removeByBytes(key: Bytes): Promise<boolean> {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.remove(hash);
-  }
-
-  // Methods that take hash directly
-  async put(hash: Uint8Array, data: WriteableData): Promise<void> {
-    const cursor = await (this.cursor as WriteCursor).writePath([
-      new HashMapGet(new HashMapGetKey(hash)),
-    ]);
-    await cursor.writeIfEmpty(data);
-  }
-
-  async putCursor(hash: Uint8Array): Promise<WriteCursor> {
-    return (this.cursor as WriteCursor).writePath([
-      new HashMapGet(new HashMapGetKey(hash)),
-    ]);
-  }
-
-  async remove(hash: Uint8Array): Promise<boolean> {
-    try {
-      await (this.cursor as WriteCursor).writePath([new HashMapRemove(hash)]);
-    } catch (e) {
-      if (e instanceof KeyNotFoundException) {
-        return false;
-      }
-      throw e;
-    }
-    return true;
-  }
-}

package/src/write-linked-array-list.ts

@@ -1,80 +0,0 @@
-import { Slot } from './slot';
-import { ReadLinkedArrayList } from './read-linked-array-list';
-import { WriteCursor, WriteCursorIterator } from './write-cursor';
-import {
-  LinkedArrayListInit,
-  LinkedArrayListGet,
-  LinkedArrayListAppend,
-  LinkedArrayListSlice,
-  LinkedArrayListConcat,
-  LinkedArrayListInsert,
-  LinkedArrayListRemove,
-  WriteData,
-} from './database';
-import type { WriteableData } from './writeable-data';
-
-export class WriteLinkedArrayList extends ReadLinkedArrayList {
-  constructor(cursor: WriteCursor) {
-    super(cursor);
-  }
-
-  static async create(cursor: WriteCursor): Promise<WriteLinkedArrayList> {
-    const newCursor = await cursor.writePath([new LinkedArrayListInit()]);
-    return new WriteLinkedArrayList(newCursor);
-  }
-
-  override iterator(): WriteCursorIterator {
-    return (this.cursor as WriteCursor).iterator();
-  }
-
-  override async *[Symbol.asyncIterator](): AsyncIterator<WriteCursor> {
-    yield* this.cursor as WriteCursor;
-  }
-
-  async put(index: number, data: WriteableData): Promise<void> {
-    await (this.cursor as WriteCursor).writePath([
-      new LinkedArrayListGet(index),
-      new WriteData(data),
-    ]);
-  }
-
-  async putCursor(index: number): Promise<WriteCursor> {
-    return (this.cursor as WriteCursor).writePath([new LinkedArrayListGet(index)]);
-  }
-
-  async append(data: WriteableData): Promise<void> {
-    await (this.cursor as WriteCursor).writePath([
-      new LinkedArrayListAppend(),
-      new WriteData(data),
-    ]);
-  }
-
-  async appendCursor(): Promise<WriteCursor> {
-    return (this.cursor as WriteCursor).writePath([new LinkedArrayListAppend()]);
-  }
-
-  async slice(offset: number, size: number): Promise<void> {
-    await (this.cursor as WriteCursor).writePath([
-      new LinkedArrayListSlice(offset, size),
-    ]);
-  }
-
-  async concat(list: Slot): Promise<void> {
-    await (this.cursor as WriteCursor).writePath([new LinkedArrayListConcat(list)]);
-  }
-
-  async insert(index: number, data: WriteableData): Promise<void> {
-    await (this.cursor as WriteCursor).writePath([
-      new LinkedArrayListInsert(index),
-      new WriteData(data),
-    ]);
-  }
-
-  async insertCursor(index: number): Promise<WriteCursor> {
-    return (this.cursor as WriteCursor).writePath([new LinkedArrayListInsert(index)]);
-  }
-
-  async remove(index: number): Promise<void> {
-    await (this.cursor as WriteCursor).writePath([new LinkedArrayListRemove(index)]);
-  }
-}

package/src/writeable-data.ts

@@ -1,67 +0,0 @@
-import { InvalidFormatTagSizeException } from './exceptions';
-
-export interface WriteableData {}
-
-export class Uint implements WriteableData {
-  readonly value: number;
-
-  constructor(value: number) {
-    if (value < 0) {
-      throw new Error('Uint must not be negative');
-    }
-    this.value = value;
-  }
-}
-
-export class Int implements WriteableData {
-  readonly value: number;
-
-  constructor(value: number) {
-    this.value = value;
-  }
-}
-
-export class Float implements WriteableData {
-  readonly value: number;
-
-  constructor(value: number) {
-    this.value = value;
-  }
-}
-
-export class Bytes implements WriteableData {
-  readonly value: Uint8Array;
-  readonly formatTag: Uint8Array | null;
-
-  constructor(value: Uint8Array | string, formatTag?: Uint8Array | string | null) {
-    if (typeof value === 'string') {
-      this.value = new TextEncoder().encode(value);
-    } else {
-      this.value = value;
-    }
-
-    if (formatTag === undefined || formatTag === null) {
-      this.formatTag = null;
-    } else if (typeof formatTag === 'string') {
-      const encoded = new TextEncoder().encode(formatTag);
-      if (encoded.length !== 2) {
-        throw new InvalidFormatTagSizeException();
-      }
-      this.formatTag = encoded;
-    } else {
-      if (formatTag.length !== 2) {
-        throw new InvalidFormatTagSizeException();
-      }
-      this.formatTag = formatTag;
-    }
-  }
-
-  isShort(): boolean {
-    const totalSize = this.formatTag !== null ? 6 : 8;
-    if (this.value.length > totalSize) return false;
-    for (const b of this.value) {
-      if (b === 0) return false;
-    }
-    return true;
-  }
-}