sliftutils 0.10.0 → 0.12.0

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/misc/dist/environment.ts.cache

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.isInBrowser = exports.isInBuild = exports.triggerIsInBuild = exports.isInElectron = exports.isInChromeExtensionContentScript = exports.isInChromeExtensionBackground = exports.isInChromeExtension = void 0;
+/// <reference path="../node_modules/@types/chrome/index.d.ts" />
+function isInChromeExtension() {
+    return typeof chrome !== "undefined" && chrome.runtime && chrome.runtime.id;
+}
+exports.isInChromeExtension = isInChromeExtension;
+function isInChromeExtensionBackground() {
+    if (!isInChromeExtension())
+        return false;
+    // Manifest V3: Service Worker context (has importScripts but no document)
+    if (typeof globalThis.importScripts === "function" && typeof document === "undefined") {
+        return true;
+    }
+    // Manifest V2: Background page
+    if (typeof chrome.extension !== "undefined" && typeof chrome.extension.getBackgroundPage === "function") {
+        try {
+            return chrome.extension.getBackgroundPage() === window;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    return false;
+}
+exports.isInChromeExtensionBackground = isInChromeExtensionBackground;
+function isInChromeExtensionContentScript() {
+    return isInChromeExtension() && !isInChromeExtensionBackground();
+}
+exports.isInChromeExtensionContentScript = isInChromeExtensionContentScript;
+function isInElectron() {
+    return typeof process !== "undefined" && process.versions && process.versions.electron;
+}
+exports.isInElectron = isInElectron;
+let isInBuildFlag = false;
+function triggerIsInBuild() {
+    isInBuildFlag = true;
+}
+exports.triggerIsInBuild = triggerIsInBuild;
+function isInBuild() {
+    return isInBuildFlag;
+}
+exports.isInBuild = isInBuild;
+function isInBrowser() {
+    return typeof document !== "undefined";
+}
+exports.isInBrowser = isInBrowser;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "00e183aa5fcbb1b2f725fb79092153bc802c27df18e93e60d79fd567f7502e12"; */

package/misc/dist/fs.ts.cache

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.getAllFiles = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function* getAllFiles(folder) {
+    const files = await fs_1.default.promises.readdir(folder);
+    for (const file of files) {
+        const filePath = path_1.default.join(folder, file);
+        try {
+            const stats = await fs_1.default.promises.stat(filePath);
+            if (stats.isDirectory()) {
+                yield* getAllFiles(filePath);
+            }
+            else {
+                yield filePath;
+            }
+        }
+        catch (error) {
+            console.warn(`Failed while accessing path, skipping: ${filePath}`, error);
+        }
+    }
+}
+exports.getAllFiles = getAllFiles;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJmcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSw0Q0FBb0I7QUFDcEIsZ0RBQXdCO0FBRWpCLEtBQUssU0FBUyxDQUFDLENBQUMsV0FBVyxDQUFDLE1BQWM7SUFDN0MsTUFBTSxLQUFLLEdBQUcsTUFBTSxZQUFFLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNoRCxLQUFLLE1BQU0sSUFBSSxJQUFJLEtBQUssRUFBRSxDQUFDO1FBQ3ZCLE1BQU0sUUFBUSxHQUFHLGNBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQ3pDLElBQUksQ0FBQztZQUNELE1BQU0sS0FBSyxHQUFHLE1BQU0sWUFBRSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7WUFDL0MsSUFBSSxLQUFLLENBQUMsV0FBVyxFQUFFLEVBQUUsQ0FBQztnQkFDdEIsS0FBSyxDQUFDLENBQUMsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQ2pDLENBQUM7aUJBQU0sQ0FBQztnQkFDSixNQUFNLFFBQVEsQ0FBQztZQUNuQixDQUFDO1FBQ0wsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDYixPQUFPLENBQUMsSUFBSSxDQUFDLDBDQUEwQyxRQUFRLEVBQUUsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUM5RSxDQUFDO0lBQ0wsQ0FBQztBQUNMLENBQUM7QUFmRCxrQ0FlQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBmcyBmcm9tIFwiZnNcIjtcbmltcG9ydCBwYXRoIGZyb20gXCJwYXRoXCI7XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiogZ2V0QWxsRmlsZXMoZm9sZGVyOiBzdHJpbmcpOiBBc3luY0l0ZXJhYmxlSXRlcmF0b3I8c3RyaW5nPiB7XG4gICAgY29uc3QgZmlsZXMgPSBhd2FpdCBmcy5wcm9taXNlcy5yZWFkZGlyKGZvbGRlcik7XG4gICAgZm9yIChjb25zdCBmaWxlIG9mIGZpbGVzKSB7XG4gICAgICAgIGNvbnN0IGZpbGVQYXRoID0gcGF0aC5qb2luKGZvbGRlciwgZmlsZSk7XG4gICAgICAgIHRyeSB7XG4gICAgICAgICAgICBjb25zdCBzdGF0cyA9IGF3YWl0IGZzLnByb21pc2VzLnN0YXQoZmlsZVBhdGgpO1xuICAgICAgICAgICAgaWYgKHN0YXRzLmlzRGlyZWN0b3J5KCkpIHtcbiAgICAgICAgICAgICAgICB5aWVsZCogZ2V0QWxsRmlsZXMoZmlsZVBhdGgpO1xuICAgICAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgICAgICB5aWVsZCBmaWxlUGF0aDtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgICAgICAgIGNvbnNvbGUud2FybihgRmFpbGVkIHdoaWxlIGFjY2Vzc2luZyBwYXRoLCBza2lwcGluZzogJHtmaWxlUGF0aH1gLCBlcnJvcik7XG4gICAgICAgIH1cbiAgICB9XG59Il19
+ /* _JS_SOURCE_HASH = "24eb29f93f883487ee5dfa0d45c550084abc4077a1c9f6422385c9a305444b33"; */

package/nodejs/dist/exampleFile.ts.cache

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.exampleFunction = void 0;
+// Either set this flag on the files you want to hot reload, or add a file called hotreload.flag and that folder, everything in it and all the child uh files will hot reload. 
+module.hotreload = true;
+function exampleFunction() {
+    return "Hello from exampleFile.ts";
+}
+exports.exampleFunction = exampleFunction;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhhbXBsZUZpbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJleGFtcGxlRmlsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwrS0FBK0s7QUFDL0ssTUFBTSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUM7QUFFeEIsU0FBZ0IsZUFBZTtJQUMzQixPQUFPLDJCQUEyQixDQUFDO0FBQ3ZDLENBQUM7QUFGRCwwQ0FFQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEVpdGhlciBzZXQgdGhpcyBmbGFnIG9uIHRoZSBmaWxlcyB5b3Ugd2FudCB0byBob3QgcmVsb2FkLCBvciBhZGQgYSBmaWxlIGNhbGxlZCBob3RyZWxvYWQuZmxhZyBhbmQgdGhhdCBmb2xkZXIsIGV2ZXJ5dGhpbmcgaW4gaXQgYW5kIGFsbCB0aGUgY2hpbGQgdWggZmlsZXMgd2lsbCBob3QgcmVsb2FkLiBcbm1vZHVsZS5ob3RyZWxvYWQgPSB0cnVlO1xuXG5leHBvcnQgZnVuY3Rpb24gZXhhbXBsZUZ1bmN0aW9uKCkge1xuICAgIHJldHVybiBcIkhlbGxvIGZyb20gZXhhbXBsZUZpbGUudHNcIjtcbn0iXX0=
+ /* _JS_SOURCE_HASH = "5ce927e8446d0fc48114e61b3f1481145250a61049c1f754bbf963fbc06fe53e"; */

package/nodejs/dist/server.ts.cache

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+const batching_1 = require("socket-function/src/batching");
+const exampleFile_1 = require("./exampleFile");
+const hotReload_1 = require("../builders/hotReload");
+async function main() {
+    await (0, hotReload_1.enableHotReloading)();
+    while (true) {
+        console.log((0, exampleFile_1.exampleFunction)());
+        await (0, batching_1.delay)(1000);
+    }
+}
+main().catch(console.error);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic2VydmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsMkRBQXFEO0FBQ3JELCtDQUFnRDtBQUNoRCxxREFBMkQ7QUFFM0QsS0FBSyxVQUFVLElBQUk7SUFDZixNQUFNLElBQUEsOEJBQWtCLEdBQUUsQ0FBQztJQUMzQixPQUFPLElBQUksRUFBRSxDQUFDO1FBQ1YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFBLDZCQUFlLEdBQUUsQ0FBQyxDQUFDO1FBQy9CLE1BQU0sSUFBQSxnQkFBSyxFQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3RCLENBQUM7QUFDTCxDQUFDO0FBRUQsSUFBSSxFQUFFLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGRlbGF5IH0gZnJvbSBcInNvY2tldC1mdW5jdGlvbi9zcmMvYmF0Y2hpbmdcIjtcbmltcG9ydCB7IGV4YW1wbGVGdW5jdGlvbiB9IGZyb20gXCIuL2V4YW1wbGVGaWxlXCI7XG5pbXBvcnQgeyBlbmFibGVIb3RSZWxvYWRpbmcgfSBmcm9tIFwiLi4vYnVpbGRlcnMvaG90UmVsb2FkXCI7XG5cbmFzeW5jIGZ1bmN0aW9uIG1haW4oKSB7XG4gICAgYXdhaXQgZW5hYmxlSG90UmVsb2FkaW5nKCk7XG4gICAgd2hpbGUgKHRydWUpIHtcbiAgICAgICAgY29uc29sZS5sb2coZXhhbXBsZUZ1bmN0aW9uKCkpO1xuICAgICAgICBhd2FpdCBkZWxheSgxMDAwKTtcbiAgICB9XG59XG5cbm1haW4oKS5jYXRjaChjb25zb2xlLmVycm9yKTtcblxuIl1//9
+ /* _JS_SOURCE_HASH = "9d5836fddfa312252033bbc20caa82669811e9ebfcaff9dc2b932bbf657228c1"; */

package/package.json

@@ -1,8 +1,12 @@
 {
     "name": "sliftutils",
-    "version": "0.10.0",
+    "version": "0.12.0",
     "main": "index.js",
     "license": "MIT",
+    "files": [
+        "**/*",
+        ".gitignore"
+    ],
     "scripts": {
         "type": "yarn tsc --noEmit",
         "update-types": "yarn emit-dts && yarn generate-index-dts",

package/render-utils/dist/observer.tsx.cache

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.observer = void 0;
+const mobx_1 = require("mobx");
+let globalConstructOrder = 1;
+function observer(Constructor) {
+    let name = Constructor.name;
+    return class extends Constructor {
+        constructor() {
+            super(...arguments);
+            this.reaction = new mobx_1.Reaction(`render.${name}.${globalConstructOrder++}`, () => {
+                super.forceUpdate();
+            });
+        }
+        // @ts-ignore
+        static get name() { return Constructor.name; }
+        componentWillUnmount() {
+            var _a;
+            this.reaction.dispose();
+            (_a = super.componentWillUnmount) === null || _a === void 0 ? void 0 : _a.call(this);
+        }
+        render(...args) {
+            let output;
+            this.reaction.track(() => {
+                output = super.render(...args);
+            });
+            return output;
+        }
+    };
+}
+exports.observer = observer;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "aa8d03d3849c2a27da30d4ba63a17e14c12256a9cf8719a3f9f17af6f7f83c98"; */

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