@exodus/atoms 7.0.5 → 7.2.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [7.2.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@7.1.0...@exodus/atoms@7.2.0) (2024-04-16)
+
+### Features
+
+- add `mergeWithValue` enhancer ([#6390](https://github.com/ExodusMovement/exodus-hydra/issues/6390)) ([125d708](https://github.com/ExodusMovement/exodus-hydra/commit/125d708bcf541c56248241fc921e53755c398671))
+
+## [7.1.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@7.0.5...@exodus/atoms@7.1.0) (2024-04-15)
+
+### Features
+
+- add `atom.reset` ([#6461](https://github.com/ExodusMovement/exodus-hydra/issues/6461)) ([f687e48](https://github.com/ExodusMovement/exodus-hydra/commit/f687e4836dd36d478bde0dc3a86d481c40d15c78))
+
+### Bug Fixes
+
+- omit undefined from storage atom type when defaultValue set ([#6507](https://github.com/ExodusMovement/exodus-hydra/issues/6507)) ([2c8590c](https://github.com/ExodusMovement/exodus-hydra/commit/2c8590c5e2e6be30ab5df1d6702c37e14c5e76d5))
+
 ## [7.0.5](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@7.0.4...@exodus/atoms@7.0.5) (2024-02-28)
 
 ### Bug Fixes

package/lib/enforce-rules.d.ts

@@ -3,6 +3,6 @@ type Params<T> = {
     getInitialized?: () => boolean;
     defaultValue?: T;
     set: (value: T) => Promise<void>;
-} & Omit<Atom<T>, 'set'>;
+} & Omit<Atom<T>, 'set' | 'reset'>;
 declare const enforceObservableRules: <T>({ defaultValue, getInitialized, ...atom }: Params<T>) => Atom<T>;
 export default enforceObservableRules;

package/lib/enforce-rules.js

@@ -53,6 +53,7 @@ const enforceObservableRules = ({ defaultValue, getInitialized = () => true, ...
     return {
         get,
         set,
+        reset: () => set(undefined),
         observe,
     };
 };

package/lib/enhancers/block-until.d.ts

@@ -8,5 +8,6 @@ export default function blockUntil<T>({ atom, unblock }: Params<T>): {
     observe: (listener: Listener<T>) => () => void;
     set(value: T): Promise<void>;
     set(setter: import("../utils/types.js").Setter<T>): Promise<void>;
+    reset(): Promise<void>;
 };
 export {};

package/lib/enhancers/merge-with-value.d.ts

@@ -0,0 +1,7 @@
+import { Atom } from '../utils/types.js';
+type Params<T extends object> = {
+    atom: Atom<T>;
+    value: T;
+};
+declare const mergeWithValue: <T extends object>({ atom, value }: Params<T>) => Atom<T>;
+export default mergeWithValue;

package/lib/enhancers/merge-with-value.js

@@ -0,0 +1,27 @@
+const mergeWithValue = ({ atom, value }) => {
+    const get = async () => {
+        const values = await atom.get();
+        return { ...value, ...values };
+    };
+    const observe = (callback) => {
+        return atom.observe((values) => {
+            const finalValue = { ...value, ...values };
+            return callback(finalValue);
+        });
+    };
+    const set = async (newValue) => {
+        if (typeof newValue === 'function') {
+            return atom.set((currentValue) => {
+                return newValue({ ...value, ...currentValue });
+            });
+        }
+        return atom.set({ ...value, ...newValue });
+    };
+    return {
+        ...atom,
+        set,
+        get,
+        observe,
+    };
+};
+export default mergeWithValue;

package/lib/enhancers/swallow-observer-errors.d.ts

@@ -8,5 +8,6 @@ declare const swallowObserverErrors: <T>({ atom, logger }: Params<T>) => {
     get(): Promise<T>;
     set(value: T): Promise<void>;
     set(setter: import("../utils/types.js").Setter<T>): Promise<void>;
+    reset(): Promise<void>;
 };
 export default swallowObserverErrors;

package/lib/factories/storage.d.ts

@@ -3,10 +3,13 @@ import { Storage } from '@exodus/storage-interface';
 type FactoryParams<T> = {
     storage: Storage<T>;
 };
-type Params<T> = {
+type Params<D> = {
     key: string;
-    defaultValue?: T;
+    defaultValue?: D;
     isSoleWriter?: boolean;
 };
-declare const createStorageAtomFactory: <T>({ storage }: FactoryParams<T>) => ({ key, defaultValue, isSoleWriter }: Params<T>) => Atom<T | undefined>;
+declare const createStorageAtomFactory: <T>({ storage }: FactoryParams<T>) => {
+    (opts: Omit<Params<unknown>, 'defaultValue'>): Atom<T | undefined>;
+    <D extends T>(opts: Params<D>): Atom<T | D>;
+};
 export default createStorageAtomFactory;

package/lib/factories/storage.js

@@ -1,46 +1,49 @@
 import createSimpleObserver from '../simple-observer.js';
 import enforceObservableRules from '../enforce-rules.js';
 import pDefer from 'p-defer';
-const createStorageAtomFactory = ({ storage }) => ({ key, defaultValue, isSoleWriter }) => {
-    const { notify, observe } = createSimpleObserver({ enable: isSoleWriter });
-    let cached;
-    let writePromiseDefer;
-    const set = async (value) => {
-        if (value === undefined) {
-            writePromiseDefer = pDefer();
-            await storage.delete(key);
-        }
-        else {
-            writePromiseDefer = pDefer();
-            await storage.set(key, value);
-        }
-        writePromiseDefer.resolve();
-        if (isSoleWriter) {
-            cached = value;
-            await notify(value);
-        }
-    };
-    const get = async () => {
-        if (cached) {
-            return cached;
-        }
-        if (writePromiseDefer) {
-            await writePromiseDefer.promise;
-        }
-        if (cached) {
-            return cached;
-        }
-        const value = await storage.get(key);
-        if (isSoleWriter) {
-            cached = value;
-        }
-        return value;
-    };
-    return enforceObservableRules({
-        get,
-        set,
-        observe,
-        defaultValue,
-    });
+const createStorageAtomFactory = ({ storage }) => {
+    function createStorageAtom({ key, defaultValue, isSoleWriter, }) {
+        const { notify, observe } = createSimpleObserver({ enable: isSoleWriter });
+        let cached;
+        let writePromiseDefer;
+        const set = async (value) => {
+            if (value === undefined) {
+                writePromiseDefer = pDefer();
+                await storage.delete(key);
+            }
+            else {
+                writePromiseDefer = pDefer();
+                await storage.set(key, value);
+            }
+            writePromiseDefer.resolve();
+            if (isSoleWriter) {
+                cached = value;
+                await notify(value);
+            }
+        };
+        const get = async () => {
+            if (cached) {
+                return cached;
+            }
+            if (writePromiseDefer) {
+                await writePromiseDefer.promise;
+            }
+            if (cached) {
+                return cached;
+            }
+            const value = await storage.get(key);
+            if (isSoleWriter) {
+                cached = value;
+            }
+            return value;
+        };
+        return enforceObservableRules({
+            get,
+            set,
+            observe,
+            defaultValue,
+        });
+    }
+    return createStorageAtom;
 };
 export default createStorageAtomFactory;

package/lib/index.d.ts

@@ -16,6 +16,7 @@ export { default as warnOnSameValueSet } from './enhancers/warn-on-same-value-se
 export { default as swallowObserverErrors } from './enhancers/swallow-observer-errors.js';
 export { default as timeoutObservers } from './enhancers/timeout-observers.js';
 export { default as optimisticNotifier } from './enhancers/optimistic-notifier.js';
+export { default as mergeWithValue } from './enhancers/merge-with-value.js';
 export { default as waitUntil } from './effects/wait-until.js';
 export { default as enforceObservableRules } from './enforce-rules.js';
 export { default as fromEventEmitter } from './event-emitter.js';

package/lib/index.js

@@ -16,6 +16,7 @@ export { default as warnOnSameValueSet } from './enhancers/warn-on-same-value-se
 export { default as swallowObserverErrors } from './enhancers/swallow-observer-errors.js';
 export { default as timeoutObservers } from './enhancers/timeout-observers.js';
 export { default as optimisticNotifier } from './enhancers/optimistic-notifier.js';
+export { default as mergeWithValue } from './enhancers/merge-with-value.js';
 export { default as waitUntil } from './effects/wait-until.js';
 export { default as enforceObservableRules } from './enforce-rules.js';
 export { default as fromEventEmitter } from './event-emitter.js';

package/lib/utils/types.d.ts

@@ -10,8 +10,9 @@ export interface Atom<T> {
     set(value: T): Promise<void>;
     set(setter: Setter<T>): Promise<void>;
     observe(listener: Listener<T>): Unsubscribe;
+    reset(): Promise<void>;
 }
-export type ReadonlyAtom<T> = Omit<Atom<T>, 'set'>;
+export type ReadonlyAtom<T> = Omit<Atom<T>, 'set' | 'reset'>;
 export type KeystoreValue = string | number;
 export interface Port<T> {
     emit(event: string, value: T): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/atoms",
-  "version": "7.0.5",
+  "version": "7.2.0",
   "description": "Abstraction for encapsulating a piece of data behind a simple unified interface: get, set, observe",
   "type": "module",
   "main": "lib/index.js",
@@ -45,5 +45,5 @@
     "@types/lodash": "^4.14.200",
     "@types/minimalistic-assert": "^1.0.2"
   },
-  "gitHead": "c21223c12402e16bdc94166fbf089e191c077cdd"
+  "gitHead": "fa602a1a0c09f5e0afe7218d05a85eb162ae84c8"
 }