@aws-amplify/graphql-api-construct 1.18.3-ai-next.0 → 1.18.3

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

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unionOf = exports.diffKeyedEntities = exports.deepEqual = void 0;
+/**
+ * Compares two objects for equality, deeply. The function handles arguments that are
+ * +null+, +undefined+, arrays and objects. For objects, the function will not take the
+ * object prototype into account for the purpose of the comparison, only the values of
+ * properties reported by +Object.keys+.
+ *
+ * If both operands can be parsed to equivalent numbers, will return true.
+ * This makes diff consistent with CloudFormation, where a numeric 10 and a literal "10"
+ * are considered equivalent.
+ *
+ * @param lvalue the left operand of the equality comparison.
+ * @param rvalue the right operand of the equality comparison.
+ *
+ * @returns +true+ if both +lvalue+ and +rvalue+ are equivalent to each other.
+ */
+function deepEqual(lvalue, rvalue) {
+    if (lvalue === rvalue) {
+        return true;
+    }
+    // CloudFormation allows passing strings into boolean-typed fields
+    if (((typeof lvalue === 'string' && typeof rvalue === 'boolean') ||
+        (typeof lvalue === 'boolean' && typeof rvalue === 'string')) &&
+        lvalue.toString() === rvalue.toString()) {
+        return true;
+    }
+    // allows a numeric 10 and a literal "10" to be equivalent;
+    // this is consistent with CloudFormation.
+    if ((typeof lvalue === 'string' || typeof rvalue === 'string') &&
+        safeParseFloat(lvalue) === safeParseFloat(rvalue)) {
+        return true;
+    }
+    if (typeof lvalue !== typeof rvalue) {
+        return false;
+    }
+    if (Array.isArray(lvalue) !== Array.isArray(rvalue)) {
+        return false;
+    }
+    if (Array.isArray(lvalue) /* && Array.isArray(rvalue) */) {
+        if (lvalue.length !== rvalue.length) {
+            return false;
+        }
+        for (let i = 0; i < lvalue.length; i++) {
+            if (!deepEqual(lvalue[i], rvalue[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (typeof lvalue === 'object' /* && typeof rvalue === 'object' */) {
+        if (lvalue === null || rvalue === null) {
+            // If both were null, they'd have been ===
+            return false;
+        }
+        const keys = Object.keys(lvalue);
+        if (keys.length !== Object.keys(rvalue).length) {
+            return false;
+        }
+        for (const key of keys) {
+            if (!rvalue.hasOwnProperty(key)) {
+                return false;
+            }
+            if (key === 'DependsOn') {
+                if (!dependsOnEqual(lvalue[key], rvalue[key])) {
+                    return false;
+                }
+                ;
+                // check differences other than `DependsOn`
+                continue;
+            }
+            if (!deepEqual(lvalue[key], rvalue[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Neither object, nor array: I deduce this is primitive type
+    // Primitive type and not ===, so I deduce not deepEqual
+    return false;
+}
+exports.deepEqual = deepEqual;
+/**
+ * Compares two arguments to DependsOn for equality.
+ *
+ * @param lvalue the left operand of the equality comparison.
+ * @param rvalue the right operand of the equality comparison.
+ *
+ * @returns +true+ if both +lvalue+ and +rvalue+ are equivalent to each other.
+ */
+function dependsOnEqual(lvalue, rvalue) {
+    // allows ['Value'] and 'Value' to be equal
+    if (Array.isArray(lvalue) !== Array.isArray(rvalue)) {
+        const array = Array.isArray(lvalue) ? lvalue : rvalue;
+        const nonArray = Array.isArray(lvalue) ? rvalue : lvalue;
+        if (array.length === 1 && deepEqual(array[0], nonArray)) {
+            return true;
+        }
+        return false;
+    }
+    // allows arrays passed to DependsOn to be equivalent irrespective of element order
+    if (Array.isArray(lvalue) && Array.isArray(rvalue)) {
+        if (lvalue.length !== rvalue.length) {
+            return false;
+        }
+        for (let i = 0; i < lvalue.length; i++) {
+            for (let j = 0; j < lvalue.length; j++) {
+                if ((!deepEqual(lvalue[i], rvalue[j])) && (j === lvalue.length - 1)) {
+                    return false;
+                }
+                break;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Produce the differences between two maps, as a map, using a specified diff function.
+ *
+ * @param oldValue  the old map.
+ * @param newValue  the new map.
+ * @param elementDiff the diff function.
+ *
+ * @returns a map representing the differences between +oldValue+ and +newValue+.
+ */
+function diffKeyedEntities(oldValue, newValue, elementDiff) {
+    const result = {};
+    for (const logicalId of unionOf(Object.keys(oldValue || {}), Object.keys(newValue || {}))) {
+        const oldElement = oldValue && oldValue[logicalId];
+        const newElement = newValue && newValue[logicalId];
+        result[logicalId] = elementDiff(oldElement, newElement, logicalId);
+    }
+    return result;
+}
+exports.diffKeyedEntities = diffKeyedEntities;
+/**
+ * Computes the union of two sets of strings.
+ *
+ * @param lv the left set of strings.
+ * @param rv the right set of strings.
+ *
+ * @returns a new array containing all elemebts from +lv+ and +rv+, with no duplicates.
+ */
+function unionOf(lv, rv) {
+    const result = new Set(lv);
+    for (const v of rv) {
+        result.add(v);
+    }
+    return new Array(...result);
+}
+exports.unionOf = unionOf;
+/**
+ * A parseFloat implementation that does the right thing for
+ * strings like '0.0.0'
+ * (for which JavaScript's parseFloat() returns 0).
+ * We return NaN for all of these strings that do not represent numbers,
+ * and so comparing them fails,
+ * and doesn't short-circuit the diff logic.
+ */
+function safeParseFloat(str) {
+    return Number(str);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Compares two objects for equality, deeply. The function handles arguments that are\n * +null+, +undefined+, arrays and objects. For objects, the function will not take the\n * object prototype into account for the purpose of the comparison, only the values of\n * properties reported by +Object.keys+.\n *\n * If both operands can be parsed to equivalent numbers, will return true.\n * This makes diff consistent with CloudFormation, where a numeric 10 and a literal \"10\"\n * are considered equivalent.\n *\n * @param lvalue the left operand of the equality comparison.\n * @param rvalue the right operand of the equality comparison.\n *\n * @returns +true+ if both +lvalue+ and +rvalue+ are equivalent to each other.\n */\nexport function deepEqual(lvalue: any, rvalue: any): boolean {\n  if (lvalue === rvalue) { return true; }\n  // CloudFormation allows passing strings into boolean-typed fields\n  if (((typeof lvalue === 'string' && typeof rvalue === 'boolean') ||\n      (typeof lvalue === 'boolean' && typeof rvalue === 'string')) &&\n      lvalue.toString() === rvalue.toString()) {\n    return true;\n  }\n  // allows a numeric 10 and a literal \"10\" to be equivalent;\n  // this is consistent with CloudFormation.\n  if ((typeof lvalue === 'string' || typeof rvalue === 'string') &&\n      safeParseFloat(lvalue) === safeParseFloat(rvalue)) {\n    return true;\n  }\n  if (typeof lvalue !== typeof rvalue) { return false; }\n  if (Array.isArray(lvalue) !== Array.isArray(rvalue)) { return false; }\n  if (Array.isArray(lvalue) /* && Array.isArray(rvalue) */) {\n    if (lvalue.length !== rvalue.length) { return false; }\n    for (let i = 0 ; i < lvalue.length ; i++) {\n      if (!deepEqual(lvalue[i], rvalue[i])) { return false; }\n    }\n    return true;\n  }\n  if (typeof lvalue === 'object' /* && typeof rvalue === 'object' */) {\n    if (lvalue === null || rvalue === null) {\n      // If both were null, they'd have been ===\n      return false;\n    }\n    const keys = Object.keys(lvalue);\n    if (keys.length !== Object.keys(rvalue).length) { return false; }\n    for (const key of keys) {\n      if (!rvalue.hasOwnProperty(key)) { return false; }\n      if (key === 'DependsOn') {\n        if (!dependsOnEqual(lvalue[key], rvalue[key])) { return false; };\n        // check differences other than `DependsOn`\n        continue;\n      }\n      if (!deepEqual(lvalue[key], rvalue[key])) { return false; }\n    }\n    return true;\n  }\n  // Neither object, nor array: I deduce this is primitive type\n  // Primitive type and not ===, so I deduce not deepEqual\n  return false;\n}\n\n/**\n * Compares two arguments to DependsOn for equality.\n *\n * @param lvalue the left operand of the equality comparison.\n * @param rvalue the right operand of the equality comparison.\n *\n * @returns +true+ if both +lvalue+ and +rvalue+ are equivalent to each other.\n */\nfunction dependsOnEqual(lvalue: any, rvalue: any): boolean {\n  // allows ['Value'] and 'Value' to be equal\n  if (Array.isArray(lvalue) !== Array.isArray(rvalue)) {\n    const array = Array.isArray(lvalue) ? lvalue : rvalue;\n    const nonArray = Array.isArray(lvalue) ? rvalue : lvalue;\n\n    if (array.length === 1 && deepEqual(array[0], nonArray)) {\n      return true;\n    }\n    return false;\n  }\n\n  // allows arrays passed to DependsOn to be equivalent irrespective of element order\n  if (Array.isArray(lvalue) && Array.isArray(rvalue)) {\n    if (lvalue.length !== rvalue.length) { return false; }\n    for (let i = 0 ; i < lvalue.length ; i++) {\n      for (let j = 0 ; j < lvalue.length ; j++) {\n        if ((!deepEqual(lvalue[i], rvalue[j])) && (j === lvalue.length - 1)) {\n          return false;\n        }\n        break;\n      }\n    }\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Produce the differences between two maps, as a map, using a specified diff function.\n *\n * @param oldValue  the old map.\n * @param newValue  the new map.\n * @param elementDiff the diff function.\n *\n * @returns a map representing the differences between +oldValue+ and +newValue+.\n */\nexport function diffKeyedEntities<T>(\n  oldValue: { [key: string]: any } | undefined,\n  newValue: { [key: string]: any } | undefined,\n  elementDiff: (oldElement: any, newElement: any, key: string) => T): { [name: string]: T } {\n  const result: { [name: string]: T } = {};\n  for (const logicalId of unionOf(Object.keys(oldValue || {}), Object.keys(newValue || {}))) {\n    const oldElement = oldValue && oldValue[logicalId];\n    const newElement = newValue && newValue[logicalId];\n    result[logicalId] = elementDiff(oldElement, newElement, logicalId);\n  }\n  return result;\n}\n\n/**\n * Computes the union of two sets of strings.\n *\n * @param lv the left set of strings.\n * @param rv the right set of strings.\n *\n * @returns a new array containing all elemebts from +lv+ and +rv+, with no duplicates.\n */\nexport function unionOf(lv: string[] | Set<string>, rv: string[] | Set<string>): string[] {\n  const result = new Set(lv);\n  for (const v of rv) {\n    result.add(v);\n  }\n  return new Array(...result);\n}\n\n/**\n * A parseFloat implementation that does the right thing for\n * strings like '0.0.0'\n * (for which JavaScript's parseFloat() returns 0).\n * We return NaN for all of these strings that do not represent numbers,\n * and so comparing them fails,\n * and doesn't short-circuit the diff logic.\n */\nfunction safeParseFloat(str: string): number {\n  return Number(str);\n}\n"]}

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

@@ -0,0 +1,21 @@
+import * as types from './diff/types';
+export * from './diff/types';
+/**
+ * Compare two CloudFormation templates and return semantic differences between them.
+ *
+ * @param currentTemplate the current state of the stack.
+ * @param newTemplate     the target state of the stack.
+ *
+ * @returns a +types.TemplateDiff+ object that represents the changes that will happen if
+ *      a stack which current state is described by +currentTemplate+ is updated with
+ *      the template +newTemplate+.
+ */
+export declare function diffTemplate(currentTemplate: {
+    [key: string]: any;
+}, newTemplate: {
+    [key: string]: any;
+}): types.TemplateDiff;
+/**
+ * Compare two CloudFormation resources and return semantic differences between them
+ */
+export declare function diffResource(oldValue: types.Resource, newValue: types.Resource): types.ResourceDifference;

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

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffResource = exports.diffTemplate = void 0;
+const impl = require("./diff");
+const types = require("./diff/types");
+const util_1 = require("./diff/util");
+__exportStar(require("./diff/types"), exports);
+const DIFF_HANDLERS = {
+    AWSTemplateFormatVersion: (diff, oldValue, newValue) => diff.awsTemplateFormatVersion = impl.diffAttribute(oldValue, newValue),
+    Description: (diff, oldValue, newValue) => diff.description = impl.diffAttribute(oldValue, newValue),
+    Metadata: (diff, oldValue, newValue) => diff.metadata = new types.DifferenceCollection(util_1.diffKeyedEntities(oldValue, newValue, impl.diffMetadata)),
+    Parameters: (diff, oldValue, newValue) => diff.parameters = new types.DifferenceCollection(util_1.diffKeyedEntities(oldValue, newValue, impl.diffParameter)),
+    Mappings: (diff, oldValue, newValue) => diff.mappings = new types.DifferenceCollection(util_1.diffKeyedEntities(oldValue, newValue, impl.diffMapping)),
+    Conditions: (diff, oldValue, newValue) => diff.conditions = new types.DifferenceCollection(util_1.diffKeyedEntities(oldValue, newValue, impl.diffCondition)),
+    Transform: (diff, oldValue, newValue) => diff.transform = impl.diffAttribute(oldValue, newValue),
+    Resources: (diff, oldValue, newValue) => diff.resources = new types.DifferenceCollection(util_1.diffKeyedEntities(oldValue, newValue, impl.diffResource)),
+    Outputs: (diff, oldValue, newValue) => diff.outputs = new types.DifferenceCollection(util_1.diffKeyedEntities(oldValue, newValue, impl.diffOutput)),
+};
+/**
+ * Compare two CloudFormation templates and return semantic differences between them.
+ *
+ * @param currentTemplate the current state of the stack.
+ * @param newTemplate     the target state of the stack.
+ *
+ * @returns a +types.TemplateDiff+ object that represents the changes that will happen if
+ *      a stack which current state is described by +currentTemplate+ is updated with
+ *      the template +newTemplate+.
+ */
+function diffTemplate(currentTemplate, newTemplate) {
+    // Base diff
+    const theDiff = calculateTemplateDiff(currentTemplate, newTemplate);
+    // We're going to modify this in-place
+    const newTemplateCopy = deepCopy(newTemplate);
+    let didPropagateReferenceChanges;
+    let diffWithReplacements;
+    do {
+        diffWithReplacements = calculateTemplateDiff(currentTemplate, newTemplateCopy);
+        // Propagate replacements for replaced resources
+        didPropagateReferenceChanges = false;
+        if (diffWithReplacements.resources) {
+            diffWithReplacements.resources.forEachDifference((logicalId, change) => {
+                if (change.changeImpact === types.ResourceImpact.WILL_REPLACE) {
+                    if (propagateReplacedReferences(newTemplateCopy, logicalId)) {
+                        didPropagateReferenceChanges = true;
+                    }
+                }
+            });
+        }
+    } while (didPropagateReferenceChanges);
+    // Copy "replaced" states from `diffWithReplacements` to `theDiff`.
+    diffWithReplacements.resources
+        .filter(r => isReplacement(r.changeImpact))
+        .forEachDifference((logicalId, downstreamReplacement) => {
+        const resource = theDiff.resources.get(logicalId);
+        if (resource.changeImpact !== downstreamReplacement.changeImpact) {
+            propagatePropertyReplacement(downstreamReplacement, resource);
+        }
+    });
+    return theDiff;
+}
+exports.diffTemplate = diffTemplate;
+function isReplacement(impact) {
+    return impact === types.ResourceImpact.MAY_REPLACE || impact === types.ResourceImpact.WILL_REPLACE;
+}
+/**
+ * For all properties in 'source' that have a "replacement" impact, propagate that impact to "dest"
+ */
+function propagatePropertyReplacement(source, dest) {
+    for (const [propertyName, diff] of Object.entries(source.propertyUpdates)) {
+        if (diff.changeImpact && isReplacement(diff.changeImpact)) {
+            // Use the propertydiff of source in target. The result of this happens to be clear enough.
+            dest.setPropertyChange(propertyName, diff);
+        }
+    }
+}
+function calculateTemplateDiff(currentTemplate, newTemplate) {
+    const differences = {};
+    const unknown = {};
+    for (const key of util_1.unionOf(Object.keys(currentTemplate), Object.keys(newTemplate)).sort()) {
+        const oldValue = currentTemplate[key];
+        const newValue = newTemplate[key];
+        if (util_1.deepEqual(oldValue, newValue)) {
+            continue;
+        }
+        const handler = DIFF_HANDLERS[key]
+            || ((_diff, oldV, newV) => unknown[key] = impl.diffUnknown(oldV, newV));
+        handler(differences, oldValue, newValue);
+    }
+    if (Object.keys(unknown).length > 0) {
+        differences.unknown = new types.DifferenceCollection(unknown);
+    }
+    return new types.TemplateDiff(differences);
+}
+/**
+ * Compare two CloudFormation resources and return semantic differences between them
+ */
+function diffResource(oldValue, newValue) {
+    return impl.diffResource(oldValue, newValue);
+}
+exports.diffResource = diffResource;
+/**
+ * Replace all references to the given logicalID on the given template, in-place
+ *
+ * Returns true iff any references were replaced.
+ */
+function propagateReplacedReferences(template, logicalId) {
+    let ret = false;
+    function recurse(obj) {
+        if (Array.isArray(obj)) {
+            obj.forEach(recurse);
+        }
+        if (typeof obj === 'object' && obj !== null) {
+            if (!replaceReference(obj)) {
+                Object.values(obj).forEach(recurse);
+            }
+        }
+    }
+    function replaceReference(obj) {
+        const keys = Object.keys(obj);
+        if (keys.length !== 1) {
+            return false;
+        }
+        const key = keys[0];
+        if (key === 'Ref') {
+            if (obj.Ref === logicalId) {
+                obj.Ref = logicalId + ' (replaced)';
+                ret = true;
+            }
+            return true;
+        }
+        if (key.startsWith('Fn::')) {
+            if (Array.isArray(obj[key]) && obj[key].length > 0 && obj[key][0] === logicalId) {
+                obj[key][0] = logicalId + '(replaced)';
+                ret = true;
+            }
+            return true;
+        }
+        return false;
+    }
+    recurse(template);
+    return ret;
+}
+function deepCopy(x) {
+    if (Array.isArray(x)) {
+        return x.map(deepCopy);
+    }
+    if (typeof x === 'object' && x !== null) {
+        const ret = {};
+        for (const key of Object.keys(x)) {
+            ret[key] = deepCopy(x[key]);
+        }
+        return ret;
+    }
+    return x;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diff-template.js","sourceRoot":"","sources":["diff-template.ts"],"names":[],"mappings":"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","sourcesContent":["import * as impl from './diff';\nimport * as types from './diff/types';\nimport { deepEqual, diffKeyedEntities, unionOf } from './diff/util';\n\nexport * from './diff/types';\n\ntype DiffHandler = (diff: types.ITemplateDiff, oldValue: any, newValue: any) => void;\ntype HandlerRegistry = { [section: string]: DiffHandler };\n\nconst DIFF_HANDLERS: HandlerRegistry = {\n  AWSTemplateFormatVersion: (diff, oldValue, newValue) =>\n    diff.awsTemplateFormatVersion = impl.diffAttribute(oldValue, newValue),\n  Description: (diff, oldValue, newValue) =>\n    diff.description = impl.diffAttribute(oldValue, newValue),\n  Metadata: (diff, oldValue, newValue) =>\n    diff.metadata = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffMetadata)),\n  Parameters: (diff, oldValue, newValue) =>\n    diff.parameters = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffParameter)),\n  Mappings: (diff, oldValue, newValue) =>\n    diff.mappings = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffMapping)),\n  Conditions: (diff, oldValue, newValue) =>\n    diff.conditions = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffCondition)),\n  Transform: (diff, oldValue, newValue) =>\n    diff.transform = impl.diffAttribute(oldValue, newValue),\n  Resources: (diff, oldValue, newValue) =>\n    diff.resources = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffResource)),\n  Outputs: (diff, oldValue, newValue) =>\n    diff.outputs = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffOutput)),\n};\n\n/**\n * Compare two CloudFormation templates and return semantic differences between them.\n *\n * @param currentTemplate the current state of the stack.\n * @param newTemplate     the target state of the stack.\n *\n * @returns a +types.TemplateDiff+ object that represents the changes that will happen if\n *      a stack which current state is described by +currentTemplate+ is updated with\n *      the template +newTemplate+.\n */\nexport function diffTemplate(currentTemplate: { [key: string]: any }, newTemplate: { [key: string]: any }): types.TemplateDiff {\n  // Base diff\n  const theDiff = calculateTemplateDiff(currentTemplate, newTemplate);\n\n  // We're going to modify this in-place\n  const newTemplateCopy = deepCopy(newTemplate);\n\n  let didPropagateReferenceChanges;\n  let diffWithReplacements;\n  do {\n    diffWithReplacements = calculateTemplateDiff(currentTemplate, newTemplateCopy);\n\n    // Propagate replacements for replaced resources\n    didPropagateReferenceChanges = false;\n    if (diffWithReplacements.resources) {\n      diffWithReplacements.resources.forEachDifference((logicalId, change) => {\n        if (change.changeImpact === types.ResourceImpact.WILL_REPLACE) {\n          if (propagateReplacedReferences(newTemplateCopy, logicalId)) {\n            didPropagateReferenceChanges = true;\n          }\n        }\n      });\n    }\n  } while (didPropagateReferenceChanges);\n\n  // Copy \"replaced\" states from `diffWithReplacements` to `theDiff`.\n  diffWithReplacements.resources\n    .filter(r => isReplacement(r!.changeImpact))\n    .forEachDifference((logicalId, downstreamReplacement) => {\n      const resource = theDiff.resources.get(logicalId);\n\n      if (resource.changeImpact !== downstreamReplacement.changeImpact) {\n        propagatePropertyReplacement(downstreamReplacement, resource);\n      }\n    });\n\n  return theDiff;\n}\n\nfunction isReplacement(impact: types.ResourceImpact) {\n  return impact === types.ResourceImpact.MAY_REPLACE || impact === types.ResourceImpact.WILL_REPLACE;\n}\n\n/**\n * For all properties in 'source' that have a \"replacement\" impact, propagate that impact to \"dest\"\n */\nfunction propagatePropertyReplacement(source: types.ResourceDifference, dest: types.ResourceDifference) {\n  for (const [propertyName, diff] of Object.entries(source.propertyUpdates)) {\n    if (diff.changeImpact && isReplacement(diff.changeImpact)) {\n      // Use the propertydiff of source in target. The result of this happens to be clear enough.\n      dest.setPropertyChange(propertyName, diff);\n    }\n  }\n}\n\nfunction calculateTemplateDiff(currentTemplate: { [key: string]: any }, newTemplate: { [key: string]: any }): types.TemplateDiff {\n  const differences: types.ITemplateDiff = {};\n  const unknown: { [key: string]: types.Difference<any> } = {};\n  for (const key of unionOf(Object.keys(currentTemplate), Object.keys(newTemplate)).sort()) {\n    const oldValue = currentTemplate[key];\n    const newValue = newTemplate[key];\n    if (deepEqual(oldValue, newValue)) {\n      continue;\n    }\n    const handler: DiffHandler = DIFF_HANDLERS[key]\n                  || ((_diff, oldV, newV) => unknown[key] = impl.diffUnknown(oldV, newV));\n    handler(differences, oldValue, newValue);\n\n  }\n  if (Object.keys(unknown).length > 0) {\n    differences.unknown = new types.DifferenceCollection(unknown);\n  }\n\n  return new types.TemplateDiff(differences);\n}\n\n/**\n * Compare two CloudFormation resources and return semantic differences between them\n */\nexport function diffResource(oldValue: types.Resource, newValue: types.Resource): types.ResourceDifference {\n  return impl.diffResource(oldValue, newValue);\n}\n\n/**\n * Replace all references to the given logicalID on the given template, in-place\n *\n * Returns true iff any references were replaced.\n */\nfunction propagateReplacedReferences(template: object, logicalId: string): boolean {\n  let ret = false;\n\n  function recurse(obj: any) {\n    if (Array.isArray(obj)) {\n      obj.forEach(recurse);\n    }\n\n    if (typeof obj === 'object' && obj !== null) {\n      if (!replaceReference(obj)) {\n        Object.values(obj).forEach(recurse);\n      }\n    }\n  }\n\n  function replaceReference(obj: any) {\n    const keys = Object.keys(obj);\n    if (keys.length !== 1) { return false; }\n    const key = keys[0];\n\n    if (key === 'Ref') {\n      if (obj.Ref === logicalId) {\n        obj.Ref = logicalId + ' (replaced)';\n        ret = true;\n      }\n      return true;\n    }\n\n    if (key.startsWith('Fn::')) {\n      if (Array.isArray(obj[key]) && obj[key].length > 0 && obj[key][0] === logicalId) {\n        obj[key][0] = logicalId + '(replaced)';\n        ret = true;\n      }\n      return true;\n    }\n\n    return false;\n  }\n\n  recurse(template);\n  return ret;\n}\n\nfunction deepCopy(x: any): any {\n  if (Array.isArray(x)) {\n    return x.map(deepCopy);\n  }\n\n  if (typeof x === 'object' && x !== null) {\n    const ret: any = {};\n    for (const key of Object.keys(x)) {\n      ret[key] = deepCopy(x[key]);\n    }\n    return ret;\n  }\n\n  return x;\n}\n"]}

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

@@ -0,0 +1,22 @@
+/**
+ * Calculate differences of immutable elements
+ */
+export declare class DiffableCollection<T extends Eq<T>> {
+    readonly additions: T[];
+    readonly removals: T[];
+    private readonly oldElements;
+    private readonly newElements;
+    addOld(...elements: T[]): void;
+    addNew(...elements: T[]): void;
+    calculateDiff(): void;
+    get hasChanges(): boolean;
+    get hasAdditions(): boolean;
+    get hasRemovals(): boolean;
+}
+/**
+ * Things that can be compared to themselves (by value)
+ */
+interface Eq<T> {
+    equal(other: T): boolean;
+}
+export {};

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffableCollection = void 0;
+/**
+ * Calculate differences of immutable elements
+ */
+class DiffableCollection {
+    constructor() {
+        this.additions = [];
+        this.removals = [];
+        this.oldElements = [];
+        this.newElements = [];
+    }
+    addOld(...elements) {
+        this.oldElements.push(...elements);
+    }
+    addNew(...elements) {
+        this.newElements.push(...elements);
+    }
+    calculateDiff() {
+        this.additions.push(...difference(this.newElements, this.oldElements));
+        this.removals.push(...difference(this.oldElements, this.newElements));
+    }
+    get hasChanges() {
+        return this.additions.length + this.removals.length > 0;
+    }
+    get hasAdditions() {
+        return this.additions.length > 0;
+    }
+    get hasRemovals() {
+        return this.removals.length > 0;
+    }
+}
+exports.DiffableCollection = DiffableCollection;
+/**
+ * Whether a collection contains some element (by value)
+ */
+function contains(element, xs) {
+    return xs.some(x => x.equal(element));
+}
+/**
+ * Return collection except for elements
+ */
+function difference(collection, elements) {
+    return collection.filter(x => !contains(x, elements));
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,6 @@
+/**
+ * Render a two-dimensional array to a visually attractive table
+ *
+ * First row is considered the table header.
+ */
+export declare function formatTable(cells: string[][], columns: number | undefined): string;

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTable = void 0;
+const chalk = require("chalk");
+const string_width_1 = require("string-width");
+const table = require("table");
+/**
+ * Render a two-dimensional array to a visually attractive table
+ *
+ * First row is considered the table header.
+ */
+function formatTable(cells, columns) {
+    return table.table(cells, {
+        border: TABLE_BORDER_CHARACTERS,
+        columns: buildColumnConfig(columns !== undefined ? calculateColumnWidths(cells, columns) : undefined),
+        drawHorizontalLine: (line) => {
+            // Numbering like this: [line 0] [header = row[0]] [line 1] [row 1] [line 2] [content 2] [line 3]
+            return (line < 2 || line === cells.length) || lineBetween(cells[line - 1], cells[line]);
+        },
+    }).trimRight();
+}
+exports.formatTable = formatTable;
+/**
+ * Whether we should draw a line between two rows
+ *
+ * Draw horizontal line if 2nd column values are different.
+ */
+function lineBetween(rowA, rowB) {
+    return rowA[1] !== rowB[1];
+}
+function buildColumnConfig(widths) {
+    if (widths === undefined) {
+        return undefined;
+    }
+    const ret = {};
+    widths.forEach((width, i) => {
+        if (width === undefined) {
+            return;
+        }
+        ret[i] = { width };
+    });
+    return ret;
+}
+/**
+ * Calculate column widths given a terminal width
+ *
+ * We do this by calculating a fair share for every column. Extra width smaller
+ * than the fair share is evenly distributed over all columns that exceed their
+ * fair share.
+ */
+function calculateColumnWidths(rows, terminalWidth) {
+    // The terminal is sometimes reported to be 0. Also if the terminal is VERY narrow,
+    // just assume a reasonable minimum size.
+    terminalWidth = Math.max(terminalWidth, 40);
+    // use 'string-width' to not count ANSI chars as actual character width
+    const columns = rows[0].map((_, i) => Math.max(...rows.map(row => string_width_1.default(String(row[i])))));
+    // If we have no terminal width, do nothing
+    const contentWidth = terminalWidth - 2 - columns.length * 3;
+    // If we don't exceed the terminal width, do nothing
+    if (sum(columns) <= contentWidth) {
+        return columns;
+    }
+    const fairShare = Math.min(contentWidth / columns.length);
+    const smallColumns = columns.filter(w => w < fairShare);
+    let distributableWidth = contentWidth - sum(smallColumns);
+    const fairDistributable = Math.floor(distributableWidth / (columns.length - smallColumns.length));
+    const ret = new Array();
+    for (const requestedWidth of columns) {
+        if (requestedWidth < fairShare) {
+            // Small column gets what they want
+            ret.push(requestedWidth);
+        }
+        else {
+            // Last column gets all remaining, otherwise get fair redist share
+            const width = distributableWidth < 2 * fairDistributable ? distributableWidth : fairDistributable;
+            ret.push(width);
+            distributableWidth -= width;
+        }
+    }
+    return ret;
+}
+function sum(xs) {
+    let total = 0;
+    for (const x of xs) {
+        total += x;
+    }
+    return total;
+}
+// What color the table is going to be
+const tableColor = chalk.gray;
+// Unicode table characters with a color
+const TABLE_BORDER_CHARACTERS = {
+    topBody: tableColor('─'),
+    topJoin: tableColor('┬'),
+    topLeft: tableColor('┌'),
+    topRight: tableColor('┐'),
+    bottomBody: tableColor('─'),
+    bottomJoin: tableColor('┴'),
+    bottomLeft: tableColor('└'),
+    bottomRight: tableColor('┘'),
+    bodyLeft: tableColor('│'),
+    bodyRight: tableColor('│'),
+    bodyJoin: tableColor('│'),
+    joinBody: tableColor('─'),
+    joinLeft: tableColor('├'),
+    joinRight: tableColor('┤'),
+    joinJoin: tableColor('┼'),
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format-table.js","sourceRoot":"","sources":["format-table.ts"],"names":[],"mappings":"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","sourcesContent":["import * as chalk from 'chalk';\nimport stringWidth from 'string-width';\nimport * as table from 'table';\n\n/**\n * Render a two-dimensional array to a visually attractive table\n *\n * First row is considered the table header.\n */\nexport function formatTable(cells: string[][], columns: number | undefined): string {\n  return table.table(cells, {\n    border: TABLE_BORDER_CHARACTERS,\n    columns: buildColumnConfig(columns !== undefined ? calculateColumnWidths(cells, columns) : undefined),\n    drawHorizontalLine: (line) => {\n      // Numbering like this: [line 0] [header = row[0]] [line 1] [row 1] [line 2] [content 2] [line 3]\n      return (line < 2 || line === cells.length) || lineBetween(cells[line - 1], cells[line]);\n    },\n  }).trimRight();\n}\n\n/**\n * Whether we should draw a line between two rows\n *\n * Draw horizontal line if 2nd column values are different.\n */\nfunction lineBetween(rowA: string[], rowB: string[]) {\n  return rowA[1] !== rowB[1];\n}\n\nfunction buildColumnConfig(widths: number[] | undefined): { [index: number]: table.ColumnUserConfig } | undefined {\n  if (widths === undefined) { return undefined; }\n\n  const ret: { [index: number]: table.ColumnUserConfig } = {};\n  widths.forEach((width, i) => {\n    if (width === undefined) {\n      return;\n    }\n    ret[i] = { width };\n  });\n\n  return ret;\n}\n\n/**\n * Calculate column widths given a terminal width\n *\n * We do this by calculating a fair share for every column. Extra width smaller\n * than the fair share is evenly distributed over all columns that exceed their\n * fair share.\n */\nfunction calculateColumnWidths(rows: string[][], terminalWidth: number): number[] {\n  // The terminal is sometimes reported to be 0. Also if the terminal is VERY narrow,\n  // just assume a reasonable minimum size.\n  terminalWidth = Math.max(terminalWidth, 40);\n\n  // use 'string-width' to not count ANSI chars as actual character width\n  const columns = rows[0].map((_, i) => Math.max(...rows.map(row => stringWidth(String(row[i])))));\n\n  // If we have no terminal width, do nothing\n  const contentWidth = terminalWidth - 2 - columns.length * 3;\n\n  // If we don't exceed the terminal width, do nothing\n  if (sum(columns) <= contentWidth) { return columns; }\n\n  const fairShare = Math.min(contentWidth / columns.length);\n  const smallColumns = columns.filter(w => w < fairShare);\n\n  let distributableWidth = contentWidth - sum(smallColumns);\n  const fairDistributable = Math.floor(distributableWidth / (columns.length - smallColumns.length));\n\n  const ret = new Array<number>();\n  for (const requestedWidth of columns) {\n    if (requestedWidth < fairShare) {\n      // Small column gets what they want\n      ret.push(requestedWidth);\n    } else {\n      // Last column gets all remaining, otherwise get fair redist share\n      const width = distributableWidth < 2 * fairDistributable ? distributableWidth : fairDistributable;\n      ret.push(width);\n      distributableWidth -= width;\n    }\n  }\n\n  return ret;\n}\n\nfunction sum(xs: number[]): number {\n  let total = 0;\n  for (const x of xs) {\n    total += x;\n  }\n  return total;\n}\n\n// What color the table is going to be\nconst tableColor = chalk.gray;\n\n// Unicode table characters with a color\nconst TABLE_BORDER_CHARACTERS = {\n  topBody: tableColor('─'),\n  topJoin: tableColor('┬'),\n  topLeft: tableColor('┌'),\n  topRight: tableColor('┐'),\n  bottomBody: tableColor('─'),\n  bottomJoin: tableColor('┴'),\n  bottomLeft: tableColor('└'),\n  bottomRight: tableColor('┘'),\n  bodyLeft: tableColor('│'),\n  bodyRight: tableColor('│'),\n  bodyJoin: tableColor('│'),\n  joinBody: tableColor('─'),\n  joinLeft: tableColor('├'),\n  joinRight: tableColor('┤'),\n  joinJoin: tableColor('┼'),\n};\n"]}

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

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { TemplateDiff } from './diff/types';
+export interface FormatStream extends NodeJS.WritableStream {
+    columns?: number;
+}
+/**
+ * Renders template differences to the process' console.
+ *
+ * @param stream           The IO stream where to output the rendered diff.
+ * @param templateDiff     TemplateDiff to be rendered to the console.
+ * @param logicalToPathMap A map from logical ID to construct path. Useful in
+ *                         case there is no aws:cdk:path metadata in the template.
+ * @param context          the number of context lines to use in arbitrary JSON diff (defaults to 3).
+ */
+export declare function formatDifferences(stream: FormatStream, templateDiff: TemplateDiff, logicalToPathMap?: {
+    [logicalId: string]: string;
+}, context?: number): void;
+/**
+ * Renders a diff of security changes to the given stream
+ */
+export declare function formatSecurityChanges(stream: NodeJS.WriteStream, templateDiff: TemplateDiff, logicalToPathMap?: {
+    [logicalId: string]: string;
+}, context?: number): void;