xitdb 0.12.0 → 0.14.0

package/dist/core-buffered-file.js

@@ -0,0 +1,182 @@
+import { CoreFile } from './core-file.js';
+import { CoreMemory } from './core-memory.js';
+export class CoreBufferedFile {
+    file;
+    constructor(filePath, bufferSize) {
+        this.file = new RandomAccessBufferedFile(filePath, bufferSize);
+    }
+    reader() {
+        return this.file;
+    }
+    writer() {
+        return this.file;
+    }
+    length() {
+        return this.file.length();
+    }
+    seek(pos) {
+        this.file.seek(pos);
+    }
+    position() {
+        return this.file.position();
+    }
+    setLength(len) {
+        this.file.setLength(len);
+    }
+    flush() {
+        this.file.flush();
+    }
+    sync() {
+        this.file.sync();
+    }
+    [Symbol.dispose]() {
+        this.file.file[Symbol.dispose]();
+    }
+}
+const DEFAULT_BUFFER_SIZE = 8 * 1024 * 1024; // 8MB
+class RandomAccessBufferedFile {
+    file;
+    memory;
+    bufferSize; // flushes when the memory is >= this size
+    filePos;
+    memoryPos;
+    constructor(filePath, bufferSize = DEFAULT_BUFFER_SIZE) {
+        this.file = new CoreFile(filePath);
+        this.memory = new CoreMemory();
+        this.bufferSize = bufferSize;
+        this.filePos = 0;
+        this.memoryPos = 0;
+    }
+    seek(pos) {
+        // flush if we are going past the end of the in-memory buffer
+        if (pos > this.memoryPos + this.memory.length()) {
+            this.flush();
+        }
+        this.filePos = pos;
+        // if the buffer is empty, set its position to this offset as well
+        if (this.memory.length() === 0) {
+            this.memoryPos = pos;
+        }
+    }
+    length() {
+        return Math.max(this.memoryPos + this.memory.length(), this.file.length());
+    }
+    position() {
+        return this.filePos;
+    }
+    setLength(len) {
+        this.flush();
+        this.file.setLength(len);
+        this.filePos = Math.min(len, this.filePos);
+    }
+    flush() {
+        if (this.memory.length() > 0) {
+            this.file.seek(this.memoryPos);
+            this.file.writer().write(this.memory.memory.toByteArray());
+            this.memoryPos = 0;
+            this.memory.memory.reset();
+        }
+    }
+    sync() {
+        this.flush();
+        this.file.sync();
+    }
+    // DataWriter interface
+    write(buffer) {
+        if (this.memory.length() + buffer.length > this.bufferSize) {
+            this.flush();
+        }
+        if (this.filePos >= this.memoryPos && this.filePos <= this.memoryPos + this.memory.length()) {
+            this.memory.seek(this.filePos - this.memoryPos);
+            this.memory.memory.write(buffer);
+        }
+        else {
+            // a direct disk write that overlaps the buffered region would be
+            // clobbered by a later flush of stale buffer bytes, so flush first
+            if (this.filePos < this.memoryPos + this.memory.length() && this.filePos + buffer.length > this.memoryPos) {
+                this.flush();
+            }
+            // Write directly to file
+            this.file.seek(this.filePos);
+            this.file.writer().write(buffer);
+        }
+        this.filePos += buffer.length;
+    }
+    writeByte(v) {
+        this.write(new Uint8Array([v & 0xff]));
+    }
+    writeShort(v) {
+        const buffer = new ArrayBuffer(2);
+        const view = new DataView(buffer);
+        view.setInt16(0, v & 0xffff, false); // big-endian
+        this.write(new Uint8Array(buffer));
+    }
+    writeLong(v) {
+        const buffer = new ArrayBuffer(8);
+        const view = new DataView(buffer);
+        view.setBigInt64(0, BigInt(v), false);
+        this.write(new Uint8Array(buffer));
+    }
+    // DataReader interface
+    readFully(buffer) {
+        let pos = 0;
+        // read from the disk -- before the in-memory buffer
+        if (this.filePos < this.memoryPos) {
+            const sizeBeforeMem = Math.min(this.memoryPos - this.filePos, buffer.length);
+            const tempBuffer = new Uint8Array(sizeBeforeMem);
+            this.file.seek(this.filePos);
+            this.file.reader().readFully(tempBuffer);
+            buffer.set(tempBuffer, pos);
+            pos += sizeBeforeMem;
+            this.filePos += sizeBeforeMem;
+        }
+        if (pos === buffer.length)
+            return;
+        // read from the in-memory buffer
+        if (this.filePos >= this.memoryPos && this.filePos < this.memoryPos + this.memory.length()) {
+            const memPos = this.filePos - this.memoryPos;
+            const sizeInMem = Math.min(this.memory.length() - memPos, buffer.length - pos);
+            this.memory.seek(memPos);
+            const memBuffer = new Uint8Array(sizeInMem);
+            this.memory.memory.readFully(memBuffer);
+            buffer.set(memBuffer, pos);
+            pos += sizeInMem;
+            this.filePos += sizeInMem;
+        }
+        if (pos === buffer.length)
+            return;
+        // read from the disk -- after the in-memory buffer
+        if (this.filePos >= this.memoryPos + this.memory.length()) {
+            const sizeAfterMem = buffer.length - pos;
+            const tempBuffer = new Uint8Array(sizeAfterMem);
+            this.file.seek(this.filePos);
+            this.file.reader().readFully(tempBuffer);
+            buffer.set(tempBuffer, pos);
+            pos += sizeAfterMem;
+            this.filePos += sizeAfterMem;
+        }
+    }
+    readByte() {
+        const bytes = new Uint8Array(1);
+        this.readFully(bytes);
+        return bytes[0];
+    }
+    readShort() {
+        const bytes = new Uint8Array(2);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getInt16(0, false); // big-endian
+    }
+    readInt() {
+        const bytes = new Uint8Array(4);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getInt32(0, false); // big-endian
+    }
+    readLong() {
+        const bytes = new Uint8Array(8);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return Number(view.getBigInt64(0, false));
+    }
+}

package/dist/core-file.d.ts

@@ -1,18 +1,16 @@
-import type { Core, DataReader, DataWriter } from './core';
-import type { FileHandle } from 'fs/promises';
+import type { Core, DataReader, DataWriter } from './core.js';
 export declare class CoreFile implements Core {
     filePath: string;
     private _position;
-    fileHandle: FileHandle;
-    private constructor();
-    static create(filePath: string): Promise<CoreFile>;
+    fd: number;
+    constructor(filePath: string);
     reader(): DataReader;
     writer(): DataWriter;
-    length(): Promise<number>;
-    seek(pos: number): Promise<void>;
+    length(): number;
+    seek(pos: number): void;
     position(): number;
-    setLength(len: number): Promise<void>;
-    flush(): Promise<void>;
-    sync(): Promise<void>;
+    setLength(len: number): void;
+    flush(): void;
+    sync(): void;
     [Symbol.dispose](): void;
 }

package/dist/core-file.js

@@ -0,0 +1,105 @@
+import * as fs from 'fs';
+export class CoreFile {
+    filePath;
+    _position = 0;
+    fd;
+    constructor(filePath) {
+        this.filePath = filePath;
+        // Create file if it doesn't exist
+        try {
+            fs.accessSync(filePath);
+        }
+        catch {
+            fs.writeFileSync(filePath, new Uint8Array(0));
+        }
+        // Open file for reading and writing
+        this.fd = fs.openSync(filePath, 'r+');
+    }
+    reader() {
+        return new FileDataReader(this);
+    }
+    writer() {
+        return new FileDataWriter(this);
+    }
+    length() {
+        const stats = fs.fstatSync(this.fd);
+        return stats.size;
+    }
+    seek(pos) {
+        this._position = pos;
+    }
+    position() {
+        return this._position;
+    }
+    setLength(len) {
+        fs.ftruncateSync(this.fd, len);
+    }
+    flush() {
+    }
+    sync() {
+        fs.fsyncSync(this.fd);
+    }
+    [Symbol.dispose]() {
+        fs.closeSync(this.fd);
+    }
+}
+class FileDataReader {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    readFully(b) {
+        const position = this.core.position();
+        fs.readSync(this.core.fd, b, 0, b.length, position);
+        this.core.seek(position + b.length);
+    }
+    readByte() {
+        const bytes = new Uint8Array(1);
+        this.readFully(bytes);
+        return bytes[0];
+    }
+    readShort() {
+        const bytes = new Uint8Array(2);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getInt16(0, false);
+    }
+    readInt() {
+        const bytes = new Uint8Array(4);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getInt32(0, false);
+    }
+    readLong() {
+        const bytes = new Uint8Array(8);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return Number(view.getBigInt64(0, false));
+    }
+}
+class FileDataWriter {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    write(buffer) {
+        const position = this.core.position();
+        fs.writeSync(this.core.fd, buffer, 0, buffer.length, position);
+        this.core.seek(position + buffer.length);
+    }
+    writeByte(v) {
+        this.write(new Uint8Array([v & 0xff]));
+    }
+    writeShort(v) {
+        const buffer = new ArrayBuffer(2);
+        const view = new DataView(buffer);
+        view.setInt16(0, v, false);
+        this.write(new Uint8Array(buffer));
+    }
+    writeLong(v) {
+        const buffer = new ArrayBuffer(8);
+        const view = new DataView(buffer);
+        view.setBigInt64(0, BigInt(v), false);
+        this.write(new Uint8Array(buffer));
+    }
+}

package/dist/core-memory.d.ts

@@ -1,15 +1,15 @@
-import type { Core, DataReader, DataWriter } from './core';
+import type { Core, DataReader, DataWriter } from './core.js';
 export declare class CoreMemory implements Core {
     memory: RandomAccessMemory;
     constructor();
     reader(): DataReader;
     writer(): DataWriter;
-    length(): Promise<number>;
-    seek(pos: number): Promise<void>;
+    length(): number;
+    seek(pos: number): void;
     position(): number;
-    setLength(len: number): Promise<void>;
-    flush(): Promise<void>;
-    sync(): Promise<void>;
+    setLength(len: number): void;
+    flush(): void;
+    sync(): void;
 }
 declare class RandomAccessMemory implements DataReader, DataWriter {
     private buffer;
@@ -23,14 +23,14 @@ declare class RandomAccessMemory implements DataReader, DataWriter {
     setLength(len: number): void;
     reset(): void;
     toByteArray(): Uint8Array;
-    write(data: Uint8Array): Promise<void>;
-    writeByte(v: number): Promise<void>;
-    writeShort(v: number): Promise<void>;
-    writeLong(v: number): Promise<void>;
-    readFully(b: Uint8Array): Promise<void>;
-    readByte(): Promise<number>;
-    readShort(): Promise<number>;
-    readInt(): Promise<number>;
-    readLong(): Promise<number>;
+    write(data: Uint8Array): void;
+    writeByte(v: number): void;
+    writeShort(v: number): void;
+    writeLong(v: number): void;
+    readFully(b: Uint8Array): void;
+    readByte(): number;
+    readShort(): number;
+    readInt(): number;
+    readLong(): number;
 }
 export {};

package/dist/core-memory.js

@@ -0,0 +1,152 @@
+export class CoreMemory {
+    memory;
+    constructor() {
+        this.memory = new RandomAccessMemory();
+    }
+    reader() {
+        return this.memory;
+    }
+    writer() {
+        return this.memory;
+    }
+    length() {
+        return this.memory.size();
+    }
+    seek(pos) {
+        this.memory.seek(pos);
+    }
+    position() {
+        return this.memory.getPosition();
+    }
+    setLength(len) {
+        this.memory.setLength(len);
+    }
+    flush() {
+        // no-op for in-memory
+    }
+    sync() {
+        // no-op for in-memory
+    }
+}
+class RandomAccessMemory {
+    buffer;
+    _position = 0;
+    _count = 0;
+    constructor(initialSize = 1024) {
+        this.buffer = new Uint8Array(initialSize);
+    }
+    ensureCapacity(minCapacity) {
+        if (minCapacity > this.buffer.length) {
+            let newCapacity = this.buffer.length * 2;
+            if (newCapacity < minCapacity) {
+                newCapacity = minCapacity;
+            }
+            const newBuffer = new Uint8Array(newCapacity);
+            newBuffer.set(this.buffer.subarray(0, this._count));
+            this.buffer = newBuffer;
+        }
+    }
+    size() {
+        return this._count;
+    }
+    seek(pos) {
+        if (pos > this._count) {
+            this._position = this._count;
+        }
+        else {
+            this._position = pos;
+        }
+    }
+    getPosition() {
+        return this._position;
+    }
+    setLength(len) {
+        if (len === 0) {
+            this.reset();
+        }
+        else {
+            if (len > this._count)
+                throw new Error('Cannot extend length');
+            this._count = len;
+            if (this._position > len) {
+                this._position = len;
+            }
+        }
+    }
+    reset() {
+        this._count = 0;
+        this._position = 0;
+    }
+    toByteArray() {
+        return this.buffer.slice(0, this._count);
+    }
+    // DataWriter interface
+    write(data) {
+        const pos = this._position;
+        if (pos < this._count) {
+            const bytesBeforeEnd = Math.min(data.length, this._count - pos);
+            for (let i = 0; i < bytesBeforeEnd; i++) {
+                this.buffer[pos + i] = data[i];
+            }
+            if (bytesBeforeEnd < data.length) {
+                const bytesAfterEnd = data.length - bytesBeforeEnd;
+                this.ensureCapacity(this._count + bytesAfterEnd);
+                this.buffer.set(data.subarray(bytesBeforeEnd), this._count);
+                this._count += bytesAfterEnd;
+            }
+        }
+        else {
+            this.ensureCapacity(this._count + data.length);
+            this.buffer.set(data, this._count);
+            this._count += data.length;
+        }
+        this._position = pos + data.length;
+    }
+    writeByte(v) {
+        this.write(new Uint8Array([v & 0xff]));
+    }
+    writeShort(v) {
+        const buffer = new ArrayBuffer(2);
+        const view = new DataView(buffer);
+        view.setInt16(0, v, false); // big-endian
+        this.write(new Uint8Array(buffer));
+    }
+    writeLong(v) {
+        const buffer = new ArrayBuffer(8);
+        const view = new DataView(buffer);
+        view.setBigInt64(0, BigInt(v), false);
+        this.write(new Uint8Array(buffer));
+    }
+    // DataReader interface
+    readFully(b) {
+        const pos = this._position;
+        if (pos + b.length > this._count) {
+            throw new Error('End of stream');
+        }
+        b.set(this.buffer.subarray(pos, pos + b.length));
+        this._position = pos + b.length;
+    }
+    readByte() {
+        const bytes = new Uint8Array(1);
+        this.readFully(bytes);
+        return bytes[0];
+    }
+    readShort() {
+        const bytes = new Uint8Array(2);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getInt16(0, false); // big-endian
+    }
+    readInt() {
+        const bytes = new Uint8Array(4);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getInt32(0, false); // big-endian
+    }
+    readLong() {
+        const bytes = new Uint8Array(8);
+        this.readFully(bytes);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return Number(view.getBigInt64(0, false));
+    }
+}

package/dist/core.d.ts

@@ -1,23 +1,23 @@
 export interface DataReader {
-    readFully(buffer: Uint8Array): Promise<void>;
-    readByte(): Promise<number>;
-    readShort(): Promise<number>;
-    readInt(): Promise<number>;
-    readLong(): Promise<number>;
+    readFully(buffer: Uint8Array): void;
+    readByte(): number;
+    readShort(): number;
+    readInt(): number;
+    readLong(): number;
 }
 export interface DataWriter {
-    write(buffer: Uint8Array): Promise<void>;
-    writeByte(v: number): Promise<void>;
-    writeShort(v: number): Promise<void>;
-    writeLong(v: number): Promise<void>;
+    write(buffer: Uint8Array): void;
+    writeByte(v: number): void;
+    writeShort(v: number): void;
+    writeLong(v: number): void;
 }
 export interface Core {
     reader(): DataReader;
     writer(): DataWriter;
-    length(): Promise<number>;
-    seek(pos: number): Promise<void>;
+    length(): number;
+    seek(pos: number): void;
     position(): number;
-    setLength(len: number): Promise<void>;
-    flush(): Promise<void>;
-    sync(): Promise<void>;
+    setLength(len: number): void;
+    flush(): void;
+    sync(): void;
 }

package/dist/core.js

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