@exodus/atoms 4.0.1 → 5.1.0

package/README.md

@@ -22,7 +22,6 @@ This library provides helpers for creating atoms from multiple data sources we u
 | ------------- | --- | ----- | ------- |
 | Memory        | ✅  | ✅    | ✅      |
 | Storage       | ✅  | 🟡 \* | ✅      |
-| Fusion        | ✅  | ✅    | ✅      |
 | Remote config | ✅  | ❌    | ✅      |
 | Local config  | ✅  | ✅    | ✅      |
 | Event emitter | ✅  | ❌    | ✅      |
@@ -35,7 +34,6 @@ This library provides helpers for creating atoms from multiple data sources we u
 import {
   createInMemoryAtom,
   createStorageAtomFactory,
-  createFusionAtomFactory,
   createRemoteConfigAtomFactory,
   fromEventEmitter,
 } from '@exodus/atoms'
@@ -54,14 +52,6 @@ const acceptedTermsAtom = storageAtomFactory({
   isSoleWriter: true,
 })
 
-// Fusion atoms
-const fusionAtomFactory = createFusionAtomFactory({ fusion })
-
-const shareActivityAtom = createFusionAtom({
-  path: 'shareActivity',
-  defaultValue: true,
-})
-
 // Remote config atoms
 const createRemoteConfigAtom = createRemoteConfigAtomFactory({ remoteConfig })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/atoms",
-  "version": "4.0.1",
+  "version": "5.1.0",
   "main": "src/index.js",
   "author": "Exodus Movement Inc.",
   "scripts": {
@@ -34,5 +34,5 @@
     "eslint": "^8.33.0",
     "jest": "^29.1.2"
   },
-  "gitHead": "ac6c0c517dc7ce598f40dedf289d03b3825c9298"
+  "gitHead": "da31eb7383fbc80205aef2c85c88ae31807f1146"
 }

package/src/enforce-rules.js

@@ -5,22 +5,17 @@ const withChangeDetection = (listener) => {
   let currentValue
   let called = false
 
-  return {
-    listener: async (value) => {
-      if (called && value === currentValue) return
+  return async (value) => {
+    if (called && value === currentValue) return
 
-      called = true
-      currentValue = value
+    called = true
+    currentValue = value
 
-      await listener(currentValue)
-    },
-    get called() {
-      return called
-    },
+    await listener(currentValue)
   }
 }
 
-const enforceObservableRules = ({ defaultValue, logger, ...atom }) => {
+const enforceObservableRules = ({ defaultValue, getInitialized = () => true, logger, ...atom }) => {
   // ensure observers get called in series
   const enqueue = makeConcurrent((fn) => fn(), { concurrency: 1 })
 
@@ -30,18 +25,28 @@ const enforceObservableRules = ({ defaultValue, logger, ...atom }) => {
   const get = () => atom.get().then(postProcessValue)
 
   const observe = (listener) => {
-    const deduped = withChangeDetection(listener)
-    const publishSerially = (value) => enqueue(() => deduped.listener(value))
+    let called = false
+    listener = withChangeDetection(listener)
+
+    const publishSerially = (value) => {
+      called = true
+      return enqueue(() => listener(value))
+    }
+
     // note: call observe() first to give it a chance to throw if it's not supported
-    const unsubscribe = atom.observe((value) => publishSerially(postProcessValue(value)))
     // if the subscription already fired once, ignore first get
-    get().then((value) => !deduped.called && publishSerially(value))
-    return unsubscribe
+    get().then((value) => !called && publishSerially(value))
+    return atom.observe((value) => publishSerially(postProcessValue(value)))
   }
 
   const set = async (value) => {
     // support a function a la React's setState(oldState => newState)
-    if (typeof value === 'function') value = await value(await get())
+    if (typeof value === 'function') {
+      const current = getInitialized() ? await get() : defaultValue
+      value = await value(current)
+
+      if (current === value) return
+    }
 
     await atom.set(value)
   }

package/src/enhancers/block-until.js

@@ -1,17 +1,9 @@
-import enforceObservableRules from '../enforce-rules'
-
 export default function blockUntil({ atom, unblock }) {
   const get = async () => unblock().then(atom.get)
 
-  const { observe, ...rest } = enforceObservableRules({
+  return {
     ...atom,
     get,
-    set: atom.set,
-    observe: atom.observe,
-  })
-
-  return {
-    ...rest,
     observe: (callback) => {
       let isSubscribed = true
       let unsubscribe = () => {}

package/src/enhancers/combine.js

@@ -1,6 +1,6 @@
 import createCountdownLock from '../countdown-lock'
-import enforceObservableRules from '../enforce-rules'
 import createSimpleObserver from '../simple-observer'
+import enforceObservableRules from '../enforce-rules'
 
 const combine = (atoms) => {
   const { notify, observe } = createSimpleObserver()

package/src/enhancers/compute.js

@@ -1,5 +1,3 @@
-import enforceObservableRules from '../enforce-rules'
-
 const compute = ({ atom, selector }) => {
   const get = async () => {
     const values = await atom.get()
@@ -14,7 +12,12 @@ const compute = ({ atom, selector }) => {
     return atom.observe((values) => callback(selector(values), values))
   }
 
-  return enforceObservableRules({ ...atom, get, set, observe })
+  return {
+    ...atom,
+    get,
+    set,
+    observe,
+  }
 }
 
 export default compute

package/src/enhancers/dedupe.js

@@ -0,0 +1,12 @@
+import { isEqual } from 'lodash'
+
+const dedupe = (atom) => {
+  const set = (value) => atom.set((previous) => (isEqual(previous, value) ? previous : value))
+
+  return {
+    ...atom,
+    set,
+  }
+}
+
+export default dedupe

package/src/enhancers/difference.js

@@ -1,15 +1,20 @@
-import compute from './compute'
-
 const difference = (atom) => {
-  let prev
+  const observe = (callback) => {
+    let prev
+
+    const selector = (value) => {
+      const p = prev
+      prev = value
+      return { previous: p, current: value }
+    }
 
-  const selector = (value) => {
-    const p = prev
-    prev = value
-    return { previous: p, current: value }
+    return atom.observe((value) => callback(selector(value)))
   }
 
-  return compute({ atom, selector })
+  return {
+    ...atom,
+    observe,
+  }
 }
 
 export default difference

package/src/enhancers/read-only.js

@@ -1,11 +1,12 @@
-import enforceObservableRules from '../enforce-rules'
-
 const readOnly = (atom) => {
   const set = async () => {
     throw new Error('selected atom does not support set')
   }
 
-  return enforceObservableRules({ ...atom, set })
+  return {
+    ...atom,
+    set,
+  }
 }
 
 export default readOnly

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

@@ -1,5 +1,4 @@
 import assert from 'minimalistic-assert'
-import enforceObservableRules from '../enforce-rules'
 
 const swallowObserverErrors = ({ atom, logger }) => {
   assert(atom, 'expected "atom')
@@ -14,7 +13,10 @@ const swallowObserverErrors = ({ atom, logger }) => {
       }
     })
 
-  return enforceObservableRules({ ...atom, observe })
+  return {
+    ...atom,
+    observe,
+  }
 }
 
 export default swallowObserverErrors

package/src/enhancers/timeout-observers.js

@@ -1,6 +1,5 @@
 import delay from 'delay'
 import assert from 'minimalistic-assert'
-import enforceObservableRules from '../enforce-rules'
 
 const timeoutObservers = ({ atom, timeout }) => {
   assert(atom, 'expected "atom')
@@ -19,7 +18,10 @@ const timeoutObservers = ({ atom, timeout }) => {
       ]).then(() => timeoutPromise.clear())
     })
 
-  return enforceObservableRules({ ...atom, observe })
+  return {
+    ...atom,
+    observe,
+  }
 }
 
 export default timeoutObservers

package/src/enhancers/with-serialization.js

@@ -5,6 +5,10 @@ const withSerialization = ({ atom, serialize, deserialize }) => {
   }
 
   const set = async (value) => {
+    if (typeof value === 'function') {
+      return atom.set((previousValue) => serialize(value(deserialize(previousValue))))
+    }
+
     const serialized = serialize(value)
     return atom.set(serialized)
   }

package/src/event-emitter.js

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

package/src/factories/memory.js

@@ -30,7 +30,14 @@ const createAtomMock = (options = {}) => {
     }
   }
 
-  return fromEventEmitter({ ...options, emitter, event: 'data', get, set })
+  return fromEventEmitter({
+    ...options,
+    getInitialized: () => initialized.resolved,
+    emitter,
+    event: 'data',
+    get,
+    set,
+  })
 }
 
 export default createAtomMock

package/src/factories/remote-config.js

@@ -1,4 +1,4 @@
-import { get as getValueAtPath } from 'lodash'
+import { get as getValueAtPath, isEqual } from 'lodash'
 
 import createSimpleObserver from '../simple-observer'
 import enforceObservableRules from '../enforce-rules'
@@ -30,10 +30,19 @@ const createRemoteConfigAtomFactory =
       return notify(data)
     })
 
+    const observeDistinct = (callback) =>
+      observe(
+        function (value) {
+          if (isEqual(this.lastValue, value)) return
+          this.lastValue = value
+          callback(value)
+        }.bind({})
+      )
+
     return enforceObservableRules({
       get,
       set,
-      observe,
+      observe: observeDistinct,
       defaultValue,
     })
   }

package/src/index.js

@@ -1,8 +1,6 @@
 export { default as createAtomMock } from './factories/memory'
 export { default as createInMemoryAtom } from './factories/memory'
-export { default as createFusionAtomFactory } from './factories/fusion'
 export { default as createStorageAtomFactory } from './factories/storage'
-export { default as createLocalConfigAtomFactory } from './factories/local-config'
 export { default as createRemoteConfigAtomFactory } from './factories/remote-config'
 export { default as createKeystoreAtom } from './factories/keystore'
 export { default as createSequencedKeystoreAtom } from './factories/sequenced-keystore'
@@ -13,6 +11,7 @@ export { default as difference } from './enhancers/difference'
 export { default as withSerialization } from './enhancers/with-serialization'
 export { default as combine } from './enhancers/combine'
 export { default as readOnly } from './enhancers/read-only'
+export { default as dedupe } from './enhancers/dedupe'
 export { default as warnOnSameValueSet } from './enhancers/warn-on-same-value-set'
 export { default as swallowObserverErrors } from './enhancers/swallow-observer-errors'
 export { default as timeoutObservers } from './enhancers/timeout-observers'

package/src/factories/fusion.js

@@ -1,30 +0,0 @@
-import { get as getValueAtPath, set as setValueAtPath } from 'lodash'
-
-import enforceObservableRules from '../enforce-rules'
-
-const createFusionAtomFactory =
-  ({ fusion, logger }) =>
-  ({ path, defaultValue }) => {
-    const set = async (value) => {
-      await fusion.mergeProfile(setValueAtPath({}, path, value))
-    }
-
-    const get = async () => {
-      const profile = await fusion.getProfile()
-      return getValueFromProfile(profile)
-    }
-
-    const getValueFromProfile = (profile) => getValueAtPath(profile, path)
-
-    const observe = (listener) => fusion.subscribe(getValueFromProfile, listener)
-
-    return enforceObservableRules({
-      get,
-      set,
-      observe,
-      defaultValue,
-      logger,
-    })
-  }
-
-export default createFusionAtomFactory

package/src/factories/local-config.js

@@ -1,19 +0,0 @@
-import createSimpleObserver from '../simple-observer'
-import enforceObservableRules from '../enforce-rules'
-
-const createLocalConfigAtomFactory =
-  ({ localConfig }) =>
-  ({ key, defaultValue }) => {
-    const { notify, observe } = createSimpleObserver()
-
-    localConfig.on(`update:${key}`, ({ current }) => notify(current))
-
-    return enforceObservableRules({
-      get: () => localConfig.get(key),
-      set: (value) => localConfig.set(key, value),
-      observe,
-      defaultValue,
-    })
-  }
-
-export default createLocalConfigAtomFactory