@exodus/atoms 2.1.0 → 2.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@exodus/atoms",
-  "version": "2.1.0",
-  "main": "index.js",
+  "version": "2.3.0",
+  "main": "src/index.js",
   "author": "Exodus Movement Inc.",
   "scripts": {
     "test": "jest",
@@ -9,7 +9,7 @@
     "lint:fix": "yarn lint --fix"
   },
   "files": [
-    "index.js"
+    "src"
   ],
   "repository": {
     "type": "git",
@@ -29,5 +29,5 @@
     "@exodus/storage-memory": "^1.0.0",
     "delay": "^5.0.0"
   },
-  "gitHead": "231a041f31a91990024a1282067b737a3c9dfe41"
+  "gitHead": "0aa83431337d91d8a519aaa77fb3512c4e5ed3cc"
 }

package/src/enforce-rules.js

@@ -0,0 +1,53 @@
+import makeConcurrent from 'make-concurrent'
+import proxyFreeze from 'proxy-freeze'
+
+const withChangeDetection = (listener) => {
+  let currentValue
+  let called = false
+
+  return {
+    listener: async (value) => {
+      if (called && value === currentValue) return
+
+      called = true
+      currentValue = value
+
+      try {
+        await listener(currentValue)
+      } catch (err) {
+        console.warn('observer failed', err)
+      }
+    },
+    get called() {
+      return called
+    },
+  }
+}
+
+const enforceObservableRules = ({ defaultValue, ...atom }) => {
+  // ensure observers get called in series
+  const enqueue = makeConcurrent((fn) => fn(), { concurrency: 1 })
+
+  const postProcessValue = (value = defaultValue) =>
+    value && typeof value === 'object' ? proxyFreeze(value) : value
+
+  const get = () => atom.get().then(postProcessValue)
+
+  const observe = (listener) => {
+    const deduped = withChangeDetection(listener)
+    const publishSerially = (value) => enqueue(() => deduped.listener(postProcessValue(value)))
+    // note: call observe() first to give it a chance to throw if it's not supported
+    const unsubscribe = atom.observe(publishSerially)
+    // if the subscription already fired once, ignore first get
+    get().then((value) => !deduped.called && publishSerially(value))
+    return unsubscribe
+  }
+
+  return {
+    get,
+    set: atom.set,
+    observe,
+  }
+}
+
+export default enforceObservableRules

package/src/enhancers/compute.js

@@ -0,0 +1,20 @@
+import enforceObservableRules from '../enforce-rules'
+
+const compute = ({ atom, selector }) => {
+  const get = async () => {
+    const values = await atom.get()
+    return selector(values)
+  }
+
+  const set = async () => {
+    throw new Error('selected atom does not support set')
+  }
+
+  const observe = (callback) => {
+    return atom.observe((values) => callback(selector(values), values))
+  }
+
+  return enforceObservableRules({ ...atom, get, set, observe })
+}
+
+export default compute

package/src/enhancers/with-serialization.js

@@ -0,0 +1,19 @@
+const withSerialization = ({ atom, serialize, deserialize }) => {
+  const get = async () => {
+    const serialized = await atom.get()
+    return deserialize(serialized)
+  }
+
+  const set = async (value) => {
+    const serialized = serialize(value)
+    return atom.set(serialized)
+  }
+
+  const observe = async (callback) => {
+    return atom.observe((value) => callback(deserialize(value), value))
+  }
+
+  return { ...atom, get, set, observe }
+}
+
+export default withSerialization

package/src/event-emitter.js

@@ -0,0 +1,16 @@
+import enforceObservableRules from './enforce-rules'
+
+const fromEventEmitter = ({ emitter, event, get, defaultValue }) => {
+  const observe = (listener) => {
+    emitter.on(event, listener)
+    return () => emitter.removeListener(event, listener)
+  }
+
+  return enforceObservableRules({
+    get,
+    observe,
+    defaultValue,
+  })
+}
+
+export default fromEventEmitter

package/src/factories/enabled-assets.js

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

package/src/factories/fusion.js

@@ -0,0 +1,29 @@
+import { get as getValueAtPath, set as setValueAtPath } from 'lodash'
+
+import enforceObservableRules from '../enforce-rules'
+
+const createFusionAtomFactory =
+  ({ fusion }) =>
+  ({ 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,
+    })
+  }
+
+export default createFusionAtomFactory

package/src/factories/local-config.js

@@ -0,0 +1,19 @@
+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

package/src/factories/mock.js

@@ -0,0 +1,23 @@
+import { EventEmitter } from 'events'
+
+import fromEventEmitter from '../event-emitter'
+
+const createAtomMock = ({ defaultValue }) => {
+  let latestValue = defaultValue
+
+  const emitter = new EventEmitter()
+
+  const get = async () => latestValue
+
+  const set = (data) => {
+    latestValue = data
+    emitter.emit('data', data)
+  }
+
+  return {
+    ...fromEventEmitter({ emitter, event: 'data', get, defaultValue }),
+    set,
+  }
+}
+
+export default createAtomMock

package/src/factories/remote-config.js

@@ -0,0 +1,27 @@
+import { get as getValueAtPath } from 'lodash'
+
+import createSimpleObserver from '../simple-observer'
+import enforceObservableRules from '../enforce-rules'
+
+const createRemoteConfigAtomFactory =
+  ({ remoteConfig }) =>
+  ({ path, defaultValue }) => {
+    const { notify, observe } = createSimpleObserver()
+
+    const get = () => remoteConfig.get(path)
+
+    const set = async () => {
+      throw new Error('remoteConfig is read-only')
+    }
+
+    remoteConfig.on('sync', ({ current }) => notify(getValueAtPath(current, path)))
+
+    return enforceObservableRules({
+      get,
+      set,
+      observe,
+      defaultValue,
+    })
+  }
+
+export default createRemoteConfigAtomFactory

package/src/factories/storage.js

@@ -0,0 +1,30 @@
+import createSimpleObserver from '../simple-observer'
+import enforceObservableRules from '../enforce-rules'
+
+const createStorageAtomFactory =
+  ({ storage }) =>
+  ({ key, defaultValue, isSoleWriter }) => {
+    const { notify, observe } = createSimpleObserver({ enable: isSoleWriter })
+
+    const set = async (value) => {
+      if (typeof value === 'undefined') {
+        await storage.delete(key)
+      } else {
+        await storage.set(key, value)
+      }
+      if (isSoleWriter) {
+        await notify(value)
+      }
+    }
+
+    const get = () => storage.get(key)
+
+    return enforceObservableRules({
+      get,
+      set,
+      observe,
+      defaultValue,
+    })
+  }
+
+export default createStorageAtomFactory

package/src/index.js

@@ -0,0 +1,9 @@
+export { default as createAtomMock } from './factories/mock'
+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 createEnabledAssetsAtom } from './factories/enabled-assets'
+export { default as fromEventEmitter } from './event-emitter'
+export { default as compute } from './enhancers/compute'
+export { default as withSerialization } from './enhancers/with-serialization'

package/src/simple-observer.js

@@ -0,0 +1,22 @@
+const createSimpleObserver = ({ enable = true } = {}) => {
+  let listeners = []
+
+  const notify = async (value) => Promise.all(listeners.map((listener) => listener(value)))
+
+  const observe = (listener) => {
+    if (!enable) {
+      throw new Error('observe method is not supported')
+    }
+    listeners.push(listener)
+    return () => {
+      listeners = listeners.filter((fn) => fn !== listener)
+    }
+  }
+
+  return {
+    observe,
+    notify,
+  }
+}
+
+export default createSimpleObserver

package/index.js

@@ -1,184 +0,0 @@
-import { EventEmitter } from 'events'
-import { get as getValueAtPath, set as setValueAtPath } from 'lodash'
-import makeConcurrent from 'make-concurrent'
-import proxyFreeze from 'proxy-freeze'
-
-const withChangeDetection = (listener) => {
-  let currentValue
-  let called = false
-  return {
-    listener: async (value) => {
-      if (called && value === currentValue) return
-
-      called = true
-      currentValue = value
-      try {
-        await listener(currentValue)
-      } catch (err) {
-        console.warn('observer failed', err)
-      }
-    },
-    get called() {
-      return called
-    },
-  }
-}
-
-const enforceObservableRules = ({ defaultValue, ...atom }) => {
-  // ensure observers get called in series
-  const enqueue = makeConcurrent((fn) => fn(), { concurrency: 1 })
-
-  const postProcessValue = (value = defaultValue) =>
-    value && typeof value === 'object' ? proxyFreeze(value) : value
-  const get = () => atom.get().then(postProcessValue)
-
-  const observe = (listener) => {
-    const deduped = withChangeDetection(listener)
-    const publishSerially = (value) => enqueue(() => deduped.listener(postProcessValue(value)))
-    // note: call observe() first to give it a chance to throw if it's not supported
-    const unsubscribe = atom.observe(publishSerially)
-    // if the subscription already fired once, ignore first get
-    get().then((value) => !deduped.called && publishSerially(value))
-    return unsubscribe
-  }
-
-  return {
-    get,
-    set: atom.set,
-    observe,
-  }
-}
-
-export const createFusionAtomFactory =
-  ({ fusion }) =>
-  ({ 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,
-    })
-  }
-
-const createSimpleObserver = ({ enable = true } = {}) => {
-  let listeners = []
-  const notify = async (value) => Promise.all(listeners.map((listener) => listener(value)))
-
-  const observe = (listener) => {
-    if (!enable) {
-      throw new Error('observe method is not supported')
-    }
-    listeners.push(listener)
-    return () => {
-      listeners = listeners.filter((fn) => fn !== listener)
-    }
-  }
-
-  return {
-    observe,
-    notify,
-  }
-}
-
-export const createStorageAtomFactory =
-  ({ storage }) =>
-  ({ key, defaultValue, isSoleWriter }) => {
-    const { notify, observe } = createSimpleObserver({ enable: isSoleWriter })
-
-    const set = async (value) => {
-      if (typeof value === 'undefined') {
-        await storage.delete(key)
-      } else {
-        await storage.set(key, value)
-      }
-      if (isSoleWriter) {
-        await notify(value)
-      }
-    }
-
-    const get = () => storage.get(key)
-
-    return enforceObservableRules({
-      get,
-      set,
-      observe,
-      defaultValue,
-    })
-  }
-
-export const createRemoteConfigAtomFactory =
-  ({ remoteConfig }) =>
-  ({ path, defaultValue }) => {
-    const { notify, observe } = createSimpleObserver()
-
-    const get = () => remoteConfig.get(path)
-    const set = async () => {
-      throw new Error('remoteConfig is read-only')
-    }
-
-    remoteConfig.on('sync', ({ current }) => notify(getValueAtPath(current, path)))
-
-    return enforceObservableRules({
-      get,
-      set,
-      observe,
-      defaultValue,
-    })
-  }
-
-export 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 const fromEventEmitter = ({ emitter, event, get, defaultValue }) => {
-  const observe = (listener) => {
-    emitter.on(event, listener)
-    return () => emitter.removeListener(event, listener)
-  }
-
-  return enforceObservableRules({
-    get,
-    observe,
-    defaultValue,
-  })
-}
-
-export const createAtomMock = ({ defaultValue }) => {
-  let latestValue = defaultValue
-
-  const emitter = new EventEmitter()
-  const get = async () => latestValue
-
-  const set = (data) => {
-    latestValue = data
-    emitter.emit('data', data)
-  }
-
-  return {
-    ...fromEventEmitter({ emitter, event: 'data', get, defaultValue }),
-    set,
-  }
-}