@exodus/atoms 10.0.0 → 10.2.0

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [10.2.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@10.1.0...@exodus/atoms@10.2.0) (2026-03-23)
+
+### Features
+
+- feat(atoms): difference with skipInitial option (#15641)
+
+- feat: convert wallet-accounts feature to TypeScript (#15556)
+
+## [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

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/difference.d.ts

@@ -1,9 +1,19 @@
 import type { Atom } from '../utils/types.js';
 type Diff<T> = {
-    previous?: T;
+    previous: T | undefined;
     current: T;
 };
-declare const difference: <T>(atom: Atom<T>) => Omit<Atom<T>, "observe"> & {
-    observe: Atom<Diff<T>>["observe"];
+type NonInitialDiff<T> = {
+    previous: T;
+    current: T;
+};
+type Options = {
+    skipInitial?: boolean;
+};
+type DiffForOptions<T, O extends Options | undefined> = O extends {
+    skipInitial: true;
+} ? NonInitialDiff<T> : Diff<T>;
+declare const difference: <T, O extends Options | undefined = undefined>(atom: Atom<T>, options?: O) => Omit<Atom<T>, "observe"> & {
+    observe: Atom<DiffForOptions<T, O>>["observe"];
 };
 export default difference;

package/lib/enhancers/difference.js

@@ -1,12 +1,20 @@
-const difference = (atom) => {
+const difference = (atom, options) => {
     const observe = (callback) => {
         let prev;
+        let initialValueAssigned = false;
         const selector = (value) => {
             const p = prev;
             prev = value;
             return { previous: p, current: value };
         };
-        return atom.observe((value) => callback(selector(value)));
+        return atom.observe((value) => {
+            const diffWrappedValue = selector(value);
+            if (options?.skipInitial && !initialValueAssigned) {
+                initialValueAssigned = true;
+                return;
+            }
+            return callback(diffWrappedValue);
+        });
     };
     return {
         ...atom,

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/factories/storage.d.ts

@@ -1,13 +1,19 @@
 import type { Atom } from '../utils/types.js';
 import type { Storage } from '@exodus/storage-interface';
-type FactoryParams<T> = {
-    storage: Storage<T>;
-};
 type Params<D> = {
     key: string;
     defaultValue?: D;
+    isSoleWriter?: boolean;
 };
-declare const createStorageAtomFactory: <T>({ storage }: FactoryParams<T>) => {
+declare function createStorageAtomFactory<T>(params: {
+    storage: Storage<T>;
+}): ReturnType<typeof _createStorageAtomFactory<T>>;
+declare function createStorageAtomFactory<T = unknown>(params: {
+    storage: Storage;
+}): ReturnType<typeof _createStorageAtomFactory<T>>;
+declare const _createStorageAtomFactory: <T = unknown>({ storage }: {
+    storage: Storage;
+}) => {
     (opts: Omit<Params<unknown>, "defaultValue">): Atom<T | undefined>;
     <D extends T>(opts: Params<D>): Atom<T | D>;
 };

package/lib/factories/storage.js

@@ -1,6 +1,9 @@
 import createSimpleObserver from '../simple-observer.js';
 import enforceObservableRules from '../enforce-rules.js';
-const createStorageAtomFactory = ({ storage }) => {
+function createStorageAtomFactory({ storage, }) {
+    return _createStorageAtomFactory({ storage });
+}
+const _createStorageAtomFactory = ({ storage }) => {
     function createStorageAtom({ key, defaultValue }) {
         let version = 0;
         const { notify, observe, listeners } = createSimpleObserver({ enable: true });
@@ -35,7 +38,7 @@ const createStorageAtomFactory = ({ storage }) => {
                 return cached;
             }
             const currentVersion = version;
-            const value = await storage.get(key);
+            const value = (await storage.get(key));
             if (currentVersion !== version) {
                 return get();
             }

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,6 +1,6 @@
 {
   "name": "@exodus/atoms",
-  "version": "10.0.0",
+  "version": "10.2.0",
   "description": "Abstraction for encapsulating a piece of data behind a simple unified interface: get, set, observe",
   "type": "module",
   "main": "lib/index.js",
@@ -12,7 +12,8 @@
   "scripts": {
     "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"
@@ -45,7 +46,7 @@
     "@exodus/atom-tests": "^1.0.0",
     "@exodus/deferring-storage": "^1.0.2",
     "@exodus/storage-encrypted": "^1.5.1",
-    "@exodus/storage-memory": "^2.3.0",
+    "@exodus/storage-memory": "^2.4.0",
     "@types/jest": "^29.5.11",
     "@types/json-stringify-safe": "^5.0.3",
     "@types/lodash": "^4.14.200",
@@ -55,5 +56,5 @@
   "publishConfig": {
     "provenance": false
   },
-  "gitHead": "72e1044962bc88cb5e22fb69c56997d11e3fdd20"
+  "gitHead": "ac175d43359e60fe2b201bf72c889c8ec501dc86"
 }