@exodus/atoms 5.7.3 → 6.0.1

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [6.0.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@6.0.0...@exodus/atoms@6.0.1) (2023-10-25)
+
+### Bug Fixes
+
+- **atom:** valueEmittedFromGet is not cleared in the observe ([#4566](https://github.com/ExodusMovement/exodus-hydra/issues/4566)) ([e1eb8a0](https://github.com/ExodusMovement/exodus-hydra/commit/e1eb8a0e690614c154c48cfed5dc5471eb06400a))
+
+## [6.0.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@5.7.3...@exodus/atoms@6.0.0) (2023-10-21)
+
+### ⚠ BREAKING CHANGES
+
+- atoms to typescript (#4505)
+
+### Bug Fixes
+
+- dedupe enhancer when `set` called with function ([#4515](https://github.com/ExodusMovement/exodus-hydra/issues/4515)) ([ac63578](https://github.com/ExodusMovement/exodus-hydra/commit/ac6357880b5d14238bdcb1bd6a4d06a2b698fb58))
+
+### Code Refactoring
+
+- atoms to typescript ([#4505](https://github.com/ExodusMovement/exodus-hydra/issues/4505)) ([3873134](https://github.com/ExodusMovement/exodus-hydra/commit/3873134baacd69602d13e228be797eb7a96ad13e))
+
 ## [5.7.3](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@5.7.2...@exodus/atoms@5.7.3) (2023-10-20)
 
 ### Bug Fixes

package/lib/countdown-lock.d.ts

@@ -0,0 +1,5 @@
+declare const createCountdownLock: (keys: string[]) => {
+    promise: Promise<unknown>;
+    unlock: (key: string) => boolean;
+};
+export default createCountdownLock;

package/lib/countdown-lock.js

@@ -0,0 +1,24 @@
+import pDefer from 'p-defer';
+const createCountdownLock = (keys) => {
+    if (!Array.isArray(keys))
+        throw new TypeError('lock keys must be an array');
+    for (const key of keys) {
+        if (typeof key !== 'string')
+            throw new TypeError(`lock keys must be all strings. Invalid ${key}`);
+    }
+    const deferred = pDefer();
+    const unlockedKeys = [];
+    return {
+        promise: deferred.promise,
+        unlock: (key) => {
+            if (!unlockedKeys.includes(key))
+                unlockedKeys.push(key);
+            if (unlockedKeys.length === keys.length) {
+                deferred.resolve();
+                return true;
+            }
+            return false;
+        },
+    };
+};
+export default createCountdownLock;

package/lib/effects/wait-until.d.ts

@@ -0,0 +1,11 @@
+import { Atom } from '../utils/types';
+type Params<T> = {
+    atom: Atom<T>;
+    predicate: (value: T) => boolean;
+    rejectAfter?: number;
+};
+type UnobservablePromise<T> = Promise<T> & {
+    unobserve: () => void;
+};
+declare const waitUntil: <T>({ atom, predicate, rejectAfter }: Params<T>) => UnobservablePromise<T>;
+export default waitUntil;

package/lib/effects/wait-until.js

@@ -0,0 +1,28 @@
+const waitUntil = ({ atom, predicate, rejectAfter }) => {
+    let unobserve;
+    let timeout;
+    const promise = new Promise((resolve, reject) => {
+        unobserve = atom.observe((v) => {
+            if (predicate(v)) {
+                clearTimeout(timeout);
+                unobserve();
+                resolve(v);
+            }
+        });
+        if (rejectAfter) {
+            timeout = setTimeout(() => {
+                unobserve();
+                reject(new Error('rejected by timeout'));
+            }, rejectAfter);
+        }
+    });
+    Object.defineProperty(promise, 'unobserve', {
+        value: () => {
+            unobserve();
+            clearTimeout(timeout);
+        },
+        writable: false,
+    });
+    return promise;
+};
+export default waitUntil;

package/lib/enforce-rules.d.ts

@@ -0,0 +1,8 @@
+import { Atom } from './utils/types';
+type Params<T> = {
+    getInitialized?: () => boolean;
+    defaultValue?: T;
+    set: (value: T) => Promise<void>;
+} & Omit<Atom<T>, 'set'>;
+declare const enforceObservableRules: <T>({ defaultValue, getInitialized, ...atom }: Params<T>) => Atom<T>;
+export default enforceObservableRules;

package/lib/enforce-rules.js

@@ -0,0 +1,59 @@
+import makeConcurrent from 'make-concurrent';
+import proxyFreeze from 'proxy-freeze';
+import { isSetter } from './utils/guards';
+const withChangeDetection = (listener) => {
+    let currentValue;
+    let called = false;
+    return async (value) => {
+        if (called && value === currentValue)
+            return;
+        called = true;
+        currentValue = value;
+        await listener(currentValue);
+    };
+};
+const enforceObservableRules = ({ defaultValue, getInitialized = () => true, ...atom }) => {
+    const enqueue = makeConcurrent((fn) => fn(), { concurrency: 1 });
+    const postProcessValue = (value = defaultValue) => value && typeof value === 'object' ? proxyFreeze(value) : value;
+    const get = () => atom.get().then(postProcessValue);
+    const observe = (listener) => {
+        let called = false;
+        let valueEmittedFromGet;
+        listener = withChangeDetection(listener);
+        const publishSerially = (value) => {
+            called = true;
+            return enqueue(() => listener(value));
+        };
+        get().then((value) => {
+            if (!called) {
+                valueEmittedFromGet = value;
+                publishSerially(value);
+            }
+        });
+        return atom.observe((value) => {
+            if (valueEmittedFromGet) {
+                const isAlreadyEmitted = value === valueEmittedFromGet;
+                valueEmittedFromGet = undefined;
+                if (isAlreadyEmitted) {
+                    return;
+                }
+            }
+            return publishSerially(postProcessValue(value));
+        });
+    };
+    const set = makeConcurrent(async (value) => {
+        if (isSetter(value)) {
+            const current = getInitialized() ? await get() : defaultValue;
+            value = await value(current);
+            if (current === value)
+                return;
+        }
+        await atom.set(value);
+    });
+    return {
+        get,
+        set,
+        observe,
+    };
+};
+export default enforceObservableRules;

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

@@ -0,0 +1,12 @@
+import { Atom, Listener } from '../utils/types';
+type Params<T> = {
+    atom: Atom<T>;
+    unblock: () => Promise<unknown>;
+};
+export default function blockUntil<T>({ atom, unblock }: Params<T>): {
+    get: () => Promise<T>;
+    observe: (listener: Listener<T>) => () => void;
+    set(value: T): Promise<void>;
+    set(setter: import("../utils/types").Setter<T>): Promise<void>;
+};
+export {};

package/lib/enhancers/block-until.js

@@ -0,0 +1,20 @@
+export default function blockUntil({ atom, unblock }) {
+    const get = async () => unblock().then(atom.get);
+    return {
+        ...atom,
+        get,
+        observe: (listener) => {
+            let isSubscribed = true;
+            let unsubscribe = () => { };
+            unblock().then(() => {
+                if (isSubscribed) {
+                    unsubscribe = atom.observe(listener);
+                }
+            });
+            return () => {
+                isSubscribed = false;
+                unsubscribe();
+            };
+        },
+    };
+}

package/lib/enhancers/combine.d.ts

@@ -0,0 +1,8 @@
+import { Atom, ReadonlyAtom } from '../utils/types';
+type CombinedValue<T> = {
+    [Key in keyof T]: T[Key] extends Atom<infer U> ? U : never;
+};
+declare const combine: <T, U extends {
+    [key: string]: Atom<T>;
+}>(atoms: U) => ReadonlyAtom<CombinedValue<U>>;
+export default combine;

package/lib/enhancers/combine.js

@@ -0,0 +1,47 @@
+import createCountdownLock from '../countdown-lock';
+import createSimpleObserver from '../simple-observer';
+import enforceObservableRules from '../enforce-rules';
+const combine = (atoms) => {
+    const { notify, observe: observeSimpleObserver } = createSimpleObserver();
+    const countdownLock = createCountdownLock(Object.keys(atoms));
+    let values = {};
+    let subscriptions = [];
+    let subscribers = 0;
+    const maybeUnsubscribeSourceObservables = () => {
+        subscribers -= 1;
+        if (subscribers > 0)
+            return;
+        subscriptions.forEach((unsubscribe) => unsubscribe());
+        subscriptions = [];
+    };
+    const observe = (callback) => {
+        subscribers += 1;
+        if (subscribers === 1) {
+            subscriptions = Object.entries(atoms).map(([name, atom]) => atom.observe(async (value) => {
+                values = {
+                    ...values,
+                    [name]: value,
+                };
+                if (countdownLock.unlock(name))
+                    await notify(values);
+            }));
+        }
+        const unsubscribe = observeSimpleObserver(callback);
+        return () => {
+            unsubscribe();
+            maybeUnsubscribeSourceObservables();
+        };
+    };
+    const get = async () => {
+        return Object.fromEntries(await Promise.all(Object.entries(atoms).map(async ([name, atom]) => [name, await atom.get()])));
+    };
+    const set = async () => {
+        throw new Error('combine does not support method: set');
+    };
+    return enforceObservableRules({
+        get,
+        set,
+        observe,
+    });
+};
+export default combine;

package/lib/enhancers/compute.d.ts

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

package/lib/enhancers/compute.js

@@ -0,0 +1,28 @@
+const compute = ({ atom, selector }) => {
+    const get = async () => {
+        const values = await atom.get();
+        return selector(values);
+    };
+    const set = async () => {
+        throw new Error('selected atom does not support set');
+    };
+    const observe = (callback) => {
+        let prev;
+        let called;
+        return atom.observe((values) => {
+            const selected = selector(values);
+            if (called && prev === selected)
+                return;
+            called = true;
+            prev = selected;
+            return callback(selected);
+        });
+    };
+    return {
+        ...atom,
+        get,
+        set,
+        observe,
+    };
+};
+export default compute;

package/lib/enhancers/dedupe.d.ts

@@ -0,0 +1,3 @@
+import { Atom } from '../utils/types';
+declare const dedupe: <T>(atom: Atom<T>) => Atom<T>;
+export default dedupe;

package/lib/enhancers/dedupe.js

@@ -0,0 +1,29 @@
+import { isEqual } from 'lodash';
+import { isSetter } from '../utils/guards';
+const dedupe = (atom) => {
+    const set = (value) => {
+        if (value === undefined)
+            return atom.set(value);
+        return atom.set(async (previous) => {
+            const newValue = isSetter(value) ? await value(previous) : value;
+            return isEqual(previous, newValue) ? previous : newValue;
+        });
+    };
+    const observe = (callback) => {
+        let called = false;
+        let previous;
+        return atom.observe(async (value) => {
+            if (called && isEqual(previous, value))
+                return;
+            called = true;
+            previous = value;
+            return callback(value);
+        });
+    };
+    return {
+        ...atom,
+        set,
+        observe,
+    };
+};
+export default dedupe;

package/lib/enhancers/difference.d.ts

@@ -0,0 +1,9 @@
+import { Atom, Listener } from '../utils/types';
+type Diff<T> = {
+    previous?: T;
+    current: T;
+};
+declare const difference: <T>(atom: Atom<T>) => Omit<Atom<T>, "observe"> & {
+    observe: (listener: Listener<Diff<T>>) => import("../utils/types").Unsubscribe;
+};
+export default difference;

package/lib/enhancers/difference.js

@@ -0,0 +1,16 @@
+const difference = (atom) => {
+    const observe = (callback) => {
+        let prev;
+        const selector = (value) => {
+            const p = prev;
+            prev = value;
+            return { previous: p, current: value };
+        };
+        return atom.observe((value) => callback(selector(value)));
+    };
+    return {
+        ...atom,
+        observe,
+    };
+};
+export default difference;

package/lib/enhancers/optimistic-notifier.d.ts

@@ -0,0 +1,3 @@
+import { Atom } from '../utils/types';
+declare const optimisticNotifier: <T>(atom: Atom<T>) => Atom<T | undefined>;
+export default optimisticNotifier;

package/lib/enhancers/optimistic-notifier.js

@@ -0,0 +1,48 @@
+import makeConcurrent from 'make-concurrent';
+import createInMemoryAtom from '../factories/memory';
+const optimisticNotifier = (atom) => {
+    const memoryAtom = createInMemoryAtom();
+    const set = makeConcurrent(async (newValue) => {
+        let previous;
+        await memoryAtom.set((previousValue) => {
+            previous = previousValue;
+            return newValue;
+        });
+        atom
+            .set(newValue)
+            .catch(() => memoryAtom.set((value) => (value === newValue ? previous : value)));
+    });
+    let unsubscribeSource;
+    let subscribers = 0;
+    const maybeUnsubscribeSource = () => {
+        subscribers -= 1;
+        if (subscribers > 0)
+            return;
+        unsubscribeSource();
+        unsubscribeSource = undefined;
+    };
+    const observe = (callback) => {
+        if (subscribers === 0) {
+            unsubscribeSource = atom.observe(set);
+        }
+        subscribers += 1;
+        const unsubscribe = memoryAtom.observe(callback);
+        return () => {
+            unsubscribe();
+            maybeUnsubscribeSource();
+        };
+    };
+    const get = async () => {
+        if (subscribers === 0) {
+            return atom.get();
+        }
+        return memoryAtom.get();
+    };
+    return {
+        ...memoryAtom,
+        set,
+        get,
+        observe,
+    };
+};
+export default optimisticNotifier;

package/lib/enhancers/read-only.d.ts

@@ -0,0 +1,3 @@
+import { Atom, ReadonlyAtom } from '../utils/types';
+declare const readOnly: <T>(atom: Atom<T>) => ReadonlyAtom<T>;
+export default readOnly;

package/lib/enhancers/read-only.js

@@ -0,0 +1,10 @@
+const readOnly = (atom) => {
+    const set = async () => {
+        throw new Error('selected atom does not support set');
+    };
+    return {
+        ...atom,
+        set,
+    };
+};
+export default readOnly;

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

@@ -0,0 +1,12 @@
+import { Atom, Listener, Logger } from '../utils/types';
+type Params<T> = {
+    atom: Atom<T>;
+    logger: Logger;
+};
+declare const swallowObserverErrors: <T>({ atom, logger }: Params<T>) => {
+    observe: (observer: Listener<T>) => import("../utils/types").Unsubscribe;
+    get(): Promise<T>;
+    set(value: T): Promise<void>;
+    set(setter: import("../utils/types").Setter<T>): Promise<void>;
+};
+export default swallowObserverErrors;

package/lib/enhancers/swallow-observer-errors.js

@@ -0,0 +1,18 @@
+import assert from 'minimalistic-assert';
+const swallowObserverErrors = ({ atom, logger }) => {
+    assert(atom, 'expected "atom');
+    assert(typeof logger?.error === 'function', 'expected logger with ".error" function');
+    const observe = (observer) => atom.observe(async (...args) => {
+        try {
+            await observer(...args);
+        }
+        catch (err) {
+            logger.error('Observer threw error', err);
+        }
+    });
+    return {
+        ...atom,
+        observe,
+    };
+};
+export default swallowObserverErrors;

package/lib/enhancers/timeout-observers.d.ts

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

package/lib/enhancers/timeout-observers.js

@@ -0,0 +1,20 @@
+import delay from 'delay';
+import assert from 'minimalistic-assert';
+const timeoutObservers = ({ atom, timeout }) => {
+    assert(atom, 'expected "atom');
+    assert(typeof timeout === 'number', 'expected number "timeout"');
+    const observe = (observer) => atom.observe(async (...args) => {
+        const timeoutPromise = delay.reject(timeout, {
+            value: new Error('Observer timed out!'),
+        });
+        await Promise.race([
+            observer(...args),
+            timeoutPromise,
+        ]).then(() => timeoutPromise.clear());
+    });
+    return {
+        ...atom,
+        observe,
+    };
+};
+export default timeoutObservers;

package/lib/enhancers/warn-on-same-value-set.d.ts

@@ -0,0 +1,8 @@
+import { Atom, Logger } from '../utils/types';
+type Params<T> = {
+    atom: Atom<T>;
+    logger: Logger;
+    isEqual?: (a: unknown, b: unknown) => boolean;
+};
+declare const warnOnSameValueSet: <T>({ atom, isEqual, logger }: Params<T>) => Atom<T>;
+export default warnOnSameValueSet;

package/lib/enhancers/warn-on-same-value-set.js

@@ -0,0 +1,30 @@
+import assert from 'minimalistic-assert';
+import { isEqual as deepEqual } from 'lodash';
+const STRINGIFY_LIMIT = 1000;
+const limitedStringify = (obj, limit = STRINGIFY_LIMIT) => {
+    let count = 0;
+    return JSON.stringify(obj, (_, value) => {
+        if (count > limit) {
+            return;
+        }
+        if (count === limit) {
+            count++;
+            return '...more properties not shown';
+        }
+        count++;
+        return value;
+    });
+};
+const warnOnSameValueSet = ({ atom, isEqual = deepEqual, logger }) => {
+    assert(atom, 'expected "atom');
+    assert(typeof logger?.warn === 'function', 'expected logger with ".warn" function');
+    let previousValue;
+    atom.observe((value) => {
+        if (value !== undefined && isEqual(value, previousValue)) {
+            logger.warn(`Atom was called with the same value it currently holds: ${limitedStringify(value)}`);
+        }
+        previousValue = value;
+    });
+    return atom;
+};
+export default warnOnSameValueSet;

package/lib/enhancers/with-serialization.d.ts

@@ -0,0 +1,8 @@
+import { Atom } from '../utils/types';
+type Params<T, S> = {
+    atom: Atom<S>;
+    serialize: (value: T) => S;
+    deserialize: (serialized: S) => T;
+};
+declare const withSerialization: <T, S>({ atom, serialize, deserialize }: Params<T, S>) => Atom<T>;
+export default withSerialization;

package/lib/enhancers/with-serialization.js

@@ -0,0 +1,19 @@
+import { isSetter } from '../utils/guards';
+const withSerialization = ({ atom, serialize, deserialize }) => {
+    const get = async () => {
+        const serialized = await atom.get();
+        return deserialize(serialized);
+    };
+    const set = async (value) => {
+        if (isSetter(value)) {
+            return atom.set(async (previousValue) => serialize(await value(deserialize(previousValue))));
+        }
+        const serialized = serialize(value);
+        return atom.set(serialized);
+    };
+    const observe = (callback) => {
+        return atom.observe((value) => callback(deserialize(value), value));
+    };
+    return { ...atom, get, set, observe };
+};
+export default withSerialization;

package/lib/event-emitter.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from './utils/types';
+type Params<T> = {
+    emitter: EventEmitter;
+    event: string;
+    set: (value: T) => Promise<void>;
+    get: () => Promise<T>;
+    defaultValue?: T;
+    getInitialized?: () => boolean;
+};
+declare const fromEventEmitter: <T>({ emitter, event, get, set, defaultValue, getInitialized, }: Params<T>) => import("./utils/types").Atom<T>;
+export default fromEventEmitter;

package/lib/event-emitter.js

@@ -0,0 +1,15 @@
+import enforceObservableRules from './enforce-rules';
+const fromEventEmitter = ({ emitter, event, get, set, defaultValue, getInitialized, }) => {
+    const observe = (listener) => {
+        emitter.on(event, listener);
+        return () => emitter.removeListener(event, listener);
+    };
+    return enforceObservableRules({
+        getInitialized,
+        get,
+        set,
+        observe,
+        defaultValue,
+    });
+};
+export default fromEventEmitter;

package/lib/factories/keystore.d.ts

@@ -0,0 +1,14 @@
+import { Atom, Keystore, KeystoreValue } from '../utils/types';
+type Params = {
+    keystore: Keystore;
+    config: {
+        key: string;
+        defaultValue?: KeystoreValue;
+        isSoleWriter?: boolean;
+        getOpts?: object;
+        setOpts?: object;
+        deleteOpts?: object;
+    };
+};
+declare const createKeystoreAtom: ({ keystore, config: { key, defaultValue, isSoleWriter, getOpts, setOpts, deleteOpts, }, }: Params) => Atom<KeystoreValue | null>;
+export default createKeystoreAtom;

package/lib/factories/keystore.js

@@ -0,0 +1,23 @@
+import enforceObservableRules from '../enforce-rules';
+import createSimpleObserver from '../simple-observer';
+const createKeystoreAtom = ({ keystore, config: { key, defaultValue, isSoleWriter, getOpts, setOpts, deleteOpts, }, }) => {
+    const { notify, observe } = createSimpleObserver({ enable: isSoleWriter });
+    const set = async (value) => {
+        if (value == null) {
+            await keystore.deleteSecret(key, deleteOpts);
+        }
+        else {
+            await keystore.setSecret(key, value, setOpts);
+        }
+        if (isSoleWriter)
+            await notify(value);
+    };
+    const get = () => keystore.getSecret(key, getOpts);
+    return enforceObservableRules({
+        get,
+        set,
+        observe,
+        defaultValue,
+    });
+};
+export default createKeystoreAtom;

package/lib/factories/memory.d.ts

@@ -0,0 +1,6 @@
+import { Atom } from '../utils/types';
+type Params<T> = {
+    defaultValue?: T;
+};
+declare const createAtomMock: <T>(options?: Params<T>) => Atom<T>;
+export default createAtomMock;