sliftutils 1.1.41 → 1.1.43

package/index.d.ts

@@ -715,6 +715,7 @@ declare module "sliftutils/render-utils/colors" {
 }
 
 declare module "sliftutils/render-utils/mobxTyped" {
+    export { observable, runInAction, computed, autorun } from "mobx";
     export declare function configureMobxNextFrameScheduler(): void;
 
 }
@@ -761,6 +762,176 @@ declare module "sliftutils/render-utils/observer" {
 
 }
 
+declare module "sliftutils/storage/BulkDatabase2/BulkDatabase2" {
+    export declare class BulkDatabase2<T extends {
+        key: string;
+    }> {
+        readonly name: string;
+        constructor(name: string);
+        static clearCache(): void;
+        private storage;
+        private overlay;
+        private streamTimes;
+        private loadVersion;
+        private streamFileName;
+        private streamRowsWritten;
+        private getStreamFileName;
+        private reader;
+        private syncSetup;
+        private localTime;
+        private applyRemote;
+        private resetReader;
+        write(entry: T): Promise<void>;
+        writeBatch(entries: T[]): Promise<void>;
+        delete(key: string): Promise<void>;
+        deleteBatch(keys: string[]): Promise<void>;
+        private writeBulkFile;
+        private listStreamFiles;
+        private loadStreamEntries;
+        private orderStreamEntries;
+        private maybeRolloverStream;
+        private rolloverStream;
+        compact(): Promise<void>;
+        private listFiles;
+        private loadFileReader;
+        private handleUnreadableFile;
+        private mergeFiles;
+        private formatInfo;
+        private patchColumn;
+        getSingleField<Column extends keyof T>(key: string, column: Column): Promise<T[Column] | undefined>;
+        getColumn<Column extends keyof T>(column: Column): Promise<{
+            key: string;
+            value: T[Column];
+        }[]>;
+        getKeys(): Promise<string[]>;
+        private baseColumns;
+        private baseColumnsLoading;
+        private baseFields;
+        private baseFieldsLoading;
+        private ensureBaseColumn;
+        private ensureBaseField;
+        getSingleFieldSync<Column extends keyof T>(config: {
+            key: string;
+            column: Column;
+        }): T[Column] | undefined;
+        getColumnSync<Column extends keyof T>(column: Column): {
+            key: string;
+            value: T[Column];
+        }[] | undefined;
+        getColumnInfo(): Promise<{
+            column: string;
+            byteSize: number;
+        }[]>;
+        getReaderInfo(): Promise<{
+            rowCount: number;
+            totalBytes: number;
+            keyCount: number;
+            sampleKey: string | undefined;
+            columns: {
+                column: string;
+                byteSize: number;
+            }[];
+        }>;
+    }
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/BulkDatabaseFormat" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    export declare const KEY_COLUMN = "key";
+    export declare const EMPTY_BUFFER: Buffer;
+    export declare function buildFileBuffer(rows: Record<string, unknown>[]): Buffer;
+    export type BaseBulkDatabaseReader = {
+        rowCount: number;
+        totalBytes: number;
+        keys: string[];
+        columns: {
+            column: string;
+            byteSize: number;
+        }[];
+        deletedKeys?: Set<string>;
+        getColumn: (column: string) => Promise<{
+            key: string;
+            value: unknown;
+        }[]>;
+        getSingleField: (key: string, column: string) => Promise<unknown | undefined>;
+    };
+    export declare function loadBulkDatabase(config: {
+        totalBytes: number;
+        getRange: (start: number, end: number) => Promise<Buffer>;
+    }): Promise<BaseBulkDatabaseReader>;
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/blockCache" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    export type GetRange = (start: number, end: number) => Promise<Buffer>;
+    export declare function encodeCompressedBlocks(data: Buffer): Buffer;
+    export declare class BlockCache {
+        private blocks;
+        private indexes;
+        clear(): void;
+        private touch;
+        private readIndex;
+        open(fileId: string, fileSize: number, rawGetRange: GetRange): Promise<{
+            uncompressedSize: number;
+            getRange: GetRange;
+        }>;
+        private makeGetRange;
+    }
+    export declare const blockCache: BlockCache;
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/streamLog" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { BaseBulkDatabaseReader } from "./BulkDatabaseFormat";
+    export declare const STREAM_EXTENSION = ".stream";
+    export type StreamEntry = {
+        time: number;
+        row?: Record<string, unknown>;
+        deletedKey?: string;
+    };
+    export declare function frameRows(entries: {
+        time: number;
+        row: Record<string, unknown>;
+    }[]): Buffer;
+    export declare function frameDeletes(entries: {
+        time: number;
+        key: string;
+    }[]): Buffer;
+    export declare function parseStream(buffer: Buffer): {
+        entries: StreamEntry[];
+        badBytes: number;
+    };
+    export declare function streamReaderFromEntries(entries: StreamEntry[], totalBytes: number): {
+        reader: BaseBulkDatabaseReader;
+        times: Map<string, number>;
+    };
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/syncClient" {
+    export type RemoteWrite = {
+        key: string;
+        time: number;
+        deleted?: boolean;
+        value?: unknown;
+    };
+    export declare function isSyncSupported(): boolean;
+    export declare function connect(collection: string, onWrite: (write: RemoteWrite) => void): Promise<RemoteWrite[]>;
+    export declare function broadcast(collection: string, write: RemoteWrite): void;
+
+}
+
+declare module "sliftutils/storage/BulkDatabase2/syncWorker" {
+    export {};
+
+}
+
 declare module "sliftutils/storage/CBORStorage" {
     /// <reference types="node" />
     /// <reference types="node" />
@@ -987,6 +1158,52 @@ declare module "sliftutils/storage/FileFolderAPI" {
         ]>;
     };
     export declare function setFileAPIKey(key: string): void;
+    export declare class NodeJSFileHandleWrapper implements FileWrapper {
+        private filePath;
+        constructor(filePath: string);
+        getFile(): Promise<{
+            size: number;
+            lastModified: number;
+            arrayBuffer: () => Promise<ArrayBuffer>;
+            slice: (start: number, end: number) => {
+                arrayBuffer: () => Promise<ArrayBuffer>;
+            };
+        }>;
+        createWritable(config?: {
+            keepExistingData?: boolean;
+        }): Promise<{
+            seek: (offset: number) => Promise<void>;
+            write: (value: Buffer) => Promise<void>;
+            close: () => Promise<void>;
+        }>;
+    }
+    export declare class NodeJSDirectoryHandleWrapper implements DirectoryWrapper {
+        private rootPath;
+        constructor(rootPath: string);
+        removeEntry(key: string, options?: {
+            recursive?: boolean;
+        }): Promise<void>;
+        getFileHandle(key: string, options?: {
+            create?: boolean;
+        }): Promise<FileWrapper>;
+        getDirectoryHandle(key: string, options?: {
+            create?: boolean;
+        }): Promise<DirectoryWrapper>;
+        [Symbol.asyncIterator](): AsyncIterableIterator<[
+            string,
+            {
+                kind: "file";
+                name: string;
+                getFile(): Promise<FileWrapper>;
+            } | {
+                kind: "directory";
+                name: string;
+                getDirectoryHandle(key: string, options?: {
+                    create?: boolean;
+                }): Promise<DirectoryWrapper>;
+            }
+        ]>;
+    }
     export declare const getDirectoryHandle: {
         (): Promise<DirectoryWrapper>;
         reset(): void;
@@ -1015,6 +1232,8 @@ declare module "sliftutils/storage/FileFolderAPI" {
     export type FileStorage = IStorageRaw & {
         folder: NestedFileStorage;
     };
+    export declare function wrapHandle(handle: DirectoryWrapper): FileStorage;
+    export declare function tryToLoadPointer(pointer: string): Promise<DirectoryWrapper | undefined>;
     export {};
 
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.1.41",
+    "version": "1.1.43",
     "main": "index.js",
     "license": "MIT",
     "files": [
@@ -51,7 +51,7 @@
         "mobx": "^6.13.3",
         "preact-old-types": "^10.28.1",
         "shell-quote": "^1.8.3",
-        "socket-function": "^1.1.30",
+        "socket-function": "^1.1.38",
         "typenode": "*",
         "typesafecss": "*",
         "ws": "^8.18.3",

package/render-utils/mobxTyped.d.ts

@@ -1 +1,2 @@
+export { observable, runInAction, computed, autorun } from "mobx";
 export declare function configureMobxNextFrameScheduler(): void;

package/render-utils/mobxTyped.ts

@@ -1,5 +1,9 @@
 import * as mobx from "mobx";
 import { batchFunction } from "socket-function/src/batching";
+
+// Re-export the core mobx primitives so downstream packages (which may have their own duplicate mobx
+// in node_modules) can share THIS mobx instance, otherwise reactivity doesn't cross package boundaries.
+export { observable, runInAction, computed, autorun } from "mobx";
 export function configureMobxNextFrameScheduler() {
     // NOTE: This makes a big difference if we do await calls in a loop which mutates observable state. BUT... we should probably just do those await calls before the loop?
     let batchReactionScheduler = batchFunction({

package/storage/BulkDatabase2/BulkDatabase2.d.ts

@@ -0,0 +1,70 @@
+export declare class BulkDatabase2<T extends {
+    key: string;
+}> {
+    readonly name: string;
+    constructor(name: string);
+    static clearCache(): void;
+    private storage;
+    private overlay;
+    private streamTimes;
+    private loadVersion;
+    private streamFileName;
+    private streamRowsWritten;
+    private getStreamFileName;
+    private reader;
+    private syncSetup;
+    private localTime;
+    private applyRemote;
+    private resetReader;
+    write(entry: T): Promise<void>;
+    writeBatch(entries: T[]): Promise<void>;
+    delete(key: string): Promise<void>;
+    deleteBatch(keys: string[]): Promise<void>;
+    private writeBulkFile;
+    private listStreamFiles;
+    private loadStreamEntries;
+    private orderStreamEntries;
+    private maybeRolloverStream;
+    private rolloverStream;
+    compact(): Promise<void>;
+    private listFiles;
+    private loadFileReader;
+    private handleUnreadableFile;
+    private mergeFiles;
+    private formatInfo;
+    private patchColumn;
+    getSingleField<Column extends keyof T>(key: string, column: Column): Promise<T[Column] | undefined>;
+    getColumn<Column extends keyof T>(column: Column): Promise<{
+        key: string;
+        value: T[Column];
+    }[]>;
+    getKeys(): Promise<string[]>;
+    private baseColumns;
+    private baseColumnsLoading;
+    private baseFields;
+    private baseFieldsLoading;
+    private ensureBaseColumn;
+    private ensureBaseField;
+    getSingleFieldSync<Column extends keyof T>(config: {
+        key: string;
+        column: Column;
+    }): T[Column] | undefined;
+    getColumnSync<Column extends keyof T>(column: Column): {
+        key: string;
+        value: T[Column];
+    }[] | undefined;
+    getColumnInfo(): Promise<{
+        column: string;
+        byteSize: number;
+    }[]>;
+    getReaderInfo(): Promise<{
+        rowCount: number;
+        totalBytes: number;
+        keyCount: number;
+        sampleKey: string | undefined;
+        columns: {
+            column: string;
+            byteSize: number;
+        }[];
+    }>;
+}