@aws-amplify/graphql-model-transformer 2.1.3-jsii-build.1 → 2.2.0-rds-2.0

package/rds-lambda/node_modules/@bcoe/v8-coverage/dist/lib/_src/range-tree.ts

@@ -0,0 +1,156 @@
+import { RangeCov } from "./types";
+
+export class RangeTree {
+  start: number;
+  end: number;
+  delta: number;
+  children: RangeTree[];
+
+  constructor(
+    start: number,
+    end: number,
+    delta: number,
+    children: RangeTree[],
+  ) {
+    this.start = start;
+    this.end = end;
+    this.delta = delta;
+    this.children = children;
+  }
+
+  /**
+   * @precodition `ranges` are well-formed and pre-order sorted
+   */
+  static fromSortedRanges(ranges: ReadonlyArray<RangeCov>): RangeTree | undefined {
+    let root: RangeTree | undefined;
+    // Stack of parent trees and parent counts.
+    const stack: [RangeTree, number][] = [];
+    for (const range of ranges) {
+      const node: RangeTree = new RangeTree(range.startOffset, range.endOffset, range.count, []);
+      if (root === undefined) {
+        root = node;
+        stack.push([node, range.count]);
+        continue;
+      }
+      let parent: RangeTree;
+      let parentCount: number;
+      while (true) {
+        [parent, parentCount] = stack[stack.length - 1];
+        // assert: `top !== undefined` (the ranges are sorted)
+        if (range.startOffset < parent.end) {
+          break;
+        } else {
+          stack.pop();
+        }
+      }
+      node.delta -= parentCount;
+      parent.children.push(node);
+      stack.push([node, range.count]);
+    }
+    return root;
+  }
+
+  normalize(): void {
+    const children: RangeTree[] = [];
+    let curEnd: number;
+    let head: RangeTree | undefined;
+    const tail: RangeTree[] = [];
+    for (const child of this.children) {
+      if (head === undefined) {
+        head = child;
+      } else if (child.delta === head.delta && child.start === curEnd!) {
+        tail.push(child);
+      } else {
+        endChain();
+        head = child;
+      }
+      curEnd = child.end;
+    }
+    if (head !== undefined) {
+      endChain();
+    }
+
+    if (children.length === 1) {
+      const child: RangeTree = children[0];
+      if (child.start === this.start && child.end === this.end) {
+        this.delta += child.delta;
+        this.children = child.children;
+        // `.lazyCount` is zero for both (both are after normalization)
+        return;
+      }
+    }
+
+    this.children = children;
+
+    function endChain(): void {
+      if (tail.length !== 0) {
+        head!.end = tail[tail.length - 1].end;
+        for (const tailTree of tail) {
+          for (const subChild of tailTree.children) {
+            subChild.delta += tailTree.delta - head!.delta;
+            head!.children.push(subChild);
+          }
+        }
+        tail.length = 0;
+      }
+      head!.normalize();
+      children.push(head!);
+    }
+  }
+
+  /**
+   * @precondition `tree.start < value && value < tree.end`
+   * @return RangeTree Right part
+   */
+  split(value: number): RangeTree {
+    let leftChildLen: number = this.children.length;
+    let mid: RangeTree | undefined;
+
+    // TODO(perf): Binary search (check overhead)
+    for (let i: number = 0; i < this.children.length; i++) {
+      const child: RangeTree = this.children[i];
+      if (child.start < value && value < child.end) {
+        mid = child.split(value);
+        leftChildLen = i + 1;
+        break;
+      } else if (child.start >= value) {
+        leftChildLen = i;
+        break;
+      }
+    }
+
+    const rightLen: number = this.children.length - leftChildLen;
+    const rightChildren: RangeTree[] = this.children.splice(leftChildLen, rightLen);
+    if (mid !== undefined) {
+      rightChildren.unshift(mid);
+    }
+    const result: RangeTree = new RangeTree(
+      value,
+      this.end,
+      this.delta,
+      rightChildren,
+    );
+    this.end = value;
+    return result;
+  }
+
+  /**
+   * Get the range coverages corresponding to the tree.
+   *
+   * The ranges are pre-order sorted.
+   */
+  toRanges(): RangeCov[] {
+    const ranges: RangeCov[] = [];
+    // Stack of parent trees and counts.
+    const stack: [RangeTree, number][] = [[this, 0]];
+    while (stack.length > 0) {
+      const [cur, parentCount]: [RangeTree, number] = stack.pop()!;
+      const count: number = parentCount + cur.delta;
+      ranges.push({startOffset: cur.start, endOffset: cur.end, count});
+      for (let i: number = cur.children.length - 1; i >= 0; i--) {
+        stack.push([cur.children[i], count]);
+      }
+    }
+    return ranges;
+  }
+}

package/rds-lambda/node_modules/@bcoe/v8-coverage/dist/lib/_src/types.ts

@@ -0,0 +1,26 @@
+export interface ProcessCov {
+  result: ScriptCov[];
+}
+
+export interface ScriptCov {
+  scriptId: string;
+  url: string;
+  functions: FunctionCov[];
+}
+
+export interface FunctionCov {
+  functionName: string;
+  ranges: RangeCov[];
+  isBlockCoverage: boolean;
+}
+
+export interface Range {
+  readonly start: number;
+  readonly end: number;
+}
+
+export interface RangeCov {
+  startOffset: number;
+  endOffset: number;
+  count: number;
+}

package/rds-lambda/node_modules/@bcoe/v8-coverage/dist/lib/ascii.mjs

@@ -0,0 +1,130 @@
+import { compareRangeCovs } from "./compare";
+export function emitForest(trees) {
+    return emitForestLines(trees).join("\n");
+}
+export function emitForestLines(trees) {
+    const colMap = getColMap(trees);
+    const header = emitOffsets(colMap);
+    return [header, ...trees.map(tree => emitTree(tree, colMap).join("\n"))];
+}
+function getColMap(trees) {
+    const eventSet = new Set();
+    for (const tree of trees) {
+        const stack = [tree];
+        while (stack.length > 0) {
+            const cur = stack.pop();
+            eventSet.add(cur.start);
+            eventSet.add(cur.end);
+            for (const child of cur.children) {
+                stack.push(child);
+            }
+        }
+    }
+    const events = [...eventSet];
+    events.sort((a, b) => a - b);
+    let maxDigits = 1;
+    for (const event of events) {
+        maxDigits = Math.max(maxDigits, event.toString(10).length);
+    }
+    const colWidth = maxDigits + 3;
+    const colMap = new Map();
+    for (const [i, event] of events.entries()) {
+        colMap.set(event, i * colWidth);
+    }
+    return colMap;
+}
+function emitTree(tree, colMap) {
+    const layers = [];
+    let nextLayer = [tree];
+    while (nextLayer.length > 0) {
+        const layer = nextLayer;
+        layers.push(layer);
+        nextLayer = [];
+        for (const node of layer) {
+            for (const child of node.children) {
+                nextLayer.push(child);
+            }
+        }
+    }
+    return layers.map(layer => emitTreeLayer(layer, colMap));
+}
+export function parseFunctionRanges(text, offsetMap) {
+    const result = [];
+    for (const line of text.split("\n")) {
+        for (const range of parseTreeLayer(line, offsetMap)) {
+            result.push(range);
+        }
+    }
+    result.sort(compareRangeCovs);
+    return result;
+}
+/**
+ *
+ * @param layer Sorted list of disjoint trees.
+ * @param colMap
+ */
+function emitTreeLayer(layer, colMap) {
+    const line = [];
+    let curIdx = 0;
+    for (const { start, end, count } of layer) {
+        const startIdx = colMap.get(start);
+        const endIdx = colMap.get(end);
+        if (startIdx > curIdx) {
+            line.push(" ".repeat(startIdx - curIdx));
+        }
+        line.push(emitRange(count, endIdx - startIdx));
+        curIdx = endIdx;
+    }
+    return line.join("");
+}
+function parseTreeLayer(text, offsetMap) {
+    const result = [];
+    const regex = /\[(\d+)-*\)/gs;
+    while (true) {
+        const match = regex.exec(text);
+        if (match === null) {
+            break;
+        }
+        const startIdx = match.index;
+        const endIdx = startIdx + match[0].length;
+        const count = parseInt(match[1], 10);
+        const startOffset = offsetMap.get(startIdx);
+        const endOffset = offsetMap.get(endIdx);
+        if (startOffset === undefined || endOffset === undefined) {
+            throw new Error(`Invalid offsets for: ${JSON.stringify(text)}`);
+        }
+        result.push({ startOffset, endOffset, count });
+    }
+    return result;
+}
+function emitRange(count, len) {
+    const rangeStart = `[${count.toString(10)}`;
+    const rangeEnd = ")";
+    const hyphensLen = len - (rangeStart.length + rangeEnd.length);
+    const hyphens = "-".repeat(Math.max(0, hyphensLen));
+    return `${rangeStart}${hyphens}${rangeEnd}`;
+}
+function emitOffsets(colMap) {
+    let line = "";
+    for (const [event, col] of colMap) {
+        if (line.length < col) {
+            line += " ".repeat(col - line.length);
+        }
+        line += event.toString(10);
+    }
+    return line;
+}
+export function parseOffsets(text) {
+    const result = new Map();
+    const regex = /\d+/gs;
+    while (true) {
+        const match = regex.exec(text);
+        if (match === null) {
+            break;
+        }
+        result.set(match.index, parseInt(match[0], 10));
+    }
+    return result;
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["_src/ascii.ts"],"names":[],"mappings":"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","file":"ascii.js","sourcesContent":["import { compareRangeCovs } from \"./compare\";\nimport { RangeCov } from \"./types\";\n\ninterface ReadonlyRangeTree {\n  readonly start: number;\n  readonly end: number;\n  readonly count: number;\n  readonly children: ReadonlyRangeTree[];\n}\n\nexport function emitForest(trees: ReadonlyArray<ReadonlyRangeTree>): string {\n  return emitForestLines(trees).join(\"\\n\");\n}\n\nexport function emitForestLines(trees: ReadonlyArray<ReadonlyRangeTree>): string[] {\n  const colMap: Map<number, number> = getColMap(trees);\n  const header: string = emitOffsets(colMap);\n  return [header, ...trees.map(tree => emitTree(tree, colMap).join(\"\\n\"))];\n}\n\nfunction getColMap(trees: Iterable<ReadonlyRangeTree>): Map<number, number> {\n  const eventSet: Set<number> = new Set();\n  for (const tree of trees) {\n    const stack: ReadonlyRangeTree[] = [tree];\n    while (stack.length > 0) {\n      const cur: ReadonlyRangeTree = stack.pop()!;\n      eventSet.add(cur.start);\n      eventSet.add(cur.end);\n      for (const child of cur.children) {\n        stack.push(child);\n      }\n    }\n  }\n  const events: number[] = [...eventSet];\n  events.sort((a, b) => a - b);\n  let maxDigits: number = 1;\n  for (const event of events) {\n    maxDigits = Math.max(maxDigits, event.toString(10).length);\n  }\n  const colWidth: number = maxDigits + 3;\n  const colMap: Map<number, number> = new Map();\n  for (const [i, event] of events.entries()) {\n    colMap.set(event, i * colWidth);\n  }\n  return colMap;\n}\n\nfunction emitTree(tree: ReadonlyRangeTree, colMap: Map<number, number>): string[] {\n  const layers: ReadonlyRangeTree[][] = [];\n  let nextLayer: ReadonlyRangeTree[] = [tree];\n  while (nextLayer.length > 0) {\n    const layer: ReadonlyRangeTree[] = nextLayer;\n    layers.push(layer);\n    nextLayer = [];\n    for (const node of layer) {\n      for (const child of node.children) {\n        nextLayer.push(child);\n      }\n    }\n  }\n  return layers.map(layer => emitTreeLayer(layer, colMap));\n}\n\nexport function parseFunctionRanges(text: string, offsetMap: Map<number, number>): RangeCov[] {\n  const result: RangeCov[] = [];\n  for (const line of text.split(\"\\n\")) {\n    for (const range of parseTreeLayer(line, offsetMap)) {\n      result.push(range);\n    }\n  }\n  result.sort(compareRangeCovs);\n  return result;\n}\n\n/**\n *\n * @param layer Sorted list of disjoint trees.\n * @param colMap\n */\nfunction emitTreeLayer(layer: ReadonlyRangeTree[], colMap: Map<number, number>): string {\n  const line: string[] = [];\n  let curIdx: number = 0;\n  for (const {start, end, count} of layer) {\n    const startIdx: number = colMap.get(start)!;\n    const endIdx: number = colMap.get(end)!;\n    if (startIdx > curIdx) {\n      line.push(\" \".repeat(startIdx - curIdx));\n    }\n    line.push(emitRange(count, endIdx - startIdx));\n    curIdx = endIdx;\n  }\n  return line.join(\"\");\n}\n\nfunction parseTreeLayer(text: string, offsetMap: Map<number, number>): RangeCov[] {\n  const result: RangeCov[] = [];\n  const regex: RegExp = /\\[(\\d+)-*\\)/gs;\n  while (true) {\n    const match: RegExpMatchArray | null = regex.exec(text);\n    if (match === null) {\n      break;\n    }\n    const startIdx: number = match.index!;\n    const endIdx: number = startIdx + match[0].length;\n    const count: number = parseInt(match[1], 10);\n    const startOffset: number | undefined = offsetMap.get(startIdx);\n    const endOffset: number | undefined = offsetMap.get(endIdx);\n    if (startOffset === undefined || endOffset === undefined) {\n      throw new Error(`Invalid offsets for: ${JSON.stringify(text)}`);\n    }\n    result.push({startOffset, endOffset, count});\n  }\n  return result;\n}\n\nfunction emitRange(count: number, len: number): string {\n  const rangeStart: string = `[${count.toString(10)}`;\n  const rangeEnd: string = \")\";\n  const hyphensLen: number = len - (rangeStart.length + rangeEnd.length);\n  const hyphens: string = \"-\".repeat(Math.max(0, hyphensLen));\n  return `${rangeStart}${hyphens}${rangeEnd}`;\n}\n\nfunction emitOffsets(colMap: Map<number, number>): string {\n  let line: string = \"\";\n  for (const [event, col] of colMap) {\n    if (line.length < col) {\n      line += \" \".repeat(col - line.length);\n    }\n    line += event.toString(10);\n  }\n  return line;\n}\n\nexport function parseOffsets(text: string): Map<number, number> {\n  const result: Map<number, number> = new Map();\n  const regex: RegExp = /\\d+/gs;\n  while (true) {\n    const match: RegExpExecArray | null = regex.exec(text);\n    if (match === null) {\n      break;\n    }\n    result.set(match.index, parseInt(match[0], 10));\n  }\n  return result;\n}\n"],"sourceRoot":""}

package/rds-lambda/node_modules/@bcoe/v8-coverage/dist/lib/clone.mjs

@@ -0,0 +1,64 @@
+/**
+ * Creates a deep copy of a process coverage.
+ *
+ * @param processCov Process coverage to clone.
+ * @return Cloned process coverage.
+ */
+export function cloneProcessCov(processCov) {
+    const result = [];
+    for (const scriptCov of processCov.result) {
+        result.push(cloneScriptCov(scriptCov));
+    }
+    return {
+        result,
+    };
+}
+/**
+ * Creates a deep copy of a script coverage.
+ *
+ * @param scriptCov Script coverage to clone.
+ * @return Cloned script coverage.
+ */
+export function cloneScriptCov(scriptCov) {
+    const functions = [];
+    for (const functionCov of scriptCov.functions) {
+        functions.push(cloneFunctionCov(functionCov));
+    }
+    return {
+        scriptId: scriptCov.scriptId,
+        url: scriptCov.url,
+        functions,
+    };
+}
+/**
+ * Creates a deep copy of a function coverage.
+ *
+ * @param functionCov Function coverage to clone.
+ * @return Cloned function coverage.
+ */
+export function cloneFunctionCov(functionCov) {
+    const ranges = [];
+    for (const rangeCov of functionCov.ranges) {
+        ranges.push(cloneRangeCov(rangeCov));
+    }
+    return {
+        functionName: functionCov.functionName,
+        ranges,
+        isBlockCoverage: functionCov.isBlockCoverage,
+    };
+}
+/**
+ * Creates a deep copy of a function coverage.
+ *
+ * @param rangeCov Range coverage to clone.
+ * @return Cloned range coverage.
+ */
+export function cloneRangeCov(rangeCov) {
+    return {
+        startOffset: rangeCov.startOffset,
+        endOffset: rangeCov.endOffset,
+        count: rangeCov.count,
+    };
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/rds-lambda/node_modules/@bcoe/v8-coverage/dist/lib/compare.mjs

@@ -0,0 +1,41 @@
+/**
+ * Compares two script coverages.
+ *
+ * The result corresponds to the comparison of their `url` value (alphabetical sort).
+ */
+export function compareScriptCovs(a, b) {
+    if (a.url === b.url) {
+        return 0;
+    }
+    else if (a.url < b.url) {
+        return -1;
+    }
+    else {
+        return 1;
+    }
+}
+/**
+ * Compares two function coverages.
+ *
+ * The result corresponds to the comparison of the root ranges.
+ */
+export function compareFunctionCovs(a, b) {
+    return compareRangeCovs(a.ranges[0], b.ranges[0]);
+}
+/**
+ * Compares two range coverages.
+ *
+ * The ranges are first ordered by ascending `startOffset` and then by
+ * descending `endOffset`.
+ * This corresponds to a pre-order tree traversal.
+ */
+export function compareRangeCovs(a, b) {
+    if (a.startOffset !== b.startOffset) {
+        return a.startOffset - b.startOffset;
+    }
+    else {
+        return b.endOffset - a.endOffset;
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/rds-lambda/node_modules/@bcoe/v8-coverage/dist/lib/index.mjs

@@ -0,0 +1,7 @@
+export { emitForest, emitForestLines, parseFunctionRanges, parseOffsets } from "./ascii";
+export { cloneFunctionCov, cloneProcessCov, cloneScriptCov, cloneRangeCov } from "./clone";
+export { compareScriptCovs, compareFunctionCovs, compareRangeCovs } from "./compare";
+export { mergeFunctionCovs, mergeProcessCovs, mergeScriptCovs } from "./merge";
+export { RangeTree } from "./range-tree";
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIl9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsbUJBQW1CLEVBQUUsWUFBWSxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ3pGLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLGFBQWEsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUMzRixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsbUJBQW1CLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDckYsT0FBTyxFQUFFLGlCQUFpQixFQUFFLGdCQUFnQixFQUFFLGVBQWUsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUMvRSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sY0FBYyxDQUFDIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZW1pdEZvcmVzdCwgZW1pdEZvcmVzdExpbmVzLCBwYXJzZUZ1bmN0aW9uUmFuZ2VzLCBwYXJzZU9mZnNldHMgfSBmcm9tIFwiLi9hc2NpaVwiO1xuZXhwb3J0IHsgY2xvbmVGdW5jdGlvbkNvdiwgY2xvbmVQcm9jZXNzQ292LCBjbG9uZVNjcmlwdENvdiwgY2xvbmVSYW5nZUNvdiB9IGZyb20gXCIuL2Nsb25lXCI7XG5leHBvcnQgeyBjb21wYXJlU2NyaXB0Q292cywgY29tcGFyZUZ1bmN0aW9uQ292cywgY29tcGFyZVJhbmdlQ292cyB9IGZyb20gXCIuL2NvbXBhcmVcIjtcbmV4cG9ydCB7IG1lcmdlRnVuY3Rpb25Db3ZzLCBtZXJnZVByb2Nlc3NDb3ZzLCBtZXJnZVNjcmlwdENvdnMgfSBmcm9tIFwiLi9tZXJnZVwiO1xuZXhwb3J0IHsgUmFuZ2VUcmVlIH0gZnJvbSBcIi4vcmFuZ2UtdHJlZVwiO1xuZXhwb3J0IHsgUHJvY2Vzc0NvdiwgU2NyaXB0Q292LCBGdW5jdGlvbkNvdiwgUmFuZ2VDb3YgfSBmcm9tIFwiLi90eXBlc1wiO1xuIl0sInNvdXJjZVJvb3QiOiIifQ==