@exodus/atoms 9.0.2 → 10.0.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.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
+
+- fix: disable memoization in compute atom enhancer (#12127)
+
 ## [9.0.2](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@9.0.1...@exodus/atoms@9.0.2) (2025-03-19)
 
 **Note:** Version bump only for package @exodus/atoms

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/compute.js

@@ -1,9 +1,7 @@
-import { safeMemoize } from '../utils/memoize.js';
 const compute = ({ atom, selector }) => {
-    const memoizedSelector = safeMemoize((value) => selector(value));
     const get = async () => {
         const values = await atom.get();
-        return memoizedSelector(values);
+        return selector(values);
     };
     const set = async () => {
         throw new Error('selected atom does not support set');
@@ -12,7 +10,7 @@ const compute = ({ atom, selector }) => {
         let prev;
         let called;
         return atom.observe(async (values) => {
-            const selected = await memoizedSelector(values);
+            const selected = await selector(values);
             if (called && prev === selected)
                 return;
             called = true;

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/memory.js

@@ -7,7 +7,7 @@ const createAtomMock = (options = {}) => {
     const emitter = new EventEmitter();
     const initialized = pDefer();
     const get = async () => {
-        if (!('defaultValue' in options)) {
+        if (!Object.hasOwn(options, 'defaultValue')) {
             await initialized.promise;
         }
         return latestValue;

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/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@exodus/atoms",
-  "version": "9.0.2",
+  "version": "10.0.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",
     "lint": "run -T eslint .",
@@ -28,7 +31,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 +44,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": "86e9ba86050f754e564bcba758ccee8f9797c32d"
+  "publishConfig": {
+    "provenance": false
+  },
+  "gitHead": "72e1044962bc88cb5e22fb69c56997d11e3fdd20"
 }

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);
-}