@exodus/atoms 9.0.3 → 10.1.0

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.
 
+## [10.1.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@10.0.0...@exodus/atoms@10.1.0) (2026-01-29)
+
+### Features
+
+- feat: infer result atom in `filter`, accept readonly atoms (#15069)
+
+## [10.0.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@9.0.3...@exodus/atoms@10.0.0) (2025-10-08)
+
+### ⚠ BREAKING CHANGES
+
+- make `observer.start` a synchronous function (#12186)
+
+### Features
+
+- feat(atom): serialization support async function (#13943)
+
+- feat: export createAtomObserver separately in atoms (#12310)
+
+- feat!: make `observer.start` a synchronous function (#12186)
+
 ## [9.0.3](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@9.0.2...@exodus/atoms@9.0.3) (2025-04-30)
 
 ### Bug Fixes

package/lib/countdown-lock.js

@@ -3,8 +3,9 @@ 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')
+        if (typeof key !== 'string') {
             throw new TypeError(`lock keys must be all strings. Invalid ${key}`);
+        }
     }
     const deferred = pDefer();
     const unlockedKeys = [];

package/lib/enhancers/combine.d.ts

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

package/lib/enhancers/filter.d.ts

@@ -1,2 +1,6 @@
-import type { Atom } from '../utils/types.js';
-export default function filter<T>(atom: Atom<T>, predicate: (value: T) => boolean): Atom<T>;
+import type { AnyAtom, AtomValue, SetAtomValue } from '../utils/types.js';
+type Predicate<A extends AnyAtom, S extends AtomValue<A>> = ((value: AtomValue<A>) => value is S) | ((value: AtomValue<A>) => unknown);
+type FilteredValue<A extends AnyAtom, P extends Predicate<A, any>> = P extends ((value: AtomValue<A>) => value is infer S extends AtomValue<A>) ? S : AtomValue<A>;
+type ResultAtom<A extends AnyAtom, P extends Predicate<A, any>> = SetAtomValue<A, FilteredValue<A, P>>;
+export default function filter<A extends AnyAtom, S extends AtomValue<A>, P extends Predicate<A, S>>(atom: A, predicate: P): ResultAtom<A, P>;
+export {};

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

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

package/lib/enhancers/with-serialization.js

@@ -8,13 +8,13 @@ const withSerialization = ({ atom, serialize: customSerialize, deserialize: cust
     };
     const set = async (value) => {
         if (isSetter(value)) {
-            return atom.set(async (previousValue) => serialize(await value(deserialize(previousValue))));
+            return atom.set(async (previousValue) => serialize(await value(await deserialize(previousValue))));
         }
-        const serialized = serialize(value);
+        const serialized = await serialize(value);
         return atom.set(serialized);
     };
     const observe = (callback) => {
-        return atom.observe((value) => callback(deserialize(value), value));
+        return atom.observe(async (value) => callback(await deserialize(value), value));
     };
     return { ...atom, get, set, observe };
 };

package/lib/factories/observer.d.ts

@@ -8,6 +8,6 @@ type Params<T> = {
 declare const createAtomObserver: <T>({ port, atom, event, immediateRegister }: Params<T>) => {
     register: () => void;
     unregister: () => void;
-    start: () => Promise<void>;
+    start: () => void;
 };
 export default createAtomObserver;

package/lib/factories/observer.js

@@ -17,13 +17,16 @@ const createAtomObserver = ({ port, atom, event, immediateRegister = true }) =>
         unobserve = undefined;
         emitting = false;
     };
-    const start = async () => {
+    const emitWhenReady = async () => {
         emitting = true;
         const startTime = Date.now();
         const value = await atom.get();
         if (startTime > lastMessage)
             port.emit(event, value);
     };
+    const start = () => {
+        void emitWhenReady();
+    };
     if (immediateRegister) {
         register();
     }

package/lib/utils/types.d.ts

@@ -26,3 +26,6 @@ export interface Keystore {
     deleteSecret(key: string, options?: object): Promise<string>;
 }
 export type Logger = Pick<Console, 'trace' | 'debug' | 'error' | 'info' | 'log' | 'warn'>;
+export type AnyAtom<V = any> = Atom<V> | ReadonlyAtom<V>;
+export type AtomValue<A extends AnyAtom> = A extends AnyAtom<infer V> ? V : never;
+export type SetAtomValue<A extends AnyAtom, V> = A extends Atom<any> ? Atom<V> : A extends ReadonlyAtom<any> ? ReadonlyAtom<V> : never;

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@exodus/atoms",
-  "version": "9.0.3",
+  "version": "10.1.0",
   "description": "Abstraction for encapsulating a piece of data behind a simple unified interface: get, set, observe",
   "type": "module",
   "main": "lib/index.js",
-  "exports": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./factories/observer": "./lib/factories/observer.js"
+  },
   "author": "Exodus Movement, Inc.",
   "scripts": {
-    "build": "run -T tsc --build tsconfig.build.json",
+    "build": "run -T tsc -p tsconfig.build.json",
     "clean": "run -T tsc --build --clean",
-    "test": "run -T exodus-test --jest --esbuild",
+    "test": "run -T exodus-test --jest --esbuild && run test:types",
+    "test:types": "tsc -p tsconfig.json --noEmit",
     "lint": "run -T eslint .",
     "lint:fix": "yarn lint --fix",
     "prepublishOnly": "yarn run -T build --scope @exodus/atoms"
@@ -28,7 +32,6 @@
     "url": "https://github.com/ExodusMovement/exodus-hydra/issues?q=is%3Aissue+is%3Aopen+label%3Aatoms"
   },
   "dependencies": {
-    "@exodus/basic-utils": "^3.2.0",
     "@exodus/storage-interface": "^1.0.0",
     "delay": "^5.0.0",
     "eventemitter3": "^4.0.7",
@@ -42,13 +45,16 @@
   "devDependencies": {
     "@exodus/atom-tests": "^1.0.0",
     "@exodus/deferring-storage": "^1.0.2",
-    "@exodus/storage-encrypted": "^1.4.2",
-    "@exodus/storage-memory": "^2.2.2",
+    "@exodus/storage-encrypted": "^1.5.1",
+    "@exodus/storage-memory": "^2.3.0",
     "@types/jest": "^29.5.11",
     "@types/json-stringify-safe": "^5.0.3",
     "@types/lodash": "^4.14.200",
     "@types/minimalistic-assert": "^1.0.2",
     "events": "^3.3.0"
   },
-  "gitHead": "01cb326181e5365ba81bb086f2a7261d180d24bd"
+  "publishConfig": {
+    "provenance": false
+  },
+  "gitHead": "b381cc2639d8235acce2377e83ed27ce4dd86e0c"
 }

package/lib/utils/memoize.d.ts

@@ -1,4 +0,0 @@
-export type ModelLike = Record<string, any> & {
-    toJSON: () => object;
-};
-export declare function safeMemoize<T extends (...args: any[]) => any>(fn: T): T;

package/lib/utils/memoize.js

@@ -1,57 +0,0 @@
-import { memoize } from '@exodus/basic-utils';
-function processValue(value, seen) {
-    if (value === null || value === undefined) {
-        return value;
-    }
-    if (typeof value !== 'object') {
-        const isSpecialType = ['symbol', 'function', 'bigint'].includes(typeof value);
-        return isSpecialType ? value.toString() : value;
-    }
-    if (seen.has(value)) {
-        return '[Circular]';
-    }
-    seen.add(value);
-    if (isModelWithToJSON(value)) {
-        return value.toJSON();
-    }
-    if (value instanceof RegExp) {
-        return value.toString();
-    }
-    if (value instanceof Date) {
-        return value.toISOString();
-    }
-    if (value instanceof Map) {
-        return [...value.entries()].map(([k, v]) => [k, processValue(v, seen)]);
-    }
-    if (value instanceof Set) {
-        return [...value].map((v) => processValue(v, seen));
-    }
-    if (Array.isArray(value)) {
-        return value.map((v) => processValue(v, seen));
-    }
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-        if (val !== undefined) {
-            result[key] = processValue(val, seen);
-        }
-    }
-    return result;
-}
-function safeSerialize(value) {
-    try {
-        return JSON.stringify(processValue(value, new WeakSet()));
-    }
-    catch {
-        console.error('Could not serialize value:', value);
-        throw new Error('Value could not be serialized for memoization');
-    }
-}
-function isModelWithToJSON(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'toJSON' in value &&
-        typeof value.toJSON === 'function');
-}
-export function safeMemoize(fn) {
-    return memoize(fn, safeSerialize);
-}