astx/cjs/util/PushPullIterable.js

super powerful structural search and replace for JavaScript and TypeScript to automate your refactoring

'use strict'

var _interopRequireDefault = require('@babel/runtime/helpers/interopRequireDefault')

Object.defineProperty(exports, '__esModule', {
  value: true,
})
exports['default'] = void 0

var _regenerator = _interopRequireDefault(require('@babel/runtime/regenerator'))

var _asyncToGenerator2 = _interopRequireDefault(
  require('@babel/runtime/helpers/asyncToGenerator')
)

var _classCallCheck2 = _interopRequireDefault(
  require('@babel/runtime/helpers/classCallCheck')
)

var _createClass2 = _interopRequireDefault(
  require('@babel/runtime/helpers/createClass')
)

var _defineProperty2 = _interopRequireDefault(
  require('@babel/runtime/helpers/defineProperty')
)

var _RingBuffer = _interopRequireDefault(require('./RingBuffer'))

var _Symbol$asyncIterator

function _createForOfIteratorHelper(o, allowArrayLike) {
  var it =
    (typeof Symbol !== 'undefined' && o[Symbol.iterator]) || o['@@iterator']

  if (!it) {
    if (
      Array.isArray(o) ||
      (it = _unsupportedIterableToArray(o)) ||
      (allowArrayLike && o && typeof o.length === 'number')
    ) {
      if (it) o = it
      var i = 0

      var F = function F() {}
      return {
        s: F,
        n: function n() {
          if (i >= o.length)
            return {
              done: true,
            }
          return {
            done: false,
            value: o[i++],
          }
        },
        e: function e(_e) {
          throw _e
        },
        f: F,
      }
    }

    throw new TypeError(
      'Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.'
    )
  }

  var normalCompletion = true,
    didErr = false,
    err
  return {
    s: function s() {
      it = it.call(o)
    },
    n: function n() {
      var step = it.next()
      normalCompletion = step.done
      return step
    },
    e: function e(_e2) {
      didErr = true
      err = _e2
    },
    f: function f() {
      try {
        if (!normalCompletion && it['return'] != null) it['return']()
      } finally {
        if (didErr) throw err
      }
    },
  }
}

function _unsupportedIterableToArray(o, minLen) {
  if (!o) return
  if (typeof o === 'string') return _arrayLikeToArray(o, minLen)
  var n = Object.prototype.toString.call(o).slice(8, -1)
  if (n === 'Object' && o.constructor) n = o.constructor.name
  if (n === 'Map' || n === 'Set') return Array.from(o)
  if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
    return _arrayLikeToArray(o, minLen)
}

function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length) len = arr.length

  for (var i = 0, arr2 = new Array(len); i < len; i++) {
    arr2[i] = arr[i]
  }

  return arr2
}

_Symbol$asyncIterator = Symbol.asyncIterator

var PushPullIterable = /*#__PURE__*/ (function () {
  function PushPullIterable(capacity) {
    ;(0, _classCallCheck2['default'])(this, PushPullIterable)
    ;(0, _defineProperty2['default'])(this, 'queue', void 0)
    ;(0, _defineProperty2['default'])(this, 'pushQueue', [])
    ;(0, _defineProperty2['default'])(this, 'pullQueue', [])
    ;(0, _defineProperty2['default'])(this, 'producing', true)
    ;(0, _defineProperty2['default'])(this, 'consuming', true)
    ;(0, _defineProperty2['default'])(this, 'iterating', false)
    ;(0, _defineProperty2['default'])(this, 'consumeError', void 0)
    ;(0, _defineProperty2['default'])(this, 'produceError', void 0)

    if (
      (capacity !== Infinity && !Number.isFinite(capacity)) ||
      capacity < 0 ||
      capacity % 1
    ) {
      throw new Error('invalid capacity: '.concat(capacity))
    }

    this.queue = new _RingBuffer['default'](capacity)
  }

  ;(0, _createClass2['default'])(PushPullIterable, [
    {
      key: _Symbol$asyncIterator,
      value: function value() {
        if (this.iterating) {
          throw new Error(
            "this iterable doesn't support creating more than one iterator"
          )
        }

        this.iterating = true // eslint-disable-next-line @typescript-eslint/no-this-alias

        var self = this
        return {
          next: function next() {
            return (0, _asyncToGenerator2['default'])(
              /*#__PURE__*/ _regenerator['default'].mark(function _callee() {
                return _regenerator['default'].wrap(function _callee$(
                  _context
                ) {
                  while (1) {
                    switch ((_context.prev = _context.next)) {
                      case 0:
                        return _context.abrupt('return', self.pull())

                      case 1:
                      case 'end':
                        return _context.stop()
                    }
                  }
                },
                _callee)
              })
            )()
          },
          return: function _return() {
            return (0, _asyncToGenerator2['default'])(
              /*#__PURE__*/ _regenerator['default'].mark(function _callee2() {
                return _regenerator['default'].wrap(function _callee2$(
                  _context2
                ) {
                  while (1) {
                    switch ((_context2.prev = _context2.next)) {
                      case 0:
                        self.iteratorReturn()
                        return _context2.abrupt('return', {
                          value: undefined,
                          done: true,
                        })

                      case 2:
                      case 'end':
                        return _context2.stop()
                    }
                  }
                },
                _callee2)
              })
            )()
          },
          throw: function _throw(error) {
            return (0, _asyncToGenerator2['default'])(
              /*#__PURE__*/ _regenerator['default'].mark(function _callee3() {
                return _regenerator['default'].wrap(function _callee3$(
                  _context3
                ) {
                  while (1) {
                    switch ((_context3.prev = _context3.next)) {
                      case 0:
                        self.iteratorThrow({
                          error: error,
                        })
                        return _context3.abrupt('return', {
                          value: undefined,
                          done: true,
                        })

                      case 2:
                      case 'end':
                        return _context3.stop()
                    }
                  }
                },
                _callee3)
              })
            )()
          },
        }
      },
    },
    {
      key: 'push',
      value: (function () {
        var _push = (0, _asyncToGenerator2['default'])(
          /*#__PURE__*/ _regenerator['default'].mark(function _callee4(value) {
            var _this = this

            var waitingPull
            return _regenerator['default'].wrap(
              function _callee4$(_context4) {
                while (1) {
                  switch ((_context4.prev = _context4.next)) {
                    case 0:
                      if (this.producing) {
                        _context4.next = 2
                        break
                      }

                      throw new Error("can't push after returning or throwing")

                    case 2:
                      if (this.consuming) {
                        _context4.next = 4
                        break
                      }

                      return _context4.abrupt('return', false)

                    case 4:
                      if (!this.consumeError) {
                        _context4.next = 6
                        break
                      }

                      throw this.consumeError

                    case 6:
                      waitingPull = this.pullQueue.shift()

                      if (!waitingPull) {
                        _context4.next = 10
                        break
                      }

                      waitingPull.resolve({
                        value: value,
                        done: false,
                      })
                      return _context4.abrupt('return', this.consuming)

                    case 10:
                      if (this.queue.isFull) {
                        _context4.next = 13
                        break
                      }

                      this.queue.push(value)
                      return _context4.abrupt('return', this.consuming)

                    case 13:
                      return _context4.abrupt(
                        'return',
                        new Promise(function (_resolve, reject) {
                          _this.pushQueue.push({
                            resolve: function resolve(keepGoing) {
                              if (keepGoing && _this.producing)
                                _this.queue.push(value)

                              _resolve(keepGoing)
                            },
                            reject: reject,
                          })
                        })
                      )

                    case 14:
                    case 'end':
                      return _context4.stop()
                  }
                }
              },
              _callee4,
              this
            )
          })
        )

        function push(_x) {
          return _push.apply(this, arguments)
        }

        return push
      })(),
    },
    {
      key: 'pull',
      value: (function () {
        var _pull = (0, _asyncToGenerator2['default'])(
          /*#__PURE__*/ _regenerator['default'].mark(function _callee5() {
            var _this2 = this

            var _this$pushQueue$shift, pulled

            return _regenerator['default'].wrap(
              function _callee5$(_context5) {
                while (1) {
                  switch ((_context5.prev = _context5.next)) {
                    case 0:
                      if (this.consuming) {
                        _context5.next = 2
                        break
                      }

                      throw new Error(
                        "can't call next after returning or throwing"
                      )

                    case 2:
                      if (!this.produceError) {
                        _context5.next = 4
                        break
                      }

                      throw this.produceError

                    case 4:
                      if (!this.queue.size) {
                        _context5.next = 8
                        break
                      }

                      pulled = this.queue.pull()
                      ;(_this$pushQueue$shift = this.pushQueue.shift()) ===
                        null || _this$pushQueue$shift === void 0
                        ? void 0
                        : _this$pushQueue$shift.resolve(true)
                      return _context5.abrupt('return', {
                        value: pulled,
                        done: false,
                      })

                    case 8:
                      if (this.producing) {
                        _context5.next = 10
                        break
                      }

                      return _context5.abrupt('return', {
                        value: undefined,
                        done: true,
                      })

                    case 10:
                      return _context5.abrupt(
                        'return',
                        new Promise(function (resolve, reject) {
                          _this2.pullQueue.push({
                            resolve: resolve,
                            reject: reject,
                          })
                        })
                      )

                    case 11:
                    case 'end':
                      return _context5.stop()
                  }
                }
              },
              _callee5,
              this
            )
          })
        )

        function pull() {
          return _pull.apply(this, arguments)
        }

        return pull
      })(),
    },
    {
      key: 'return',
      value: function _return() {
        if (!this.producing) return
        this.producing = false
        var pullQueue = this.pullQueue
        this.pullQueue = []

        var _iterator = _createForOfIteratorHelper(pullQueue),
          _step

        try {
          for (_iterator.s(); !(_step = _iterator.n()).done; ) {
            var pull = _step.value
            pull.resolve({
              value: undefined,
              done: true,
            })
          }
        } catch (err) {
          _iterator.e(err)
        } finally {
          _iterator.f()
        }
      }, // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
    },
    {
      key: 'throw',
      value: function _throw(error) {
        if (!this.producing) return
        this.producing = false
        this.produceError = error
        var pullQueue = this.pullQueue
        this.pullQueue = []

        var _iterator2 = _createForOfIteratorHelper(pullQueue),
          _step2

        try {
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
            var pull = _step2.value
            pull.reject(error)
          }
        } catch (err) {
          _iterator2.e(err)
        } finally {
          _iterator2.f()
        }
      },
    },
    {
      key: 'iteratorReturn',
      value: function iteratorReturn() {
        if (!this.consuming) return
        this.consuming = false
        var pushQueue = this.pushQueue
        this.pushQueue = []

        var _iterator3 = _createForOfIteratorHelper(pushQueue),
          _step3

        try {
          for (_iterator3.s(); !(_step3 = _iterator3.n()).done; ) {
            var push = _step3.value
            push.resolve(false)
          }
        } catch (err) {
          _iterator3.e(err)
        } finally {
          _iterator3.f()
        }
      },
    },
    {
      key: 'iteratorThrow',
      value: function iteratorThrow(error) {
        if (!this.consuming) return
        this.consuming = false
        this.consumeError = error
        var pushQueue = this.pushQueue
        this.pushQueue = []
        var _iterator4 = _createForOfIteratorHelper(pushQueue),
          _step4

        try {
          for (_iterator4.s(); !(_step4 = _iterator4.n()).done; ) {
            var push = _step4.value
            push.reject(error)
          }
        } catch (err) {
          _iterator4.e(err)
        } finally {
          _iterator4.f()
        }
      },
    },
  ])
  return PushPullIterable
})()

exports['default'] = PushPullIterable