deps: @gar/promise-retry@1.0.3

Author: wraithgar

DEPENDENCIES.md

@@ -270,7 +270,6 @@ graph LR;
   debug-->ms;
   fdir-->picomatch;
   fs-minipass-->minipass;
-  gar-promise-retry-->retry;
   glob-->minimatch;
   glob-->minipass;
   glob-->path-scurry;

node_modules/.gitignore

@@ -123,7 +123,6 @@
 !/qrcode-terminal
 !/read-cmd-shim
 !/read
-!/retry
 !/safer-buffer
 !/semver
 !/signal-exit

node_modules/@gar/promise-retry/LICENSE

@@ -1,3 +1,4 @@
+Copyright (c) 2011 Tim Koschützki (tim@debuggable.com), Felix Geisendörfer (felix@debuggable.com)
 Copyright (c) 2014 IndigoUnited
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

node_modules/@gar/promise-retry/lib/index.js

@@ -1,9 +1,44 @@
-const retry = require('retry')
+const { RetryOperation } = require('./retry')
 
-const isRetryError = (err) => err?.code === 'EPROMISERETRY' && Object.hasOwn(err, 'retried')
+const createTimeout = (attempt, opts) => Math.min(Math.round((1 + (opts.randomize ? Math.random() : 0)) * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt)), opts.maxTimeout)
+const isRetryError = err => err?.code === 'EPROMISERETRY' && Object.hasOwn(err, 'retried')
 
-async function promiseRetry (fn, options = {}) {
-  const operation = retry.operation(options)
+const promiseRetry = async (fn, options = {}) => {
+  let timeouts = []
+  if (options instanceof Array) {
+    timeouts = [...options]
+  } else {
+    if (options.retries === Infinity) {
+      options.forever = true
+      delete options.retries
+    }
+    const opts = {
+      retries: 10,
+      factor: 2,
+      minTimeout: 1 * 1000,
+      maxTimeout: Infinity,
+      randomize: false,
+      ...options
+    }
+    if (opts.minTimeout > opts.maxTimeout) {
+      throw new Error('minTimeout is greater than maxTimeout')
+    }
+    if (opts.retries) {
+      for (let i = 0; i < opts.retries; i++) {
+        timeouts.push(createTimeout(i, opts))
+      }
+      // sort the array numerically ascending (since the timeouts may be out of order at factor < 1)
+      timeouts.sort((a, b) => a - b)
+    } else if (options.forever) {
+      timeouts.push(createTimeout(0, opts))
+    }
+  }
+
+  const operation = new RetryOperation(timeouts, {
+    forever: options.forever,
+    unref: options.unref,
+    maxRetryTime: options.maxRetryTime
+  })
 
   return new Promise(function (resolve, reject) {
     operation.attempt(async number => {
@@ -13,13 +48,12 @@ async function promiseRetry (fn, options = {}) {
         }, number, operation)
         return resolve(result)
       } catch (err) {
-        if (isRetryError(err)) {
-          if (operation.retry(err.retried || new Error())) {
-            return
-          }
+        if (!isRetryError(err)) {
+          return reject(err)
+        }
+        if (!operation.retry(err.retried || new Error())) {
           return reject(err.retried)
         }
-        return reject(err)
       }
     })
   })

node_modules/@gar/promise-retry/lib/retry.js

@@ -0,0 +1,109 @@
+class RetryOperation {
+  #attempts = 1
+  #cachedTimeouts = null
+  #errors = []
+  #fn = null
+  #maxRetryTime
+  #operationStart = null
+  #originalTimeouts
+  #timeouts
+  #timer = null
+  #unref
+
+  constructor (timeouts, options = {}) {
+    this.#originalTimeouts = [...timeouts]
+    this.#timeouts = [...timeouts]
+    this.#unref = options.unref
+    this.#maxRetryTime = options.maxRetryTime || Infinity
+    if (options.forever) {
+      this.#cachedTimeouts = [...this.#timeouts]
+    }
+  }
+
+  get timeouts () {
+    return [...this.#timeouts]
+  }
+
+  get errors () {
+    return [...this.#errors]
+  }
+
+  get attempts () {
+    return this.#attempts
+  }
+
+  get mainError () {
+    let mainError = null
+    if (this.#errors.length) {
+      let mainErrorCount = 0
+      const counts = {}
+      for (let i = 0; i < this.#errors.length; i++) {
+        const error = this.#errors[i]
+        const { message } = error
+        if (!counts[message]) {
+          counts[message] = 0
+        }
+        counts[message]++
+
+        if (counts[message] >= mainErrorCount) {
+          mainError = error
+          mainErrorCount = counts[message]
+        }
+      }
+    }
+    return mainError
+  }
+
+  reset () {
+    this.#attempts = 1
+    this.#timeouts = [...this.#originalTimeouts]
+  }
+
+  stop () {
+    if (this.#timer) {
+      clearTimeout(this.#timer)
+    }
+
+    this.#timeouts = []
+    this.#cachedTimeouts = null
+  }
+
+  retry (err) {
+    this.#errors.push(err)
+    if (new Date().getTime() - this.#operationStart >= this.#maxRetryTime) {
+      // XXX This puts the timeout error first, meaning it will never show as mainError, there may be no way to ever see this
+      this.#errors.unshift(new Error('RetryOperation timeout occurred'))
+      return false
+    }
+
+    let timeout = this.#timeouts.shift()
+    if (timeout === undefined) {
+      // We're out of timeouts, clear the last error and repeat the final timeout
+      if (this.#cachedTimeouts) {
+        this.#errors.pop()
+        timeout = this.#cachedTimeouts.at(-1)
+      } else {
+        return false
+      }
+    }
+
+    // TODO what if there already is a timer?
+    this.#timer = setTimeout(() => {
+      this.#attempts++
+      this.#fn(this.#attempts)
+    }, timeout)
+
+    if (this.#unref) {
+      this.#timer.unref()
+    }
+
+    return true
+  }
+
+  attempt (fn) {
+    this.#fn = fn
+    this.#operationStart = new Date().getTime()
+    this.#fn(this.#attempts)
+  }
+}
+module.exports = { RetryOperation }

node_modules/@gar/promise-retry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gar/promise-retry",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Retries a function that returns a promise, leveraging the power of the retry module.",
   "main": "./lib/index.js",
   "files": [
@@ -39,9 +39,6 @@
     "replay"
   ],
   "license": "MIT",
-  "dependencies": {
-    "retry": "^0.13.1"
-  },
   "engines": {
     "node": "^20.17.0 || >=22.9.0"
   }