xitdb 0.1.0 → 0.2.0

package/src/exceptions.ts

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

package/src/hasher.ts

@@ -1,52 +0,0 @@
-export class Hasher {
-  readonly algorithm: string;
-  readonly id: number;
-  readonly digestLength: number;
-
-  constructor(algorithm: string, id: number = 0) {
-    this.algorithm = algorithm;
-    this.id = id;
-    // Determine digest length based on algorithm
-    switch (algorithm) {
-      case 'SHA-1':
-        this.digestLength = 20;
-        break;
-      case 'SHA-256':
-        this.digestLength = 32;
-        break;
-      case 'SHA-384':
-        this.digestLength = 48;
-        break;
-      case 'SHA-512':
-        this.digestLength = 64;
-        break;
-      default:
-        throw new Error(`Unsupported hash algorithm: ${algorithm}`);
-    }
-  }
-
-  async digest(data: Uint8Array): Promise<Uint8Array> {
-    // Create a new ArrayBuffer to ensure compatibility with crypto.subtle
-    const buffer = new ArrayBuffer(data.length);
-    const view = new Uint8Array(buffer);
-    view.set(data);
-    const hashBuffer = await crypto.subtle.digest(this.algorithm, buffer);
-    return new Uint8Array(hashBuffer);
-  }
-
-  static stringToId(hashIdName: string): number {
-    const bytes = new TextEncoder().encode(hashIdName);
-    if (bytes.length !== 4) {
-      throw new Error('Name must be exactly four bytes long');
-    }
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getInt32(0, false); // big-endian
-  }
-
-  static idToString(id: number): string {
-    const buffer = new ArrayBuffer(4);
-    const view = new DataView(buffer);
-    view.setInt32(0, id, false); // big-endian
-    return new TextDecoder().decode(new Uint8Array(buffer));
-  }
-}

package/src/index.ts

@@ -1,110 +0,0 @@
-// Tag
-export { Tag, tagValueOf } from './tag';
-
-// Slot
-export { Slot } from './slot';
-export { SlotPointer } from './slot-pointer';
-export type { Slotted } from './slotted';
-
-// Writeable Data
-export { Uint, Int, Float, Bytes, type WriteableData } from './writeable-data';
-
-// Exceptions
-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';
-
-// Core
-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';
-
-// Database
-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,
-  // PathParts
-  type PathPart,
-  ArrayListInit,
-  ArrayListGet,
-  ArrayListAppend,
-  ArrayListSlice,
-  LinkedArrayListInit,
-  LinkedArrayListGet,
-  LinkedArrayListAppend,
-  LinkedArrayListSlice,
-  LinkedArrayListConcat,
-  LinkedArrayListInsert,
-  LinkedArrayListRemove,
-  HashMapInit,
-  HashMapGet,
-  HashMapRemove,
-  WriteData,
-  Context,
-  // HashMapGetTarget
-  type HashMapGetTarget,
-  HashMapGetKVPair,
-  HashMapGetKey,
-  HashMapGetValue,
-  type ContextFunction,
-} from './database';
-
-// Cursors
-export { ReadCursor, Reader, CursorIterator, KeyValuePairCursor } from './read-cursor';
-export { WriteCursor, Writer, WriteCursorIterator, WriteKeyValuePairCursor } from './write-cursor';
-
-// Collections
-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';

package/src/read-array-list.ts

@@ -1,45 +0,0 @@
-import { Tag } from './tag';
-import { Slot } from './slot';
-import type { Slotted } from './slotted';
-import { ReadCursor, CursorIterator } from './read-cursor';
-import { ArrayListGet } from './database';
-import { UnexpectedTagException } from './exceptions';
-
-export class ReadArrayList implements Slotted {
-  public cursor: ReadCursor;
-
-  constructor(cursor: ReadCursor) {
-    switch (cursor.slotPtr.slot.tag) {
-      case Tag.NONE:
-      case Tag.ARRAY_LIST:
-        this.cursor = cursor;
-        break;
-      default:
-        throw new UnexpectedTagException();
-    }
-  }
-
-  slot(): Slot {
-    return this.cursor.slot();
-  }
-
-  async count(): Promise<number> {
-    return this.cursor.count();
-  }
-
-  iterator(): CursorIterator {
-    return this.cursor.iterator();
-  }
-
-  async *[Symbol.asyncIterator](): AsyncIterator<ReadCursor> {
-    yield* this.cursor;
-  }
-
-  async getCursor(index: number): Promise<ReadCursor | null> {
-    return this.cursor.readPath([new ArrayListGet(index)]);
-  }
-
-  async getSlot(index: number): Promise<Slot | null> {
-    return this.cursor.readPathSlot([new ArrayListGet(index)]);
-  }
-}

package/src/read-counted-hash-map.ts

@@ -1,28 +0,0 @@
-import { Tag } from './tag';
-import { ReadHashMap } from './read-hash-map';
-import { ReadCursor } from './read-cursor';
-import { UnexpectedTagException } from './exceptions';
-
-export class ReadCountedHashMap extends ReadHashMap {
-  protected constructor() {
-    super();
-  }
-
-  static override async create(cursor: ReadCursor): Promise<ReadCountedHashMap> {
-    const map = new ReadCountedHashMap();
-    switch (cursor.slotPtr.slot.tag) {
-      case Tag.NONE:
-      case Tag.COUNTED_HASH_MAP:
-      case Tag.COUNTED_HASH_SET:
-        map.cursor = cursor;
-        break;
-      default:
-        throw new UnexpectedTagException();
-    }
-    return map;
-  }
-
-  async count(): Promise<number> {
-    return this.cursor.count();
-  }
-}

package/src/read-counted-hash-set.ts

@@ -1,28 +0,0 @@
-import { Tag } from './tag';
-import { ReadHashSet } from './read-hash-set';
-import { ReadCursor } from './read-cursor';
-import { UnexpectedTagException } from './exceptions';
-
-export class ReadCountedHashSet extends ReadHashSet {
-  protected constructor() {
-    super();
-  }
-
-  static override async create(cursor: ReadCursor): Promise<ReadCountedHashSet> {
-    const set = new ReadCountedHashSet();
-    switch (cursor.slotPtr.slot.tag) {
-      case Tag.NONE:
-      case Tag.COUNTED_HASH_MAP:
-      case Tag.COUNTED_HASH_SET:
-        set.cursor = cursor;
-        break;
-      default:
-        throw new UnexpectedTagException();
-    }
-    return set;
-  }
-
-  async count(): Promise<number> {
-    return this.cursor.count();
-  }
-}