@exodus/atoms 2.5.1 → 2.7.0

package/README.md

@@ -0,0 +1,91 @@
+# `@exodus/atoms`
+
+Module to store and manage wallet accounts instances.
+
+## Install
+
+```sh
+    yarn add @exodus/atoms
+```
+
+## What is an atom?
+
+An atom is a data source wrapper that exposes a single piece of data through 3 different methods:
+
+- **get()**: read data
+- **set(newValue)**: write data
+- **observe(async (data) => {})**: observes data changes. Will be called initially with current data value. Observers are awaited in series.
+
+## Data sources
+
+This library provides helpers for creating atoms from multiple data sources we use in our apps
+
+|               | get | set   | observe |
+| ------------- | --- | ----- | ------- |
+| Memory        | ✅  | ✅    | ✅      |
+| Storage       | ✅  | 🟡 \* | ✅      |
+| Fusion        | ✅  | ✅    | ✅      |
+| Remote config | ✅  | ❌    | ✅      |
+| Local config  | ✅  | ✅    | ✅      |
+| Event emitter | ✅  | ❌    | ✅      |
+
+\* A storage atom needs a special `isSoleWriter` param to allow write access. This is because storage instances can overlap, e.g. a parent namespace can mutate a child namespace, and our [storage-spec](https://github.com/ExodusMovement/exodus-hydra/tree/master/modules/storage-spec) doesn't currently provide for detecting changes across those instances.
+
+## Usage
+
+```js
+import {
+  createInMemoryAtom,
+  createStorageAtomFactory,
+  createFusionAtomFactory,
+  createRemoteConfigAtomFactory,
+  fromEventEmitter,
+} from '@exodus/atoms'
+
+// In memory atoms
+const availableAssetNamesAtom = createInMemoryAtom({
+  defaultValue: {},
+})
+
+// Storage atoms
+const storageAtomFactory = createStorageAtomFactory({ storage })
+
+const acceptedTermsAtom = storageAtomFactory({
+  key: 'acceptedTerms',
+  defaultValue: false,
+  isSoleWriter: true,
+})
+
+// Fusion atoms
+const fusionAtomFactory = createFusionAtomFactory({ fusion })
+
+const shareActivityAtom = createFusionAtom({
+  path: 'shareActivity',
+  defaultValue: true,
+})
+
+// Remote config atoms
+const createRemoteConfigAtom = createRemoteConfigAtomFactory({ remoteConfig })
+
+const fiatOnrampConfigAtom = createRemoteConfigAtom({
+  path: `dapps.fiatOnramp`,
+  defaultValue: {},
+})
+
+// Event emitter
+const geolocationAtom = fromEventEmitter({
+  emitter: geolocation,
+  event: 'geolocation',
+  get: geolocation.get,
+})
+```
+
+## Helper functions
+
+### compute({ atom, selector })
+
+Computes an atom from another by applying a selector function to the observed data source. Returned atom is read-only, i.e. **set** will fail.
+
+### withSerialization({ atom, serialize, deserialize })
+
+Computes an atom from another by serializing it's data after reading it and deserializing it before writing it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/atoms",
-  "version": "2.5.1",
+  "version": "2.7.0",
   "main": "src/index.js",
   "author": "Exodus Movement Inc.",
   "scripts": {
@@ -23,6 +23,7 @@
   "dependencies": {
     "lodash": "^4.17.21",
     "make-concurrent": ">=4 <6",
+    "p-defer": "^4.0.0",
     "proxy-freeze": "^1.0.0"
   },
   "devDependencies": {
@@ -30,5 +31,5 @@
     "delay": "^5.0.0",
     "jest": "^29.1.2"
   },
-  "gitHead": "791cafc56909b0eb584a1e6526dc2cbd3f6fd235"
+  "gitHead": "876d717e70f271148807b5c13eb607d154169717"
 }

package/src/factories/disabled-assets.js

@@ -0,0 +1,17 @@
+import { compute } from '../index'
+
+const createDisabledAssetsAtom = ({ enabledAndDisabledAssetsAtom }) => {
+  const selector = (values) =>
+    Object.fromEntries(
+      Object.keys(values.disabled)
+        .filter((assetName) => {
+          const disabled = values.disabled[assetName]
+          return disabled === true
+        })
+        .map((assetName) => [assetName, true])
+    )
+
+  return compute({ atom: enabledAndDisabledAssetsAtom, selector })
+}
+
+export default createDisabledAssetsAtom

package/src/factories/memory.js

@@ -1,16 +1,27 @@
 import { EventEmitter } from 'events'
 
 import fromEventEmitter from '../event-emitter'
+import pDefer from 'p-defer'
+
+const createAtomMock = (options = {}) => {
+  const { defaultValue } = options
 
-const createAtomMock = ({ defaultValue }) => {
   let latestValue = defaultValue
 
   const emitter = new EventEmitter()
 
-  const get = async () => latestValue
+  const initialized = pDefer()
+
+  const get = async () => {
+    if (!('defaultValue' in options)) {
+      await initialized.promise
+    }
+    return latestValue
+  }
 
   const set = (data) => {
     latestValue = data
+    initialized.resolve()
     emitter.emit('data', data)
   }
 

package/src/index.js

@@ -5,6 +5,7 @@ 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 createEnabledAssetsAtom } from './factories/enabled-assets'
+export { default as createDisabledAssetsAtom } from './factories/disabled-assets'
 export { default as fromEventEmitter } from './event-emitter'
 export { default as compute } from './enhancers/compute'
 export { default as difference } from './enhancers/difference'