sliftutils 0.11.0 → 0.13.0

package/.gitignore

@@ -35,4 +35,5 @@ test*.json
 center_channel.txt
 *.part
 *.ytdl
-cloudflare.json
+cloudflare.json
+data

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdGVJbmRleER0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImdlbmVyYXRlSW5kZXhEdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHVDQUF5QjtBQUN6QiwyQ0FBNkI7QUFFN0IsTUFBTSxrQkFBa0IsR0FBRyxDQUFDLGNBQWMsRUFBRSxNQUFNLENBQUMsQ0FBQztBQUVwRCxTQUFTLGNBQWMsQ0FBQyxHQUFXLEVBQUUsV0FBcUIsRUFBRTtJQUN4RCxNQUFNLEtBQUssR0FBRyxFQUFFLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBRWxDLEtBQUssTUFBTSxJQUFJLElBQUksS0FBSyxFQUFFLENBQUM7UUFDdkIsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFDdEMsTUFBTSxJQUFJLEdBQUcsRUFBRSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUVuQyxJQUFJLElBQUksQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDO1lBQ3JCLGNBQWMsQ0FBQyxRQUFRLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDdkMsQ0FBQzthQUFNLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1lBQ2hDLFFBQVEsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDNUIsQ0FBQztJQUNMLENBQUM7SUFFRCxPQUFPLFFBQVEsQ0FBQztBQUNwQixDQUFDO0FBRUQsU0FBUyxnQkFBZ0I7SUFDckIsTUFBTSxVQUFVLEdBQWEsRUFBRSxDQUFDO0lBRWhDLEtBQUssTUFBTSxVQUFVLElBQUksa0JBQWtCLEVBQUUsQ0FBQztRQUMxQyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxJQUFJLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFFMUQsSUFBSSxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQztZQUM3QixPQUFPLENBQUMsR0FBRyxDQUFDLG1CQUFtQixVQUFVLDhCQUE4QixDQUFDLENBQUM7WUFDekUsU0FBUztRQUNiLENBQUM7UUFFRCxNQUFNLFFBQVEsR0FBRyxjQUFjLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFNUMsTUFBTSxPQUFPLEdBQUcsUUFBUTthQUNuQixHQUFHLENBQUMsUUFBUSxDQUFDLEVBQUU7WUFDWixNQUFNLFlBQVksR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsRUFBRSxRQUFRLENBQUMsQ0FBQztZQUN6RCxNQUFNLFVBQVUsR0FBRyxZQUFZLENBQUMsT0FBTyxDQUFDLFVBQVUsRUFBRSxFQUFFLENBQUMsQ0FBQztZQUN4RCxNQUFNLFVBQVUsR0FBRyxhQUFhLEdBQUcsVUFBVSxHQUFHLEdBQUcsR0FBRyxVQUFVLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQztZQUVyRixNQUFNLE9BQU8sR0FBRyxFQUFFLENBQUMsWUFBWSxDQUFDLFFBQVEsRUFBRSxNQUFNLENBQUMsQ0FBQztZQUNsRCxNQUFNLGVBQWUsR0FBRyxPQUFPO2lCQUMxQixLQUFLLENBQUMsSUFBSSxDQUFDO2lCQUNYLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO2lCQUN4QyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7WUFFaEIsT0FBTyxtQkFBbUIsVUFBVSxRQUFRLGVBQWUsS0FBSyxDQUFDO1FBQ3JFLENBQUMsQ0FBQyxDQUFDO1FBRVAsVUFBVSxDQUFDLElBQUksQ0FBQyxHQUFHLE9BQU8sQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRCxNQUFNLGFBQWEsR0FBRyxVQUFVLENBQUMsSUFBSSxFQUFFLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3JELE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLElBQUksRUFBRSxZQUFZLENBQUMsQ0FBQztJQUM1RCxNQUFNLE1BQU0sR0FBRyw2RkFBNkYsQ0FBQztJQUU3RyxFQUFFLENBQUMsYUFBYSxDQUFDLFVBQVUsRUFBRSxNQUFNLEdBQUcsYUFBYSxHQUFHLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNwRSxPQUFPLENBQUMsR0FBRyxDQUFDLGFBQWEsVUFBVSxTQUFTLFVBQVUsQ0FBQyxNQUFNLHNCQUFzQixDQUFDLENBQUM7QUFDekYsQ0FBQztBQUVELGdCQUFnQixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBmcyBmcm9tIFwiZnNcIjtcbmltcG9ydCAqIGFzIHBhdGggZnJvbSBcInBhdGhcIjtcblxuY29uc3QgRk9MREVSU19UT19JTkNMVURFID0gW1wicmVuZGVyLXV0aWxzXCIsIFwibWlzY1wiXTtcblxuZnVuY3Rpb24gZ2V0QWxsRHRzRmlsZXMoZGlyOiBzdHJpbmcsIGZpbGVMaXN0OiBzdHJpbmdbXSA9IFtdKTogc3RyaW5nW10ge1xuICAgIGNvbnN0IGZpbGVzID0gZnMucmVhZGRpclN5bmMoZGlyKTtcblxuICAgIGZvciAoY29uc3QgZmlsZSBvZiBmaWxlcykge1xuICAgICAgICBjb25zdCBmaWxlUGF0aCA9IHBhdGguam9pbihkaXIsIGZpbGUpO1xuICAgICAgICBjb25zdCBzdGF0ID0gZnMuc3RhdFN5bmMoZmlsZVBhdGgpO1xuXG4gICAgICAgIGlmIChzdGF0LmlzRGlyZWN0b3J5KCkpIHtcbiAgICAgICAgICAgIGdldEFsbER0c0ZpbGVzKGZpbGVQYXRoLCBmaWxlTGlzdCk7XG4gICAgICAgIH0gZWxzZSBpZiAoZmlsZS5lbmRzV2l0aChcIi5kLnRzXCIpKSB7XG4gICAgICAgICAgICBmaWxlTGlzdC5wdXNoKGZpbGVQYXRoKTtcbiAgICAgICAgfVxuICAgIH1cblxuICAgIHJldHVybiBmaWxlTGlzdDtcbn1cblxuZnVuY3Rpb24gZ2VuZXJhdGVJbmRleER0cygpIHtcbiAgICBjb25zdCBhbGxNb2R1bGVzOiBzdHJpbmdbXSA9IFtdO1xuXG4gICAgZm9yIChjb25zdCBmb2xkZXJOYW1lIG9mIEZPTERFUlNfVE9fSU5DTFVERSkge1xuICAgICAgICBjb25zdCBmb2xkZXJQYXRoID0gcGF0aC5qb2luKF9fZGlybmFtZSwgXCIuLlwiLCBmb2xkZXJOYW1lKTtcblxuICAgICAgICBpZiAoIWZzLmV4aXN0c1N5bmMoZm9sZGVyUGF0aCkpIHtcbiAgICAgICAgICAgIGNvbnNvbGUubG9nKGBXYXJuaW5nOiBGb2xkZXIgJHtmb2xkZXJOYW1lfSBkb2VzIG5vdCBleGlzdCwgc2tpcHBpbmcuLi5gKTtcbiAgICAgICAgICAgIGNvbnRpbnVlO1xuICAgICAgICB9XG5cbiAgICAgICAgY29uc3QgZHRzRmlsZXMgPSBnZXRBbGxEdHNGaWxlcyhmb2xkZXJQYXRoKTtcblxuICAgICAgICBjb25zdCBtb2R1bGVzID0gZHRzRmlsZXNcbiAgICAgICAgICAgIC5tYXAoZmlsZVBhdGggPT4ge1xuICAgICAgICAgICAgICAgIGNvbnN0IHJlbGF0aXZlUGF0aCA9IHBhdGgucmVsYXRpdmUoZm9sZGVyUGF0aCwgZmlsZVBhdGgpO1xuICAgICAgICAgICAgICAgIGNvbnN0IHdpdGhvdXRFeHQgPSByZWxhdGl2ZVBhdGgucmVwbGFjZSgvXFwuZFxcLnRzJC8sIFwiXCIpO1xuICAgICAgICAgICAgICAgIGNvbnN0IG1vZHVsZVBhdGggPSBcInNsaWZ0dXRpbHMvXCIgKyBmb2xkZXJOYW1lICsgXCIvXCIgKyB3aXRob3V0RXh0LnJlcGxhY2UoL1xcXFwvZywgXCIvXCIpO1xuXG4gICAgICAgICAgICAgICAgY29uc3QgY29udGVudCA9IGZzLnJlYWRGaWxlU3luYyhmaWxlUGF0aCwgXCJ1dGY4XCIpO1xuICAgICAgICAgICAgICAgIGNvbnN0IGluZGVudGVkQ29udGVudCA9IGNvbnRlbnRcbiAgICAgICAgICAgICAgICAgICAgLnNwbGl0KFwiXFxuXCIpXG4gICAgICAgICAgICAgICAgICAgIC5tYXAobGluZSA9PiBsaW5lID8gXCIgICAgXCIgKyBsaW5lIDogbGluZSlcbiAgICAgICAgICAgICAgICAgICAgLmpvaW4oXCJcXG5cIik7XG5cbiAgICAgICAgICAgICAgICByZXR1cm4gYGRlY2xhcmUgbW9kdWxlIFwiJHttb2R1bGVQYXRofVwiIHtcXG4ke2luZGVudGVkQ29udGVudH1cXG59YDtcbiAgICAgICAgICAgIH0pO1xuXG4gICAgICAgIGFsbE1vZHVsZXMucHVzaCguLi5tb2R1bGVzKTtcbiAgICB9XG5cbiAgICBjb25zdCBzb3J0ZWRNb2R1bGVzID0gYWxsTW9kdWxlcy5zb3J0KCkuam9pbihcIlxcblxcblwiKTtcbiAgICBjb25zdCBvdXRwdXRQYXRoID0gcGF0aC5qb2luKF9fZGlybmFtZSwgXCIuLlwiLCBcImluZGV4LmQudHNcIik7XG4gICAgY29uc3QgaGVhZGVyID0gYC8vIEF1dG8tZ2VuZXJhdGVkIGZpbGUuIERvIG5vdCBlZGl0IG1hbnVhbGx5Llxcbi8vIEdlbmVyYXRlZCBieTogeWFybiBnZW5lcmF0ZS1pbmRleC1kdHNcXG5cXG5gO1xuXG4gICAgZnMud3JpdGVGaWxlU3luYyhvdXRwdXRQYXRoLCBoZWFkZXIgKyBzb3J0ZWRNb2R1bGVzICsgXCJcXG5cIiwgXCJ1dGY4XCIpO1xuICAgIGNvbnNvbGUubG9nKGBHZW5lcmF0ZWQgJHtvdXRwdXRQYXRofSB3aXRoICR7YWxsTW9kdWxlcy5sZW5ndGh9IG1vZHVsZSBkZWNsYXJhdGlvbnNgKTtcbn1cblxuZ2VuZXJhdGVJbmRleER0cygpO1xuXG4iXX0=
- /* _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

@@ -318,19 +318,23 @@ declare module "sliftutils/render-utils/Table" {
 }
 
 declare module "sliftutils/render-utils/URLParam" {
-    export declare class URLParamStr {
-        readonly urlKey: string;
-        private state;
-        lastSetValue: string;
-        constructor(urlKey: string);
-        forceUpdate(): void;
-        get(): string;
-        set(value: string): void;
-        get value(): string;
-        set value(value: string);
+    export declare class URLParam<T = unknown> {
+        readonly key: string;
+        private defaultValue;
+        constructor(key: string, defaultValue?: T);
+        valueSeqNum: {
+            value: number;
+        };
+        get(): T;
+        set(value: T): void;
+        reset(): void;
+        getOverride(value: T): [string, string];
+        get value(): T;
+        set value(value: T);
     }
-    export declare function batchUrlUpdate<T>(code: () => T): T;
-    export declare function createLink(params: [URLParamStr, string][]): string;
+    export declare function getResolvedParam(param: [URLParam, unknown] | [string, string]): [string, string];
+    export declare function batchURLParamUpdate(params: ([URLParam, unknown] | [string, string])[]): void;
+    export declare function getCurrentUrl(): string;
 
 }
 
@@ -356,6 +360,15 @@ declare module "sliftutils/render-utils/modal" {
 
 }
 
+declare module "sliftutils/render-utils/niceStringify" {
+    export declare const niceStringifyTrue = "";
+    export declare const niceStringifyNan = "{NaN}";
+    export declare const niceStringifyUndefined = "{Undefined}";
+    export declare function niceStringify(value: unknown): string;
+    export declare function niceParse(str: string | undefined, noSpecialTrue?: boolean): unknown;
+
+}
+
 declare module "sliftutils/render-utils/observer" {
     import * as preact from "preact";
     import { Reaction } from "mobx";
@@ -376,3 +389,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.13.0",
     "main": "index.js",
     "license": "MIT",
     "files": [
@@ -12,6 +12,7 @@
         "update-types": "yarn emit-dts && yarn generate-index-dts",
         "emit-dts": "yarn tsc --project tsconfig.declarations.json || true",
         "generate-index-dts": "typenode ./builders/generateIndexDts.ts",
+        "prepublishOnly": "yarn update-types",
         "run-nodejs": "node ./build-nodejs/server.js",
         "run-nodejs-dev": "typenode ./nodejs/server.ts",
         "run-web": "node ./builders/webRun.js",

package/render-utils/Anchor.tsx

@@ -0,0 +1,62 @@
+import preact from "preact";
+import { URLParam, batchURLParamUpdate, getResolvedParam } from "./URLParam";
+import { css, isNode } from "typesafecss";
+
+export const AnchorClass = (
+    css.textDecoration("none").color("hsl(210, 75%, 65%)").opacity(0.8, "hover")
+);
+
+export class Anchor extends preact.Component<{
+    className?: string;
+    params: ([URLParam, unknown] | [string, string])[];
+    button?: boolean;
+} & Omit<preact.JSX.HTMLAttributes<HTMLAnchorElement>, "href">> {
+    render() {
+        const { params, button, className, ...remaining } = this.props;
+        let resolvedParams = params.map(getResolvedParam);
+        let searchObj = new URLSearchParams(window.location.search);
+        let selected = resolvedParams.every(([param, value]) => searchObj.get(param) === value);
+        let link = (
+            <a
+                {...remaining}
+                className={
+                    css.textDecoration("none")
+                        .opacity(0.8, "hover")
+                    + (selected && css.color("hsl(110, 75%, 65%)", "soft"))
+                    + (!selected && css.color("hsl(210, 75%, 65%)", "soft"))
+                    + className
+                }
+                href={createLink(resolvedParams)}
+                onClick={e => {
+                    if (this.props.target) return;
+                    e.preventDefault();
+                    e.stopPropagation();
+                    batchURLParamUpdate(params);
+                }}
+            >
+                {this.props.children}
+            </a>
+        );
+        if (button) {
+            return <button className={css.button} onClick={() => {
+                batchURLParamUpdate(params);
+            }}>
+                {link}
+            </button>;
+        }
+        return link;
+    }
+}
+
+function createLink(params: ([string, string])[]) {
+    let searchParams = new URLSearchParams(isNode() ? "https://planquickly.com" : window.location.search);
+    for (let [param, value] of params) {
+        searchParams.set(param, value);
+    }
+    return "?" + searchParams.toString();
+}
+
+export function createLinkRaw(params: ([URLParam, unknown])[]) {
+    let paramsText = params.map(getResolvedParam);
+    return createLink(paramsText);
+}