aws-cdk 0.0.0

package/lib/util/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 });
+__exportStar(require("./arrays"), exports);
+__exportStar(require("./bool"), exports);
+__exportStar(require("./objects"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./tables"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMkNBQXlCO0FBQ3pCLHlDQUF1QjtBQUN2Qiw0Q0FBMEI7QUFDMUIsMENBQXdCO0FBQ3hCLDJDQUF5QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXJyYXlzJztcbmV4cG9ydCAqIGZyb20gJy4vYm9vbCc7XG5leHBvcnQgKiBmcm9tICcuL29iamVjdHMnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL3RhYmxlcyc7XG4iXX0=

package/lib/util/objects.d.ts

@@ -0,0 +1,52 @@
+import { 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];

package/lib/util/objects.js

@@ -0,0 +1,183 @@
+"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;
+const types_1 = require("./types");
+const error_1 = require("../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 error_1.ToolkitError('Path may not be empty');
+    }
+    while (path.length > 1 && (0, types_1.isObject)(x)) {
+        const key = path.shift();
+        if (!(key in x)) {
+            x[key] = {};
+        }
+        x = x[key];
+    }
+    if (!(0, types_1.isObject)(x)) {
+        throw new error_1.ToolkitError(`Expected an object, got '${x}'`);
+    }
+    if (value !== undefined) {
+        x[path[0]] = value;
+    }
+    else {
+        delete x[path[0]];
+    }
+}
+/**
+ * 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 (key === '__proto__' || key === 'constructor') {
+                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)),
+        ];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"objects.js","sourceRoot":"","sources":["objects.ts"],"names":[],"mappings":"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","sourcesContent":["import { isArray, isObject, Obj } from './types';\nimport { ToolkitError } from '../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) { return false; }\n  if (isArray(x)) { return x.length === 0; }\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') { return undefined; }\n  if (x === null) { return null; }\n  if (isArray(x)) { return x.map(deepClone); }\n  if (isObject(x)) { return makeObject(mapObject(x, (k, v) => [k, deepClone(v)] as [string, any])); }\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    if (!(key in x)) { x[key] = {}; }\n    x = x[key];\n  }\n\n  if (!isObject(x)) {\n    throw new ToolkitError(`Expected an object, got '${x}'`);\n  }\n\n  if (value !== undefined) {\n    x[path[0]] = value;\n  } else {\n    delete x[path[0]];\n  }\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 (key === '__proto__' || key === 'constructor') {\n        continue;\n      }\n\n      const value = source[key];\n\n      if (isObject(value)) {\n        if (!isObject(target[key])) { target[key] = {}; } // 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) { return {}; }\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"]}

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,44 @@
+"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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyYWxsZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJwYXJhbGxlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUtBLDRDQXNDQztBQTNDRDs7OztHQUlHO0FBQ0ksS0FBSyxVQUFVLGdCQUFnQixDQUFJLENBQVMsRUFBRSxRQUFpQztJQUNwRixNQUFNLEdBQUcsR0FBRyxJQUFJLEtBQUssRUFBSyxDQUFDO0lBQzNCLElBQUksS0FBSyxHQUFHLENBQUMsQ0FBQztJQUNkLElBQUksS0FBd0IsQ0FBQztJQUM3QixNQUFNLEtBQUssR0FBRyxDQUFDLEdBQUcsUUFBUSxDQUFDLENBQUM7SUFFNUIsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLEVBQUUsRUFBRSxFQUFFLEVBQUUsRUFBRTtRQUM1QixJQUFJLEVBQUUsQ0FBQztRQUVQLFNBQVMsSUFBSTtZQUNYLElBQUksS0FBSyxLQUFLLENBQUMsSUFBSSxLQUFLLEVBQUUsQ0FBQztnQkFDekIsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDO2dCQUNWLE9BQU87WUFDVCxDQUFDO1lBQ0QsSUFBSSxLQUFLLEtBQUssQ0FBQyxJQUFJLEtBQUssQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7Z0JBQ3RDLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQztnQkFDUixPQUFPO1lBQ1QsQ0FBQztZQUVELE9BQU8sS0FBSyxHQUFHLENBQUMsSUFBSSxLQUFLLENBQUMsTUFBTSxHQUFHLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUMvQyxNQUFNLElBQUksR0FBRyxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7Z0JBQzNCLElBQUksSUFBSSxLQUFLLFNBQVMsRUFBRSxDQUFDO29CQUN2QixLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7Z0JBQ2QsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO1FBRUQsU0FBUyxLQUFLLENBQUMsRUFBb0I7WUFDakMsS0FBSyxJQUFJLENBQUMsQ0FBQztZQUNYLEVBQUUsRUFBRTtpQkFDRCxJQUFJLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxHQUFHLEdBQUcsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7aUJBQ3ZDLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLEdBQUcsS0FBSyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztpQkFDNUIsT0FBTyxDQUFDLEdBQUcsRUFBRTtnQkFDWixLQUFLLElBQUksQ0FBQyxDQUFDO2dCQUNYLElBQUksRUFBRSxDQUFDO1lBQ1QsQ0FBQyxDQUFDLENBQUM7UUFDUCxDQUFDO0lBQ0gsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSdW4gYSBudW1iZXIgb2YgcHJvbWlzZSBnZW5lcmF0b3JzIHdpdGggbWF4IHBhcmFsbGVsaXNtXG4gKlxuICogT3JkZXIgaXMgbm90IG1haW50YWluZWQgYmV0d2VlbiB0aGUgaW5wdXQgYW5kIG91dHB1dC5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHBhcmFsbGVsUHJvbWlzZXM8QT4objogbnVtYmVyLCBwcm9taXNlczogQXJyYXk8KCkgPT4gUHJvbWlzZTxBPj4pOiBQcm9taXNlPEFycmF5PEE+PiB7XG4gIGNvbnN0IHJldCA9IG5ldyBBcnJheTxBPigpO1xuICBsZXQgY291bnQgPSAwO1xuICBsZXQgZXJyb3I6IEVycm9yIHwgdW5kZWZpbmVkO1xuICBjb25zdCBxdWV1ZSA9IFsuLi5wcm9taXNlc107XG5cbiAgcmV0dXJuIG5ldyBQcm9taXNlKChvaywga28pID0+IHtcbiAgICB0aWNrKCk7XG5cbiAgICBmdW5jdGlvbiB0aWNrKCkge1xuICAgICAgaWYgKGNvdW50ID09PSAwICYmIGVycm9yKSB7XG4gICAgICAgIGtvKGVycm9yKTtcbiAgICAgICAgcmV0dXJuO1xuICAgICAgfVxuICAgICAgaWYgKGNvdW50ID09PSAwICYmIHF1ZXVlLmxlbmd0aCA9PT0gMCkge1xuICAgICAgICBvayhyZXQpO1xuICAgICAgICByZXR1cm47XG4gICAgICB9XG5cbiAgICAgIHdoaWxlIChjb3VudCA8IG4gJiYgcXVldWUubGVuZ3RoID4gMCAmJiAhZXJyb3IpIHtcbiAgICAgICAgY29uc3QgbmV4dCA9IHF1ZXVlLnNoaWZ0KCk7XG4gICAgICAgIGlmIChuZXh0ICE9PSB1bmRlZmluZWQpIHtcbiAgICAgICAgICBzdGFydChuZXh0KTtcbiAgICAgICAgfVxuICAgICAgfVxuICAgIH1cblxuICAgIGZ1bmN0aW9uIHN0YXJ0KGZuOiAoKSA9PiBQcm9taXNlPEE+KSB7XG4gICAgICBjb3VudCArPSAxO1xuICAgICAgZm4oKVxuICAgICAgICAudGhlbigocmVzdWx0KSA9PiB7IHJldC5wdXNoKHJlc3VsdCk7IH0pXG4gICAgICAgIC5jYXRjaCgoZSkgPT4geyBlcnJvciA9IGU7IH0pXG4gICAgICAgIC5maW5hbGx5KCgpID0+IHtcbiAgICAgICAgICBjb3VudCAtPSAxO1xuICAgICAgICAgIHRpY2soKTtcbiAgICAgICAgfSk7XG4gICAgfVxuICB9KTtcbn1cbiJdfQ==

package/lib/util/tables.d.ts

@@ -0,0 +1 @@
+export declare function renderTable(cells: string[][], columns?: number): string;

package/lib/util/tables.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTable = renderTable;
+const cfnDiff = require("@aws-cdk/cloudformation-diff");
+function renderTable(cells, columns) {
+    // The cfnDiff module has logic for terminal-width aware table
+    // formatting (and nice colors), let's just reuse that.
+    return cfnDiff.formatTable(cells, columns);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGFibGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBRUEsa0NBSUM7QUFORCx3REFBd0Q7QUFFeEQsU0FBZ0IsV0FBVyxDQUFDLEtBQWlCLEVBQUUsT0FBZ0I7SUFDN0QsOERBQThEO0lBQzlELHVEQUF1RDtJQUN2RCxPQUFPLE9BQU8sQ0FBQyxXQUFXLENBQUMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQzdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBjZm5EaWZmIGZyb20gJ0Bhd3MtY2RrL2Nsb3VkZm9ybWF0aW9uLWRpZmYnO1xuXG5leHBvcnQgZnVuY3Rpb24gcmVuZGVyVGFibGUoY2VsbHM6IHN0cmluZ1tdW10sIGNvbHVtbnM/OiBudW1iZXIpIHtcbiAgLy8gVGhlIGNmbkRpZmYgbW9kdWxlIGhhcyBsb2dpYyBmb3IgdGVybWluYWwtd2lkdGggYXdhcmUgdGFibGVcbiAgLy8gZm9ybWF0dGluZyAoYW5kIG5pY2UgY29sb3JzKSwgbGV0J3MganVzdCByZXVzZSB0aGF0LlxuICByZXR1cm4gY2ZuRGlmZi5mb3JtYXRUYWJsZShjZWxscywgY29sdW1ucyk7XG59XG4iXX0=

package/lib/util/type-brands.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Type branding
+ *
+ * This allows marking certain types as having gone through particular operations.
+ *
+ * Branded types can be used anywhere the base type is expected, but the base type
+ * cannot be used where a branded type is expected; the values have to go through
+ * a type assertion operation to confirm their brand.
+ *
+ * Usage:
+ *
+ * ```
+ * type ValidatedString = Branded<string, 'PassedMyValidation'>;
+ *
+ * function validate(x: string): asserts x is ValidatedString {
+ *   // ... throw an error if not
+ * }
+ *
+ * function isValid(x: string): x is ValidatedString {
+ *   // ... throw an error if not
+ * }
+ * ```
+ */
+declare const __brand: unique symbol;
+export type Brand<B> = {
+    [__brand]: B;
+};
+export type Branded<T, B> = T & Brand<B>;
+/**
+ * Marks a value as being branded a certain way.
+ *
+ * You should in general avoid calling this, and use validation or
+ * asserting functions instead. However, this can be useful to produce
+ * values which are branded by construction (really just an elaborate
+ * way to write 'as').
+ */
+export declare function createBranded<A extends Branded<any, any>>(value: TypeUnderlyingBrand<A>): A;
+type TypeUnderlyingBrand<A> = A extends Branded<infer T, any> ? T : never;
+export {};

package/lib/util/type-brands.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Type branding
+ *
+ * This allows marking certain types as having gone through particular operations.
+ *
+ * Branded types can be used anywhere the base type is expected, but the base type
+ * cannot be used where a branded type is expected; the values have to go through
+ * a type assertion operation to confirm their brand.
+ *
+ * Usage:
+ *
+ * ```
+ * type ValidatedString = Branded<string, 'PassedMyValidation'>;
+ *
+ * function validate(x: string): asserts x is ValidatedString {
+ *   // ... throw an error if not
+ * }
+ *
+ * function isValid(x: string): x is ValidatedString {
+ *   // ... throw an error if not
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBranded = createBranded;
+/**
+ * Marks a value as being branded a certain way.
+ *
+ * You should in general avoid calling this, and use validation or
+ * asserting functions instead. However, this can be useful to produce
+ * values which are branded by construction (really just an elaborate
+ * way to write 'as').
+ */
+function createBranded(value) {
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Type of a map mapping strings to some arbitrary type
+ *
+ * Name is not ideal, but:
+ *
+ * - Cannot call it Object, that already means something.
+ * - Cannot call it Dict or Dictionary, since in other languages
+ *   those also allow specifying the key type.
+ */
+export type Obj<T> = {
+    [key: string]: T;
+};
+/**
+ * Return whether the given value is an object
+ *
+ * Even though arrays technically are objects, we usually want to treat them differently,
+ * so we return false in those cases.
+ */
+export declare function isObject(x: any): x is Obj<any>;
+/**
+ * Return whether the given value is an array
+ */
+export declare const isArray: (arg: any) => arg is any[];
+/**
+ * Return the value of the first argument if it's not undefined, otherwise the default
+ */
+export declare function ifDefined<T>(x: T | undefined, def: T): T;

package/lib/util/types.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArray = void 0;
+exports.isObject = isObject;
+exports.ifDefined = ifDefined;
+/**
+ * Return whether the given value is an object
+ *
+ * Even though arrays technically are objects, we usually want to treat them differently,
+ * so we return false in those cases.
+ */
+function isObject(x) {
+    return x !== null && typeof x === 'object' && !(0, exports.isArray)(x);
+}
+/**
+ * Return whether the given value is an array
+ */
+exports.isArray = Array.isArray;
+/**
+ * Return the value of the first argument if it's not undefined, otherwise the default
+ */
+function ifDefined(x, def) {
+    return typeof x !== 'undefined' ? x : def;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFpQkEsNEJBRUM7QUFVRCw4QkFFQztBQXBCRDs7Ozs7R0FLRztBQUNILFNBQWdCLFFBQVEsQ0FBQyxDQUFNO0lBQzdCLE9BQU8sQ0FBQyxLQUFLLElBQUksSUFBSSxPQUFPLENBQUMsS0FBSyxRQUFRLElBQUksQ0FBQyxJQUFBLGVBQU8sRUFBQyxDQUFDLENBQUMsQ0FBQztBQUM1RCxDQUFDO0FBRUQ7O0dBRUc7QUFDVSxRQUFBLE9BQU8sR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDO0FBRXJDOztHQUVHO0FBQ0gsU0FBZ0IsU0FBUyxDQUFJLENBQWdCLEVBQUUsR0FBTTtJQUNuRCxPQUFPLE9BQU8sQ0FBQyxLQUFLLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUM7QUFDNUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVHlwZSBvZiBhIG1hcCBtYXBwaW5nIHN0cmluZ3MgdG8gc29tZSBhcmJpdHJhcnkgdHlwZVxuICpcbiAqIE5hbWUgaXMgbm90IGlkZWFsLCBidXQ6XG4gKlxuICogLSBDYW5ub3QgY2FsbCBpdCBPYmplY3QsIHRoYXQgYWxyZWFkeSBtZWFucyBzb21ldGhpbmcuXG4gKiAtIENhbm5vdCBjYWxsIGl0IERpY3Qgb3IgRGljdGlvbmFyeSwgc2luY2UgaW4gb3RoZXIgbGFuZ3VhZ2VzXG4gKiAgIHRob3NlIGFsc28gYWxsb3cgc3BlY2lmeWluZyB0aGUga2V5IHR5cGUuXG4gKi9cbmV4cG9ydCB0eXBlIE9iajxUPiA9IHtba2V5OiBzdHJpbmddOiBUfTtcblxuLyoqXG4gKiBSZXR1cm4gd2hldGhlciB0aGUgZ2l2ZW4gdmFsdWUgaXMgYW4gb2JqZWN0XG4gKlxuICogRXZlbiB0aG91Z2ggYXJyYXlzIHRlY2huaWNhbGx5IGFyZSBvYmplY3RzLCB3ZSB1c3VhbGx5IHdhbnQgdG8gdHJlYXQgdGhlbSBkaWZmZXJlbnRseSxcbiAqIHNvIHdlIHJldHVybiBmYWxzZSBpbiB0aG9zZSBjYXNlcy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzT2JqZWN0KHg6IGFueSk6IHggaXMgT2JqPGFueT4ge1xuICByZXR1cm4geCAhPT0gbnVsbCAmJiB0eXBlb2YgeCA9PT0gJ29iamVjdCcgJiYgIWlzQXJyYXkoeCk7XG59XG5cbi8qKlxuICogUmV0dXJuIHdoZXRoZXIgdGhlIGdpdmVuIHZhbHVlIGlzIGFuIGFycmF5XG4gKi9cbmV4cG9ydCBjb25zdCBpc0FycmF5ID0gQXJyYXkuaXNBcnJheTtcblxuLyoqXG4gKiBSZXR1cm4gdGhlIHZhbHVlIG9mIHRoZSBmaXJzdCBhcmd1bWVudCBpZiBpdCdzIG5vdCB1bmRlZmluZWQsIG90aGVyd2lzZSB0aGUgZGVmYXVsdFxuICovXG5leHBvcnQgZnVuY3Rpb24gaWZEZWZpbmVkPFQ+KHg6IFQgfCB1bmRlZmluZWQsIGRlZjogVCk6IFQge1xuICByZXR1cm4gdHlwZW9mIHggIT09ICd1bmRlZmluZWQnID8geCA6IGRlZjtcbn1cbiJdfQ==

package/lib/util/validate-notification-arn.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Validate SNS topic arn
+ */
+export declare function validateSnsTopicArn(arn: string): boolean;

package/lib/util/validate-notification-arn.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSnsTopicArn = validateSnsTopicArn;
+/**
+ * Validate SNS topic arn
+ */
+function validateSnsTopicArn(arn) {
+    return /^arn:aws:sns:[a-z0-9\-]+:[0-9]+:[a-z0-9\-\_]+$/i.test(arn);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtbm90aWZpY2F0aW9uLWFybi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInZhbGlkYXRlLW5vdGlmaWNhdGlvbi1hcm4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSxrREFFQztBQUxEOztHQUVHO0FBQ0gsU0FBZ0IsbUJBQW1CLENBQUMsR0FBVztJQUM3QyxPQUFPLGlEQUFpRCxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNyRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBWYWxpZGF0ZSBTTlMgdG9waWMgYXJuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB2YWxpZGF0ZVNuc1RvcGljQXJuKGFybjogc3RyaW5nKTogYm9vbGVhbiB7XG4gIHJldHVybiAvXmFybjphd3M6c25zOlthLXowLTlcXC1dKzpbMC05XSs6W2EtejAtOVxcLVxcX10rJC9pLnRlc3QoYXJuKTtcbn1cbiJdfQ==

package/lib/util/version-range.d.ts

@@ -0,0 +1,2 @@
+export type RangeType = 'bracket' | 'pep';
+export declare function rangeFromSemver(ver: string, targetType: RangeType): string;

package/lib/util/version-range.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeFromSemver = rangeFromSemver;
+const semver = require("semver");
+const error_1 = require("../toolkit/error");
+function rangeFromSemver(ver, targetType) {
+    const re = ver.match(/^([^\d]*)([\d.]*)$/);
+    if (!re || !semver.valid(re[2])) {
+        throw new error_1.ToolkitError('not a semver or unsupported range syntax');
+    }
+    const prefixPart = re[1];
+    const verPart = re[2];
+    switch (targetType) {
+        case 'bracket':
+            switch (prefixPart) {
+                case '':
+                    // if there's no prefix and the remaining is a valid semver, there's no range specified
+                    return ver;
+                case '^':
+                    return `[${verPart},${semver.major(verPart) + 1}.0.0)`;
+                default:
+                    throw new error_1.ToolkitError(`unsupported range syntax - ${prefixPart}`);
+            }
+        case 'pep':
+            switch (prefixPart) {
+                case '':
+                    // if there's no prefix and the remaining is a valid semver, there's no range specified
+                    return `==${ver}`;
+                case '^':
+                    return `>=${verPart},<${semver.major(verPart) + 1}.0.0`;
+                default:
+                    throw new error_1.ToolkitError(`unsupported range syntax - ${prefixPart}`);
+            }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util/work-graph-builder.d.ts

@@ -0,0 +1,32 @@
+import * as cxapi from '@aws-cdk/cx-api';
+import { WorkGraph } from './work-graph';
+import { WorkNode } from './work-graph-types';
+export declare class WorkGraphBuilder {
+    private readonly prebuildAssets;
+    private readonly idPrefix;
+    /**
+     * Default priorities for nodes
+     *
+     * Assets builds have higher priority than the other two operations, to make good on our promise that
+     * '--prebuild-assets' will actually do assets before stacks (if it can). Unfortunately it is the
+     * default :(
+     *
+     * But between stack dependencies and publish dependencies, stack dependencies go first
+     */
+    static PRIORITIES: Record<WorkNode['type'], number>;
+    private readonly graph;
+    constructor(prebuildAssets: boolean, idPrefix?: string);
+    private addStack;
+    /**
+     * Oof, see this parameter list
+     */
+    private addAsset;
+    build(artifacts: cxapi.CloudArtifact[]): WorkGraph;
+    private stackArtifactIds;
+    private stackArtifactId;
+    /**
+     * We may have accidentally introduced cycles in an attempt to make the messages printed to the
+     * console not interfere with each other too much. Remove them again.
+     */
+    private removeStackPublishCycles;
+}