@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

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/net.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get a human-readable error message for a network error
+ * @param error The network error object
+ */
+export declare function humanNetworkError(error: NodeJS.ErrnoException): string;
+/**
+ * Get a human-readable error message for a HTTP status code
+ */
+export declare function humanHttpStatusError(statusCode: number): string;

package/lib/util/net.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.humanNetworkError = humanNetworkError;
+exports.humanHttpStatusError = humanHttpStatusError;
+/**
+ * Get a human-readable error message for a network error
+ * @param error The network error object
+ */
+function humanNetworkError(error) {
+    switch (error.code) {
+        case 'ENOTFOUND':
+            return `Cannot reach the server. Please check your internet connection or the URL (${error.hostname}).`;
+        case 'ECONNREFUSED':
+            return `Connection refused. The server at ${error.address}:${error.port} is not accepting connections.`;
+        case 'ECONNRESET':
+            return 'Connection was suddenly closed by the server. Please try again later.';
+        case 'ETIMEDOUT':
+            return 'Connection timed out. The server took too long to respond.';
+        case 'CERT_HAS_EXPIRED':
+            return 'The SSL certificate of the server has expired. This could be a security risk.';
+        case 'UNABLE_TO_VERIFY_LEAF_SIGNATURE':
+        case 'CERT_SIGNATURE_FAILURE':
+        case 'ERR_TLS_CERT_ALTNAME_INVALID':
+            return 'SSL certificate validation failed. This could indicate a security issue or a misconfigured server.';
+        default:
+            return `Network error: ${error.message || error.code || 'Unknown error'}`;
+    }
+}
+/**
+ * Get a human-readable error message for a HTTP status code
+ */
+function humanHttpStatusError(statusCode) {
+    switch (statusCode) {
+        case 400:
+            return 'Bad request - the server could not understand the request';
+        case 401:
+            return 'Unauthorized - authentication is required';
+        case 403:
+            return 'Forbidden - you do not have permission to access this resource';
+        case 404:
+            return 'Not found - the requested resource does not exist';
+        case 408:
+            return 'Request timeout - the server timed out waiting for the request';
+        case 429:
+            return 'Too many requests - you have sent too many requests in a given amount of time';
+        case 500:
+            return 'Internal server error - something went wrong on the server';
+        case 502:
+            return 'Bad gateway - the server received an invalid response from an upstream server';
+        case 503:
+            return 'Service unavailable - the server is temporarily unable to handle the request';
+        case 504:
+            return 'Gateway timeout - the server did not receive a timely response from an upstream server';
+        default:
+            return statusCode >= 500
+                ? 'Server error - something went wrong on the server'
+                : 'Client error - something went wrong with the request';
+    }
+}
+//# 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("../toolkit/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":"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","sourcesContent":["import type { Obj } from './types';\nimport { isArray, isObject } from './types';\nimport { ToolkitError } from '../toolkit/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;