keet-deobfuscated / @holepunchto / keet-store / store / lib / effects.js

import {
  call as e,
  spawn as r,
  delay as t,
  takeEvery as n,
  all as o,
  fork as i,
} from "redux-saga/effects"
export function block() {
  return e(() => new Promise(() => {}))
}
const c = 300,
  a = 1
export function spawnRestarted(n, ...o) {
  let i = 1
  return r(function* () {
    for (; i >= 0; )
      try {
        yield e(n, ...o)
        break
      } catch (e) {
        ;(console.error(e), (i -= 1), yield t(c))
      }
  })
}
export const createSpawnRestarted =
  ({ onError: n, attempts: o }) =>
  (i, ...a) => {
    let l = o || 1
    return r(function* () {
      for (; l >= 0; )
        try {
          yield e(i, ...a)
          break
        } catch (e) {
          ;(yield n(i.name || "unknown", e), (l -= 1), yield t(c))
        }
    })
  }
export function* safeCall(r, ...t) {
  let n
  if ("function" != typeof r) return ((n = new Error("safeCall: invalid function param")), n)
  try {
    yield e(r, ...t)
  } catch (e) {
    ;((n = e), console.error(e))
  }
  return n
}
export function* forkChildren(e, r, t, c) {
  const a = {}
  let l = []
  function* u({ taskId: e, childSaga: r }) {
    try {
      yield r({ taskId: e })
    } catch (e) {
      c ? yield c(e) : console.error(e)
    }
  }
  yield n(e, function* (e) {
    try {
      const n = yield r(e)
      if (l === n || !Array.isArray(n)) return
      let c
      if (l.length === n.length) {
        c = !0
        for (let e = 0; e < n.length; e += 1)
          if (l[e] !== n[e]) {
            c = !1
            break
          }
      }
      if (((l = n), c)) return
      const { uniqueIds: s } = n.reduce(
        (e, r) =>
          r && "string" == typeof r
            ? (e.uniqueMap[r] || ((e.uniqueMap[r] = !0), e.uniqueIds.push(r)), e)
            : e,
        { uniqueMap: {}, uniqueIds: [] },
      )
      Object.keys(a).forEach((e) => {
        s.includes(e) || (a[e].cancel(), delete a[e])
      })
      const f = s.filter((e) => !a[e]),
        d = yield o(f.map((e) => i(u, { taskId: e, childSaga: t })))
      f.forEach((e, r) => {
        a[e] = d[r]
      })
    } catch (e) {
      c ? yield c(e) : console.error(e)
    }
  })
}