@exodus/atoms 5.7.3 → 6.0.0

package/src/enhancers/combine.js

@@ -1,59 +0,0 @@
-import createCountdownLock from '../countdown-lock'
-import createSimpleObserver from '../simple-observer'
-import enforceObservableRules from '../enforce-rules'
-
-const combine = (atoms) => {
-  const { notify, observe: observeSimpleObserver } = createSimpleObserver()
-  const countdownLock = createCountdownLock(Object.keys(atoms))
-
-  let values = {}
-  let subscriptions = []
-  let subscribers = 0
-
-  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 () => {
-    return Object.fromEntries(
-      await Promise.all(Object.entries(atoms).map(async ([name, atom]) => [name, await atom.get()]))
-    )
-  }
-
-  const set = async () => {
-    throw new Error('combine does not support method: set')
-  }
-
-  return enforceObservableRules({
-    get,
-    set,
-    observe,
-  })
-}
-
-export default combine

package/src/enhancers/compute.js

@@ -1,31 +0,0 @@
-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) => {
-    let prev
-    let called
-    return atom.observe((values) => {
-      const selected = selector(values)
-      if (called && prev === selected) return
-      called = true
-      prev = selected
-      return callback(selected)
-    })
-  }
-
-  return {
-    ...atom,
-    get,
-    set,
-    observe,
-  }
-}
-
-export default compute

package/src/enhancers/dedupe.js

@@ -1,31 +0,0 @@
-import { isEqual } from 'lodash'
-
-const dedupe = (atom) => {
-  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))
-  }
-
-  const observe = (callback) => {
-    let called
-    let previous
-    return atom.observe(async (value) => {
-      if (called && isEqual(previous, value)) return
-
-      called = true
-      previous = value
-      return callback(value)
-    })
-  }
-
-  return {
-    ...atom,
-    set,
-    observe,
-  }
-}
-
-export default dedupe

package/src/enhancers/difference.js

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

package/src/enhancers/optimistic-notifier.js

@@ -1,60 +0,0 @@
-import makeConcurrent from 'make-concurrent'
-import createInMemoryAtom from '../factories/memory'
-
-const optimisticNotifier = (atom) => {
-  const memoryAtom = createInMemoryAtom()
-
-  const set = makeConcurrent(async (newValue) => {
-    let previous
-    await memoryAtom.set((previousValue) => {
-      previous = previousValue
-      return newValue
-    })
-
-    atom
-      .set(newValue)
-      // only revert in case the value hasn't changed in the meanwhile
-      .catch(() => memoryAtom.set((value) => (value === newValue ? previous : value)))
-  })
-
-  let unsubscribeSource
-  let subscribers = 0
-
-  const maybeUnsubscribeSource = () => {
-    subscribers -= 1
-    if (subscribers > 0) return
-    unsubscribeSource()
-    unsubscribeSource = undefined
-  }
-
-  const observe = (callback) => {
-    if (subscribers === 0) {
-      unsubscribeSource = atom.observe(set)
-    }
-
-    subscribers += 1
-    const unsubscribe = memoryAtom.observe(callback)
-
-    return () => {
-      unsubscribe()
-      maybeUnsubscribeSource()
-    }
-  }
-
-  const get = async () => {
-    if (subscribers === 0) {
-      return atom.get()
-    }
-
-    return memoryAtom.get()
-  }
-
-  return {
-    ...memoryAtom,
-    set,
-    get,
-    observe,
-  }
-}
-
-export default optimisticNotifier

package/src/enhancers/read-only.js

@@ -1,12 +0,0 @@
-const readOnly = (atom) => {
-  const set = async () => {
-    throw new Error('selected atom does not support set')
-  }
-
-  return {
-    ...atom,
-    set,
-  }
-}
-
-export default readOnly

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

@@ -1,22 +0,0 @@
-import assert from 'minimalistic-assert'
-
-const swallowObserverErrors = ({ atom, logger }) => {
-  assert(atom, 'expected "atom')
-  assert(typeof logger?.error === 'function', 'expected logger with ".error" function')
-
-  const observe = (observer) =>
-    atom.observe(async (...args) => {
-      try {
-        await observer(...args)
-      } catch (err) {
-        logger.error('Observer threw error', err)
-      }
-    })
-
-  return {
-    ...atom,
-    observe,
-  }
-}
-
-export default swallowObserverErrors

package/src/enhancers/timeout-observers.js

@@ -1,27 +0,0 @@
-import delay from 'delay'
-import assert from 'minimalistic-assert'
-
-const timeoutObservers = ({ atom, timeout }) => {
-  assert(atom, 'expected "atom')
-  assert(typeof timeout === 'number', 'expected number "timeout"')
-
-  const observe = (observer) =>
-    atom.observe(async (...args) => {
-      const timeoutPromise = delay.reject(timeout, {
-        value: new Error('Observer timed out!'),
-      })
-
-      await Promise.race([
-        //
-        observer(...args),
-        timeoutPromise,
-      ]).then(() => timeoutPromise.clear())
-    })
-
-  return {
-    ...atom,
-    observe,
-  }
-}
-
-export default timeoutObservers

package/src/enhancers/warn-on-same-value-set.js

@@ -1,49 +0,0 @@
-import assert from 'minimalistic-assert'
-import { isEqual as deepEqual } from 'lodash'
-
-const STRINGIFY_LIMIT = 1000
-
-/**
- * Serialize an object to a JSON string with a limit on the number of properties shown
- * @param {Object} obj - The object to be serialized
- * @param {number} limit - The maximum number of properties to include in the output
- * @returns {string} - The JSON string representation of the object
- */
-const limitedStringify = (obj, limit = STRINGIFY_LIMIT) => {
-  let count = 0
-
-  return JSON.stringify(obj, (_, value) => {
-    if (count > limit) {
-      return
-    }
-
-    if (count === limit) {
-      count++
-      return '...more properties not shown'
-    }
-
-    count++
-    return value
-  })
-}
-
-const warnOnSameValueSet = ({ atom, isEqual = deepEqual, logger }) => {
-  assert(atom, 'expected "atom')
-  assert(typeof logger?.warn === 'function', 'expected logger with ".warn" function')
-
-  let previousValue
-  atom.observe((value) => {
-    if (value !== undefined && isEqual(value, previousValue)) {
-      // limit value shown to avoid a CPU spike that can lead to Android freezing
-      logger.warn(
-        `Atom was called with the same value it currently holds: ${limitedStringify(value)}`
-      )
-    }
-
-    previousValue = value
-  })
-
-  return atom
-}
-
-export default warnOnSameValueSet

package/src/enhancers/with-serialization.js

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

package/src/event-emitter.js

@@ -1,19 +0,0 @@
-import enforceObservableRules from './enforce-rules'
-
-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,
-    defaultValue,
-    logger,
-  })
-}
-
-export default fromEventEmitter

package/src/factories/keystore.js

@@ -1,40 +0,0 @@
-import enforceObservableRules from '../enforce-rules'
-import createSimpleObserver from '../simple-observer'
-
-const createKeystoreAtom = ({
-  keystore,
-  logger,
-  config: {
-    //
-    key,
-    defaultValue,
-    isSoleWriter,
-    getOpts,
-    setOpts,
-    deleteOpts,
-  },
-}) => {
-  const { notify, observe } = createSimpleObserver({ enable: isSoleWriter })
-
-  const set = async (value) => {
-    if (value == null) {
-      await keystore.deleteSecret(key, deleteOpts)
-    } else {
-      await keystore.setSecret(key, value, setOpts)
-    }
-
-    if (isSoleWriter) await notify(value)
-  }
-
-  const get = () => keystore.getSecret(key, getOpts)
-
-  return enforceObservableRules({
-    get,
-    set,
-    observe,
-    defaultValue,
-    logger,
-  })
-}
-
-export default createKeystoreAtom

package/src/factories/memory.js

@@ -1,46 +0,0 @@
-import EventEmitter from 'events/'
-
-import fromEventEmitter from '../event-emitter'
-import pDefer from 'p-defer'
-
-const createAtomMock = (options = {}) => {
-  const { defaultValue } = options
-
-  let latestValue = defaultValue
-
-  const emitter = new EventEmitter()
-  emitter.setMaxListeners(Number.POSITIVE_INFINITY)
-
-  const initialized = pDefer()
-
-  const get = async () => {
-    if (!('defaultValue' in options)) {
-      await initialized.promise
-    }
-
-    return latestValue
-  }
-
-  const set = (data) => {
-    latestValue = data
-    if (data !== undefined) {
-      initialized.resolve()
-      initialized.resolved = true
-    }
-
-    if (initialized.resolved) {
-      emitter.emit('data', data)
-    }
-  }
-
-  return fromEventEmitter({
-    ...options,
-    getInitialized: () => initialized.resolved,
-    emitter,
-    event: 'data',
-    get,
-    set,
-  })
-}
-
-export default createAtomMock

package/src/factories/observer.js

@@ -1,33 +0,0 @@
-const createAtomObserver = ({ port, atom, event, immediateRegister = true }) => {
-  let emitting = false
-  let unobserve
-
-  const register = () => {
-    if (unobserve) return
-
-    unobserve = atom.observe((value) => {
-      if (emitting) port.emit(event, value)
-    })
-  }
-
-  const unregister = () => {
-    unobserve?.()
-  }
-
-  const start = async () => {
-    emitting = true
-    port.emit(event, await atom.get())
-  }
-
-  if (immediateRegister) {
-    register()
-  }
-
-  return {
-    register,
-    unregister,
-    start,
-  }
-}
-
-export default createAtomObserver

package/src/factories/remote-config.js

@@ -1,50 +0,0 @@
-import { get as getValueAtPath, isEqual } from 'lodash'
-
-import createSimpleObserver from '../simple-observer'
-import enforceObservableRules from '../enforce-rules'
-
-const createRemoteConfigAtomFactory =
-  ({ remoteConfig }) =>
-  ({ path, selector, defaultValue }) => {
-    if (path && selector) {
-      throw new Error(
-        'Provide either a path or a selector to get data from remote config - not both.'
-      )
-    }
-
-    const getValue = (value) => (selector ? selector(value) : getValueAtPath(value, path))
-
-    const { notify, observe } = createSimpleObserver()
-
-    const get = async () => {
-      const data = await remoteConfig.getAll()
-      return getValue(data)
-    }
-
-    const set = async () => {
-      throw new Error('remoteConfig is read-only')
-    }
-
-    remoteConfig.on('sync', async ({ current }) => {
-      const data = getValue(current)
-      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: observeDistinct,
-      defaultValue,
-    })
-  }
-
-export default createRemoteConfigAtomFactory

package/src/factories/sequenced-keystore.js

@@ -1,108 +0,0 @@
-import assert from 'minimalistic-assert'
-
-import enforceObservableRules from '../enforce-rules'
-import createSimpleObserver from '../simple-observer'
-
-const getRange = (offset, length) => Array.from({ length }, (_, i) => i + offset)
-
-const createSequencedKeystoreAtom = ({
-  keystore,
-  config: {
-    //
-    key,
-    separator = '.',
-    defaultValue = [],
-    isSoleWriter,
-    getOpts,
-    setOpts,
-    deleteOpts,
-  },
-}) => {
-  assert(key, 'sequence keystore atom: key missing')
-
-  assert(typeof key === 'string', 'sequence keystore atom: key must be a string')
-
-  assert(Array.isArray(defaultValue), 'sequence keystore atom: default value must be an array')
-
-  const { notify, observe } = createSimpleObserver({ enable: isSoleWriter })
-
-  let cache
-
-  const getKey = (index) =>
-    key.endsWith(separator) ? `${key}${index}` : `${key}${separator}${index}`
-
-  const getByIndex = async (index) => {
-    const key = getKey(index)
-    const value = await keystore.getSecret(key, getOpts)
-    if (value) return { key, value }
-  }
-
-  const list = async () => {
-    let result = []
-    let batch = []
-    let offset = 0
-    const batchSize = 5
-
-    // paginate until we're out of items
-    do {
-      const range = getRange(offset, batchSize)
-      batch = await Promise.all(range.map(getByIndex))
-      batch = batch.filter(Boolean)
-      result = [...result, ...batch]
-      offset += batchSize
-    } while (batch.length > 0)
-
-    return result
-  }
-
-  const clear = async () => {
-    const items = await list()
-    await Promise.all(items.map((item) => keystore.deleteSecret(item.key, deleteOpts)))
-  }
-
-  const _set = async (value) => {
-    assert(Array.isArray(value), 'sequence keystore atom: set value must be an array')
-
-    await Promise.all(
-      value.map((value, index) => {
-        return keystore.setSecret(getKey(index), value, setOpts)
-      })
-    )
-  }
-
-  const set = async (value) => {
-    await clear()
-
-    if (value !== undefined) {
-      await _set(value)
-    }
-
-    if (isSoleWriter) {
-      cache = value
-      await notify(value)
-    }
-  }
-
-  const get = async () => {
-    if (cache) return cache
-
-    const items = await list()
-    const value = items.map((item) => item.value)
-
-    if (isSoleWriter) {
-      cache = value
-    }
-
-    // let default value be used
-    return items.length === 0 ? undefined : value
-  }
-
-  return enforceObservableRules({
-    get,
-    set,
-    observe,
-    defaultValue,
-  })
-}
-
-export default createSequencedKeystoreAtom

package/src/factories/storage.js

@@ -1,60 +0,0 @@
-import createSimpleObserver from '../simple-observer'
-import enforceObservableRules from '../enforce-rules'
-import pDefer from 'p-defer'
-
-const createStorageAtomFactory =
-  ({ storage, logger }) =>
-  ({ key, defaultValue, isSoleWriter }) => {
-    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
-        await notify(value)
-      }
-    }
-
-    const get = async () => {
-      if (cached) {
-        return cached
-      }
-
-      if (writePromiseDefer) {
-        await writePromiseDefer.promise
-      }
-
-      if (cached) {
-        return cached
-      }
-
-      const value = await storage.get(key)
-
-      if (isSoleWriter) {
-        cached = value
-      }
-
-      return value
-    }
-
-    return enforceObservableRules({
-      get,
-      set,
-      observe,
-      defaultValue,
-      logger,
-    })
-  }
-
-export default createStorageAtomFactory