@chainlink/external-adapter-framework 1.7.5 → 1.7.7

package/generator-adapter/node_modules/@octokit/types/package.json

@@ -1,21 +1,14 @@
 {
   "name": "@octokit/types",
+  "version": "9.3.2",
+  "publishConfig": {
+    "access": "public"
+  },
   "description": "Shared TypeScript definitions for Octokit projects",
-  "version": "6.41.0",
-  "license": "MIT",
-  "files": [
-    "dist-*/",
-    "bin/"
-  ],
-  "source": "dist-src/index.js",
-  "types": "dist-types/index.d.ts",
-  "octokit": {
-    "openapi-version": "6.8.0"
+  "dependencies": {
+    "@octokit/openapi-types": "^18.0.0"
   },
-  "main": "dist-node/index.js",
-  "module": "dist-web/index.js",
-  "pika": true,
-  "sideEffects": false,
+  "repository": "github:octokit/types.ts",
   "keywords": [
     "github",
     "api",
@@ -23,32 +16,31 @@
     "toolkit",
     "typescript"
   ],
-  "repository": "github:octokit/types.ts",
-  "dependencies": {
-    "@octokit/openapi-types": "^12.11.0"
-  },
+  "author": "Gregor Martynus (https://twitter.com/gr2m)",
+  "license": "MIT",
   "devDependencies": {
-    "@pika/pack": "^0.3.7",
-    "@pika/plugin-build-node": "^0.9.0",
-    "@pika/plugin-build-web": "^0.9.0",
-    "@pika/plugin-ts-standard-pkg": "^0.9.0",
+    "@octokit/tsconfig": "^1.0.2",
     "@types/node": ">= 8",
-    "github-openapi-graphql-query": "^2.0.0",
+    "github-openapi-graphql-query": "^4.0.0",
     "handlebars": "^4.7.6",
-    "json-schema-to-typescript": "^11.0.0",
+    "json-schema-to-typescript": "^13.0.0",
     "lodash.set": "^4.3.2",
     "npm-run-all": "^4.1.5",
     "pascal-case": "^3.1.1",
-    "pika-plugin-merge-properties": "^1.0.6",
     "prettier": "^2.0.0",
-    "semantic-release": "^19.0.3",
+    "semantic-release": "^21.0.0",
     "semantic-release-plugin-update-version-in-files": "^1.0.0",
     "sort-keys": "^4.2.0",
     "string-to-jsdoc-comment": "^1.0.0",
-    "typedoc": "^0.23.0",
-    "typescript": "^4.0.2"
+    "typedoc": "^0.24.0",
+    "typescript": "^5.0.0"
   },
-  "publishConfig": {
-    "access": "public"
-  }
+  "octokit": {
+    "openapi-version": "12.0.0"
+  },
+  "files": [
+    "dist-types/**"
+  ],
+  "types": "dist-types/index.d.ts",
+  "sideEffects": false
 }

package/generator-adapter/node_modules/get-stream/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "get-stream",
-	"version": "6.0.1",
-	"description": "Get a stream as a string, buffer, or array",
+	"version": "8.0.1",
+	"description": "Get a stream as a string, Buffer, ArrayBuffer or array",
 	"license": "MIT",
 	"repository": "sindresorhus/get-stream",
 	"funding": "https://github.com/sponsors/sindresorhus",
@@ -10,16 +10,21 @@
 		"email": "sindresorhus@gmail.com",
 		"url": "https://sindresorhus.com"
 	},
+	"type": "module",
+	"exports": {
+		"types": "./source/index.d.ts",
+		"default": "./source/index.js"
+	},
 	"engines": {
-		"node": ">=10"
+		"node": ">=16"
 	},
 	"scripts": {
-		"test": "xo && ava && tsd"
+		"benchmark": "node benchmarks/index.js",
+		"test": "xo && ava && tsd --typings=source/index.d.ts --files=source/index.test-d.ts"
 	},
 	"files": [
-		"index.js",
-		"index.d.ts",
-		"buffer-stream.js"
+		"source",
+		"!*.test-d.ts"
 	],
 	"keywords": [
 		"get",
@@ -34,14 +39,15 @@
 		"consume",
 		"readable",
 		"readablestream",
-		"array",
-		"object"
+		"object",
+		"concat"
 	],
 	"devDependencies": {
-		"@types/node": "^14.0.27",
-		"ava": "^2.4.0",
-		"into-stream": "^5.0.0",
-		"tsd": "^0.13.1",
-		"xo": "^0.24.0"
+		"@types/node": "^20.5.0",
+		"ava": "^5.3.1",
+		"precise-now": "^2.0.0",
+		"stream-json": "^1.8.0",
+		"tsd": "^0.28.1",
+		"xo": "^0.56.0"
 	}
 }

package/generator-adapter/node_modules/get-stream/readme.md

@@ -1,124 +1,291 @@
 # get-stream
 
-> Get a stream as a string, buffer, or array
+> Get a stream as a string, Buffer, ArrayBuffer or array
+
+## Features
+
+- Works in any JavaScript environment ([Node.js](#nodejs-streams), [browsers](#web-streams), etc.).
+- Supports [text streams](#getstreamstream-options), [binary streams](#getstreamasbufferstream-options) and [object streams](#getstreamasarraystream-options).
+- Supports [async iterables](#async-iterables).
+- Can set a [maximum stream size](#maxbuffer).
+- Returns [partially read data](#errors) when the stream errors.
+- [Fast](#benchmarks).
 
 ## Install
 
-```
-$ npm install get-stream
+```sh
+npm install get-stream
 ```
 
 ## Usage
 
+### Node.js streams
+
 ```js
-const fs = require('fs');
-const getStream = require('get-stream');
-
-(async () => {
-	const stream = fs.createReadStream('unicorn.txt');
-
-	console.log(await getStream(stream));
-	/*
-	              ,,))))))));,
-	           __)))))))))))))),
-	\|/       -\(((((''''((((((((.
-	-*-==//////((''  .     `)))))),
-	/|\      ))| o    ;-.    '(((((                                  ,(,
-	         ( `|    /  )    ;))))'                               ,_))^;(~
-	            |   |   |   ,))((((_     _____------~~~-.        %,;(;(>';'~
-	            o_);   ;    )))(((` ~---~  `::           \      %%~~)(v;(`('~
-	                  ;    ''''````         `:       `:::|\,__,%%    );`'; ~
-	                 |   _                )     /      `:|`----'     `-'
-	           ______/\/~    |                 /        /
-	         /~;;.____/;;'  /          ___--,-(   `;;;/
-	        / //  _;______;'------~~~~~    /;;/\    /
-	       //  | |                        / ;   \;;,\
-	      (<_  | ;                      /',/-----'  _>
-	       \_| ||_                     //~;~~~~~~~~~
-	           `\_|                   (,~~
-	                                   \~\
-	                                    ~~
-	*/
-})();
+import fs from 'node:fs';
+import getStream from 'get-stream';
+
+const stream = fs.createReadStream('unicorn.txt');
+
+console.log(await getStream(stream));
+/*
+              ,,))))))));,
+           __)))))))))))))),
+\|/       -\(((((''''((((((((.
+-*-==//////((''  .     `)))))),
+/|\      ))| o    ;-.    '(((((                                  ,(,
+         ( `|    /  )    ;))))'                               ,_))^;(~
+            |   |   |   ,))((((_     _____------~~~-.        %,;(;(>';'~
+            o_);   ;    )))(((` ~---~  `::           \      %%~~)(v;(`('~
+                  ;    ''''````         `:       `:::|\,__,%%    );`'; ~
+                 |   _                )     /      `:|`----'     `-'
+           ______/\/~    |                 /        /
+         /~;;.____/;;'  /          ___--,-(   `;;;/
+        / //  _;______;'------~~~~~    /;;/\    /
+       //  | |                        / ;   \;;,\
+      (<_  | ;                      /',/-----'  _>
+       \_| ||_                     //~;~~~~~~~~~
+           `\_|                   (,~~
+                                   \~\
+                                    ~~
+*/
+```
+
+### Web streams
+
+```js
+import getStream from 'get-stream';
+
+const {body: readableStream} = await fetch('https://example.com');
+console.log(await getStream(readableStream));
+```
+
+### Async iterables
+
+```js
+import {opendir} from 'node:fs/promises';
+import {getStreamAsArray} from 'get-stream';
+
+const asyncIterable = await opendir(directory);
+console.log(await getStreamAsArray(asyncIterable));
 ```
 
 ## API
 
-The methods returns a promise that resolves when the `end` event fires on the stream, indicating that there is no more data to be read. The stream is switched to flowing mode.
+The following methods read the stream's contents and return it as a promise.
 
 ### getStream(stream, options?)
 
-Get the `stream` as a string.
+`stream`: [`stream.Readable`](https://nodejs.org/api/stream.html#class-streamreadable), [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream), or [`AsyncIterable<string | Buffer | ArrayBuffer | DataView | TypedArray>`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_async_iterator_and_async_iterable_protocols)\
+`options`: [`Options`](#options)
 
-#### options
+Get the given `stream` as a string.
 
-Type: `object`
+### getStreamAsBuffer(stream, options?)
+
+Get the given `stream` as a Node.js [`Buffer`](https://nodejs.org/api/buffer.html#class-buffer).
+
+```js
+import {getStreamAsBuffer} from 'get-stream';
+
+const stream = fs.createReadStream('unicorn.png');
+console.log(await getStreamAsBuffer(stream));
+```
 
-##### encoding
+### getStreamAsArrayBuffer(stream, options?)
 
-Type: `string`\
-Default: `'utf8'`
+Get the given `stream` as an [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer).
 
-[Encoding](https://nodejs.org/api/buffer.html#buffer_buffer) of the incoming stream.
+```js
+import {getStreamAsArrayBuffer} from 'get-stream';
+
+const {body: readableStream} = await fetch('https://example.com');
+console.log(await getStreamAsArrayBuffer(readableStream));
+```
+
+### getStreamAsArray(stream, options?)
+
+Get the given `stream` as an array. Unlike [other methods](#api), this supports [streams of objects](https://nodejs.org/api/stream.html#object-mode).
+
+```js
+import {getStreamAsArray} from 'get-stream';
+
+const {body: readableStream} = await fetch('https://example.com');
+console.log(await getStreamAsArray(readableStream));
+```
+
+#### options
+
+Type: `object`
 
 ##### maxBuffer
 
 Type: `number`\
 Default: `Infinity`
 
-Maximum length of the returned string. If it exceeds this value before the stream ends, the promise will be rejected with a `getStream.MaxBufferError` error.
+Maximum length of the stream. If exceeded, the promise will be rejected with a `MaxBufferError`.
+
+Depending on the [method](#api), the length is measured with [`string.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length), [`buffer.length`](https://nodejs.org/api/buffer.html#buflength), [`arrayBuffer.byteLength`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/byteLength) or [`array.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length).
+
+## Errors
 
-### getStream.buffer(stream, options?)
+If the stream errors, the returned promise will be rejected with the `error`. Any contents already read from the stream will be set to `error.bufferedData`, which is a `string`, a `Buffer`, an `ArrayBuffer` or an array depending on the [method used](#api).
 
-Get the `stream` as a buffer.
+```js
+import getStream from 'get-stream';
+
+try {
+	await getStream(streamThatErrorsAtTheEnd('unicorn'));
+} catch (error) {
+	console.log(error.bufferedData);
+	//=> 'unicorn'
+}
+```
 
-It honors the `maxBuffer` option as above, but it refers to byte length rather than string length.
+## Tips
 
-### getStream.array(stream, options?)
+### Alternatives
 
-Get the `stream` as an array of values.
+If you do not need the [`maxBuffer`](#maxbuffer) option, [`error.bufferedData`](#errors), nor browser support, you can use the following methods instead of this package.
 
-It honors both the `maxBuffer` and `encoding` options. The behavior changes slightly based on the encoding chosen:
+#### [`streamConsumers.text()`](https://nodejs.org/api/webstreams.html#streamconsumerstextstream)
 
-- When `encoding` is unset, it assumes an [object mode stream](https://nodesource.com/blog/understanding-object-streams/) and collects values emitted from `stream` unmodified. In this case `maxBuffer` refers to the number of items in the array (not the sum of their sizes).
+```js
+import fs from 'node:fs';
+import {text} from 'node:stream/consumers';
 
-- When `encoding` is set to `buffer`, it collects an array of buffers. `maxBuffer` refers to the summed byte lengths of every buffer in the array.
+const stream = fs.createReadStream('unicorn.txt', {encoding: 'utf8'});
+console.log(await text(stream))
+```
 
-- When `encoding` is set to anything else, it collects an array of strings. `maxBuffer` refers to the summed character lengths of every string in the array.
+#### [`streamConsumers.buffer()`](https://nodejs.org/api/webstreams.html#streamconsumersbufferstream)
 
-## Errors
+```js
+import {buffer} from 'node:stream/consumers';
+
+console.log(await buffer(stream))
+```
+
+#### [`streamConsumers.arrayBuffer()`](https://nodejs.org/api/webstreams.html#streamconsumersarraybufferstream)
+
+```js
+import {arrayBuffer} from 'node:stream/consumers';
+
+console.log(await arrayBuffer(stream))
+```
+
+#### [`readable.toArray()`](https://nodejs.org/api/stream.html#readabletoarrayoptions)
+
+```js
+console.log(await stream.toArray())
+```
+
+#### [`Array.fromAsync()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fromAsync)
+
+If your [environment supports it](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fromAsync#browser_compatibility):
+
+```js
+console.log(await Array.fromAsync(stream))
+```
+
+### Non-UTF-8 encoding
+
+When all of the following conditions apply:
+  - [`getStream()`](#getstreamstream-options) is used (as opposed to [`getStreamAsBuffer()`](#getstreamasbufferstream-options) or [`getStreamAsArrayBuffer()`](#getstreamasarraybufferstream-options))
+  - The stream is binary (not text)
+  - The stream's encoding is not UTF-8 (for example, it is UTF-16, hexadecimal, or Base64)
+
+Then the stream must be decoded using a transform stream like [`TextDecoderStream`](https://developer.mozilla.org/en-US/docs/Web/API/TextDecoderStream) or [`b64`](https://github.com/hapijs/b64).
+
+```js
+import getStream from 'get-stream';
+
+const textDecoderStream = new TextDecoderStream('utf-16le');
+const {body: readableStream} = await fetch('https://example.com');
+console.log(await getStream(readableStream.pipeThrough(textDecoderStream)));
+```
 
-If the input stream emits an `error` event, the promise will be rejected with the error. The buffered data will be attached to the `bufferedData` property of the error.
+### Blobs
+
+[`getStreamAsArrayBuffer()`](#getstreamasarraybufferstream-options) can be used to create [Blobs](https://developer.mozilla.org/en-US/docs/Web/API/Blob).
 
 ```js
-(async () => {
-	try {
-		await getStream(streamThatErrorsAtTheEnd('unicorn'));
-	} catch (error) {
-		console.log(error.bufferedData);
-		//=> 'unicorn'
-	}
-})()
+import {getStreamAsArrayBuffer} from 'get-stream';
+
+const stream = fs.createReadStream('unicorn.txt');
+console.log(new Blob([await getStreamAsArrayBuffer(stream)]));
 ```
 
+### JSON streaming
+
+[`getStreamAsArray()`](#getstreamasarraystream-options) can be combined with JSON streaming utilities to parse JSON incrementally.
+
+```js
+import fs from 'node:fs';
+import {compose as composeStreams} from 'node:stream';
+import {getStreamAsArray} from 'get-stream';
+import streamJson from 'stream-json';
+import streamJsonArray from 'stream-json/streamers/StreamArray.js';
+
+const stream = fs.createReadStream('big-array-of-objects.json');
+console.log(await getStreamAsArray(
+	composeStreams(stream, streamJson.parser(), streamJsonArray.streamArray()),
+));
+```
+
+## Benchmarks
+
+### Node.js stream (100 MB, binary)
+
+- `getStream()`: 142ms
+- `text()`: 139ms
+- `getStreamAsBuffer()`: 106ms
+- `buffer()`: 83ms
+- `getStreamAsArrayBuffer()`: 105ms
+- `arrayBuffer()`: 81ms
+- `getStreamAsArray()`: 24ms
+- `stream.toArray()`: 21ms
+
+### Node.js stream (100 MB, text)
+
+- `getStream()`: 90ms
+- `text()`: 89ms
+- `getStreamAsBuffer()`: 127ms
+- `buffer()`: 192ms
+- `getStreamAsArrayBuffer()`: 129ms
+- `arrayBuffer()`: 195ms
+- `getStreamAsArray()`: 89ms
+- `stream.toArray()`: 90ms
+
+### Web ReadableStream (100 MB, binary)
+
+- `getStream()`: 223ms
+- `text()`: 221ms
+- `getStreamAsBuffer()`: 182ms
+- `buffer()`: 153ms
+- `getStreamAsArrayBuffer()`: 171ms
+- `arrayBuffer()`: 155ms
+- `getStreamAsArray()`: 83ms
+
+### Web ReadableStream (100 MB, text)
+
+- `getStream()`: 141ms
+- `text()`: 139ms
+- `getStreamAsBuffer()`: 91ms
+- `buffer()`: 80ms
+- `getStreamAsArrayBuffer()`: 89ms
+- `arrayBuffer()`: 81ms
+- `getStreamAsArray()`: 21ms
+
+[Benchmarks' source file](benchmarks/index.js).
+
 ## FAQ
 
 ### How is this different from [`concat-stream`](https://github.com/maxogden/concat-stream)?
 
-This module accepts a stream instead of being one and returns a promise instead of using a callback. The API is simpler and it only supports returning a string, buffer, or array. It doesn't have a fragile type inference. You explicitly choose what you want. And it doesn't depend on the huge `readable-stream` package.
+This module accepts a stream instead of being one and returns a promise instead of using a callback. The API is simpler and it only supports returning a string, `Buffer`, an `ArrayBuffer` or an array. It doesn't have a fragile type inference. You explicitly choose what you want. And it doesn't depend on the huge `readable-stream` package.
 
 ## Related
 
 - [get-stdin](https://github.com/sindresorhus/get-stdin) - Get stdin as a string or buffer
-
----
-
-<div align="center">
-	<b>
-		<a href="https://tidelift.com/subscription/pkg/npm-get-stream?utm_source=npm-get-stream&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
-	</b>
-	<br>
-	<sub>
-		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
-	</sub>
-</div>
+- [into-stream](https://github.com/sindresorhus/into-stream) - The opposite of this package

package/generator-adapter/node_modules/github-username/index.d.ts

@@ -1,9 +1,9 @@
-export interface Options {
+export type Options = {
 	/**
 	GitHub [personal access token](https://github.com/settings/tokens/new).
 	*/
 	readonly token?: string;
-}
+};
 
 /**
 Get the GitHub username from an email address if the email can be found in any commits on GitHub.

package/generator-adapter/node_modules/github-username/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "github-username",
-	"version": "7.0.0",
+	"version": "8.0.0",
 	"description": "Get a GitHub username from an email address",
 	"license": "MIT",
 	"repository": "sindresorhus/github-username",
@@ -11,9 +11,12 @@
 		"url": "https://sindresorhus.com"
 	},
 	"type": "module",
-	"exports": "./index.js",
+	"exports": {
+		"types": "./index.d.ts",
+		"default": "./index.js"
+	},
 	"engines": {
-		"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+		"node": ">=16"
 	},
 	"scripts": {
 		"test": "xo && ava && tsd"
@@ -32,11 +35,11 @@
 		"git"
 	],
 	"dependencies": {
-		"@octokit/rest": "^18.12.0"
+		"@octokit/rest": "^19.0.13"
 	},
 	"devDependencies": {
-		"ava": "^3.15.0",
-		"tsd": "^0.18.0",
-		"xo": "^0.45.0"
+		"ava": "^5.3.1",
+		"tsd": "^0.28.1",
+		"xo": "^0.55.0"
 	}
 }

package/generator-adapter/node_modules/ky/distribution/core/Ky.d.ts

@@ -0,0 +1,16 @@
+import type { Input, InternalOptions, Options } from '../types/options.js';
+import { type ResponsePromise } from '../types/ResponsePromise.js';
+export declare class Ky {
+    static create(input: Input, options: Options): ResponsePromise;
+    request: Request;
+    protected abortController?: AbortController;
+    protected _retryCount: number;
+    protected _input: Input;
+    protected _options: InternalOptions;
+    constructor(input: Input, options?: Options);
+    protected _calculateRetryDelay(error: unknown): number;
+    protected _decorateResponse(response: Response): Response;
+    protected _retry<T extends (...arguments_: any) => Promise<any>>(function_: T): Promise<ReturnType<T> | void>;
+    protected _fetch(): Promise<Response>;
+    protected _stream(response: Response, onDownloadProgress: Options['onDownloadProgress']): Response;
+}