sliftutils 0.11.0 → 0.13.0

package/render-utils/URLParam.d.ts

@@ -1,13 +1,17 @@
-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;

package/render-utils/URLParam.ts

@@ -1,84 +1,101 @@
 import { isNode } from "typesafecss";
 import { observable } from "mobx";
+import { throttleFunction } from "socket-function/src/misc";
+import { niceParse, niceStringify } from "./niceStringify";
 
-let allParams: URLParamStr[] = [];
+let urlParamLookup = new Map<string, URLParam<unknown>>();
+let pauseUpdate = false;
 
-let updated: URLParamStr[] = [];
-
-export class URLParamStr {
-    private state = observable({
-        seqNum: 0
-    });
-    public lastSetValue = "";
-    constructor(public readonly urlKey: string) {
-        allParams.push(this);
+export class URLParam<T = unknown> {
+    constructor(public readonly key: string, private defaultValue: T = "" as any) {
+        urlParamLookup.set(key, this);
     }
-    public forceUpdate() {
-        this.state.seqNum++;
+    valueSeqNum = observable({ value: 1 });
+    public get(): T {
+        urlBackSeqNum.value;
+        this.valueSeqNum.value;
+        let value = new URL(getCurrentUrl()).searchParams.get(this.key);
+        if (value === null) {
+            return this.defaultValue;
+        }
+        return niceParse(value) as T;
     }
-
-    public get() {
-        this.state.seqNum;
-        return new URLSearchParams(window.location.search).get(this.urlKey) || "";
+    public set(value: T) {
+        let url = new URL(getCurrentUrl());
+        if (value === this.defaultValue) {
+            url.searchParams.delete(this.key);
+        } else {
+            url.searchParams.set(this.key, niceStringify(value));
+        }
+        if (!pauseUpdate) {
+            void throttledUrlPush(url.toString());
+            this.valueSeqNum.value++;
+        }
     }
-    public set(value: string) {
-        if (value === this.get()) return;
-        this.lastSetValue = value;
-        batchUrlUpdate(() => {
-            updated.push(this);
-        });
-        this.state.seqNum++;
+    public reset() {
+        let url = new URL(getCurrentUrl());
+        url.searchParams.delete(this.key);
+        if (!pauseUpdate) {
+            void throttledUrlPush(url.toString());
+            this.valueSeqNum.value++;
+        }
+    }
+
+    public getOverride(value: T): [string, string] {
+        return [this.key, value as any];
     }
 
     public get value() {
         return this.get();
     }
-    public set value(value: string) {
+    public set value(value: T) {
         this.set(value);
     }
 }
 
-let inBatchUpdate = false;
-export function batchUrlUpdate<T>(code: () => T): T {
-    if (inBatchUpdate) return code();
-    inBatchUpdate = true;
+export function getResolvedParam(param: [URLParam, unknown] | [string, string]): [string, string] {
+    if (typeof param[0] === "string") {
+        return [param[0], niceStringify(param[1])];
+    }
+    return [param[0].key, niceStringify(param[1])];
+}
+export function batchURLParamUpdate(params: ([URLParam, unknown] | [string, string])[]) {
+    let resolvedParams = params.map(getResolvedParam);
+    pauseUpdate = true;
+    let url = new URL(location.href);
     try {
-        return code();
-    } finally {
-        inBatchUpdate = false;
-
-        let prevUpdated = updated;
-        updated = [];
-        let searchParams = new URLSearchParams(window.location.search);
-        for (let obj of prevUpdated) {
-            searchParams.set(obj.urlKey, obj.lastSetValue);
-        }
-        let newURL = "?" + searchParams.toString();
-        if (window.location.hash) {
-            newURL += window.location.hash;
+        for (let [key, value] of resolvedParams) {
+            url.searchParams.set(key, value);
+            let urlParam = urlParamLookup.get(key);
+            urlParam?.set(niceParse(value));
         }
-        window.history.pushState({}, "", newURL);
+    } finally {
+        pauseUpdate = false;
     }
+    urlBackSeqNum.value++;
+    void throttledUrlPush(url.toString());
 }
 
-export function createLink(params: [URLParamStr, string][]) {
-    let searchParams = new URLSearchParams(window.location.search);
-    for (let [param, value] of params) {
-        searchParams.set(param.urlKey, value);
-    }
-    let newURL = "?" + searchParams.toString();
-    if (window.location.hash) {
-        newURL += window.location.hash;
-    }
-    return newURL;
+export function getCurrentUrl() {
+    return currentBatchedUrl ?? location.href;
 }
 
+
+let currentBatchedUrl: string | undefined;
+function throttledUrlPush(url: string) {
+    history.pushState({}, "", url);
+    //currentBatchedUrl = url;
+    // NOTE: Stopped throttling, so when you click on links, it immediately updates the selected state. 
+    //void throttledUrlPushBase(url);
+}
+const throttledUrlPushBase = throttleFunction(1000, (url: string) => {
+    currentBatchedUrl = undefined;
+    history.pushState({}, "", url);
+});
+
+let urlBackSeqNum = observable({ value: 1 });
 if (!isNode()) {
-    // Watch for url push states
     window.addEventListener("popstate", () => {
-        // Force all to update, in case their param changed
-        for (let param of allParams) {
-            param.forceUpdate();
-        }
+        urlBackSeqNum.value++;
     });
 }

package/render-utils/niceStringify.d.ts

@@ -0,0 +1,5 @@
+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;

package/render-utils/niceStringify.ts

@@ -0,0 +1,83 @@
+// true => ""
+// "" => JSON.stringify("")
+
+export const niceStringifyTrue = "";
+// Starting/ending with a JSON character means anything string that looks like this
+//  will be encoded like: `"{Nan`, and it is impossible for an object to serialize to look like this.
+export const niceStringifyNan = `{NaN}`;
+export const niceStringifyUndefined = `{Undefined}`;
+
+
+// BUG: This is actually broken for hex strings. Hex strings may sometimes be entirely numbers,
+//  which means they will randomly change type.
+function looksLikeJSON(str: string) {
+    return (
+        str === "null"
+        || str === "true"
+        || str === "false"
+        || str[0] === `"` && str[str.length - 1] === `"`
+        || str[0] === `[` && str[str.length - 1] === `]`
+        || str[0] === `{` && str[str.length - 1] === `}`
+        || (48 <= str.charCodeAt(0) && str.charCodeAt(0) <= 57)
+        || str.length > 1 && str[0] === "-" && (48 <= str.charCodeAt(1) && str.charCodeAt(1) <= 57)
+        || str === niceStringifyTrue
+        || str === niceStringifyUndefined
+    );
+}
+
+export function niceStringify(value: unknown): string {
+    if (value === undefined) {
+        return niceStringifyUndefined;
+    }
+    if (value === true) return niceStringifyTrue;
+    if (Number.isNaN(value)) return niceStringifyNan;
+
+    // Any strings that don't look like JSON, don't need to encoded as JSON, and can instead
+    //  just be stored as strings.
+    if (typeof value === "string" && !looksLikeJSON(value)) {
+        return value;
+    }
+
+
+    let str = JSON.stringify(value);
+    if (typeof value !== "object") {
+        let testParse = niceParse(str);
+        if (testParse !== value) {
+            console.log(`niceStringify did not reverse correctly. Should have received ${JSON.stringify(value)}, did received ${JSON.stringify(testParse)}`);
+            debugger;
+        }
+    }
+
+    return str;
+}
+
+export function niceParse(str: string | undefined, noSpecialTrue = false): unknown {
+    if (str === undefined) {
+        return undefined;
+    }
+    if (str === niceStringifyTrue && !noSpecialTrue) return true;
+    if (str === niceStringifyNan) return Number.NaN;
+    if (str === niceStringifyUndefined) return undefined;
+    if (str === "") return str;
+
+    if (looksLikeJSON(str)) {
+        try {
+            return JSON.parse(str);
+        } catch { }
+    }
+    return str;
+}
+
+/*
+
+function setFromUrlValue(key: string, valueJSON: string) {
+    if(isMaybeJSON(valueJSON)) {
+        try {
+            values[key] = JSON.parse(valueJSON);
+            return;
+        } catch { }
+    }
+    // Always set it, if it isn't JSON, just assume it is raw text.
+    values[key] = valueJSON;
+}
+*/

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 {};