@aws-cdk/toolkit-lib 0.3.1 → 0.3.3

package/lib/util/json.d.ts

@@ -0,0 +1,48 @@
+/**
+ * This gets the values of the jsonObject at the paths specified in propertiesToReturn.
+ *
+ * For example, jsonObject = {
+ *   key1: 'abc',
+ *   key2: {
+ *     foo: 'qwerty',
+ *     bar: 'data',
+ *   }
+ * }
+ *
+ * propertiesToReturn = ['key1', 'key2.foo'];
+ *
+ * The returned object is:
+ *
+ * ```
+ * {
+ *   key1: 'abc',
+ *   'key2.foo': 'qwerty',
+ *   Identifier: identifier
+ * }
+ * ```
+ */
+export declare function getResultObj(jsonObject: any, identifier: string, propertiesToReturn: string[]): {
+    [key: string]: any;
+};
+/**
+ * This finds the value of the jsonObject at the path.  Path is delimited by '.'.
+ *
+ * For example, jsonObject = {
+ *   key1: 'abc',
+ *   key2: {
+ *     foo: 'qwerty',
+ *     bar: 'data',
+ *   }
+ * }
+ *
+ * If path is 'key1', then it will return 'abc'.
+ * If path is 'key2.foo', then it will return 'qwerty'.
+ * If path is 'key2', then it will return the object:
+ * {
+ *   foo: 'qwerty',
+ *   bar: 'data',
+ * }
+ *
+ * If the path is not found, an Error will be thrown stating which token is missing.
+ */
+export declare function findJsonValue(jsonObject: any, path: string): any;

package/lib/util/json.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResultObj = getResultObj;
+exports.findJsonValue = findJsonValue;
+/**
+ * This gets the values of the jsonObject at the paths specified in propertiesToReturn.
+ *
+ * For example, jsonObject = {
+ *   key1: 'abc',
+ *   key2: {
+ *     foo: 'qwerty',
+ *     bar: 'data',
+ *   }
+ * }
+ *
+ * propertiesToReturn = ['key1', 'key2.foo'];
+ *
+ * The returned object is:
+ *
+ * ```
+ * {
+ *   key1: 'abc',
+ *   'key2.foo': 'qwerty',
+ *   Identifier: identifier
+ * }
+ * ```
+ */
+function getResultObj(jsonObject, identifier, propertiesToReturn) {
+    const propsObj = {};
+    propertiesToReturn.forEach((propName) => {
+        Object.assign(propsObj, { [propName]: findJsonValue(jsonObject, propName) });
+    });
+    Object.assign(propsObj, { ['Identifier']: identifier });
+    return propsObj;
+}
+/**
+ * This finds the value of the jsonObject at the path.  Path is delimited by '.'.
+ *
+ * For example, jsonObject = {
+ *   key1: 'abc',
+ *   key2: {
+ *     foo: 'qwerty',
+ *     bar: 'data',
+ *   }
+ * }
+ *
+ * If path is 'key1', then it will return 'abc'.
+ * If path is 'key2.foo', then it will return 'qwerty'.
+ * If path is 'key2', then it will return the object:
+ * {
+ *   foo: 'qwerty',
+ *   bar: 'data',
+ * }
+ *
+ * If the path is not found, an Error will be thrown stating which token is missing.
+ */
+function findJsonValue(jsonObject, path) {
+    const paths = path.split('.');
+    let obj = jsonObject;
+    paths.forEach(p => {
+        obj = obj[p];
+        if (obj === undefined) {
+            throw new TypeError(`Cannot read field ${path}. ${p} is not found.`);
+        }
+    });
+    return obj;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util/objects.d.ts

@@ -0,0 +1,65 @@
+import type { Obj } from './types';
+/**
+ * Return a new object by adding missing keys into another object
+ */
+export declare function applyDefaults(hash: any, defaults: any): any;
+/**
+ * Return whether the given parameter is an empty object or empty list.
+ */
+export declare function isEmpty(x: any): boolean;
+/**
+ * Deep clone a tree of objects, lists or scalars
+ *
+ * Does not support cycles.
+ */
+export declare function deepClone(x: any): any;
+/**
+ * Map over an object, treating it as a dictionary
+ */
+export declare function mapObject<T, U>(x: Obj<T>, fn: (key: string, value: T) => U): U[];
+/**
+ * Construct an object from a list of (k, v) pairs
+ */
+export declare function makeObject<T>(pairs: Array<[string, T]>): Obj<T>;
+/**
+ * Deep get a value from a tree of nested objects
+ *
+ * Returns undefined if any part of the path was unset or
+ * not an object.
+ */
+export declare function deepGet(x: any, path: string[]): any;
+/**
+ * Deep set a value in a tree of nested objects
+ *
+ * Throws an error if any part of the path is not an object.
+ */
+export declare function deepSet(x: any, path: string[], value: any): void;
+/**
+ * Recursively merge objects together
+ *
+ * The leftmost object is mutated and returned. Arrays are not merged
+ * but overwritten just like scalars.
+ *
+ * If an object is merged into a non-object, the non-object is lost.
+ */
+export declare function deepMerge(...objects: Array<Obj<any> | undefined>): Obj<any>;
+/**
+ * Splits the given object into two, such that:
+ *
+ * 1. The size of the first object (after stringified in UTF-8) is less than or equal to the provided size limit.
+ * 2. Merging the two objects results in the original one.
+ */
+export declare function splitBySize(data: any, maxSizeBytes: number): [any, any];
+type Exclude = {
+    [key: string]: Exclude | true;
+};
+/**
+ * This function transforms all keys (recursively) in the provided `val` object.
+ *
+ * @param val The object whose keys need to be transformed.
+ * @param transform The function that will be applied to each key.
+ * @param exclude The keys that will not be transformed and copied to output directly
+ * @returns A new object with the same values as `val`, but with all keys transformed according to `transform`.
+ */
+export declare function transformObjectKeys(val: any, transform: (str: string) => string, exclude?: Exclude): any;
+export {};

package/lib/util/objects.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDefaults = applyDefaults;
+exports.isEmpty = isEmpty;
+exports.deepClone = deepClone;
+exports.mapObject = mapObject;
+exports.makeObject = makeObject;
+exports.deepGet = deepGet;
+exports.deepSet = deepSet;
+exports.deepMerge = deepMerge;
+exports.splitBySize = splitBySize;
+exports.transformObjectKeys = transformObjectKeys;
+const types_1 = require("./types");
+const toolkit_error_1 = require("../api/toolkit-error");
+/**
+ * Return a new object by adding missing keys into another object
+ */
+function applyDefaults(hash, defaults) {
+    const result = {};
+    Object.keys(hash).forEach(k => result[k] = hash[k]);
+    Object.keys(defaults)
+        .filter(k => !(k in result))
+        .forEach(k => result[k] = defaults[k]);
+    return result;
+}
+/**
+ * Return whether the given parameter is an empty object or empty list.
+ */
+function isEmpty(x) {
+    if (x == null) {
+        return false;
+    }
+    if ((0, types_1.isArray)(x)) {
+        return x.length === 0;
+    }
+    return Object.keys(x).length === 0;
+}
+/**
+ * Deep clone a tree of objects, lists or scalars
+ *
+ * Does not support cycles.
+ */
+function deepClone(x) {
+    if (typeof x === 'undefined') {
+        return undefined;
+    }
+    if (x === null) {
+        return null;
+    }
+    if ((0, types_1.isArray)(x)) {
+        return x.map(deepClone);
+    }
+    if ((0, types_1.isObject)(x)) {
+        return makeObject(mapObject(x, (k, v) => [k, deepClone(v)]));
+    }
+    return x;
+}
+/**
+ * Map over an object, treating it as a dictionary
+ */
+function mapObject(x, fn) {
+    const ret = [];
+    Object.keys(x).forEach(key => {
+        ret.push(fn(key, x[key]));
+    });
+    return ret;
+}
+/**
+ * Construct an object from a list of (k, v) pairs
+ */
+function makeObject(pairs) {
+    const ret = {};
+    for (const pair of pairs) {
+        ret[pair[0]] = pair[1];
+    }
+    return ret;
+}
+/**
+ * Deep get a value from a tree of nested objects
+ *
+ * Returns undefined if any part of the path was unset or
+ * not an object.
+ */
+function deepGet(x, path) {
+    path = path.slice();
+    while (path.length > 0 && (0, types_1.isObject)(x)) {
+        const key = path.shift();
+        x = x[key];
+    }
+    return path.length === 0 ? x : undefined;
+}
+/**
+ * Deep set a value in a tree of nested objects
+ *
+ * Throws an error if any part of the path is not an object.
+ */
+function deepSet(x, path, value) {
+    path = path.slice();
+    if (path.length === 0) {
+        throw new toolkit_error_1.ToolkitError('Path may not be empty');
+    }
+    while (path.length > 1 && (0, types_1.isObject)(x)) {
+        const key = path.shift();
+        if (isPrototypePollutingKey(key)) {
+            continue;
+        }
+        if (!(key in x)) {
+            x[key] = {};
+        }
+        x = x[key];
+    }
+    if (!(0, types_1.isObject)(x)) {
+        throw new toolkit_error_1.ToolkitError(`Expected an object, got '${x}'`);
+    }
+    const finalKey = path[0];
+    if (isPrototypePollutingKey(finalKey)) {
+        return;
+    }
+    if (value !== undefined) {
+        x[finalKey] = value;
+    }
+    else {
+        delete x[finalKey];
+    }
+}
+/**
+ * Helper to detect prototype polluting keys
+ *
+ * A key matching this, MUST NOT be used in an assignment.
+ * Use this to check user-input.
+ */
+function isPrototypePollutingKey(key) {
+    return key === '__proto__' || key === 'constructor' || key === 'prototype';
+}
+/**
+ * Recursively merge objects together
+ *
+ * The leftmost object is mutated and returned. Arrays are not merged
+ * but overwritten just like scalars.
+ *
+ * If an object is merged into a non-object, the non-object is lost.
+ */
+function deepMerge(...objects) {
+    function mergeOne(target, source) {
+        for (const key of Object.keys(source)) {
+            if (isPrototypePollutingKey(key)) {
+                continue;
+            }
+            const value = source[key];
+            if ((0, types_1.isObject)(value)) {
+                if (!(0, types_1.isObject)(target[key])) {
+                    target[key] = {};
+                } // Overwrite on purpose
+                mergeOne(target[key], value);
+            }
+            else if (typeof value !== 'undefined') {
+                target[key] = value;
+            }
+        }
+    }
+    const others = objects.filter(x => x != null);
+    if (others.length === 0) {
+        return {};
+    }
+    const into = others.splice(0, 1)[0];
+    others.forEach(other => mergeOne(into, other));
+    return into;
+}
+/**
+ * Splits the given object into two, such that:
+ *
+ * 1. The size of the first object (after stringified in UTF-8) is less than or equal to the provided size limit.
+ * 2. Merging the two objects results in the original one.
+ */
+function splitBySize(data, maxSizeBytes) {
+    if (maxSizeBytes < 2) {
+        // It's impossible to fit anything in the first object
+        return [undefined, data];
+    }
+    const entries = Object.entries(data);
+    return recurse(0, 0);
+    function recurse(index, runningTotalSize) {
+        if (index >= entries.length) {
+            // Everything fits in the first object
+            return [data, undefined];
+        }
+        const size = runningTotalSize + entrySize(entries[index]);
+        return (size > maxSizeBytes) ? cutAt(index) : recurse(index + 1, size);
+    }
+    function entrySize(entry) {
+        return Buffer.byteLength(JSON.stringify(Object.fromEntries([entry])));
+    }
+    function cutAt(index) {
+        return [
+            Object.fromEntries(entries.slice(0, index)),
+            Object.fromEntries(entries.slice(index)),
+        ];
+    }
+}
+/**
+ * This function transforms all keys (recursively) in the provided `val` object.
+ *
+ * @param val The object whose keys need to be transformed.
+ * @param transform The function that will be applied to each key.
+ * @param exclude The keys that will not be transformed and copied to output directly
+ * @returns A new object with the same values as `val`, but with all keys transformed according to `transform`.
+ */
+function transformObjectKeys(val, transform, exclude = {}) {
+    if (val == null || typeof val !== 'object') {
+        return val;
+    }
+    if (Array.isArray(val)) {
+        // For arrays we just pass parent's exclude object directly
+        // since it makes no sense to specify different exclude options for each array element
+        return val.map((input) => transformObjectKeys(input, transform, exclude));
+    }
+    const ret = {};
+    for (const [k, v] of Object.entries(val)) {
+        const childExclude = exclude[k];
+        if (childExclude === true) {
+            // we don't transform this object if the key is specified in exclude
+            ret[transform(k)] = v;
+        }
+        else {
+            ret[transform(k)] = transformObjectKeys(v, transform, childExclude);
+        }
+    }
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"objects.js","sourceRoot":"","sources":["objects.ts"],"names":[],"mappings":";;AAOA,sCAUC;AAKD,0BAQC;AAOD,8BAcC;AAKD,8BAMC;AAKD,gCAMC;AAQD,0BAQC;AAOD,0BAmCC;AAoBD,8BA6BC;AAQD,kCA4BC;AAYD,kDAoBC;AAvPD,mCAA4C;AAC5C,wDAAoD;AAEpD;;GAEG;AACH,SAAgB,aAAa,CAAC,IAAS,EAAE,QAAa;IACpD,MAAM,MAAM,GAAQ,EAAG,CAAC;IAExB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAEpD,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC;SAClB,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC;SAC3B,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IAEzC,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,SAAgB,OAAO,CAAC,CAAM;IAC5B,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;QACd,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,IAAA,eAAO,EAAC,CAAC,CAAC,EAAE,CAAC;QACf,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;IACxB,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;AACrC,CAAC;AAED;;;;GAIG;AACH,SAAgB,SAAS,CAAC,CAAM;IAC9B,IAAI,OAAO,CAAC,KAAK,WAAW,EAAE,CAAC;QAC7B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;QACf,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,IAAA,eAAO,EAAC,CAAC,CAAC,EAAE,CAAC;QACf,OAAO,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAC1B,CAAC;IACD,IAAI,IAAA,gBAAQ,EAAC,CAAC,CAAC,EAAE,CAAC;QAChB,OAAO,UAAU,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAkB,CAAC,CAAC,CAAC;IAChF,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;GAEG;AACH,SAAgB,SAAS,CAAO,CAAS,EAAE,EAAgC;IACzE,MAAM,GAAG,GAAQ,EAAE,CAAC;IACpB,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;QAC3B,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC5B,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;GAEG;AACH,SAAgB,UAAU,CAAI,KAAyB;IACrD,MAAM,GAAG,GAAW,EAAE,CAAC;IACvB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;GAKG;AACH,SAAgB,OAAO,CAAC,CAAM,EAAE,IAAc;IAC5C,IAAI,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;IAEpB,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,IAAA,gBAAQ,EAAC,CAAC,CAAC,EAAE,CAAC;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,EAAG,CAAC;QAC1B,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;IACD,OAAO,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC3C,CAAC;AAED;;;;GAIG;AACH,SAAgB,OAAO,CAAC,CAAM,EAAE,IAAc,EAAE,KAAU;IACxD,IAAI,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;IAEpB,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,4BAAY,CAAC,uBAAuB,CAAC,CAAC;IAClD,CAAC;IAED,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,IAAA,gBAAQ,EAAC,CAAC,CAAC,EAAE,CAAC;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,EAAG,CAAC;QAE1B,IAAI,uBAAuB,CAAC,GAAG,CAAC,EAAE,CAAC;YACjC,SAAS;QACX,CAAC;QAED,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC;YAChB,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;QACd,CAAC;QACD,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;IAED,IAAI,CAAC,IAAA,gBAAQ,EAAC,CAAC,CAAC,EAAE,CAAC;QACjB,MAAM,IAAI,4BAAY,CAAC,4BAA4B,CAAC,GAAG,CAAC,CAAC;IAC3D,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAEzB,IAAI,uBAAuB,CAAC,QAAQ,CAAC,EAAE,CAAC;QACtC,OAAO;IACT,CAAC;IAED,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,CAAC,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC;IACtB,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC;IACrB,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,uBAAuB,CAAC,GAAW;IAC1C,OAAO,GAAG,KAAK,WAAW,IAAI,GAAG,KAAK,aAAa,IAAI,GAAG,KAAK,WAAW,CAAC;AAC7E,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,SAAS,CAAC,GAAG,OAAoC;IAC/D,SAAS,QAAQ,CAAC,MAAgB,EAAE,MAAgB;QAClD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACtC,IAAI,uBAAuB,CAAC,GAAG,CAAC,EAAE,CAAC;gBACjC,SAAS;YACX,CAAC;YAED,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAE1B,IAAI,IAAA,gBAAQ,EAAC,KAAK,CAAC,EAAE,CAAC;gBACpB,IAAI,CAAC,IAAA,gBAAQ,EAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;oBAC3B,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;gBACnB,CAAC,CAAC,uBAAuB;gBACzB,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;YAC/B,CAAC;iBAAM,IAAI,OAAO,KAAK,KAAK,WAAW,EAAE,CAAC;gBACxC,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;YACtB,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAoB,CAAC;IAEjE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEpC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;IAC/C,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,SAAgB,WAAW,CAAC,IAAS,EAAE,YAAoB;IACzD,IAAI,YAAY,GAAG,CAAC,EAAE,CAAC;QACrB,sDAAsD;QACtD,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC3B,CAAC;IACD,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAErB,SAAS,OAAO,CAAC,KAAa,EAAE,gBAAwB;QACtD,IAAI,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YAC5B,sCAAsC;YACtC,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC3B,CAAC;QAED,MAAM,IAAI,GAAG,gBAAgB,GAAG,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;QAC1D,OAAO,CAAC,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;IACzE,CAAC;IAED,SAAS,SAAS,CAAC,KAAwB;QACzC,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE,CAAC;IAED,SAAS,KAAK,CAAC,KAAa;QAC1B,OAAO;YACL,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAC3C,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;SACzC,CAAC;IACJ,CAAC;AACH,CAAC;AAID;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CAAC,GAAQ,EAAE,SAAkC,EAAE,UAAmB,EAAE;IACrG,IAAI,GAAG,IAAI,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC3C,OAAO,GAAG,CAAC;IACb,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACvB,2DAA2D;QAC3D,sFAAsF;QACtF,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,mBAAmB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;IACjF,CAAC;IACD,MAAM,GAAG,GAAyB,EAAE,CAAC;IACrC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACzC,MAAM,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QAChC,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;YAC1B,oEAAoE;YACpE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACxB,CAAC;aAAM,CAAC;YACN,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;QACtE,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import type { Obj } from './types';\nimport { isArray, isObject } from './types';\nimport { ToolkitError } from '../api/toolkit-error';\n\n/**\n * Return a new object by adding missing keys into another object\n */\nexport function applyDefaults(hash: any, defaults: any) {\n  const result: any = { };\n\n  Object.keys(hash).forEach(k => result[k] = hash[k]);\n\n  Object.keys(defaults)\n    .filter(k => !(k in result))\n    .forEach(k => result[k] = defaults[k]);\n\n  return result;\n}\n\n/**\n * Return whether the given parameter is an empty object or empty list.\n */\nexport function isEmpty(x: any) {\n  if (x == null) {\n    return false;\n  }\n  if (isArray(x)) {\n    return x.length === 0;\n  }\n  return Object.keys(x).length === 0;\n}\n\n/**\n * Deep clone a tree of objects, lists or scalars\n *\n * Does not support cycles.\n */\nexport function deepClone(x: any): any {\n  if (typeof x === 'undefined') {\n    return undefined;\n  }\n  if (x === null) {\n    return null;\n  }\n  if (isArray(x)) {\n    return x.map(deepClone);\n  }\n  if (isObject(x)) {\n    return makeObject(mapObject(x, (k, v) => [k, deepClone(v)] as [string, any]));\n  }\n  return x;\n}\n\n/**\n * Map over an object, treating it as a dictionary\n */\nexport function mapObject<T, U>(x: Obj<T>, fn: (key: string, value: T) => U): U[] {\n  const ret: U[] = [];\n  Object.keys(x).forEach(key => {\n    ret.push(fn(key, x[key]));\n  });\n  return ret;\n}\n\n/**\n * Construct an object from a list of (k, v) pairs\n */\nexport function makeObject<T>(pairs: Array<[string, T]>): Obj<T> {\n  const ret: Obj<T> = {};\n  for (const pair of pairs) {\n    ret[pair[0]] = pair[1];\n  }\n  return ret;\n}\n\n/**\n * Deep get a value from a tree of nested objects\n *\n * Returns undefined if any part of the path was unset or\n * not an object.\n */\nexport function deepGet(x: any, path: string[]): any {\n  path = path.slice();\n\n  while (path.length > 0 && isObject(x)) {\n    const key = path.shift()!;\n    x = x[key];\n  }\n  return path.length === 0 ? x : undefined;\n}\n\n/**\n * Deep set a value in a tree of nested objects\n *\n * Throws an error if any part of the path is not an object.\n */\nexport function deepSet(x: any, path: string[], value: any) {\n  path = path.slice();\n\n  if (path.length === 0) {\n    throw new ToolkitError('Path may not be empty');\n  }\n\n  while (path.length > 1 && isObject(x)) {\n    const key = path.shift()!;\n\n    if (isPrototypePollutingKey(key)) {\n      continue;\n    }\n\n    if (!(key in x)) {\n      x[key] = {};\n    }\n    x = x[key];\n  }\n\n  if (!isObject(x)) {\n    throw new ToolkitError(`Expected an object, got '${x}'`);\n  }\n\n  const finalKey = path[0];\n\n  if (isPrototypePollutingKey(finalKey)) {\n    return;\n  }\n\n  if (value !== undefined) {\n    x[finalKey] = value;\n  } else {\n    delete x[finalKey];\n  }\n}\n\n/**\n * Helper to detect prototype polluting keys\n *\n * A key matching this, MUST NOT be used in an assignment.\n * Use this to check user-input.\n */\nfunction isPrototypePollutingKey(key: string) {\n  return key === '__proto__' || key === 'constructor' || key === 'prototype';\n}\n\n/**\n * Recursively merge objects together\n *\n * The leftmost object is mutated and returned. Arrays are not merged\n * but overwritten just like scalars.\n *\n * If an object is merged into a non-object, the non-object is lost.\n */\nexport function deepMerge(...objects: Array<Obj<any> | undefined>) {\n  function mergeOne(target: Obj<any>, source: Obj<any>) {\n    for (const key of Object.keys(source)) {\n      if (isPrototypePollutingKey(key)) {\n        continue;\n      }\n\n      const value = source[key];\n\n      if (isObject(value)) {\n        if (!isObject(target[key])) {\n          target[key] = {};\n        } // Overwrite on purpose\n        mergeOne(target[key], value);\n      } else if (typeof value !== 'undefined') {\n        target[key] = value;\n      }\n    }\n  }\n\n  const others = objects.filter(x => x != null) as Array<Obj<any>>;\n\n  if (others.length === 0) {\n    return {};\n  }\n  const into = others.splice(0, 1)[0];\n\n  others.forEach(other => mergeOne(into, other));\n  return into;\n}\n\n/**\n * Splits the given object into two, such that:\n *\n * 1. The size of the first object (after stringified in UTF-8) is less than or equal to the provided size limit.\n * 2. Merging the two objects results in the original one.\n */\nexport function splitBySize(data: any, maxSizeBytes: number): [any, any] {\n  if (maxSizeBytes < 2) {\n    // It's impossible to fit anything in the first object\n    return [undefined, data];\n  }\n  const entries = Object.entries(data);\n  return recurse(0, 0);\n\n  function recurse(index: number, runningTotalSize: number): [any, any] {\n    if (index >= entries.length) {\n      // Everything fits in the first object\n      return [data, undefined];\n    }\n\n    const size = runningTotalSize + entrySize(entries[index]);\n    return (size > maxSizeBytes) ? cutAt(index) : recurse(index + 1, size);\n  }\n\n  function entrySize(entry: [string, unknown]) {\n    return Buffer.byteLength(JSON.stringify(Object.fromEntries([entry])));\n  }\n\n  function cutAt(index: number): [any, any] {\n    return [\n      Object.fromEntries(entries.slice(0, index)),\n      Object.fromEntries(entries.slice(index)),\n    ];\n  }\n}\n\ntype Exclude = { [key: string]: Exclude | true };\n\n/**\n * This function transforms all keys (recursively) in the provided `val` object.\n *\n * @param val The object whose keys need to be transformed.\n * @param transform The function that will be applied to each key.\n * @param exclude The keys that will not be transformed and copied to output directly\n * @returns A new object with the same values as `val`, but with all keys transformed according to `transform`.\n */\nexport function transformObjectKeys(val: any, transform: (str: string) => string, exclude: Exclude = {}): any {\n  if (val == null || typeof val !== 'object') {\n    return val;\n  }\n  if (Array.isArray(val)) {\n    // For arrays we just pass parent's exclude object directly\n    // since it makes no sense to specify different exclude options for each array element\n    return val.map((input: any) => transformObjectKeys(input, transform, exclude));\n  }\n  const ret: { [k: string]: any } = {};\n  for (const [k, v] of Object.entries(val)) {\n    const childExclude = exclude[k];\n    if (childExclude === true) {\n      // we don't transform this object if the key is specified in exclude\n      ret[transform(k)] = v;\n    } else {\n      ret[transform(k)] = transformObjectKeys(v, transform, childExclude);\n    }\n  }\n  return ret;\n}\n"]}

package/lib/util/package-info.d.ts

@@ -0,0 +1,3 @@
+export declare function displayVersion(): string;
+export declare function isDeveloperBuild(): boolean;
+export declare function versionNumber(): string;

package/lib/util/package-info.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayVersion = displayVersion;
+exports.isDeveloperBuild = isDeveloperBuild;
+exports.versionNumber = versionNumber;
+const path = require("path");
+const directories_1 = require("./directories");
+function displayVersion() {
+    return `${versionNumber()} (build ${commit()})`;
+}
+function isDeveloperBuild() {
+    return versionNumber() === '0.0.0';
+}
+function versionNumber() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require(path.join((0, directories_1.bundledPackageRootDir)(__dirname), 'package.json')).version.replace(/\+[0-9a-f]+$/, '');
+}
+function commit() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require(path.join((0, directories_1.bundledPackageRootDir)(__dirname), 'build-info.json')).commit;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFja2FnZS1pbmZvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsicGFja2FnZS1pbmZvLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0Esd0NBRUM7QUFFRCw0Q0FFQztBQUVELHNDQUdDO0FBZEQsNkJBQTZCO0FBQzdCLCtDQUFzRDtBQUV0RCxTQUFnQixjQUFjO0lBQzVCLE9BQU8sR0FBRyxhQUFhLEVBQUUsV0FBVyxNQUFNLEVBQUUsR0FBRyxDQUFDO0FBQ2xELENBQUM7QUFFRCxTQUFnQixnQkFBZ0I7SUFDOUIsT0FBTyxhQUFhLEVBQUUsS0FBSyxPQUFPLENBQUM7QUFDckMsQ0FBQztBQUVELFNBQWdCLGFBQWE7SUFDM0IsaUVBQWlFO0lBQ2pFLE9BQU8sT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBQSxtQ0FBcUIsRUFBQyxTQUFTLENBQUMsRUFBRSxjQUFjLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsY0FBYyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0FBQ2xILENBQUM7QUFFRCxTQUFTLE1BQU07SUFDYixpRUFBaUU7SUFDakUsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFBLG1DQUFxQixFQUFDLFNBQVMsQ0FBQyxFQUFFLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUM7QUFDeEYsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHBhdGggZnJvbSAncGF0aCc7XG5pbXBvcnQgeyBidW5kbGVkUGFja2FnZVJvb3REaXIgfSBmcm9tICcuL2RpcmVjdG9yaWVzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGRpc3BsYXlWZXJzaW9uKCkge1xuICByZXR1cm4gYCR7dmVyc2lvbk51bWJlcigpfSAoYnVpbGQgJHtjb21taXQoKX0pYDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGlzRGV2ZWxvcGVyQnVpbGQoKTogYm9vbGVhbiB7XG4gIHJldHVybiB2ZXJzaW9uTnVtYmVyKCkgPT09ICcwLjAuMCc7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiB2ZXJzaW9uTnVtYmVyKCk6IHN0cmluZyB7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tcmVxdWlyZS1pbXBvcnRzXG4gIHJldHVybiByZXF1aXJlKHBhdGguam9pbihidW5kbGVkUGFja2FnZVJvb3REaXIoX19kaXJuYW1lKSwgJ3BhY2thZ2UuanNvbicpKS52ZXJzaW9uLnJlcGxhY2UoL1xcK1swLTlhLWZdKyQvLCAnJyk7XG59XG5cbmZ1bmN0aW9uIGNvbW1pdCgpOiBzdHJpbmcge1xuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXJlcXVpcmUtaW1wb3J0c1xuICByZXR1cm4gcmVxdWlyZShwYXRoLmpvaW4oYnVuZGxlZFBhY2thZ2VSb290RGlyKF9fZGlybmFtZSksICdidWlsZC1pbmZvLmpzb24nKSkuY29tbWl0O1xufVxuIl19

package/lib/util/parallel.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Run a number of promise generators with max parallelism
+ *
+ * Order is not maintained between the input and output.
+ */
+export declare function parallelPromises<A>(n: number, promises: Array<() => Promise<A>>): Promise<Array<A>>;

package/lib/util/parallel.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parallelPromises = parallelPromises;
+/**
+ * Run a number of promise generators with max parallelism
+ *
+ * Order is not maintained between the input and output.
+ */
+async function parallelPromises(n, promises) {
+    const ret = new Array();
+    let count = 0;
+    let error;
+    const queue = [...promises];
+    return new Promise((ok, ko) => {
+        tick();
+        function tick() {
+            if (count === 0 && error) {
+                ko(error);
+                return;
+            }
+            if (count === 0 && queue.length === 0) {
+                ok(ret);
+                return;
+            }
+            while (count < n && queue.length > 0 && !error) {
+                const next = queue.shift();
+                if (next !== undefined) {
+                    start(next);
+                }
+            }
+        }
+        function start(fn) {
+            count += 1;
+            fn()
+                .then((result) => {
+                ret.push(result);
+            })
+                .catch((e) => {
+                error = e;
+            })
+                .finally(() => {
+                count -= 1;
+                tick();
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util/serialize.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Stringify to YAML
+ */
+export declare function toYAML(obj: any): string;
+/**
+ * Parse either YAML or JSON
+ */
+export declare function deserializeStructure(str: string): any;
+/**
+ * Serialize to either YAML or JSON
+ */
+export declare function serializeStructure(object: any, json: boolean): string;
+/**
+ * Load a YAML or JSON file from disk
+ */
+export declare function loadStructuredFile(fileName: string): Promise<any>;
+/**
+ * Remove any template elements that we don't want to show users.
+ */
+export declare function obscureTemplate(template?: any): any;
+/**
+ * A JSON.stringify() replacer that converts Buffers into a string with information
+ * Use this if you plan to print out JSON stringified objects that may contain a Buffer.
+ * Without this, large buffers (think: Megabytes) will completely fill up the output
+ * and even crash the system.
+ */
+export declare function replacerBufferWithInfo(_key: any, value: any): any;

package/lib/util/serialize.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toYAML = toYAML;
+exports.deserializeStructure = deserializeStructure;
+exports.serializeStructure = serializeStructure;
+exports.loadStructuredFile = loadStructuredFile;
+exports.obscureTemplate = obscureTemplate;
+exports.replacerBufferWithInfo = replacerBufferWithInfo;
+const fs = require("fs/promises");
+const bytes_1 = require("./bytes");
+const yaml_cfn = require("./yaml-cfn");
+/**
+ * Stringify to YAML
+ */
+function toYAML(obj) {
+    return yaml_cfn.serialize(obj);
+}
+/**
+ * Parse either YAML or JSON
+ */
+function deserializeStructure(str) {
+    return yaml_cfn.deserialize(str);
+}
+/**
+ * Serialize to either YAML or JSON
+ */
+function serializeStructure(object, json) {
+    if (json) {
+        return JSON.stringify(object, undefined, 2);
+    }
+    else {
+        return toYAML(object);
+    }
+}
+/**
+ * Load a YAML or JSON file from disk
+ */
+async function loadStructuredFile(fileName) {
+    const contents = await fs.readFile(fileName, { encoding: 'utf-8' });
+    return deserializeStructure(contents);
+}
+/**
+ * Remove any template elements that we don't want to show users.
+ */
+function obscureTemplate(template = {}) {
+    if (template.Rules) {
+        // see https://github.com/aws/aws-cdk/issues/17942
+        if (template.Rules.CheckBootstrapVersion) {
+            if (Object.keys(template.Rules).length > 1) {
+                delete template.Rules.CheckBootstrapVersion;
+            }
+            else {
+                delete template.Rules;
+            }
+        }
+    }
+    return template;
+}
+/**
+ * Detects a buffer that has been converted to a JSON-like object
+ * In Node, `Buffer`s have `toJSON()` method that converts the buffer
+ * into a JS object that can be JSON stringified.
+ * Unfortunately this conversion happens before the replacer is called,
+ * so normal means of detecting a `Buffer` objet don't work anymore.
+ * @see https://github.com/nodejs/node-v0.x-archive/issues/5110
+ */
+function isJsonBuffer(value) {
+    return typeof value === 'object'
+        && 'type' in value
+        && value.type === 'Buffer'
+        && 'data' in value
+        && Array.isArray(value.data);
+}
+/**
+ * A JSON.stringify() replacer that converts Buffers into a string with information
+ * Use this if you plan to print out JSON stringified objects that may contain a Buffer.
+ * Without this, large buffers (think: Megabytes) will completely fill up the output
+ * and even crash the system.
+ */
+function replacerBufferWithInfo(_key, value) {
+    if (isJsonBuffer(value)) {
+        return `<Buffer: ${(0, bytes_1.formatBytes)(value.data.length)}>`;
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,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