sliftutils 0.86.0 → 0.88.0

package/builders/setup.ts

@@ -78,7 +78,7 @@ async function main() {
     let packageJsonPath = path.join(targetDir, "package.json");
     if (fs.existsSync(packageJsonPath)) {
         console.log("\nUpdating package.json scripts...");
-        updatePackageJson(packageJsonPath);
+        await updatePackageJson(packageJsonPath);
     } else {
         console.warn("\nNo package.json found in target directory");
     }
@@ -136,7 +136,7 @@ function replaceImports(content: string, importMappings: { [key: string]: string
     return processedLines.join("\n");
 }
 
-function updatePackageJson(packageJsonPath: string) {
+async function updatePackageJson(packageJsonPath: string) {
     let packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
 
     // Read our current package.json to get the type script
@@ -191,8 +191,22 @@ function updatePackageJson(packageJsonPath: string) {
         }
     }
 
+    let needsYarnInstall = false;
+
+    // ALSO, add socket-function, if it doesn't have it already. This fixes intelliSense, for socket-function, which has a lot of useful utilities related to caching.
+    if (!packageJson.dependencies?.["socket-function"]) {
+        packageJson.dependencies = packageJson.dependencies || {};
+        packageJson.dependencies["socket-function"] = "*";
+        needsYarnInstall = true;
+    }
+
     fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, undefined, 4) + "\n", "utf8");
     console.log("  package.json updated");
+
+    if (needsYarnInstall) {
+        console.log("  Needs yarn install");
+        await execSync("yarn install", { cwd: path.dirname(packageJsonPath), stdio: "inherit" });
+    }
 }
 
 main().catch(error => {

package/index.d.ts

@@ -127,6 +127,8 @@ declare module "sliftutils/misc/random" {
 
 declare module "sliftutils/misc/types" {
     export declare function isDefined<T>(value: T | undefined | null): value is T;
+    export declare function freezeObject(value: unknown): unknown;
+    export declare function deepFreezeObject(value: unknown): void;
 
 }
 
@@ -658,6 +660,12 @@ declare module "sliftutils/storage/DiskCollection" {
             writeDelay?: number | undefined;
             cbor?: boolean | undefined;
             noPrompt?: boolean | undefined;
+            freeze?: "deep" | "shallow" | undefined;
+            beforeWrite?: ((update: {
+                newValue: T;
+                key: string;
+                collection: DiskCollection<T>;
+            }) => void) | undefined;
         } | undefined);
         transactionStorage: TransactionStorage | undefined;
         initStorage(): Promise<IStorage<T>>;
@@ -969,6 +977,7 @@ declare module "sliftutils/storage/StorageObservable" {
     import { IStorage, IStorageSync } from "./IStorage";
     export declare class StorageSync<T> implements IStorageSync<T> {
         storage: IStorage<T>;
+        private config?;
         cached: import("mobx").ObservableMap<string, T | undefined>;
         infoCached: import("mobx").ObservableMap<string, {
             size: number;
@@ -978,7 +987,14 @@ declare module "sliftutils/storage/StorageObservable" {
         synced: {
             keySeqNum: number;
         };
-        constructor(storage: IStorage<T>);
+        constructor(storage: IStorage<T>, config?: {
+            freeze?: "deep" | "shallow" | undefined;
+            beforeWrite?: ((update: {
+                newValue: T;
+                key: string;
+                collection: StorageSync<T>;
+            }) => void) | undefined;
+        } | undefined);
         get(key: string): T | undefined;
         set(key: string, value: T): void;
         remove(key: string): void;

package/misc/types.d.ts

@@ -1 +1,3 @@
 export declare function isDefined<T>(value: T | undefined | null): value is T;
+export declare function freezeObject(value: unknown): unknown;
+export declare function deepFreezeObject(value: unknown): void;

package/misc/types.ts

@@ -1,3 +1,24 @@
 export function isDefined<T>(value: T | undefined | null): value is T {
     return value !== undefined && value !== null;
+}
+
+
+export function freezeObject(value: unknown) {
+    if (!value) return value;
+    Object.freeze(value);
+}
+
+export function deepFreezeObject(value: unknown) {
+    if (!value) return;
+    if (typeof value !== "object") return;
+    if (Object.isFrozen(value)) return;
+
+    Object.freeze(value);
+
+    Object.getOwnPropertyNames(value).forEach(prop => {
+        const propValue = (value as any)[prop];
+        if (propValue && typeof propValue === "object") {
+            deepFreezeObject(propValue);
+        }
+    });
 }

package/package.json

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

package/storage/DiskCollection.d.ts

@@ -10,6 +10,12 @@ export declare class DiskCollection<T> implements IStorageSync<T> {
         writeDelay?: number | undefined;
         cbor?: boolean | undefined;
         noPrompt?: boolean | undefined;
+        freeze?: "deep" | "shallow" | undefined;
+        beforeWrite?: ((update: {
+            newValue: T;
+            key: string;
+            collection: DiskCollection<T>;
+        }) => void) | undefined;
     } | undefined);
     transactionStorage: TransactionStorage | undefined;
     initStorage(): Promise<IStorage<T>>;

package/storage/DiskCollection.ts

@@ -18,6 +18,9 @@ export class DiskCollection<T> implements IStorageSync<T> {
             writeDelay?: number;
             cbor?: boolean;
             noPrompt?: boolean;
+            freeze?: "shallow" | "deep";
+            // May mutate newValue in order to change what will be written
+            beforeWrite?: (update: { newValue: T; key: string; collection: DiskCollection<T> }) => void;
         }
     ) {
     }
@@ -41,7 +44,11 @@ export class DiskCollection<T> implements IStorageSync<T> {
     private synced = new StorageSync(
         new PendingStorage(`Collection (${this.collectionName})`,
             new DelayedStorage<T>(this.baseStorage)
-        )
+        ),
+        {
+            freeze: this.config?.freeze,
+            beforeWrite: this.config?.beforeWrite && ((update) => this.config!.beforeWrite!({ ...update, collection: this })),
+        }
     );
 
     public get(key: string): T | undefined {

package/storage/StorageObservable.d.ts

@@ -1,6 +1,7 @@
 import { IStorage, IStorageSync } from "./IStorage";
 export declare class StorageSync<T> implements IStorageSync<T> {
     storage: IStorage<T>;
+    private config?;
     cached: import("mobx").ObservableMap<string, T | undefined>;
     infoCached: import("mobx").ObservableMap<string, {
         size: number;
@@ -10,7 +11,14 @@ export declare class StorageSync<T> implements IStorageSync<T> {
     synced: {
         keySeqNum: number;
     };
-    constructor(storage: IStorage<T>);
+    constructor(storage: IStorage<T>, config?: {
+        freeze?: "deep" | "shallow" | undefined;
+        beforeWrite?: ((update: {
+            newValue: T;
+            key: string;
+            collection: StorageSync<T>;
+        }) => void) | undefined;
+    } | undefined);
     get(key: string): T | undefined;
     set(key: string, value: T): void;
     remove(key: string): void;

package/storage/StorageObservable.ts

@@ -1,5 +1,5 @@
 import { observable } from "mobx";
-import { isDefined } from "../misc/types";
+import { deepFreezeObject, freezeObject, isDefined } from "../misc/types";
 import { IStorage, IStorageSync } from "./IStorage";
 
 // NOTE: At around 500K values (depending on their size to some degree), this will take about 2 minutes to load. But once it does it will be fast. So... keep that in mind. I recommend not exceeding 100K
@@ -11,7 +11,11 @@ export class StorageSync<T> implements IStorageSync<T> {
         keySeqNum: 0,
     }, undefined, { deep: false });
 
-    constructor(public storage: IStorage<T>) {
+    constructor(public storage: IStorage<T>, private config?: {
+        freeze?: "shallow" | "deep";
+        // May mutate newValue in order to change what will be written
+        beforeWrite?: (update: { newValue: T; key: string; collection: StorageSync<T> }) => void;
+    }) {
         storage.watchResync?.(async () => {
             // NOTE: If there's multiple tabs open, this'll trigger a lot, so we can't just clear all the values, as that'll cause a render where nothing's loaded. 
             this.loadedKeys = false;
@@ -33,6 +37,9 @@ export class StorageSync<T> implements IStorageSync<T> {
         return this.cached.get(key);
     }
     public set(key: string, value: T): void {
+        if (this.config?.beforeWrite) {
+            this.config.beforeWrite({ newValue: value, key, collection: this });
+        }
         if (!this.keys.has(key)) {
             this.keys.add(key);
             this.synced.keySeqNum++;
@@ -79,7 +86,12 @@ export class StorageSync<T> implements IStorageSync<T> {
         let value = this.cached.get(key);
         if (value === undefined) {
             value = await this.storage.get(key);
-            if (this.cached.get(key) === undefined) {
+            if (value !== undefined && this.cached.get(key) === undefined) {
+                if (this.config?.freeze === "shallow") {
+                    freezeObject(value);
+                } else if (this.config?.freeze === "deep") {
+                    deepFreezeObject(value);
+                }
                 this.cached.set(key, value);
             }
         }

package/storage/TransactionStorage.ts

@@ -401,26 +401,20 @@ export class TransactionStorage implements IStorage<Buffer> {
                 this.cache.delete(entry.key);
             } else {
                 if (!anyChanged && !initialLoad) {
-                    let prev = this.cache.get(entry.key);
-                    if (!prev) {
-                        anyChanged = true;
-                    } else {
-                        if (!prev.value) {
-                            if (entry.value) {
-                                anyChanged = true;
-                            }
-                        } else {
-                            if (!entry.value) {
-                                anyChanged = true;
-                            } else {
-                                // Both values, so... it might not have changed
-                                if (!prev.value.equals(entry.value)) {
-                                    anyChanged = true;
-                                }
-                            }
+                    const hasChanged = () => {
+                        let prev = this.cache.get(entry.key);
+                        if (!prev) {
+                            return true;
                         }
-                    }
+                        if (!!prev.value !== !!entry.value) return true;
+                        if (prev.value && entry.value && !prev.value.equals(entry.value)) {
+                            return true;
+                        }
+                        return false;
+                    };
+                    anyChanged = hasChanged() || anyChanged;
                 }
+
                 this.cache.set(entry.key, entry);
             }
         }

package/web/ExamplePage.tsx

@@ -13,24 +13,6 @@ export class ExamplePage extends preact.Component {
         count: 0,
     });
 
-    onKeyDown = (e: KeyboardEvent) => {
-        // Skip if the current target is an ipnut
-        if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) {
-            return;
-        }
-        let hotkeySelector = `[data-hotkey="${e.code}"]`;
-        let elements = document.querySelectorAll(hotkeySelector);
-        for (let element of elements) {
-            (element as HTMLElement).click();
-        }
-    };
-    componentDidMount(): void {
-        document.addEventListener("keydown", this.onKeyDown);
-    }
-    componentWillUnmount(): void {
-        document.removeEventListener("keydown", this.onKeyDown);
-    }
-
     render() {
         return (
             <div className={css.pad2(20)}>