pi-cursor-sdk 0.1.50 → 0.1.51

package/node_modules/undici/lib/dispatcher/agent.js

@@ -1,158 +0,0 @@
-'use strict'
-
-const { InvalidArgumentError, MaxOriginsReachedError } = require('../core/errors')
-const { kClients, kRunning, kClose, kDestroy, kDispatch, kUrl } = require('../core/symbols')
-const DispatcherBase = require('./dispatcher-base')
-const Pool = require('./pool')
-const Client = require('./client')
-const util = require('../core/util')
-
-const kOnConnect = Symbol('onConnect')
-const kOnDisconnect = Symbol('onDisconnect')
-const kOnConnectionError = Symbol('onConnectionError')
-const kOnDrain = Symbol('onDrain')
-const kFactory = Symbol('factory')
-const kOptions = Symbol('options')
-const kOrigins = Symbol('origins')
-
-function defaultFactory (origin, opts) {
-  return opts && opts.connections === 1
-    ? new Client(origin, opts)
-    : new Pool(origin, opts)
-}
-
-class Agent extends DispatcherBase {
-  constructor ({ factory = defaultFactory, maxOrigins = Infinity, connect, ...options } = {}) {
-    if (typeof factory !== 'function') {
-      throw new InvalidArgumentError('factory must be a function.')
-    }
-
-    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
-      throw new InvalidArgumentError('connect must be a function or an object')
-    }
-
-    if (typeof maxOrigins !== 'number' || Number.isNaN(maxOrigins) || maxOrigins <= 0) {
-      throw new InvalidArgumentError('maxOrigins must be a number greater than 0')
-    }
-
-    super(options)
-
-    if (connect && typeof connect !== 'function') {
-      connect = { ...connect }
-    }
-
-    this[kOptions] = { ...util.deepClone(options), maxOrigins, connect }
-    this[kFactory] = factory
-    this[kClients] = new Map()
-    this[kOrigins] = new Set()
-
-    this[kOnDrain] = (origin, targets) => {
-      this.emit('drain', origin, [this, ...targets])
-    }
-
-    this[kOnConnect] = (origin, targets) => {
-      this.emit('connect', origin, [this, ...targets])
-    }
-
-    this[kOnDisconnect] = (origin, targets, err) => {
-      this.emit('disconnect', origin, [this, ...targets], err)
-    }
-
-    this[kOnConnectionError] = (origin, targets, err) => {
-      this.emit('connectionError', origin, [this, ...targets], err)
-    }
-  }
-
-  get [kRunning] () {
-    let ret = 0
-    for (const { dispatcher } of this[kClients].values()) {
-      ret += dispatcher[kRunning]
-    }
-    return ret
-  }
-
-  [kDispatch] (opts, handler) {
-    let key
-    if (opts.origin && (typeof opts.origin === 'string' || opts.origin instanceof URL)) {
-      key = String(opts.origin)
-    } else {
-      throw new InvalidArgumentError('opts.origin must be a non-empty string or URL.')
-    }
-
-    if (this[kOrigins].size >= this[kOptions].maxOrigins && !this[kOrigins].has(key)) {
-      throw new MaxOriginsReachedError()
-    }
-
-    const result = this[kClients].get(key)
-    let dispatcher = result && result.dispatcher
-    if (!dispatcher) {
-      const closeClientIfUnused = (connected) => {
-        const result = this[kClients].get(key)
-        if (result) {
-          if (connected) result.count -= 1
-          if (result.count <= 0) {
-            this[kClients].delete(key)
-            if (!result.dispatcher.destroyed) {
-              result.dispatcher.close()
-            }
-          }
-          this[kOrigins].delete(key)
-        }
-      }
-      dispatcher = this[kFactory](opts.origin, this[kOptions])
-        .on('drain', this[kOnDrain])
-        .on('connect', (origin, targets) => {
-          const result = this[kClients].get(key)
-          if (result) {
-            result.count += 1
-          }
-          this[kOnConnect](origin, targets)
-        })
-        .on('disconnect', (origin, targets, err) => {
-          closeClientIfUnused(true)
-          this[kOnDisconnect](origin, targets, err)
-        })
-        .on('connectionError', (origin, targets, err) => {
-          closeClientIfUnused(false)
-          this[kOnConnectionError](origin, targets, err)
-        })
-
-      this[kClients].set(key, { count: 0, dispatcher })
-      this[kOrigins].add(key)
-    }
-
-    return dispatcher.dispatch(opts, handler)
-  }
-
-  [kClose] () {
-    const closePromises = []
-    for (const { dispatcher } of this[kClients].values()) {
-      closePromises.push(dispatcher.close())
-    }
-    this[kClients].clear()
-
-    return Promise.all(closePromises)
-  }
-
-  [kDestroy] (err) {
-    const destroyPromises = []
-    for (const { dispatcher } of this[kClients].values()) {
-      destroyPromises.push(dispatcher.destroy(err))
-    }
-    this[kClients].clear()
-
-    return Promise.all(destroyPromises)
-  }
-
-  get stats () {
-    const allClientStats = {}
-    for (const { dispatcher } of this[kClients].values()) {
-      if (dispatcher.stats) {
-        allClientStats[dispatcher[kUrl].origin] = dispatcher.stats
-      }
-    }
-    return allClientStats
-  }
-}
-
-module.exports = Agent

package/node_modules/undici/lib/dispatcher/balanced-pool.js

@@ -1,219 +0,0 @@
-'use strict'
-
-const {
-  BalancedPoolMissingUpstreamError,
-  InvalidArgumentError
-} = require('../core/errors')
-const {
-  PoolBase,
-  kClients,
-  kNeedDrain,
-  kAddClient,
-  kRemoveClient,
-  kGetDispatcher
-} = require('./pool-base')
-const Pool = require('./pool')
-const { kUrl } = require('../core/symbols')
-const util = require('../core/util')
-const kFactory = Symbol('factory')
-
-const kOptions = Symbol('options')
-const kGreatestCommonDivisor = Symbol('kGreatestCommonDivisor')
-const kCurrentWeight = Symbol('kCurrentWeight')
-const kIndex = Symbol('kIndex')
-const kWeight = Symbol('kWeight')
-const kMaxWeightPerServer = Symbol('kMaxWeightPerServer')
-const kErrorPenalty = Symbol('kErrorPenalty')
-
-/**
- * Calculate the greatest common divisor of two numbers by
- * using the Euclidean algorithm.
- *
- * @param {number} a
- * @param {number} b
- * @returns {number}
- */
-function getGreatestCommonDivisor (a, b) {
-  if (a === 0) return b
-
-  while (b !== 0) {
-    const t = b
-    b = a % b
-    a = t
-  }
-  return a
-}
-
-function defaultFactory (origin, opts) {
-  return new Pool(origin, opts)
-}
-
-class BalancedPool extends PoolBase {
-  constructor (upstreams = [], { factory = defaultFactory, ...opts } = {}) {
-    if (typeof factory !== 'function') {
-      throw new InvalidArgumentError('factory must be a function.')
-    }
-
-    super(opts)
-
-    this[kOptions] = { ...util.deepClone(opts) }
-    this[kOptions].interceptors = opts.interceptors
-      ? { ...opts.interceptors }
-      : undefined
-    this[kIndex] = -1
-    this[kCurrentWeight] = 0
-
-    this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100
-    this[kErrorPenalty] = this[kOptions].errorPenalty || 15
-
-    if (!Array.isArray(upstreams)) {
-      upstreams = [upstreams]
-    }
-
-    this[kFactory] = factory
-
-    for (const upstream of upstreams) {
-      this.addUpstream(upstream)
-    }
-    this._updateBalancedPoolStats()
-  }
-
-  addUpstream (upstream) {
-    const upstreamOrigin = util.parseOrigin(upstream).origin
-
-    if (this[kClients].find((pool) => (
-      pool[kUrl].origin === upstreamOrigin &&
-      pool.closed !== true &&
-      pool.destroyed !== true
-    ))) {
-      return this
-    }
-    const pool = this[kFactory](upstreamOrigin, this[kOptions])
-
-    this[kAddClient](pool)
-    pool.on('connect', () => {
-      pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty])
-    })
-
-    pool.on('connectionError', () => {
-      pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty])
-      this._updateBalancedPoolStats()
-    })
-
-    pool.on('disconnect', (...args) => {
-      const err = args[2]
-      if (err && err.code === 'UND_ERR_SOCKET') {
-        // decrease the weight of the pool.
-        pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty])
-        this._updateBalancedPoolStats()
-      }
-    })
-
-    for (const client of this[kClients]) {
-      client[kWeight] = this[kMaxWeightPerServer]
-    }
-
-    this._updateBalancedPoolStats()
-
-    return this
-  }
-
-  _updateBalancedPoolStats () {
-    let result = 0
-    for (let i = 0; i < this[kClients].length; i++) {
-      result = getGreatestCommonDivisor(this[kClients][i][kWeight], result)
-    }
-
-    this[kGreatestCommonDivisor] = result
-  }
-
-  removeUpstream (upstream) {
-    const upstreamOrigin = util.parseOrigin(upstream).origin
-
-    const pool = this[kClients].find((pool) => (
-      pool[kUrl].origin === upstreamOrigin &&
-      pool.closed !== true &&
-      pool.destroyed !== true
-    ))
-
-    if (pool) {
-      this[kRemoveClient](pool)
-    }
-
-    return this
-  }
-
-  getUpstream (upstream) {
-    const upstreamOrigin = util.parseOrigin(upstream).origin
-
-    return this[kClients].find((pool) => (
-      pool[kUrl].origin === upstreamOrigin &&
-      pool.closed !== true &&
-      pool.destroyed !== true
-    ))
-  }
-
-  get upstreams () {
-    return this[kClients]
-      .filter(dispatcher => dispatcher.closed !== true && dispatcher.destroyed !== true)
-      .map((p) => p[kUrl].origin)
-  }
-
-  [kGetDispatcher] () {
-    // We validate that pools is greater than 0,
-    // otherwise we would have to wait until an upstream
-    // is added, which might never happen.
-    if (this[kClients].length === 0) {
-      throw new BalancedPoolMissingUpstreamError()
-    }
-
-    const dispatcher = this[kClients].find(dispatcher => (
-      !dispatcher[kNeedDrain] &&
-      dispatcher.closed !== true &&
-      dispatcher.destroyed !== true
-    ))
-
-    if (!dispatcher) {
-      return
-    }
-
-    const allClientsBusy = this[kClients].map(pool => pool[kNeedDrain]).reduce((a, b) => a && b, true)
-
-    if (allClientsBusy) {
-      return
-    }
-
-    let counter = 0
-
-    let maxWeightIndex = this[kClients].findIndex(pool => !pool[kNeedDrain])
-
-    while (counter++ < this[kClients].length) {
-      this[kIndex] = (this[kIndex] + 1) % this[kClients].length
-      const pool = this[kClients][this[kIndex]]
-
-      // find pool index with the largest weight
-      if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) {
-        maxWeightIndex = this[kIndex]
-      }
-
-      // decrease the current weight every `this[kClients].length`.
-      if (this[kIndex] === 0) {
-        // Set the current weight to the next lower weight.
-        this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor]
-
-        if (this[kCurrentWeight] <= 0) {
-          this[kCurrentWeight] = this[kMaxWeightPerServer]
-        }
-      }
-      if (pool[kWeight] >= this[kCurrentWeight] && (!pool[kNeedDrain])) {
-        return pool
-      }
-    }
-
-    this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight]
-    this[kIndex] = maxWeightIndex
-    return this[kClients][maxWeightIndex]
-  }
-}
-
-module.exports = BalancedPool