sliftutils 0.36.0 → 0.37.0

package/index.d.ts

@@ -417,6 +417,26 @@ declare module "sliftutils/render-utils/observer" {
 
 }
 
+declare module "sliftutils/storage/CBORStorage" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IStorage } from "./IStorage";
+    export declare class CBORStorage<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/CachedStorage" {
     import { StorageSync } from "./StorageObservable";
     export declare function newCachedStrStorage<T>(folder: string, getValue: (key: string) => Promise<T>): StorageSync<T>;
@@ -449,31 +469,12 @@ declare module "sliftutils/storage/DiskCollection" {
     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);
+        private config?;
+        constructor(collectionName: string, config?: {
+            writeDelay?: number | undefined;
+            cbor?: boolean | undefined;
+            browserOnly?: boolean | undefined;
+        } | undefined);
         transactionStorage: TransactionStorage | undefined;
         initStorage(): Promise<IStorage<T>>;
         baseStorage: Promise<IStorage<T>>;

package/package.json

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

package/storage/CBORStorage.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IStorage } from "./IStorage";
+export declare class CBORStorage<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/CBORStorage.ts

@@ -0,0 +1,37 @@
+import { lazy } from "socket-function/src/caching";
+import { IStorage } from "./IStorage";
+import cborx from "cbor-x";
+const cborEncoder = lazy(() => new cborx.Encoder({ structuredClone: true }));
+
+
+export class CBORStorage<T> implements IStorage<T> {
+    constructor(private storage: IStorage<Buffer>) { }
+    public async get(key: string): Promise<T | undefined> {
+        let buffer = await this.storage.get(key);
+        if (buffer === undefined) {
+            return undefined;
+        }
+        try {
+            return cborEncoder().decode(buffer);
+        } catch (e) {
+            console.warn(`Failed to parse CBOR for key: ${key}`, e);
+        }
+    }
+    public async set(key: string, value: T): Promise<void> {
+        await this.storage.set(key, cborEncoder().encode(value));
+    }
+    public async remove(key: string): Promise<void> {
+        await this.storage.remove(key);
+    }
+    public async getKeys(): Promise<string[]> {
+        return await this.storage.getKeys();
+    }
+    public async getInfo(key: string) {
+        return await this.storage.getInfo(key);
+    }
+
+    public async reset() {
+        await this.storage.reset();
+    }
+}
+

package/storage/DiskCollection.d.ts

@@ -5,31 +5,12 @@ 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);
+    private config?;
+    constructor(collectionName: string, config?: {
+        writeDelay?: number | undefined;
+        cbor?: boolean | undefined;
+        browserOnly?: boolean | undefined;
+    } | undefined);
     transactionStorage: TransactionStorage | undefined;
     initStorage(): Promise<IStorage<T>>;
     baseStorage: Promise<IStorage<T>>;

package/storage/DiskCollection.ts

@@ -9,97 +9,33 @@ import { PendingStorage } from "./PendingStorage";
 import { isDefined } from "../misc/types";
 import { PrivateFileSystemStorage } from "./PrivateFileSystemStorage";
 import { isInChromeExtension } from "../misc/environment";
+import { CBORStorage } from "./CBORStorage";
 
 export class DiskCollection<T> implements IStorageSync<T> {
     constructor(
         private collectionName: string,
-        private writeDelay?: number,
+        private config?: {
+            writeDelay?: number;
+            cbor?: boolean;
+            browserOnly?: boolean;
+        }
     ) {
     }
     public transactionStorage: TransactionStorage | undefined;
     async initStorage(): Promise<IStorage<T>> {
         // If a Chrome extension, just return null. 
         if (isInChromeExtension()) return null as any;
-        let fileStorage = await getFileStorage();
-        let collections = await fileStorage.folder.getStorage("collections");
-        let curCollection = await collections.folder.getStorage(this.collectionName);
-        let baseStorage = new TransactionStorage(curCollection, this.collectionName, this.writeDelay);
-        this.transactionStorage = baseStorage;
-        return new JSONStorage<T>(baseStorage);
-    }
-    public baseStorage = this.initStorage();
-    private synced = new StorageSync(
-        new PendingStorage(`Collection (${this.collectionName})`,
-            new DelayedStorage<T>(this.baseStorage)
-        )
-    );
-
-    public get(key: string): T | undefined {
-        return this.synced.get(key);
-    }
-    public async getPromise(key: string): Promise<T | undefined> {
-        let base = await this.baseStorage;
-        return base.get(key);
-    }
-    public set(key: string, value: T): void {
-        this.synced.set(key, value);
-    }
-    public remove(key: string): void {
-        this.synced.remove(key);
-    }
-    public getKeys(): string[] {
-        return this.synced.getKeys();
-    }
-    public getKeysPromise(): Promise<string[]> {
-        return this.synced.getKeysPromise();
-    }
-
-    public getEntries(): [string, T][] {
-        let keys = this.getKeys();
-        return keys.map(key => [key, this.get(key)]).filter(([_, value]) => isDefined(value)) as [string, T][];
-    }
-    public getValues(): T[] {
-        let keys = this.getKeys();
-        return keys.map(key => this.get(key)).filter(isDefined);
-    }
-    public async getValuesPromise(): Promise<T[]> {
-        let keys = await this.getKeysPromise();
-        let values: T[] = [];
-        for (let key of keys) {
-            let value = await this.getPromise(key);
-            if (isDefined(value)) {
-                values.push(value);
-            }
-        }
-        return values;
-    }
-    public getInfo(key: string) {
-        return this.synced.getInfo(key);
-    }
-
-    public async reset() {
-        await this.synced.reset();
-    }
-}
-
-export class DiskCollectionBrowser<T> implements IStorageSync<T> {
-    constructor(
-        private collectionName: string,
-        private writeDelay?: number,
-    ) {
-    }
-    public transactionStorage: TransactionStorage | undefined;
-    async initStorage(): Promise<IStorage<T>> {
-        let curCollection: IStorageRaw | undefined;
-        if (isNode()) {
+        let curCollection: IStorageRaw;
+        if (this.config?.browserOnly) {
+            curCollection = await new PrivateFileSystemStorage(`collections/${this.collectionName}`);
+        } else {
             let fileStorage = await getFileStorage();
             let collections = await fileStorage.folder.getStorage("collections");
             curCollection = await collections.folder.getStorage(this.collectionName);
-        } else {
-            curCollection = await new PrivateFileSystemStorage(`collections/${this.collectionName}`);
         }
-        let baseStorage = new TransactionStorage(curCollection, this.collectionName);
-        return new JSONStorage<T>(baseStorage);
+        let baseStorage = new TransactionStorage(curCollection, this.collectionName, this.config?.writeDelay);
+        this.transactionStorage = baseStorage;
+        return this.config?.cbor ? new CBORStorage<T>(baseStorage) : new JSONStorage<T>(baseStorage);
     }
     public baseStorage = this.initStorage();
     private synced = new StorageSync(
@@ -156,6 +92,7 @@ export class DiskCollectionBrowser<T> implements IStorageSync<T> {
     }
 }
 
+
 export class DiskCollectionPromise<T> implements IStorage<T> {
     constructor(
         private collectionName: string,