@exodus/atoms 5.2.1 → 5.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/atoms",
-  "version": "5.2.1",
+  "version": "5.2.3",
   "main": "src/index.js",
   "description": "Abstraction for encapsulating a piece of data behind a simple unified interface: get, set, observe",
   "author": "Exodus Movement Inc.",
@@ -16,7 +16,7 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/exodus-hydra.git"
   },
-  "homepage": "https://github.com/ExodusMovement/exodus-hydra/tree/master/modules/atom",
+  "homepage": "https://github.com/ExodusMovement/exodus-hydra/tree/master/libraries/atoms",
   "license": "UNLICENSED",
   "bugs": {
     "url": "https://github.com/ExodusMovement/exodus-hydra/issues?q=is%3Aissue+is%3Aopen+label%3Aatom"
@@ -32,8 +32,8 @@
   "devDependencies": {
     "@exodus/storage-memory": "^2.1.0",
     "delay": "^5.0.0",
-    "eslint": "^8.33.0",
+    "eslint": "^8.44.0",
     "jest": "^29.1.2"
   },
-  "gitHead": "3cc58449431fce7a8fa18be6d7f389727d09665b"
+  "gitHead": "ced5da1161e6f9b688ad4571cdb9c9a6b07adb8b"
 }

package/src/enhancers/combine.js

@@ -3,24 +3,46 @@ import createSimpleObserver from '../simple-observer'
 import enforceObservableRules from '../enforce-rules'
 
 const combine = (atoms) => {
-  const { notify, observe } = createSimpleObserver()
+  const { notify, observe: observeSimpleObserver } = createSimpleObserver()
   const countdownLock = createCountdownLock(Object.keys(atoms))
 
   let values = {}
+  let subscriptions = []
+  let subscribers = 0
 
-  for (const name in atoms) {
-    atoms[name].observe(async (value) => {
-      values = {
-        ...values,
-        [name]: value,
-      }
-      if (countdownLock.unlock(name)) await notify(values)
-    })
+  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 () => {
-    await countdownLock.promise
-    return values
+    return Object.fromEntries(
+      await Promise.all(Object.entries(atoms).map(async ([name, atom]) => [name, await atom.get()]))
+    )
   }
 
   const set = async () => {

package/src/enhancers/dedupe.js

@@ -1,7 +1,13 @@
 import { isEqual } from 'lodash'
 
 const dedupe = (atom) => {
-  const set = (value) => atom.set((previous) => (isEqual(previous, value) ? previous : value))
+  const set = (value) => {
+    // avoid triggering a get() when we're resetting the atom
+    // TODO: add atom.unset and stop using atom.set(undefined)
+    if (value === undefined) return atom.set(value)
+
+    return atom.set((previous) => (isEqual(previous, value) ? previous : value))
+  }
 
   return {
     ...atom,

package/src/factories/storage.js

@@ -1,5 +1,6 @@
 import createSimpleObserver from '../simple-observer'
 import enforceObservableRules from '../enforce-rules'
+import pDefer from 'p-defer'
 
 const createStorageAtomFactory =
   ({ storage, logger }) =>
@@ -7,12 +8,16 @@ const createStorageAtomFactory =
     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
@@ -25,6 +30,13 @@ const createStorageAtomFactory =
         return cached
       }
 
+      if (writePromiseDefer) {
+        await writePromiseDefer.promise
+      }
+      if (cached) {
+        return cached
+      }
+
       const value = await storage.get(key)
 
       if (isSoleWriter) {