@exodus/atoms 1.0.0

package/index.js

@@ -0,0 +1,159 @@
+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,
+    })
+  }
+
+export const createStorageAtomFactory =
+  ({ storage }) =>
+  ({ key, defaultValue }) => {
+    const set = async (value) => storage.set(key, value)
+
+    const get = () => storage.get(key)
+
+    return enforceObservableRules({
+      get,
+      set,
+      observe: async () => {
+        throw new Error('storage atom does not support observe')
+      },
+      defaultValue,
+    })
+  }
+
+export const createRemoteConfigAtomFactory =
+  ({ remoteConfig }) =>
+  ({ path, defaultValue }) => {
+    const getValue = (remoteConfigJSON) => getValueAtPath(remoteConfigJSON, path)
+
+    let listeners = []
+
+    const notify = async (remoteConfigJSON) => {
+      const value = getValue(remoteConfigJSON)
+      return Promise.all(listeners.map((listener) => listener(value)))
+    }
+
+    const get = async () => {
+      const remoteConfigJSON = await remoteConfig.get()
+      return getValue(remoteConfigJSON)
+    }
+
+    const set = async () => {
+      throw new Error('remoteConfig is read-only')
+    }
+
+    const observe = (listener) => {
+      listeners.push(listener)
+      return () => {
+        listeners = listeners.filter((fn) => fn !== listener)
+      }
+    }
+
+    remoteConfig.on('remote-config', notify)
+
+    return enforceObservableRules({
+      get,
+      set,
+      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,
+  }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@exodus/atoms",
+  "version": "1.0.0",
+  "main": "index.js",
+  "author": "Exodus Movement Inc.",
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint .",
+    "lint:fix": "yarn lint --fix"
+  },
+  "files": [
+    "index.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExodusMovement/exodus-hydra.git"
+  },
+  "homepage": "https://github.com/ExodusMovement/exodus-hydra/tree/master/modules/atom",
+  "license": "UNLICENSED",
+  "bugs": {
+    "url": "https://github.com/ExodusMovement/exodus-hydra/issues?q=is%3Aissue+is%3Aopen+label%3Aatom"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "make-concurrent": ">=4 <6",
+    "proxy-freeze": "^1.0.0"
+  },
+  "devDependencies": {
+    "@exodus/storage-memory": "^1.0.0",
+    "delay": "^5.0.0"
+  }
+}