sliftutils 0.11.0 → 0.12.0

package/builders/dist/generateIndexDts.ts.cache

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const FOLDERS_TO_INCLUDE = ["render-utils", "misc"];
+const FOLDERS_TO_INCLUDE = ["render-utils", "misc", "storage"];
 function getAllDtsFiles(dir, fileList = []) {
     const files = fs.readdirSync(dir);
     for (const file of files) {
@@ -70,5 +70,5 @@ function generateIndexDts() {
     console.log(`Generated ${outputPath} with ${allModules.length} module declarations`);
 }
 generateIndexDts();
-//# sourceMappingURL=data:application/json;base64,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
- /* _JS_SOURCE_HASH = "7aa0476717e0d99e8ee6eb241bcad9def77971b4a515d5c677dcfe761fb019dc"; */
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "396b7ba67cc84f07dc98f22fe7d79e8fe6b153ca5bc3146e063afd6fc30913cf"; */

package/builders/generateIndexDts.ts

@@ -1,7 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 
-const FOLDERS_TO_INCLUDE = ["render-utils", "misc"];
+const FOLDERS_TO_INCLUDE = ["render-utils", "misc", "storage"];
 
 function getAllDtsFiles(dir: string, fileList: string[] = []): string[] {
     const files = fs.readdirSync(dir);

package/index.d.ts

@@ -376,3 +376,481 @@ declare module "sliftutils/render-utils/observer" {
     } & T;
 
 }
+
+declare module "sliftutils/storage/CachedStorage" {
+    import { StorageSync } from "./StorageObservable";
+    export declare function newCachedStrStorage<T>(folder: string, getValue: (key: string) => Promise<T>): StorageSync<T>;
+
+}
+
+declare module "sliftutils/storage/DelayedStorage" {
+    import { IStorage } from "./IStorage";
+    export declare class DelayedStorage<T> implements IStorage<T> {
+        private storage;
+        constructor(storage: Promise<IStorage<T>>);
+        get(key: string): Promise<T | undefined>;
+        set(key: string, value: T): Promise<void>;
+        remove(key: string): Promise<void>;
+        getKeys(): Promise<string[]>;
+        getInfo(key: string): Promise<{
+            size: number;
+            lastModified: number;
+        } | undefined>;
+        reset(): Promise<void>;
+    }
+
+}
+
+declare module "sliftutils/storage/DiskCollection" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IStorage, IStorageSync } from "./IStorage";
+    import { StorageSync } from "./StorageObservable";
+    import { TransactionStorage } from "./TransactionStorage";
+    export declare class DiskCollection<T> implements IStorageSync<T> {
+        private collectionName;
+        private writeDelay?;
+        constructor(collectionName: string, writeDelay?: number | undefined);
+        transactionStorage: TransactionStorage | undefined;
+        initStorage(): Promise<IStorage<T>>;
+        baseStorage: Promise<IStorage<T>>;
+        private synced;
+        get(key: string): T | undefined;
+        getPromise(key: string): Promise<T | undefined>;
+        set(key: string, value: T): void;
+        remove(key: string): void;
+        getKeys(): string[];
+        getKeysPromise(): Promise<string[]>;
+        getEntries(): [string, T][];
+        getValues(): T[];
+        getValuesPromise(): Promise<T[]>;
+        getInfo(key: string): {
+            size: number;
+            lastModified: number;
+        } | undefined;
+        reset(): Promise<void>;
+    }
+    export declare class DiskCollectionBrowser<T> implements IStorageSync<T> {
+        private collectionName;
+        private writeDelay?;
+        constructor(collectionName: string, writeDelay?: number | undefined);
+        transactionStorage: TransactionStorage | undefined;
+        initStorage(): Promise<IStorage<T>>;
+        baseStorage: Promise<IStorage<T>>;
+        private synced;
+        get(key: string): T | undefined;
+        getPromise(key: string): Promise<T | undefined>;
+        set(key: string, value: T): void;
+        remove(key: string): void;
+        getKeys(): string[];
+        getKeysPromise(): Promise<string[]>;
+        getEntries(): [string, T][];
+        getValues(): T[];
+        getValuesPromise(): Promise<T[]>;
+        getInfo(key: string): {
+            size: number;
+            lastModified: number;
+        } | undefined;
+        reset(): Promise<void>;
+    }
+    export declare class DiskCollectionPromise<T> implements IStorage<T> {
+        private collectionName;
+        private writeDelay?;
+        constructor(collectionName: string, writeDelay?: number | undefined);
+        initStorage(): Promise<IStorage<T>>;
+        private synced;
+        get(key: string): Promise<T | undefined>;
+        set(key: string, value: T): Promise<void>;
+        remove(key: string): Promise<void>;
+        getKeys(): Promise<string[]>;
+        getInfo(key: string): Promise<{
+            size: number;
+            lastModified: number;
+        } | undefined>;
+        reset(): Promise<void>;
+    }
+    export declare class DiskCollectionRaw implements IStorage<Buffer> {
+        private collectionName;
+        constructor(collectionName: string);
+        initStorage(): Promise<IStorage<Buffer>>;
+        private synced;
+        get(key: string): Promise<Buffer | undefined>;
+        set(key: string, value: Buffer): Promise<void>;
+        remove(key: string): Promise<void>;
+        getKeys(): Promise<string[]>;
+        getInfo(key: string): Promise<{
+            size: number;
+            lastModified: number;
+        } | undefined>;
+        reset(): Promise<void>;
+    }
+    export declare class DiskCollectionRawBrowser {
+        private collectionName;
+        constructor(collectionName: string);
+        initStorage(): Promise<IStorage<Buffer>>;
+        private synced;
+        get(key: string): Buffer | undefined;
+        getPromise(key: string): Promise<Buffer | undefined>;
+        set(key: string, value: Buffer): void;
+        getKeys(): Promise<string[]>;
+        getInfo(key: string): Promise<{
+            size: number;
+            lastModified: number;
+        } | undefined>;
+        reset(): Promise<void>;
+    }
+    export declare function newFileStorageBufferSyncer(folder?: string): StorageSync<Buffer>;
+    export declare function newFileStorageJSONSyncer<T>(folder?: string): StorageSync<T>;
+
+}
+
+declare module "sliftutils/storage/FileFolderAPI" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IStorageRaw } from "./IStorage";
+    type FileWrapper = {
+        getFile(): Promise<{
+            size: number;
+            lastModified: number;
+            arrayBuffer(): Promise<ArrayBuffer>;
+        }>;
+        createWritable(config?: {
+            keepExistingData?: boolean;
+        }): Promise<{
+            seek(offset: number): Promise<void>;
+            write(value: Buffer): Promise<void>;
+            close(): Promise<void>;
+        }>;
+    };
+    type DirectoryWrapper = {
+        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;
+        set(newValue: Promise<DirectoryWrapper>): void;
+    };
+    export declare const getFileStorageNested: {
+        (key: string): Promise<FileStorage>;
+        clear(key: string): void;
+        clearAll(): void;
+        forceSet(key: string, value: Promise<FileStorage>): void;
+        getAllKeys(): string[];
+        get(key: string): Promise<FileStorage> | undefined;
+    };
+    export declare const getFileStorage: {
+        (): Promise<FileStorage>;
+        reset(): void;
+        set(newValue: Promise<FileStorage>): void;
+    };
+    export declare function resetStorageLocation(): void;
+    export type NestedFileStorage = {
+        hasKey(key: string): Promise<boolean>;
+        getStorage(key: string): Promise<FileStorage>;
+        removeStorage(key: string): Promise<void>;
+        getKeys(): Promise<string[]>;
+    };
+    export type FileStorage = IStorageRaw & {
+        folder: NestedFileStorage;
+    };
+    export {};
+
+}
+
+declare module "sliftutils/storage/IStorage" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    export type IStorageSync<T> = {
+        get(key: string): T | undefined;
+        set(key: string, value: T): void;
+        remove(key: string): void;
+        getKeys(): string[];
+        getValues(): T[];
+        getEntries(): [string, T][];
+        getInfo(key: string): {
+            size: number;
+            lastModified: number;
+        } | undefined;
+        reset(): Promise<void>;
+    };
+    export type IStorage<T> = {
+        get(key: string): Promise<T | undefined>;
+        set(key: string, value: T): Promise<void>;
+        remove(key: string): Promise<void>;
+        getKeys(): Promise<string[]>;
+        getInfo(key: string): Promise<undefined | {
+            size: number;
+            lastModified: number;
+        }>;
+        reset(): Promise<void>;
+    };
+    export type IStorageRaw = {
+        get(key: string): Promise<Buffer | undefined>;
+        append(key: string, value: Buffer): Promise<void>;
+        set(key: string, value: Buffer): Promise<void>;
+        remove(key: string): Promise<void>;
+        getKeys(): Promise<string[]>;
+        getInfo(key: string): Promise<undefined | {
+            size: number;
+            lastModified: number;
+        }>;
+        reset(): Promise<void>;
+    };
+
+}
+
+declare module "sliftutils/storage/IndexedDBFileFolderAPI" {
+    import { FileStorage } from "./FileFolderAPI";
+    export declare const getFileStorageIndexDB: {
+        (): Promise<FileStorage>;
+        reset(): void;
+        set(newValue: Promise<FileStorage>): void;
+    };
+
+}
+
+declare module "sliftutils/storage/JSONStorage" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IStorage } from "./IStorage";
+    export declare class JSONStorage<T> implements IStorage<T> {
+        private storage;
+        constructor(storage: IStorage<Buffer>);
+        get(key: string): Promise<T | undefined>;
+        set(key: string, value: T): Promise<void>;
+        remove(key: string): Promise<void>;
+        getKeys(): Promise<string[]>;
+        getInfo(key: string): Promise<{
+            size: number;
+            lastModified: number;
+        } | undefined>;
+        reset(): Promise<void>;
+    }
+
+}
+
+declare module "sliftutils/storage/PendingManager" {
+    import preact from "preact";
+    export declare function setPending(group: string, message: string): void;
+    export declare function hasPending(): boolean;
+    export declare class PendingDisplay extends preact.Component {
+        render(): preact.JSX.Element;
+    }
+
+}
+
+declare module "sliftutils/storage/PendingStorage" {
+    import { IStorage } from "./IStorage";
+    export declare class PendingStorage<T> implements IStorage<T> {
+        private pendingGroup;
+        private storage;
+        pending: Map<string, number>;
+        constructor(pendingGroup: string, storage: IStorage<T>);
+        get(key: string): Promise<T | undefined>;
+        set(key: string, value: T): Promise<void>;
+        remove(key: string): Promise<void>;
+        getKeys(): Promise<string[]>;
+        getInfo(key: string): Promise<{
+            size: number;
+            lastModified: number;
+        } | undefined>;
+        private watchPending;
+        private updatePending;
+        reset(): Promise<void>;
+    }
+
+}
+
+declare module "sliftutils/storage/PrivateFileSystemStorage" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IStorageRaw } from "./IStorage";
+    export declare class PrivateFileSystemStorage implements IStorageRaw {
+        private path;
+        private rootHandle;
+        constructor(path: string);
+        private ensureInitialized;
+        private directoryExists;
+        private getDirectoryHandle;
+        private getFileHandle;
+        private fileExists;
+        get(key: string): Promise<Buffer | undefined>;
+        set(key: string, value: Buffer): Promise<void>;
+        append(key: string, value: Buffer): Promise<void>;
+        remove(key: string): Promise<void>;
+        getKeys(): Promise<string[]>;
+        getInfo(key: string): Promise<undefined | {
+            size: number;
+            lastModified: number;
+        }>;
+        reset(): Promise<void>;
+    }
+
+}
+
+declare module "sliftutils/storage/StorageObservable" {
+    import { IStorage, IStorageSync } from "./IStorage";
+    export declare class StorageSync<T> implements IStorageSync<T> {
+        storage: IStorage<T>;
+        cached: import("mobx").ObservableMap<string, T | undefined>;
+        infoCached: import("mobx").ObservableMap<string, {
+            size: number;
+            lastModified: number;
+        } | undefined>;
+        keys: Set<string>;
+        synced: {
+            keySeqNum: number;
+        };
+        constructor(storage: IStorage<T>);
+        get(key: string): T | undefined;
+        set(key: string, value: T): void;
+        remove(key: string): void;
+        private loadedKeys;
+        getKeys(): string[];
+        getInfo(key: string): {
+            size: number;
+            lastModified: number;
+        } | undefined;
+        getValues(): T[];
+        getEntries(): [string, T][];
+        getPromise(key: string): Promise<T | undefined>;
+        private pendingGetKeys;
+        getKeysPromise(): Promise<string[]>;
+        reload(): void;
+        reloadKeys(): void;
+        reloadKey(key: string): void;
+        reset(): Promise<void>;
+    }
+
+}
+
+declare module "sliftutils/storage/TransactionStorage" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IStorage, IStorageRaw } from "./IStorage";
+    interface TransactionEntry {
+        key: string;
+        value: Buffer | undefined;
+        isZipped: boolean;
+        time: number;
+    }
+    export declare class TransactionStorage implements IStorage<Buffer> {
+        private rawStorage;
+        private debugName;
+        private writeDelay;
+        cache: Map<string, TransactionEntry>;
+        private currentChunk;
+        private currentChunkSize;
+        private entryCount;
+        private static allStorage;
+        constructor(rawStorage: IStorageRaw, debugName: string, writeDelay?: number);
+        static compressAll(): Promise<void>;
+        private init;
+        private getChunk;
+        get(key: string): Promise<Buffer | undefined>;
+        set(key: string, value: Buffer): Promise<void>;
+        remove(key: string): Promise<void>;
+        getInfo(key: string): Promise<{
+            size: number;
+            lastModified: number;
+        } | undefined>;
+        private pendingAppends;
+        private extraAppends;
+        private pendingWrite;
+        pushAppend(entry: TransactionEntry): Promise<void>;
+        private updatePendingAppends;
+        getKeys(): Promise<string[]>;
+        private loadAllTransactions;
+        private loadTransactionFile;
+        private readTransactionEntry;
+        private serializeTransactionEntry;
+        private getHeader;
+        private chunkBuffers;
+        private compressing;
+        private compressTransactionLog;
+        reset(): Promise<void>;
+    }
+    export {};
+
+}
+
+declare module "sliftutils/storage/fileSystemPointer" {
+    export type FileSystemPointer = string;
+    export declare function storeFileSystemPointer(config: {
+        mode: "read" | "readwrite";
+        handle: FileSystemFileHandle | FileSystemDirectoryHandle;
+    }): Promise<FileSystemPointer>;
+    export declare function deleteFileSystemPointer(pointer: FileSystemPointer): Promise<void>;
+    export declare function getFileSystemPointer(config: {
+        pointer: FileSystemPointer;
+    }): Promise<{
+        onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle>;
+    } | undefined>;
+
+}
+
+declare module "sliftutils/storage/storage" {
+
+
+    declare module "node-forge" {
+        declare type Ed25519PublicKey = {
+            publicKeyBytes: Buffer;
+        } & Buffer;
+        declare type Ed25519PrivateKey = {
+            privateKeyBytes: Buffer;
+        } & Buffer;
+        class ed25519 {
+            static generateKeyPair(): { publicKey: Ed25519PublicKey, privateKey: Ed25519PrivateKey };
+            static privateKeyToPem(key: Ed25519PrivateKey): string;
+            static privateKeyFromPem(pem: string): Ed25519PrivateKey;
+            static publicKeyToPem(key: Ed25519PublicKey): string;
+            static publicKeyFromPem(pem: string): Ed25519PublicKey;
+        }
+    }
+
+
+    interface FileSystemDirectoryHandle {
+        [Symbol.asyncIterator](): AsyncIterator<[string, FileSystemFileHandle | FileSystemDirectoryHandle]>;
+        requestPermission(config: { mode: "read" | "readwrite" }): Promise<void>;
+    }
+    interface FileSystemFileHandle {
+        getFile(): File;
+        createWritable(): FileSystemWritableFileStream;
+    }
+
+    interface Window {
+        showSaveFilePicker(config?: {
+            types: {
+                description: string; accept: { [mimeType: string]: string[] }
+            }[];
+        }): Promise<FileSystemFileHandle>;
+        showDirectoryPicker(): Promise<FileSystemDirectoryHandle>;
+        showOpenFilePicker(config?: {
+            types: {
+                description: string; accept: { [mimeType: string]: string[] }
+            }[];
+        }): Promise<FileSystemFileHandle[]>;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "0.11.0",
+    "version": "0.12.0",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/storage/CachedStorage.d.ts

@@ -0,0 +1,2 @@
+import { StorageSync } from "./StorageObservable";
+export declare function newCachedStrStorage<T>(folder: string, getValue: (key: string) => Promise<T>): StorageSync<T>;

package/storage/DelayedStorage.d.ts

@@ -0,0 +1,14 @@
+import { IStorage } from "./IStorage";
+export declare class DelayedStorage<T> implements IStorage<T> {
+    private storage;
+    constructor(storage: Promise<IStorage<T>>);
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+    getKeys(): Promise<string[]>;
+    getInfo(key: string): Promise<{
+        size: number;
+        lastModified: number;
+    } | undefined>;
+    reset(): Promise<void>;
+}

package/storage/DiskCollection.d.ts

@@ -0,0 +1,99 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IStorage, IStorageSync } from "./IStorage";
+import { StorageSync } from "./StorageObservable";
+import { TransactionStorage } from "./TransactionStorage";
+export declare class DiskCollection<T> implements IStorageSync<T> {
+    private collectionName;
+    private writeDelay?;
+    constructor(collectionName: string, writeDelay?: number | undefined);
+    transactionStorage: TransactionStorage | undefined;
+    initStorage(): Promise<IStorage<T>>;
+    baseStorage: Promise<IStorage<T>>;
+    private synced;
+    get(key: string): T | undefined;
+    getPromise(key: string): Promise<T | undefined>;
+    set(key: string, value: T): void;
+    remove(key: string): void;
+    getKeys(): string[];
+    getKeysPromise(): Promise<string[]>;
+    getEntries(): [string, T][];
+    getValues(): T[];
+    getValuesPromise(): Promise<T[]>;
+    getInfo(key: string): {
+        size: number;
+        lastModified: number;
+    } | undefined;
+    reset(): Promise<void>;
+}
+export declare class DiskCollectionBrowser<T> implements IStorageSync<T> {
+    private collectionName;
+    private writeDelay?;
+    constructor(collectionName: string, writeDelay?: number | undefined);
+    transactionStorage: TransactionStorage | undefined;
+    initStorage(): Promise<IStorage<T>>;
+    baseStorage: Promise<IStorage<T>>;
+    private synced;
+    get(key: string): T | undefined;
+    getPromise(key: string): Promise<T | undefined>;
+    set(key: string, value: T): void;
+    remove(key: string): void;
+    getKeys(): string[];
+    getKeysPromise(): Promise<string[]>;
+    getEntries(): [string, T][];
+    getValues(): T[];
+    getValuesPromise(): Promise<T[]>;
+    getInfo(key: string): {
+        size: number;
+        lastModified: number;
+    } | undefined;
+    reset(): Promise<void>;
+}
+export declare class DiskCollectionPromise<T> implements IStorage<T> {
+    private collectionName;
+    private writeDelay?;
+    constructor(collectionName: string, writeDelay?: number | undefined);
+    initStorage(): Promise<IStorage<T>>;
+    private synced;
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+    getKeys(): Promise<string[]>;
+    getInfo(key: string): Promise<{
+        size: number;
+        lastModified: number;
+    } | undefined>;
+    reset(): Promise<void>;
+}
+export declare class DiskCollectionRaw implements IStorage<Buffer> {
+    private collectionName;
+    constructor(collectionName: string);
+    initStorage(): Promise<IStorage<Buffer>>;
+    private synced;
+    get(key: string): Promise<Buffer | undefined>;
+    set(key: string, value: Buffer): Promise<void>;
+    remove(key: string): Promise<void>;
+    getKeys(): Promise<string[]>;
+    getInfo(key: string): Promise<{
+        size: number;
+        lastModified: number;
+    } | undefined>;
+    reset(): Promise<void>;
+}
+export declare class DiskCollectionRawBrowser {
+    private collectionName;
+    constructor(collectionName: string);
+    initStorage(): Promise<IStorage<Buffer>>;
+    private synced;
+    get(key: string): Buffer | undefined;
+    getPromise(key: string): Promise<Buffer | undefined>;
+    set(key: string, value: Buffer): void;
+    getKeys(): Promise<string[]>;
+    getInfo(key: string): Promise<{
+        size: number;
+        lastModified: number;
+    } | undefined>;
+    reset(): Promise<void>;
+}
+export declare function newFileStorageBufferSyncer(folder?: string): StorageSync<Buffer>;
+export declare function newFileStorageJSONSyncer<T>(folder?: string): StorageSync<T>;

package/storage/FileFolderAPI.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IStorageRaw } from "./IStorage";
+type FileWrapper = {
+    getFile(): Promise<{
+        size: number;
+        lastModified: number;
+        arrayBuffer(): Promise<ArrayBuffer>;
+    }>;
+    createWritable(config?: {
+        keepExistingData?: boolean;
+    }): Promise<{
+        seek(offset: number): Promise<void>;
+        write(value: Buffer): Promise<void>;
+        close(): Promise<void>;
+    }>;
+};
+type DirectoryWrapper = {
+    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;
+    set(newValue: Promise<DirectoryWrapper>): void;
+};
+export declare const getFileStorageNested: {
+    (key: string): Promise<FileStorage>;
+    clear(key: string): void;
+    clearAll(): void;
+    forceSet(key: string, value: Promise<FileStorage>): void;
+    getAllKeys(): string[];
+    get(key: string): Promise<FileStorage> | undefined;
+};
+export declare const getFileStorage: {
+    (): Promise<FileStorage>;
+    reset(): void;
+    set(newValue: Promise<FileStorage>): void;
+};
+export declare function resetStorageLocation(): void;
+export type NestedFileStorage = {
+    hasKey(key: string): Promise<boolean>;
+    getStorage(key: string): Promise<FileStorage>;
+    removeStorage(key: string): Promise<void>;
+    getKeys(): Promise<string[]>;
+};
+export type FileStorage = IStorageRaw & {
+    folder: NestedFileStorage;
+};
+export {};

package/storage/IStorage.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export type IStorageSync<T> = {
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    remove(key: string): void;
+    getKeys(): string[];
+    getValues(): T[];
+    getEntries(): [string, T][];
+    getInfo(key: string): {
+        size: number;
+        lastModified: number;
+    } | undefined;
+    reset(): Promise<void>;
+};
+export type IStorage<T> = {
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+    getKeys(): Promise<string[]>;
+    getInfo(key: string): Promise<undefined | {
+        size: number;
+        lastModified: number;
+    }>;
+    reset(): Promise<void>;
+};
+export type IStorageRaw = {
+    get(key: string): Promise<Buffer | undefined>;
+    append(key: string, value: Buffer): Promise<void>;
+    set(key: string, value: Buffer): Promise<void>;
+    remove(key: string): Promise<void>;
+    getKeys(): Promise<string[]>;
+    getInfo(key: string): Promise<undefined | {
+        size: number;
+        lastModified: number;
+    }>;
+    reset(): Promise<void>;
+};

package/storage/IndexedDBFileFolderAPI.d.ts

@@ -0,0 +1,6 @@
+import { FileStorage } from "./FileFolderAPI";
+export declare const getFileStorageIndexDB: {
+    (): Promise<FileStorage>;
+    reset(): void;
+    set(newValue: Promise<FileStorage>): void;
+};

package/storage/JSONStorage.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IStorage } from "./IStorage";
+export declare class JSONStorage<T> implements IStorage<T> {
+    private storage;
+    constructor(storage: IStorage<Buffer>);
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+    getKeys(): Promise<string[]>;
+    getInfo(key: string): Promise<{
+        size: number;
+        lastModified: number;
+    } | undefined>;
+    reset(): Promise<void>;
+}

package/storage/PendingManager.d.ts

@@ -0,0 +1,6 @@
+import preact from "preact";
+export declare function setPending(group: string, message: string): void;
+export declare function hasPending(): boolean;
+export declare class PendingDisplay extends preact.Component {
+    render(): preact.JSX.Element;
+}

package/storage/PendingStorage.d.ts

@@ -0,0 +1,18 @@
+import { IStorage } from "./IStorage";
+export declare class PendingStorage<T> implements IStorage<T> {
+    private pendingGroup;
+    private storage;
+    pending: Map<string, number>;
+    constructor(pendingGroup: string, storage: IStorage<T>);
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+    getKeys(): Promise<string[]>;
+    getInfo(key: string): Promise<{
+        size: number;
+        lastModified: number;
+    } | undefined>;
+    private watchPending;
+    private updatePending;
+    reset(): Promise<void>;
+}

package/storage/PrivateFileSystemStorage.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IStorageRaw } from "./IStorage";
+export declare class PrivateFileSystemStorage implements IStorageRaw {
+    private path;
+    private rootHandle;
+    constructor(path: string);
+    private ensureInitialized;
+    private directoryExists;
+    private getDirectoryHandle;
+    private getFileHandle;
+    private fileExists;
+    get(key: string): Promise<Buffer | undefined>;
+    set(key: string, value: Buffer): Promise<void>;
+    append(key: string, value: Buffer): Promise<void>;
+    remove(key: string): Promise<void>;
+    getKeys(): Promise<string[]>;
+    getInfo(key: string): Promise<undefined | {
+        size: number;
+        lastModified: number;
+    }>;
+    reset(): Promise<void>;
+}

package/storage/StorageObservable.d.ts

@@ -0,0 +1,32 @@
+import { IStorage, IStorageSync } from "./IStorage";
+export declare class StorageSync<T> implements IStorageSync<T> {
+    storage: IStorage<T>;
+    cached: import("mobx").ObservableMap<string, T | undefined>;
+    infoCached: import("mobx").ObservableMap<string, {
+        size: number;
+        lastModified: number;
+    } | undefined>;
+    keys: Set<string>;
+    synced: {
+        keySeqNum: number;
+    };
+    constructor(storage: IStorage<T>);
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    remove(key: string): void;
+    private loadedKeys;
+    getKeys(): string[];
+    getInfo(key: string): {
+        size: number;
+        lastModified: number;
+    } | undefined;
+    getValues(): T[];
+    getEntries(): [string, T][];
+    getPromise(key: string): Promise<T | undefined>;
+    private pendingGetKeys;
+    getKeysPromise(): Promise<string[]>;
+    reload(): void;
+    reloadKeys(): void;
+    reloadKey(key: string): void;
+    reset(): Promise<void>;
+}

package/storage/TransactionStorage.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IStorage, IStorageRaw } from "./IStorage";
+interface TransactionEntry {
+    key: string;
+    value: Buffer | undefined;
+    isZipped: boolean;
+    time: number;
+}
+export declare class TransactionStorage implements IStorage<Buffer> {
+    private rawStorage;
+    private debugName;
+    private writeDelay;
+    cache: Map<string, TransactionEntry>;
+    private currentChunk;
+    private currentChunkSize;
+    private entryCount;
+    private static allStorage;
+    constructor(rawStorage: IStorageRaw, debugName: string, writeDelay?: number);
+    static compressAll(): Promise<void>;
+    private init;
+    private getChunk;
+    get(key: string): Promise<Buffer | undefined>;
+    set(key: string, value: Buffer): Promise<void>;
+    remove(key: string): Promise<void>;
+    getInfo(key: string): Promise<{
+        size: number;
+        lastModified: number;
+    } | undefined>;
+    private pendingAppends;
+    private extraAppends;
+    private pendingWrite;
+    pushAppend(entry: TransactionEntry): Promise<void>;
+    private updatePendingAppends;
+    getKeys(): Promise<string[]>;
+    private loadAllTransactions;
+    private loadTransactionFile;
+    private readTransactionEntry;
+    private serializeTransactionEntry;
+    private getHeader;
+    private chunkBuffers;
+    private compressing;
+    private compressTransactionLog;
+    reset(): Promise<void>;
+}
+export {};

package/storage/fileSystemPointer.d.ts

@@ -0,0 +1,11 @@
+export type FileSystemPointer = string;
+export declare function storeFileSystemPointer(config: {
+    mode: "read" | "readwrite";
+    handle: FileSystemFileHandle | FileSystemDirectoryHandle;
+}): Promise<FileSystemPointer>;
+export declare function deleteFileSystemPointer(pointer: FileSystemPointer): Promise<void>;
+export declare function getFileSystemPointer(config: {
+    pointer: FileSystemPointer;
+}): Promise<{
+    onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle>;
+} | undefined>;

package/tsconfig.declarations.json

@@ -10,7 +10,9 @@
         "render-utils/**/*.ts",
         "render-utils/**/*.tsx",
         "misc/**/*.ts",
-        "misc/**/*.tsx"
+        "misc/**/*.tsx",
+        "storage/**/*.ts",
+        "storage/**/*.tsx"
     ],
     "exclude": [
         "node_modules",