cdk-common 0.0.67 → 2.0.2

package/node_modules/@aws-cdk/cloudformation-diff/lib/render-intrinsics.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Turn CloudFormation intrinsics into strings
+ *
+ * ------
+ *
+ * This stringification is not intended to be mechanically reversible! It's intended
+ * to be understood by humans!
+ *
+ * ------
+ *
+ * Turns Fn::GetAtt and Fn::Ref objects into the same strings that can be
+ * parsed by Fn::Sub, but without the surrounding intrinsics.
+ *
+ * Evaluates Fn::Join directly if the second argument is a literal list of strings.
+ *
+ * Removes list and object values evaluating to { Ref: 'AWS::NoValue' }.
+ *
+ * For other intrinsics we choose a string representation that CloudFormation
+ * cannot actually parse, but is comprehensible to humans.
+ */
+export declare function renderIntrinsics(x: any): any;

package/node_modules/@aws-cdk/cloudformation-diff/lib/render-intrinsics.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderIntrinsics = void 0;
+/**
+ * Turn CloudFormation intrinsics into strings
+ *
+ * ------
+ *
+ * This stringification is not intended to be mechanically reversible! It's intended
+ * to be understood by humans!
+ *
+ * ------
+ *
+ * Turns Fn::GetAtt and Fn::Ref objects into the same strings that can be
+ * parsed by Fn::Sub, but without the surrounding intrinsics.
+ *
+ * Evaluates Fn::Join directly if the second argument is a literal list of strings.
+ *
+ * Removes list and object values evaluating to { Ref: 'AWS::NoValue' }.
+ *
+ * For other intrinsics we choose a string representation that CloudFormation
+ * cannot actually parse, but is comprehensible to humans.
+ */
+function renderIntrinsics(x) {
+    if (Array.isArray(x)) {
+        return x.filter(el => !isNoValue(el)).map(renderIntrinsics);
+    }
+    if (isNoValue(x)) {
+        return undefined;
+    }
+    const intrinsic = getIntrinsic(x);
+    if (intrinsic) {
+        if (intrinsic.fn === 'Ref') {
+            return '${' + intrinsic.args + '}';
+        }
+        if (intrinsic.fn === 'Fn::GetAtt') {
+            return '${' + intrinsic.args[0] + '.' + intrinsic.args[1] + '}';
+        }
+        if (intrinsic.fn === 'Fn::Join') {
+            return unCloudFormationFnJoin(intrinsic.args[0], intrinsic.args[1]);
+        }
+        return stringifyIntrinsic(intrinsic.fn, intrinsic.args);
+    }
+    if (typeof x === 'object' && x !== null) {
+        const ret = {};
+        for (const [key, value] of Object.entries(x)) {
+            if (!isNoValue(value)) {
+                ret[key] = renderIntrinsics(value);
+            }
+        }
+        return ret;
+    }
+    return x;
+}
+exports.renderIntrinsics = renderIntrinsics;
+function unCloudFormationFnJoin(separator, args) {
+    if (Array.isArray(args)) {
+        return args.filter(el => !isNoValue(el)).map(renderIntrinsics).join(separator);
+    }
+    return stringifyIntrinsic('Fn::Join', [separator, args]);
+}
+function stringifyIntrinsic(fn, args) {
+    return JSON.stringify({ [fn]: renderIntrinsics(args) });
+}
+function getIntrinsic(x) {
+    if (x === undefined || x === null || Array.isArray(x)) {
+        return undefined;
+    }
+    if (typeof x !== 'object') {
+        return undefined;
+    }
+    const keys = Object.keys(x);
+    return keys.length === 1 && (keys[0] === 'Ref' || keys[0].startsWith('Fn::')) ? { fn: keys[0], args: x[keys[0]] } : undefined;
+}
+function isNoValue(x) {
+    const int = getIntrinsic(x);
+    return int && int.fn === 'Ref' && int.args === 'AWS::NoValue';
+}
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@aws-cdk/cloudformation-diff/lib/util.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Turn a (multi-key) extraction function into a comparator for use in Array.sort()
+ */
+export declare function makeComparator<T, U>(keyFn: (x: T) => U[]): (a: T, b: T) => number;
+export declare function dropIfEmpty<T>(xs: T[]): T[] | undefined;
+export declare function deepRemoveUndefined(x: any): any;
+export declare function flatMap<T, U>(xs: T[], f: (x: T) => U[]): U[];

package/node_modules/@aws-cdk/cloudformation-diff/lib/util.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatMap = exports.deepRemoveUndefined = exports.dropIfEmpty = exports.makeComparator = void 0;
+/**
+ * Turn a (multi-key) extraction function into a comparator for use in Array.sort()
+ */
+function makeComparator(keyFn) {
+    return (a, b) => {
+        const keyA = keyFn(a);
+        const keyB = keyFn(b);
+        const len = Math.min(keyA.length, keyB.length);
+        for (let i = 0; i < len; i++) {
+            const c = compare(keyA[i], keyB[i]);
+            if (c !== 0) {
+                return c;
+            }
+        }
+        // Arrays are the same up to the min length -- shorter array sorts first
+        return keyA.length - keyB.length;
+    };
+}
+exports.makeComparator = makeComparator;
+function compare(a, b) {
+    if (a < b) {
+        return -1;
+    }
+    if (b < a) {
+        return 1;
+    }
+    return 0;
+}
+function dropIfEmpty(xs) {
+    return xs.length > 0 ? xs : undefined;
+}
+exports.dropIfEmpty = dropIfEmpty;
+function deepRemoveUndefined(x) {
+    if (typeof x === undefined || x === null) {
+        return x;
+    }
+    if (Array.isArray(x)) {
+        return x.map(deepRemoveUndefined);
+    }
+    if (typeof x === 'object') {
+        for (const [key, value] of Object.entries(x)) {
+            x[key] = deepRemoveUndefined(value);
+            if (x[key] === undefined) {
+                delete x[key];
+            }
+        }
+        return x;
+    }
+    return x;
+}
+exports.deepRemoveUndefined = deepRemoveUndefined;
+function flatMap(xs, f) {
+    const ret = new Array();
+    for (const x of xs) {
+        ret.push(...f(x));
+    }
+    return ret;
+}
+exports.flatMap = flatMap;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@aws-cdk/cloudformation-diff/node_modules/@types/node/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/node_modules/@aws-cdk/cloudformation-diff/node_modules/@types/node/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/node`
+
+# Summary
+This package contains type definitions for Node.js (http://nodejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v10.
+
+### Additional Details
+ * Last updated: Wed, 12 May 2021 19:31:33 GMT
+ * Dependencies: none
+ * Global values: `Buffer`, `NodeJS`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `require`, `setImmediate`, `setInterval`, `setTimeout`
+
+# Credits
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Chigozirim C.](https://github.com/smac89), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Hoàng Văn Khải](https://github.com/KSXGitHub), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Simon Schick](https://github.com/SimonSchick), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Zane Hannan AU](https://github.com/ZaneHannanAU), [Jeremie Rodriguez](https://github.com/jeremiergz), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Minh Son Nguyen](https://github.com/nguymin4), and [ExE Boss](https://github.com/ExE-Boss).

package/node_modules/@aws-cdk/cloudformation-diff/node_modules/@types/node/assert.d.ts

@@ -0,0 +1,99 @@
+declare module 'assert' {
+    function assert(value: any, message?: string | Error): asserts value;
+    namespace assert {
+        class AssertionError implements Error {
+            name: string;
+            message: string;
+            actual: any;
+            expected: any;
+            operator: string;
+            generatedMessage: boolean;
+            code: 'ERR_ASSERTION';
+
+            constructor(options?: {
+                message?: string;
+                actual?: any;
+                expected?: any;
+                operator?: string;
+                // tslint:disable-next-line:ban-types
+                stackStartFn?: Function;
+            });
+        }
+
+        type AssertPredicate = RegExp | (new () => object) | ((thrown: any) => boolean) | object | Error;
+
+        function fail(message?: string | Error): never;
+        /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
+        function fail(
+            actual: any,
+            expected: any,
+            message?: string | Error,
+            operator?: string,
+            // tslint:disable-next-line:ban-types
+            stackStartFn?: Function,
+        ): never;
+        function ok(value: any, message?: string | Error): asserts value;
+        /** @deprecated since v9.9.0 - use strictEqual() instead. */
+        function equal(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use notStrictEqual() instead. */
+        function notEqual(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use deepStrictEqual() instead. */
+        function deepEqual(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use notDeepStrictEqual() instead. */
+        function notDeepEqual(actual: any, expected: any, message?: string | Error): void;
+        function strictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T;
+        function notStrictEqual(actual: any, expected: any, message?: string | Error): void;
+        function deepStrictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T;
+        function notDeepStrictEqual(actual: any, expected: any, message?: string | Error): void;
+
+        function throws(block: () => any, message?: string | Error): void;
+        function throws(block: () => any, error: AssertPredicate, message?: string | Error): void;
+        function doesNotThrow(block: () => any, message?: string | Error): void;
+        function doesNotThrow(block: () => any, error: AssertPredicate, message?: string | Error): void;
+
+        function ifError(value: any): asserts value is null | undefined;
+
+        function rejects(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function rejects(
+            block: (() => Promise<any>) | Promise<any>,
+            error: AssertPredicate,
+            message?: string | Error,
+        ): Promise<void>;
+        function doesNotReject(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function doesNotReject(
+            block: (() => Promise<any>) | Promise<any>,
+            error: AssertPredicate,
+            message?: string | Error,
+        ): Promise<void>;
+
+        const strict: Omit<
+            typeof assert,
+            | 'equal'
+            | 'notEqual'
+            | 'deepEqual'
+            | 'notDeepEqual'
+            | 'ok'
+            | 'strictEqual'
+            | 'deepStrictEqual'
+            | 'ifError'
+            | 'strict'
+        > & {
+            (value: any, message?: string | Error): asserts value;
+            equal: typeof strictEqual;
+            notEqual: typeof notStrictEqual;
+            deepEqual: typeof deepStrictEqual;
+            notDeepEqual: typeof notDeepStrictEqual;
+
+            // Mapped types and assertion functions are incompatible?
+            // TS2775: Assertions require every name in the call target
+            // to be declared with an explicit type annotation.
+            ok: typeof ok;
+            strictEqual: typeof strictEqual;
+            deepStrictEqual: typeof deepStrictEqual;
+            ifError: typeof ifError;
+            strict: typeof strict;
+        };
+    }
+
+    export = assert;
+}

package/node_modules/@aws-cdk/cloudformation-diff/node_modules/@types/node/async_hooks.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Async Hooks module: https://nodejs.org/api/async_hooks.html
+ */
+declare module "async_hooks" {
+    /**
+     * Returns the asyncId of the current execution context.
+     */
+    function executionAsyncId(): number;
+
+    /**
+     * Returns the ID of the resource responsible for calling the callback that is currently being executed.
+     */
+    function triggerAsyncId(): number;
+
+    interface HookCallbacks {
+        /**
+         * Called when a class is constructed that has the possibility to emit an asynchronous event.
+         * @param asyncId a unique ID for the async resource
+         * @param type the type of the async resource
+         * @param triggerAsyncId the unique ID of the async resource in whose execution context this async resource was created
+         * @param resource reference to the resource representing the async operation, needs to be released during destroy
+         */
+        init?(asyncId: number, type: string, triggerAsyncId: number, resource: Object): void;
+
+        /**
+         * When an asynchronous operation is initiated or completes a callback is called to notify the user.
+         * The before callback is called just before said callback is executed.
+         * @param asyncId the unique identifier assigned to the resource about to execute the callback.
+         */
+        before?(asyncId: number): void;
+
+        /**
+         * Called immediately after the callback specified in before is completed.
+         * @param asyncId the unique identifier assigned to the resource which has executed the callback.
+         */
+        after?(asyncId: number): void;
+
+        /**
+         * Called when a promise has resolve() called. This may not be in the same execution id
+         * as the promise itself.
+         * @param asyncId the unique id for the promise that was resolve()d.
+         */
+        promiseResolve?(asyncId: number): void;
+
+        /**
+         * Called after the resource corresponding to asyncId is destroyed
+         * @param asyncId a unique ID for the async resource
+         */
+        destroy?(asyncId: number): void;
+    }
+
+    interface AsyncHook {
+        /**
+         * Enable the callbacks for a given AsyncHook instance. If no callbacks are provided enabling is a noop.
+         */
+        enable(): this;
+
+        /**
+         * Disable the callbacks for a given AsyncHook instance from the global pool of AsyncHook callbacks to be executed. Once a hook has been disabled it will not be called again until enabled.
+         */
+        disable(): this;
+    }
+
+    /**
+     * Registers functions to be called for different lifetime events of each async operation.
+     * @param options the callbacks to register
+     * @return an AsyncHooks instance used for disabling and enabling hooks
+     */
+    function createHook(options: HookCallbacks): AsyncHook;
+
+    interface AsyncResourceOptions {
+      /**
+       * The ID of the execution context that created this async event.
+       * @default executionAsyncId()
+       */
+      triggerAsyncId?: number;
+
+      /**
+       * Disables automatic `emitDestroy` when the object is garbage collected.
+       * This usually does not need to be set (even if `emitDestroy` is called
+       * manually), unless the resource's `asyncId` is retrieved and the
+       * sensitive API's `emitDestroy` is called with it.
+       * @default false
+       */
+      requireManualDestroy?: boolean;
+    }
+
+    /**
+     * The class AsyncResource was designed to be extended by the embedder's async resources.
+     * Using this users can easily trigger the lifetime events of their own resources.
+     */
+    class AsyncResource {
+        /**
+         * AsyncResource() is meant to be extended. Instantiating a
+         * new AsyncResource() also triggers init. If triggerAsyncId is omitted then
+         * async_hook.executionAsyncId() is used.
+         * @param type The type of async event.
+         * @param triggerAsyncId The ID of the execution context that created
+         *   this async event (default: `executionAsyncId()`), or an
+         *   AsyncResourceOptions object (since 9.3)
+         */
+        constructor(type: string, triggerAsyncId?: number|AsyncResourceOptions);
+
+        /**
+         * Call AsyncHooks before callbacks.
+         * @deprecated since 9.6 - Use asyncResource.runInAsyncScope() instead.
+         */
+        emitBefore(): void;
+
+        /**
+         * Call AsyncHooks after callbacks.
+         * @deprecated since 9.6 - Use asyncResource.runInAsyncScope() instead.
+         */
+        emitAfter(): void;
+
+        /**
+         * Call the provided function with the provided arguments in the
+         * execution context of the async resource. This will establish the
+         * context, trigger the AsyncHooks before callbacks, call the function,
+         * trigger the AsyncHooks after callbacks, and then restore the original
+         * execution context.
+         * @param fn The function to call in the execution context of this
+         *   async resource.
+         * @param thisArg The receiver to be used for the function call.
+         * @param args Optional arguments to pass to the function.
+         */
+        runInAsyncScope<This, Result>(fn: (this: This, ...args: any[]) => Result, thisArg?: This, ...args: any[]): Result;
+
+        /**
+         * Call AsyncHooks destroy callbacks.
+         */
+        emitDestroy(): this;
+
+        /**
+         * @return the unique ID assigned to this AsyncResource instance.
+         */
+        asyncId(): number;
+
+        /**
+         * @return the trigger ID for this AsyncResource instance.
+         */
+        triggerAsyncId(): number;
+    }
+}

package/node_modules/@aws-cdk/cloudformation-diff/node_modules/@types/node/base.d.ts

@@ -0,0 +1,19 @@
+// NOTE: These definitions support NodeJS and TypeScript 3.7.
+
+// NOTE: TypeScript version-specific augmentations can be found in the following paths:
+//          - ~/base.d.ts         - Shared definitions common to all TypeScript versions
+//          - ~/index.d.ts        - Definitions specific to TypeScript 2.1
+//          - ~/ts3.7/base.d.ts   - Definitions specific to TypeScript 3.7
+//          - ~/ts3.7/index.d.ts  - Definitions specific to TypeScript 3.7 with assert pulled in
+
+// Reference required types from the default lib:
+/// <reference lib="es2018" />
+/// <reference lib="esnext.asynciterable" />
+/// <reference lib="esnext.intl" />
+/// <reference lib="esnext.bigint" />
+
+// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
+/// <reference path="ts3.6/base.d.ts" />
+
+// TypeScript 3.7-specific augmentations:
+/// <reference path="assert.d.ts" />

package/node_modules/@aws-cdk/cloudformation-diff/node_modules/@types/node/buffer.d.ts

@@ -0,0 +1,16 @@
+declare module "buffer" {
+    export const INSPECT_MAX_BYTES: number;
+    const BuffType: typeof Buffer;
+
+    export type TranscodeEncoding = "ascii" | "utf8" | "utf16le" | "ucs2" | "latin1" | "binary";
+
+    export function transcode(source: Buffer | Uint8Array, fromEnc: TranscodeEncoding, toEnc: TranscodeEncoding): Buffer;
+
+    export const SlowBuffer: {
+        /** @deprecated since v6.0.0, use Buffer.allocUnsafeSlow() */
+        new(size: number): Buffer;
+        prototype: Buffer;
+    };
+
+    export { BuffType as Buffer };
+}