cdk-ecr-deployment 3.2.2 → 3.3.1

package/node_modules/got/dist/source/as-promise/normalize-arguments.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const is_1 = require("@sindresorhus/is");
-const normalizeArguments = (options, defaults) => {
-    if (is_1.default.null_(options.encoding)) {
-        throw new TypeError('To get a Buffer, set `options.responseType` to `buffer` instead');
-    }
-    is_1.assert.any([is_1.default.string, is_1.default.undefined], options.encoding);
-    is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.resolveBodyOnly);
-    is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.methodRewriting);
-    is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.isStream);
-    is_1.assert.any([is_1.default.string, is_1.default.undefined], options.responseType);
-    // `options.responseType`
-    if (options.responseType === undefined) {
-        options.responseType = 'text';
-    }
-    // `options.retry`
-    const { retry } = options;
-    if (defaults) {
-        options.retry = { ...defaults.retry };
-    }
-    else {
-        options.retry = {
-            calculateDelay: retryObject => retryObject.computedValue,
-            limit: 0,
-            methods: [],
-            statusCodes: [],
-            errorCodes: [],
-            maxRetryAfter: undefined
-        };
-    }
-    if (is_1.default.object(retry)) {
-        options.retry = {
-            ...options.retry,
-            ...retry
-        };
-        options.retry.methods = [...new Set(options.retry.methods.map(method => method.toUpperCase()))];
-        options.retry.statusCodes = [...new Set(options.retry.statusCodes)];
-        options.retry.errorCodes = [...new Set(options.retry.errorCodes)];
-    }
-    else if (is_1.default.number(retry)) {
-        options.retry.limit = retry;
-    }
-    if (is_1.default.undefined(options.retry.maxRetryAfter)) {
-        options.retry.maxRetryAfter = Math.min(
-        // TypeScript is not smart enough to handle `.filter(x => is.number(x))`.
-        // eslint-disable-next-line unicorn/no-fn-reference-in-iterator
-        ...[options.timeout.request, options.timeout.connect].filter(is_1.default.number));
-    }
-    // `options.pagination`
-    if (is_1.default.object(options.pagination)) {
-        if (defaults) {
-            options.pagination = {
-                ...defaults.pagination,
-                ...options.pagination
-            };
-        }
-        const { pagination } = options;
-        if (!is_1.default.function_(pagination.transform)) {
-            throw new Error('`options.pagination.transform` must be implemented');
-        }
-        if (!is_1.default.function_(pagination.shouldContinue)) {
-            throw new Error('`options.pagination.shouldContinue` must be implemented');
-        }
-        if (!is_1.default.function_(pagination.filter)) {
-            throw new TypeError('`options.pagination.filter` must be implemented');
-        }
-        if (!is_1.default.function_(pagination.paginate)) {
-            throw new Error('`options.pagination.paginate` must be implemented');
-        }
-    }
-    // JSON mode
-    if (options.responseType === 'json' && options.headers.accept === undefined) {
-        options.headers.accept = 'application/json';
-    }
-    return options;
-};
-exports.default = normalizeArguments;

package/node_modules/got/dist/source/as-promise/parse-body.d.ts

@@ -1,3 +0,0 @@
-import { ResponseType, Response, ParseJsonFunction } from './types';
-declare const parseBody: (response: Response, responseType: ResponseType, parseJson: ParseJsonFunction, encoding?: "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | undefined) => unknown;
-export default parseBody;

package/node_modules/got/dist/source/as-promise/parse-body.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const parseBody = (response, responseType, parseJson, encoding) => {
-    const { rawBody } = response;
-    try {
-        if (responseType === 'text') {
-            return rawBody.toString(encoding);
-        }
-        if (responseType === 'json') {
-            return rawBody.length === 0 ? '' : parseJson(rawBody.toString());
-        }
-        if (responseType === 'buffer') {
-            return rawBody;
-        }
-        throw new types_1.ParseError({
-            message: `Unknown body type '${responseType}'`,
-            name: 'Error'
-        }, response);
-    }
-    catch (error) {
-        throw new types_1.ParseError(error, response);
-    }
-};
-exports.default = parseBody;

package/node_modules/got/dist/source/as-promise/types.d.ts

@@ -1,256 +0,0 @@
-/// <reference types="node" />
-import PCancelable = require('p-cancelable');
-import Request, { Options, Response, RequestError, RequestEvents } from '../core';
-/**
-All parsing methods supported by Got.
-*/
-export declare type ResponseType = 'json' | 'buffer' | 'text';
-export interface PaginationOptions<T, R> {
-    /**
-    All options accepted by `got.paginate()`.
-    */
-    pagination?: {
-        /**
-        A function that transform [`Response`](#response) into an array of items.
-        This is where you should do the parsing.
-
-        @default response => JSON.parse(response.body)
-        */
-        transform?: (response: Response<R>) => Promise<T[]> | T[];
-        /**
-        Checks whether the item should be emitted or not.
-
-        @default (item, allItems, currentItems) => true
-        */
-        filter?: (item: T, allItems: T[], currentItems: T[]) => boolean;
-        /**
-        The function takes three arguments:
-        - `response` - The current response object.
-        - `allItems` - An array of the emitted items.
-        - `currentItems` - Items from the current response.
-
-        It should return an object representing Got options pointing to the next page.
-        The options are merged automatically with the previous request, therefore the options returned `pagination.paginate(...)` must reflect changes only.
-        If there are no more pages, `false` should be returned.
-
-        @example
-        ```
-        const got = require('got');
-
-        (async () => {
-            const limit = 10;
-
-            const items = got.paginate('https://example.com/items', {
-                searchParams: {
-                    limit,
-                    offset: 0
-                },
-                pagination: {
-                    paginate: (response, allItems, currentItems) => {
-                        const previousSearchParams = response.request.options.searchParams;
-                        const previousOffset = previousSearchParams.get('offset');
-
-                        if (currentItems.length < limit) {
-                            return false;
-                        }
-
-                        return {
-                            searchParams: {
-                                ...previousSearchParams,
-                                offset: Number(previousOffset) + limit,
-                            }
-                        };
-                    }
-                }
-            });
-
-            console.log('Items from all pages:', items);
-        })();
-        ```
-        */
-        paginate?: (response: Response<R>, allItems: T[], currentItems: T[]) => Options | false;
-        /**
-        Checks whether the pagination should continue.
-
-        For example, if you need to stop **before** emitting an entry with some flag, you should use `(item, allItems, currentItems) => !item.flag`.
-        If you want to stop **after** emitting the entry, you should use `(item, allItems, currentItems) => allItems.some(entry => entry.flag)` instead.
-
-        @default (item, allItems, currentItems) => true
-        */
-        shouldContinue?: (item: T, allItems: T[], currentItems: T[]) => boolean;
-        /**
-        The maximum amount of items that should be emitted.
-
-        @default Infinity
-        */
-        countLimit?: number;
-        /**
-        Milliseconds to wait before the next request is triggered.
-
-        @default 0
-        */
-        backoff?: number;
-        /**
-        The maximum amount of request that should be triggered.
-        Retries on failure are not counted towards this limit.
-
-        For example, it can be helpful during development to avoid an infinite number of requests.
-
-        @default 10000
-        */
-        requestLimit?: number;
-        /**
-        Defines how the parameter `allItems` in pagination.paginate, pagination.filter and pagination.shouldContinue is managed.
-        When set to `false`, the parameter `allItems` is always an empty array.
-
-        This option can be helpful to save on memory usage when working with a large dataset.
-        */
-        stackAllItems?: boolean;
-    };
-}
-export declare type AfterResponseHook = (response: Response, retryWithMergedOptions: (options: Options) => CancelableRequest<Response>) => Response | CancelableRequest<Response> | Promise<Response | CancelableRequest<Response>>;
-export declare namespace PromiseOnly {
-    interface Hooks {
-        /**
-        Called with [response object](#response) and a retry function.
-        Calling the retry function will trigger `beforeRetry` hooks.
-
-        Each function should return the response.
-        This is especially useful when you want to refresh an access token.
-
-        __Note__: When using streams, this hook is ignored.
-
-        @example
-        ```
-        const got = require('got');
-
-        const instance = got.extend({
-            hooks: {
-                afterResponse: [
-                    (response, retryWithMergedOptions) => {
-                        if (response.statusCode === 401) { // Unauthorized
-                            const updatedOptions = {
-                                headers: {
-                                    token: getNewToken() // Refresh the access token
-                                }
-                            };
-
-                            // Save for further requests
-                            instance.defaults.options = got.mergeOptions(instance.defaults.options, updatedOptions);
-
-                            // Make a new retry
-                            return retryWithMergedOptions(updatedOptions);
-                        }
-
-                        // No changes otherwise
-                        return response;
-                    }
-                ],
-                beforeRetry: [
-                    (options, error, retryCount) => {
-                        // This will be called on `retryWithMergedOptions(...)`
-                    }
-                ]
-            },
-            mutableDefaults: true
-        });
-        ```
-        */
-        afterResponse?: AfterResponseHook[];
-    }
-    interface Options extends PaginationOptions<unknown, unknown> {
-        /**
-        The parsing method.
-
-        The promise also has `.text()`, `.json()` and `.buffer()` methods which return another Got promise for the parsed body.
-
-        It's like setting the options to `{responseType: 'json', resolveBodyOnly: true}` but without affecting the main Got promise.
-
-        __Note__: When using streams, this option is ignored.
-
-        @example
-        ```
-        (async () => {
-            const responsePromise = got(url);
-            const bufferPromise = responsePromise.buffer();
-            const jsonPromise = responsePromise.json();
-
-            const [response, buffer, json] = Promise.all([responsePromise, bufferPromise, jsonPromise]);
-            // `response` is an instance of Got Response
-            // `buffer` is an instance of Buffer
-            // `json` is an object
-        })();
-        ```
-
-        @example
-        ```
-        // This
-        const body = await got(url).json();
-
-        // is semantically the same as this
-        const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
-        ```
-        */
-        responseType?: ResponseType;
-        /**
-        When set to `true` the promise will return the Response body instead of the Response object.
-
-        @default false
-        */
-        resolveBodyOnly?: boolean;
-        /**
-        Returns a `Stream` instead of a `Promise`.
-        This is equivalent to calling `got.stream(url, options?)`.
-
-        @default false
-        */
-        isStream?: boolean;
-        /**
-        [Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on `setEncoding` of the response data.
-
-        To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set `responseType` to `buffer` instead.
-        Don't set this option to `null`.
-
-        __Note__: This doesn't affect streams! Instead, you need to do `got.stream(...).setEncoding(encoding)`.
-
-        @default 'utf-8'
-        */
-        encoding?: BufferEncoding;
-    }
-    interface NormalizedOptions {
-        responseType: ResponseType;
-        resolveBodyOnly: boolean;
-        isStream: boolean;
-        encoding?: BufferEncoding;
-        pagination?: Required<PaginationOptions<unknown, unknown>['pagination']>;
-    }
-    interface Defaults {
-        responseType: ResponseType;
-        resolveBodyOnly: boolean;
-        isStream: boolean;
-        pagination?: Required<PaginationOptions<unknown, unknown>['pagination']>;
-    }
-    type HookEvent = 'afterResponse';
-}
-/**
-An error to be thrown when server response code is 2xx, and parsing body fails.
-Includes a `response` property.
-*/
-export declare class ParseError extends RequestError {
-    readonly response: Response;
-    constructor(error: Error, response: Response);
-}
-/**
-An error to be thrown when the request is aborted with `.cancel()`.
-*/
-export declare class CancelError extends RequestError {
-    readonly response: Response;
-    constructor(request: Request);
-    get isCanceled(): boolean;
-}
-export interface CancelableRequest<T extends Response | Response['body'] = Response['body']> extends PCancelable<T>, RequestEvents<CancelableRequest<T>> {
-    json: <ReturnType>() => CancelableRequest<ReturnType>;
-    buffer: () => CancelableRequest<Buffer>;
-    text: () => CancelableRequest<string>;
-}
-export * from '../core';

package/node_modules/got/dist/source/as-promise/types.js

@@ -1,42 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CancelError = exports.ParseError = void 0;
-const core_1 = require("../core");
-/**
-An error to be thrown when server response code is 2xx, and parsing body fails.
-Includes a `response` property.
-*/
-class ParseError extends core_1.RequestError {
-    constructor(error, response) {
-        const { options } = response.request;
-        super(`${error.message} in "${options.url.toString()}"`, error, response.request);
-        this.name = 'ParseError';
-        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_BODY_PARSE_FAILURE' : this.code;
-    }
-}
-exports.ParseError = ParseError;
-/**
-An error to be thrown when the request is aborted with `.cancel()`.
-*/
-class CancelError extends core_1.RequestError {
-    constructor(request) {
-        super('Promise was canceled', {}, request);
-        this.name = 'CancelError';
-        this.code = 'ERR_CANCELED';
-    }
-    get isCanceled() {
-        return true;
-    }
-}
-exports.CancelError = CancelError;
-__exportStar(require("../core"), exports);

package/node_modules/got/dist/source/core/calculate-retry-delay.d.ts

@@ -1,5 +0,0 @@
-import { RetryFunction } from '.';
-declare type Returns<T extends (...args: any) => unknown, V> = (...args: Parameters<T>) => V;
-export declare const retryAfterStatusCodes: ReadonlySet<number>;
-declare const calculateRetryDelay: Returns<RetryFunction, number>;
-export default calculateRetryDelay;

package/node_modules/got/dist/source/core/calculate-retry-delay.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retryAfterStatusCodes = void 0;
-exports.retryAfterStatusCodes = new Set([413, 429, 503]);
-const calculateRetryDelay = ({ attemptCount, retryOptions, error, retryAfter }) => {
-    if (attemptCount > retryOptions.limit) {
-        return 0;
-    }
-    const hasMethod = retryOptions.methods.includes(error.options.method);
-    const hasErrorCode = retryOptions.errorCodes.includes(error.code);
-    const hasStatusCode = error.response && retryOptions.statusCodes.includes(error.response.statusCode);
-    if (!hasMethod || (!hasErrorCode && !hasStatusCode)) {
-        return 0;
-    }
-    if (error.response) {
-        if (retryAfter) {
-            if (retryOptions.maxRetryAfter === undefined || retryAfter > retryOptions.maxRetryAfter) {
-                return 0;
-            }
-            return retryAfter;
-        }
-        if (error.response.statusCode === 413) {
-            return 0;
-        }
-    }
-    const noise = Math.random() * 100;
-    return ((2 ** (attemptCount - 1)) * 1000) + noise;
-};
-exports.default = calculateRetryDelay;