@chainlink/external-adapter-framework 2.11.0 → 2.11.2

package/generator-adapter/node_modules/p-timeout/index.js

@@ -1,39 +1,13 @@
 export class TimeoutError extends Error {
-	constructor(message) {
-		super(message);
-		this.name = 'TimeoutError';
-	}
-}
+	name = 'TimeoutError';
 
-/**
-An error to be thrown when the request is aborted by AbortController.
-DOMException is thrown instead of this Error when DOMException is available.
-*/
-export class AbortError extends Error {
-	constructor(message) {
-		super();
-		this.name = 'AbortError';
-		this.message = message;
+	constructor(message, options) {
+		super(message, options);
+		Error.captureStackTrace?.(this, TimeoutError);
 	}
 }
 
-/**
-TODO: Remove AbortError and just throw DOMException when targeting Node 18.
-*/
-const getDOMException = errorMessage => globalThis.DOMException === undefined
-	? new AbortError(errorMessage)
-	: new DOMException(errorMessage);
-
-/**
-TODO: Remove below function and just 'reject(signal.reason)' when targeting Node 18.
-*/
-const getAbortedReason = signal => {
-	const reason = signal.reason === undefined
-		? getDOMException('This operation was aborted.')
-		: signal.reason;
-
-	return reason instanceof Error ? reason : getDOMException(reason);
-};
+const getAbortedReason = signal => signal.reason ?? new DOMException('This operation was aborted.', 'AbortError');
 
 export default function pTimeout(promise, options) {
 	const {
@@ -41,40 +15,42 @@ export default function pTimeout(promise, options) {
 		fallback,
 		message,
 		customTimers = {setTimeout, clearTimeout},
+		signal,
 	} = options;
 
 	let timer;
+	let abortHandler;
 
 	const wrappedPromise = new Promise((resolve, reject) => {
 		if (typeof milliseconds !== 'number' || Math.sign(milliseconds) !== 1) {
 			throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
 		}
 
-		if (options.signal) {
-			const {signal} = options;
-			if (signal.aborted) {
-				reject(getAbortedReason(signal));
-			}
+		if (signal?.aborted) {
+			reject(getAbortedReason(signal));
+			return;
+		}
 
-			const abortHandler = () => {
+		if (signal) {
+			abortHandler = () => {
 				reject(getAbortedReason(signal));
 			};
 
 			signal.addEventListener('abort', abortHandler, {once: true});
-
-			promise.finally(() => {
-				signal.removeEventListener('abort', abortHandler);
-			});
 		}
 
+		// Use .then() instead of async IIFE to preserve stack traces
+		// eslint-disable-next-line promise/prefer-await-to-then, promise/prefer-catch
+		promise.then(resolve, reject);
+
 		if (milliseconds === Number.POSITIVE_INFINITY) {
-			promise.then(resolve, reject);
 			return;
 		}
 
 		// We create the error outside of `setTimeout` to preserve the stack trace.
 		const timeoutError = new TimeoutError();
 
+		// `.call(undefined, ...)` is needed for custom timers to avoid context issues
 		timer = customTimers.setTimeout.call(undefined, () => {
 			if (fallback) {
 				try {
@@ -99,21 +75,18 @@ export default function pTimeout(promise, options) {
 				reject(timeoutError);
 			}
 		}, milliseconds);
-
-		(async () => {
-			try {
-				resolve(await promise);
-			} catch (error) {
-				reject(error);
-			}
-		})();
 	});
 
+	// eslint-disable-next-line promise/prefer-await-to-then
 	const cancelablePromise = wrappedPromise.finally(() => {
 		cancelablePromise.clear();
+		if (abortHandler && signal) {
+			signal.removeEventListener('abort', abortHandler);
+		}
 	});
 
 	cancelablePromise.clear = () => {
+		// `.call(undefined, ...)` is needed for custom timers to avoid context issues
 		customTimers.clearTimeout.call(undefined, timer);
 		timer = undefined;
 	};

package/generator-adapter/node_modules/p-timeout/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "p-timeout",
-	"version": "6.1.3",
+	"version": "7.0.1",
 	"description": "Timeout a promise after a specified amount of time",
 	"license": "MIT",
 	"repository": "sindresorhus/p-timeout",
@@ -11,11 +11,13 @@
 		"url": "https://sindresorhus.com"
 	},
 	"type": "module",
-	"exports": "./index.js",
-	"types": "./index.d.ts",
+	"exports": {
+		"types": "./index.d.ts",
+		"default": "./index.js"
+	},
 	"sideEffects": false,
 	"engines": {
-		"node": ">=14.16"
+		"node": ">=20"
 	},
 	"scripts": {
 		"test": "xo && ava && tsd"
@@ -38,13 +40,13 @@
 		"bluebird"
 	],
 	"devDependencies": {
-		"ava": "^4.3.1",
-		"delay": "^5.0.0",
+		"ava": "^6.4.1",
+		"delay": "^6.0.0",
 		"in-range": "^3.0.0",
 		"p-cancelable": "^4.0.1",
-		"sinon": "^19.0.2",
+		"sinon": "^21.0.0",
 		"time-span": "^5.1.0",
-		"tsd": "^0.22.0",
-		"xo": "^0.54.2"
+		"tsd": "^0.33.0",
+		"xo": "^1.2.2"
 	}
 }

package/generator-adapter/node_modules/p-timeout/readme.md

@@ -54,7 +54,7 @@ Passing `Infinity` will cause it to never time out.
 ##### message
 
 Type: `string | Error | false`\
-Default: `'Promise timed out after 50 milliseconds'`
+Default: `'Promise timed out after {milliseconds} milliseconds'`
 
 Specify a custom error message or error to throw when it times out:
 
@@ -78,6 +78,8 @@ Type: `Function`
 
 Do something other than rejecting with an error on timeout.
 
+The function can return a value or a promise.
+
 You could for example retry:
 
 ```js
@@ -89,8 +91,10 @@ const delayedPromise = () => setTimeout(200);
 await pTimeout(delayedPromise(), {
 	milliseconds: 50,
 	fallback: () => {
-		return pTimeout(delayedPromise(), {milliseconds: 300});
-	},
+		return pTimeout(delayedPromise(), {
+			milliseconds: 300
+		});
+	}
 });
 ```
 
@@ -105,8 +109,8 @@ Useful for testing purposes, in particular to work around [`sinon.useFakeTimers(
 Example:
 
 ```js
-import {setTimeout} from 'node:timers/promises';
 import pTimeout from 'p-timeout';
+import sinon from 'sinon';
 
 const originalSetTimeout = setTimeout;
 const originalClearTimeout = clearTimeout;
@@ -123,13 +127,11 @@ await pTimeout(doSomething(), {
 });
 ```
 
-#### signal
+##### signal
 
 Type: [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)
 
-You can abort the promise using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
-
-*Requires Node.js 16 or later.*
+Abort the promise.
 
 ```js
 import pTimeout from 'p-timeout';
@@ -164,7 +166,7 @@ Exposed for instance checking and sub-classing.
 
 > Modern alternative to `p-timeout`
 
-Asynchronous functions like `fetch` can accept an [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal), which can be conveniently created with [`AbortSignal.timeout()`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static).
+Async functions like `fetch` can accept an [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal), which can be conveniently created with [`AbortSignal.timeout()`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static).
 
 The advantage over `p-timeout` is that the promise-generating function (like `fetch`) is actually notified that the user is no longer expecting an answer, so it can interrupt its work and free resources.
 

package/generator-adapter/node_modules/run-async/README.md

@@ -1,24 +1,21 @@
-Run Async
-=========
+# Run Async
 
-[![npm](https://badge.fury.io/js/run-async.svg)](http://badge.fury.io/js/run-async) [![tests](https://travis-ci.org/SBoudrias/run-async.svg?branch=master)](http://travis-ci.org/SBoudrias/run-async) [![dependencies](https://david-dm.org/SBoudrias/run-async.svg?theme=shields.io)](https://david-dm.org/SBoudrias/run-async)
+[![npm](https://badge.fury.io/js/run-async.svg)](http://badge.fury.io/js/run-async)
 
 Utility method to run a function either synchronously or asynchronously using a series of common patterns. This is useful for library author accepting sync or async functions as parameter. `runAsync` will always run them as an async method, and normalize the multiple signature.
 
-Installation
-=========
+# Installation
 
 ```bash
 npm install --save run-async
 ```
 
-Usage
-=========
+# Usage
 
 Here's a simple example print the function results and three options a user can provide a function.
 
 ```js
-var runAsync = require('run-async');
+var runAsync = require("run-async");
 
 var printAfter = function (func) {
   var cb = function (err, returnValue) {
@@ -29,51 +26,56 @@ var printAfter = function (func) {
 ```
 
 #### Using `this.async`
+
 ```js
 printAfter(function () {
   var done = this.async();
 
   setTimeout(function () {
-    done(null, 'done running with callback');
+    done(null, "done running with callback");
   }, 10);
 });
 ```
 
 #### Returning a promise
+
 ```js
 printAfter(function () {
   return new Promise(function (resolve, reject) {
-    resolve('done running with promises');
+    resolve("done running with promises");
   });
 });
 ```
 
 #### Synchronous function
+
 ```js
 printAfter(function () {
-  return 'done running sync function';
+  return "done running sync function";
 });
 ```
 
 #### Custom done factory
+
 ```js
-var runAsync = require('run-async');
+var runAsync = require("run-async");
 
-runAsync(function() {
+runAsync(function () {
   var callback = this.customAsync();
   callback(null, a + b);
-}, 'customAsync')(1, 2)
+}, "customAsync")(1, 2);
 ```
 
 #### Passing context to async method
+
 ```js
-var runAsync = require('run-async');
+var runAsync = require("run-async");
 
-runAsync(function() {
+runAsync(function () {
   assert(this.isBound);
   var callback = this.async();
   callback(null, a + b);
-}).call({ isBound: true }, 1, 2)
+}).call({ isBound: true }, 1, 2);
 ```
 
 ### runAsync.cb
@@ -81,20 +83,22 @@ runAsync(function() {
 `runAsync.cb` supports all the function types that `runAsync` does and additionally a traditional **callback as the last argument** signature:
 
 ```js
-var runAsync = require('run-async');
+var runAsync = require("run-async");
 
 // IMPORTANT: The wrapped function must have a fixed number of parameters.
-runAsync.cb(function(a, b, cb) {
-  cb(null, a + b);
-}, function(err, result) {
-  console.log(result)
-})(1, 2)
+runAsync.cb(
+  function (a, b, cb) {
+    cb(null, a + b);
+  },
+  function (err, result) {
+    console.log(result);
+  },
+)(1, 2);
 ```
 
 If your version of node support Promises natively (node >= 0.12), `runAsync` will return a promise. Example: `runAsync(func)(arg1, arg2).then(cb)`
 
-Licence
-========
+# Licence
 
 Copyright (c) 2014 Simon Boudrias (twitter: @vaxilart)  
 Licensed under the MIT license.

package/generator-adapter/node_modules/run-async/index.d.ts

@@ -0,0 +1,5 @@
+declare function runAsync<F extends (...args: any[]) => any>(
+  func: F,
+): (...args: Parameters<F>) => Promise<Awaited<ReturnType<F>>>;
+
+export = runAsync;

package/generator-adapter/node_modules/run-async/index.js

@@ -1,7 +1,9 @@
-'use strict';
-
 function isPromise(obj) {
-  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+  return (
+    !!obj &&
+    (typeof obj === "object" || typeof obj === "function") &&
+    typeof obj.then === "function"
+  );
 }
 
 /**
@@ -17,15 +19,14 @@ function isPromise(obj) {
  *                                return a Promise (Node >= 0.12) or call the callbacks.
  */
 
-var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
-  if (typeof cb === 'string') {
+var runAsync = (module.exports = function (func, cb, proxyProperty = "async") {
+  if (typeof cb === "string") {
     proxyProperty = cb;
     cb = undefined;
   }
   cb = cb || function () {};
 
   return function () {
-
     var args = arguments;
     var originalThis = this;
 
@@ -33,20 +34,20 @@ var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
       var resolved = false;
       const wrappedResolve = function (value) {
         if (resolved) {
-          console.warn('Run-async promise already resolved.')
+          console.warn("Run-async promise already resolved.");
         }
         resolved = true;
         resolve(value);
-      }
+      };
 
       var rejected = false;
       const wrappedReject = function (value) {
         if (rejected) {
-          console.warn('Run-async promise already rejected.')
+          console.warn("Run-async promise already rejected.");
         }
         rejected = true;
         reject(value);
-      }
+      };
 
       var usingCallback = false;
       var callbackConflict = false;
@@ -54,11 +55,15 @@ var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
 
       var doneFactory = function () {
         if (contextEnded) {
-          console.warn('Run-async async() called outside a valid run-async context, callback will be ignored.');
-          return function() {};
+          console.warn(
+            "Run-async async() called outside a valid run-async context, callback will be ignored.",
+          );
+          return function () {};
         }
         if (callbackConflict) {
-          console.warn('Run-async wrapped function (async) returned a promise.\nCalls to async() callback can have unexpected results.');
+          console.warn(
+            "Run-async wrapped function (async) returned a promise.\nCalls to async() callback can have unexpected results.",
+          );
         }
         usingCallback = true;
         return function (err, value) {
@@ -76,7 +81,9 @@ var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
           get(_target, prop) {
             if (prop === proxyProperty) {
               if (prop in _target) {
-                console.warn(`${proxyProperty} property is been shadowed by run-sync`);
+                console.warn(
+                  `${proxyProperty} property is been shadowed by run-sync`,
+                );
               }
               return doneFactory;
             }
@@ -92,7 +99,9 @@ var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
 
       if (usingCallback) {
         if (isPromise(answer)) {
-          console.warn('Run-async wrapped function (sync) returned a promise but async() callback must be executed to resolve.');
+          console.warn(
+            "Run-async wrapped function (sync) returned a promise but async() callback must be executed to resolve.",
+          );
         }
       } else {
         if (isPromise(answer)) {
@@ -108,8 +117,8 @@ var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
     promise.then(cb.bind(null, null), cb);
 
     return promise;
-  }
-};
+  };
+});
 
 runAsync.cb = function (func, cb) {
   return runAsync(function () {

package/generator-adapter/node_modules/run-async/package.json

@@ -1,10 +1,22 @@
 {
   "name": "run-async",
-  "version": "3.0.0",
+  "version": "4.0.6",
   "description": "Utility method to run function either synchronously or asynchronously using the common `this.async()` style.",
-  "main": "index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
   "scripts": {
-    "test": "mocha -R spec"
+    "test": "node --test test.js",
+    "lint": "npx oxlint && npx prettier --check ."
   },
   "engines": {
     "node": ">=0.12.0"
@@ -15,12 +27,10 @@
     "flow-control",
     "async"
   ],
-  "files": [
-    "index.js"
-  ],
   "author": "Simon Boudrias <admin@simonboudrias.com>",
   "license": "MIT",
   "devDependencies": {
-    "mocha": "^10.2.0"
+    "oxlint": "^1.2.0",
+    "prettier": "^3.5.3"
   }
 }

package/generator-adapter/node_modules/rxjs/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [7.8.2](https://github.com/reactivex/rxjs/compare/7.8.1...7.8.2) (2025-02-22)
+
+### Bug Fixes
+
+- **animationFrameScheduler:** some tasks are never flushed and sometimes it breaks completely ([#7444](https://github.com/reactivex/rxjs/issues/7444)) ([8bbfa4e](https://github.com/reactivex/rxjs/commit/8bbfa4efd15f6572316d5b2b05b2f49ded69a3ca))
+- **mergeWith:** works correctly with an Array ([#7281](https://github.com/reactivex/rxjs/issues/7281)) ([27855c6](https://github.com/reactivex/rxjs/commit/27855c635ca74107352ae3336944433a328c0b41))
+- **subscriber:** strict type signature for next method ([#7172](https://github.com/reactivex/rxjs/issues/7172)) ([0e2ef5e](https://github.com/reactivex/rxjs/commit/0e2ef5e1142699b028bc3624aae9b24c3e3aaccf))
+
 ## [7.8.1](https://github.com/reactivex/rxjs/compare/7.8.0...7.8.1) (2023-04-26)
 
 ### Bug Fixes

package/generator-adapter/node_modules/rxjs/dist/bundles/rxjs.umd.js

@@ -1977,7 +1977,7 @@
                 return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);
             }
             var actions = scheduler.actions;
-            if (id != null && ((_a = actions[actions.length - 1]) === null || _a === void 0 ? void 0 : _a.id) !== id) {
+            if (id != null && id === scheduler._scheduled && ((_a = actions[actions.length - 1]) === null || _a === void 0 ? void 0 : _a.id) !== id) {
                 animationFrameProvider.cancelAnimationFrame(id);
                 scheduler._scheduled = undefined;
             }
@@ -1993,8 +1993,14 @@
         }
         AnimationFrameScheduler.prototype.flush = function (action) {
             this._active = true;
-            var flushId = this._scheduled;
-            this._scheduled = undefined;
+            var flushId;
+            if (action) {
+                flushId = action.id;
+            }
+            else {
+                flushId = this._scheduled;
+                this._scheduled = undefined;
+            }
             var actions = this.actions;
             var error;
             action = action || actions.shift();
@@ -2560,11 +2566,13 @@
         return !!obj && (obj instanceof Observable || (isFunction(obj.lift) && isFunction(obj.subscribe)));
     }
 
-    var EmptyError = createErrorClass(function (_super) { return function EmptyErrorImpl() {
-        _super(this);
-        this.name = 'EmptyError';
-        this.message = 'no elements in sequence';
-    }; });
+    var EmptyError = createErrorClass(function (_super) {
+        return function EmptyErrorImpl() {
+            _super(this);
+            this.name = 'EmptyError';
+            this.message = 'no elements in sequence';
+        };
+    });
 
     function lastValueFrom(source, config) {
         var hasConfig = typeof config === 'object';
@@ -3937,7 +3945,7 @@
     }
 
     function distinctUntilKeyChanged(key, compare) {
-        return distinctUntilChanged(function (x, y) { return compare ? compare(x[key], y[key]) : x[key] === y[key]; });
+        return distinctUntilChanged(function (x, y) { return (compare ? compare(x[key], y[key]) : x[key] === y[key]); });
     }
 
     function throwIfEmpty(errorFactory) {
@@ -4223,7 +4231,6 @@
         }
         var scheduler = popScheduler(args);
         var concurrent = popNumber(args, Infinity);
-        args = argsOrArgArray(args);
         return operate(function (source, subscriber) {
             mergeAll(concurrent)(from(__spreadArray([source], __read(args)), scheduler)).subscribe(subscriber);
         });