sliftutils 0.10.0 → 0.12.0

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.newCachedStrStorage = void 0;
+const DelayedStorage_1 = require("./DelayedStorage");
+const FileFolderAPI_1 = require("./FileFolderAPI");
+const JSONStorage_1 = require("./JSONStorage");
+const PendingStorage_1 = require("./PendingStorage");
+const StorageObservable_1 = require("./StorageObservable");
+function newCachedStrStorage(folder, getValue) {
+    let base = new PendingStorage_1.PendingStorage(`CachedStrStorage`, new DelayedStorage_1.DelayedStorage((0, FileFolderAPI_1.getFileStorageNested)(folder)));
+    let storage = new StorageObservable_1.StorageSync(new JSONStorage_1.JSONStorage(base));
+    let pending = new Set();
+    let baseStorageGet = storage.get;
+    storage.get = (key) => {
+        if (!pending.has(key)) {
+            pending.add(key);
+            (async () => {
+                let existingValue = await storage.getPromise(key);
+                if (existingValue)
+                    return;
+                let value = await getValue(key);
+                storage.set(key, value);
+            })().catch(console.error);
+        }
+        return baseStorageGet.call(storage, key);
+    };
+    return storage;
+}
+exports.newCachedStrStorage = newCachedStrStorage;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "6b417b9d5a7a6f24cd23d3bb315476365b196d7a7314bc05772769aebd4cfeaf"; */

package/storage/dist/DelayedStorage.ts.cache

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.DelayedStorage = void 0;
+class DelayedStorage {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async get(key) {
+        const storage = await this.storage;
+        return storage.get(key);
+    }
+    async set(key, value) {
+        const storage = await this.storage;
+        return storage.set(key, value);
+    }
+    async remove(key) {
+        const storage = await this.storage;
+        return storage.remove(key);
+    }
+    async getKeys() {
+        const storage = await this.storage;
+        return storage.getKeys();
+    }
+    async getInfo(key) {
+        const storage = await this.storage;
+        return storage.getInfo(key);
+    }
+    async reset() {
+        const storage = await this.storage;
+        return storage.reset();
+    }
+}
+exports.DelayedStorage = DelayedStorage;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "1677f66b78d575c994d05644480c2abd0bd91d4dc1c9229dacb970af14213878"; */