sliftutils 0.35.0 → 0.37.0

package/builders/webBuild.ts

@@ -38,8 +38,8 @@ async function main() {
     // Collect all files to copy
     let filesToCopy: string[] = [];
 
+    filesToCopy.push(yargObj.indexHtml);
     if (hasIndexHtml) {
-        filesToCopy.push(yargObj.indexHtml);
     }
 
     // Add assets folder files if it exists
@@ -59,6 +59,8 @@ async function main() {
         }
     }
 
+    let indexHtmlOutput = "";
+
     let filesCopied = 0;
     let root = path.resolve(".");
     for (const file of filesToCopy) {
@@ -70,6 +72,10 @@ async function main() {
         let relativePath = path.relative(root, sourcePath);
         let destPath = path.join(yargObj.outputFolder, relativePath);
 
+        if (file === yargObj.indexHtml) {
+            indexHtmlOutput = destPath;
+        }
+
         let sourceTimestamp = await getTimestamp(sourcePath);
         let destTimestamp = await getTimestamp(destPath);
         if (sourceTimestamp > destTimestamp) {
@@ -84,6 +90,7 @@ async function main() {
 
     let duration = Date.now() - time;
     console.log(`Web build completed in ${formatTime(duration)}`);
+    console.log(`file://${path.resolve(indexHtmlOutput).replaceAll("\\", "/")}`);
 }
 main().catch(console.error).finally(() => process.exit());
 

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.35.0",
+    "version": "0.37.0",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/spec.txt

@@ -1,3 +1,6 @@
+TODO: Take the half finished apiServer code in vidfrontend, finish the todos, and move it here.
+    - Having an alternate version, where we run a server that does watching is nice, it's heavier and does require setting up certificates. but it makes hot reloading faster. And... It can be used to run an actual site that's public.  
+
 ALSO, go fix our typings in socket-function as well
 
 TODO:

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

@@ -1,7 +1,7 @@
 import { isNode } from "typesafecss";
 import { DelayedStorage } from "./DelayedStorage";
 import { FileStorage, getFileStorage, getFileStorageNested } from "./FileFolderAPI";
-import { IStorage, IStorageSync } from "./IStorage";
+import { IStorage, IStorageRaw, IStorageSync } from "./IStorage";
 import { JSONStorage } from "./JSONStorage";
 import { StorageSync } from "./StorageObservable";
 import { TransactionStorage } from "./TransactionStorage";
@@ -9,23 +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);
+        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);
+        }
+        let baseStorage = new TransactionStorage(curCollection, this.collectionName, this.config?.writeDelay);
         this.transactionStorage = baseStorage;
-        return new JSONStorage<T>(baseStorage);
+        return this.config?.cbor ? new CBORStorage<T>(baseStorage) : new JSONStorage<T>(baseStorage);
     }
     public baseStorage = this.initStorage();
     private synced = new StorageSync(
@@ -82,73 +92,6 @@ export class DiskCollection<T> implements IStorageSync<T> {
     }
 }
 
-export class DiskCollectionBrowser<T> implements IStorageSync<T> {
-    constructor(
-        private collectionName: string,
-        private writeDelay?: number,
-    ) {
-    }
-    public transactionStorage: TransactionStorage | undefined;
-    async initStorage(): Promise<IStorage<T>> {
-        if (isNode()) return undefined as any;
-        let curCollection = await new PrivateFileSystemStorage(`collections/${this.collectionName}`);
-        let baseStorage = new TransactionStorage(curCollection, this.collectionName);
-        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 DiskCollectionPromise<T> implements IStorage<T> {
     constructor(