projen 0.91.28 → 0.91.29

package/node_modules/just-diff-apply/index.mjs

@@ -0,0 +1,158 @@
+/*
+  const obj1 = {a: 3, b: 5};
+  diffApply(obj1,
+    [
+      { "op": "remove", "path": ['b'] },
+      { "op": "replace", "path": ['a'], "value": 4 },
+      { "op": "add", "path": ['c'], "value": 5 }
+    ]
+  );
+  obj1; // {a: 4, c: 5}
+
+  // using converter to apply jsPatch standard paths
+  // see http://jsonpatch.com
+  import {diff, jsonPatchPathConverter} from 'just-diff'
+  const obj2 = {a: 3, b: 5};
+  diffApply(obj2, [
+    { "op": "remove", "path": '/b' },
+    { "op": "replace", "path": '/a', "value": 4 }
+    { "op": "add", "path": '/c', "value": 5 }
+  ], jsonPatchPathConverter);
+  obj2; // {a: 4, c: 5}
+
+  // arrays
+  const obj3 = {a: 4, b: [1, 2, 3]};
+  diffApply(obj3, [
+    { "op": "replace", "path": ['a'], "value": 3 }
+    { "op": "replace", "path": ['b', 2], "value": 4 }
+    { "op": "add", "path": ['b', 3], "value": 9 }
+  ]);
+  obj3; // {a: 3, b: [1, 2, 4, 9]}
+
+  // nested paths
+  const obj4 = {a: 4, b: {c: 3}};
+  diffApply(obj4, [
+    { "op": "replace", "path": ['a'], "value": 5 }
+    { "op": "remove", "path": ['b', 'c']}
+    { "op": "add", "path": ['b', 'd'], "value": 4 }
+  ]);
+  obj4; // {a: 5, b: {d: 4}}
+*/
+
+var REMOVE = 'remove';
+var REPLACE = 'replace';
+var ADD = 'add';
+var MOVE = 'move';
+
+function diffApply(obj, diff, pathConverter) {
+  if (!obj || typeof obj != 'object') {
+    throw new Error('base object must be an object or an array');
+  }
+
+  if (!Array.isArray(diff)) {
+    throw new Error('diff must be an array');
+  }
+
+  var diffLength = diff.length;
+  for (var i = 0; i < diffLength; i++) {
+    var thisDiff = diff[i];
+    var subObject = obj;
+    var thisOp = thisDiff.op;
+
+    var thisPath = transformPath(pathConverter, thisDiff.path);
+    var thisFromPath = thisDiff.from && transformPath(pathConverter, thisDiff.from);
+    var toPath, toPathCopy, lastToProp, subToObject, valueToMove;
+
+    if (thisFromPath) {
+      // MOVE only, "fromPath" is effectively path and "path" is toPath
+      toPath = thisPath;
+      thisPath = thisFromPath;
+
+      toPathCopy = toPath.slice();
+      lastToProp = toPathCopy.pop();
+      prototypeCheck(lastToProp);
+      if (lastToProp == null) {
+        return false;
+      }
+
+      var thisToProp;
+      while (((thisToProp = toPathCopy.shift())) != null) {
+        prototypeCheck(thisToProp);
+        if (!(thisToProp in subToObject)) {
+          subToObject[thisToProp] = {};
+        }
+        subToObject = subToObject[thisToProp];
+      }
+    }
+
+    var pathCopy = thisPath.slice();
+    var lastProp = pathCopy.pop();
+    prototypeCheck(lastProp);
+    if (lastProp == null) {
+      return false;
+    }
+
+    var thisProp;
+    while (((thisProp = pathCopy.shift())) != null) {
+      prototypeCheck(thisProp);
+      if (!(thisProp in subObject)) {
+        subObject[thisProp] = {};
+      }
+      subObject = subObject[thisProp];
+    }
+    if (thisOp === REMOVE || thisOp === REPLACE || thisOp === MOVE) {
+      var path = thisOp === MOVE ? thisDiff.from : thisDiff.path;
+      if (!subObject.hasOwnProperty(lastProp)) {
+        throw new Error(['expected to find property', path, 'in object', obj].join(' '));
+      }
+    }
+    if (thisOp === REMOVE || thisOp === MOVE) {
+      if (thisOp === MOVE) {
+        valueToMove = subObject[lastProp];
+      }
+      Array.isArray(subObject) ? subObject.splice(lastProp, 1) : delete subObject[lastProp];
+    }
+    if (thisOp === REPLACE || thisOp === ADD) {
+      subObject[lastProp] = thisDiff.value;
+    }
+
+    if (thisOp === MOVE) {
+      subObject[lastToProp] = valueToMove;
+    }
+  }
+  return subObject;
+}
+
+function transformPath(pathConverter, thisPath) {
+  if(pathConverter) {
+    thisPath = pathConverter(thisPath);
+    if(!Array.isArray(thisPath)) {
+      throw new Error([
+        'pathConverter must return an array, returned:',
+        thisPath,
+      ].join(' '));
+    }
+  } else {
+    if(!Array.isArray(thisPath)) {
+      throw new Error([
+        'diff path',
+        thisPath,
+        'must be an array, consider supplying a path converter']
+        .join(' '));
+    }
+  }
+  return thisPath;
+}
+
+function jsonPatchPathConverter(stringPath) {
+  return stringPath.split('/').slice(1);
+}
+
+function prototypeCheck(prop) {
+  // coercion is intentional to catch prop values like `['__proto__']`
+  if (prop == '__proto__' || prop == 'constructor' || prop == 'prototype') {
+    throw new Error('setting of prototype values not supported');
+  }
+}
+
+export {diffApply, jsonPatchPathConverter};

package/node_modules/just-diff-apply/index.tests.ts

@@ -0,0 +1,108 @@
+import * as diffObj from "./index";
+
+const { diffApply, jsonPatchPathConverter } = diffObj;
+const obj1 = {
+  a: 2,
+  b: 3,
+  c: {
+    d: 5
+  }
+};
+const arr1 = [1, "bee"];
+
+const objOps: diffObj.DiffOps = [
+  {
+    op: "replace",
+    path: ["a"],
+    value: 10
+  },
+  {
+    op: "remove",
+    path: ["b"]
+  },
+  {
+    op: "add",
+    path: ["e"],
+    value: 15
+  },
+  {
+    op: "remove",
+    path: ["c", "d"]
+  }
+];
+
+const arrOps: diffObj.DiffOps = [
+  {
+    op: "replace",
+    path: [1],
+    value: 10
+  },
+  {
+    op: "remove",
+    path: [2]
+  },
+  {
+    op: "add",
+    path: [7],
+    value: 15
+  }
+];
+
+//OK
+diffApply(obj1, objOps);
+diffApply(obj1, []);
+diffApply(arr1, arrOps);
+diffApply(arr1, []);
+diffApply(obj1, objOps, jsonPatchPathConverter);
+diffApply(arr1, arrOps, jsonPatchPathConverter);
+
+// not OK
+// @ts-expect-error
+diffApply(obj1);
+// @ts-expect-error
+diffApply(arr2);
+// @ts-expect-error
+diffApply("a");
+// @ts-expect-error
+diffApply(true);
+
+// @ts-expect-error
+diffApply(obj1, 1);
+// @ts-expect-error
+diffApply(3, arr2);
+// @ts-expect-error
+diffApply(obj1, "a");
+// @ts-expect-error
+diffApply("b", arr2);
+
+// @ts-expect-error
+diffApply(obj1, [{ op: "delete", path: ["a"] }]);
+// @ts-expect-error
+diffApply(obj1, [{ op: "delete", path: ["a"] }], jsonPatchPathConverter);
+// @ts-expect-error
+diffApply(obj1, "a", jsonPatchPathConverter);
+// @ts-expect-error
+diffApply(obj1, ["a", "b", "c"], jsonPatchPathConverter);
+
+// @ts-expect-error
+diff("a", jsonPatchPathConverter);
+// @ts-expect-error
+diff(true, jsonPatchPathConverter);
+
+// @ts-expect-error
+diff(obj1, 1, jsonPatchPathConverter);
+// @ts-expect-error
+diff(3, arr2, jsonPatchPathConverter);
+// @ts-expect-error
+diff(obj1, "a", jsonPatchPathConverter);
+// @ts-expect-error
+diff("b", arr2, jsonPatchPathConverter);
+
+// @ts-expect-error
+diff(obj1, obj2, "a");
+// @ts-expect-error
+diff(arr1, arr2, 1);
+// @ts-expect-error
+diff(obj1, arr1, "bee");
+// @ts-expect-error
+diff(obj2, arr2, "nope");

package/node_modules/just-diff-apply/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "just-diff-apply",
+  "version": "5.5.0",
+  "description": "Apply a diff to an object. Optionally supports jsonPatch protocol",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.cjs",
+      "import": "./index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "index.cjs",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "rollup -c"
+  },
+  "repository": "https://github.com/angus-c/just",
+  "keywords": [
+    "object",
+    "diff",
+    "apply",
+    "jsonPatch",
+    "no-dependencies",
+    "just"
+  ],
+  "author": "Angus Croll",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/angus-c/just/issues"
+  }
+}

package/node_modules/just-diff-apply/rollup.config.js

@@ -0,0 +1,3 @@
+const createRollupConfig = require('../../config/createRollupConfig');
+
+module.exports = createRollupConfig(__dirname);

package/node_modules/parse-conflict-json/LICENSE.md

@@ -0,0 +1,20 @@
+<!-- This file is automatically added by @npmcli/template-oss. Do not edit. -->
+
+ISC License
+
+Copyright npm, Inc.
+
+Permission to use, copy, modify, and/or distribute this
+software for any purpose with or without fee is hereby
+granted, provided that the above copyright notice and this
+permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND NPM DISCLAIMS ALL
+WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
+EVENT SHALL NPM BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+USE OR PERFORMANCE OF THIS SOFTWARE.

package/node_modules/parse-conflict-json/README.md

@@ -0,0 +1,42 @@
+# parse-conflict-json
+
+Parse a JSON string that has git merge conflicts, resolving if possible.
+
+If the JSON is valid, it just does `JSON.parse` as normal.
+
+If either side of the conflict is invalid JSON, then an error is thrown for
+that.
+
+## USAGE
+
+```js
+// after a git merge that left some conflicts there
+const data = fs.readFileSync('package-lock.json', 'utf8')
+
+// reviverFunction is passed to JSON.parse as the reviver function
+// preference defaults to 'ours', set to 'theirs' to prefer the other
+// side's changes.
+const parsed = parseConflictJson(data, reviverFunction, preference)
+
+// returns true if the data looks like a conflicted diff file
+parsed.isDiff(data)
+```
+
+## Algorithm
+
+If `prefer` is set to `theirs`, then the vaules of `theirs` and `ours` are
+switched in the resolver function.  (Ie, we'll apply their changes on top
+of our object, rather than the other way around.)
+
+- Parse the conflicted file into 3 pieces: `ours`, `theirs`, and `parent`
+
+- Get the [diff](https://github.com/angus-c/just#just-diff) from `parent`
+  to `ours`.
+
+- [Apply](https://github.com/angus-c/just#just-diff-apply) each change of
+  that diff to `theirs`.
+
+    If any change in the diff set cannot be applied (ie, because they
+    changed an object into a non-object and we changed a field on that
+    object), then replace the object at the specified path with the object
+    at the path in `ours`.

package/node_modules/parse-conflict-json/lib/index.js

@@ -0,0 +1,104 @@
+const parseJSON = require('json-parse-even-better-errors')
+const { diff } = require('just-diff')
+const { diffApply } = require('just-diff-apply')
+
+const globalObjectProperties = Object.getOwnPropertyNames(Object.prototype)
+
+const stripBOM = content => {
+  content = content.toString()
+  // Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
+  // because the buffer-to-string conversion in `fs.readFileSync()`
+  // translates it to FEFF, the UTF-16 BOM.
+  if (content.charCodeAt(0) === 0xFEFF) {
+    content = content.slice(1)
+  }
+  return content
+}
+
+const PARENT_RE = /\|{7,}/g
+const OURS_RE = /<{7,}/g
+const THEIRS_RE = /={7,}/g
+const END_RE = />{7,}/g
+
+const isDiff = str =>
+  str.match(OURS_RE) && str.match(THEIRS_RE) && str.match(END_RE)
+
+const parseConflictJSON = (str, reviver, prefer) => {
+  prefer = prefer || 'ours'
+  if (prefer !== 'theirs' && prefer !== 'ours') {
+    throw new TypeError('prefer param must be "ours" or "theirs" if set')
+  }
+
+  str = stripBOM(str)
+
+  if (!isDiff(str)) {
+    return parseJSON(str)
+  }
+
+  const pieces = str.split(/[\n\r]+/g).reduce((acc, line) => {
+    if (line.match(PARENT_RE)) {
+      acc.state = 'parent'
+    } else if (line.match(OURS_RE)) {
+      acc.state = 'ours'
+    } else if (line.match(THEIRS_RE)) {
+      acc.state = 'theirs'
+    } else if (line.match(END_RE)) {
+      acc.state = 'top'
+    } else {
+      if (acc.state === 'top' || acc.state === 'ours') {
+        acc.ours += line
+      }
+      if (acc.state === 'top' || acc.state === 'theirs') {
+        acc.theirs += line
+      }
+      if (acc.state === 'top' || acc.state === 'parent') {
+        acc.parent += line
+      }
+    }
+    return acc
+  }, {
+    state: 'top',
+    ours: '',
+    theirs: '',
+    parent: '',
+  })
+
+  // this will throw if either piece is not valid JSON, that's intended
+  const parent = parseJSON(pieces.parent, reviver)
+  const ours = parseJSON(pieces.ours, reviver)
+  const theirs = parseJSON(pieces.theirs, reviver)
+
+  return prefer === 'ours'
+    ? resolve(parent, ours, theirs)
+    : resolve(parent, theirs, ours)
+}
+
+const isObj = obj => obj && typeof obj === 'object'
+
+const copyPath = (to, from, path, i) => {
+  const p = path[i]
+  if (isObj(to[p]) && isObj(from[p]) &&
+      Array.isArray(to[p]) === Array.isArray(from[p])) {
+    return copyPath(to[p], from[p], path, i + 1)
+  }
+  to[p] = from[p]
+}
+
+// get the diff from parent->ours and applying our changes on top of theirs.
+// If they turned an object into a non-object, then put it back.
+const resolve = (parent, ours, theirs) => {
+  const dours = diff(parent, ours)
+  for (let i = 0; i < dours.length; i++) {
+    if (globalObjectProperties.find(prop => dours[i].path.includes(prop))) {
+      continue
+    }
+    try {
+      diffApply(theirs, [dours[i]])
+    } catch (e) {
+      copyPath(theirs, ours, dours[i].path, 0)
+    }
+  }
+  return theirs
+}
+
+module.exports = Object.assign(parseConflictJSON, { isDiff })

package/node_modules/parse-conflict-json/node_modules/json-parse-even-better-errors/LICENSE.md

@@ -0,0 +1,25 @@
+Copyright 2017 Kat Marchán
+Copyright npm, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+---
+
+This library is a fork of 'better-json-errors' by Kat Marchán, extended and
+distributed under the terms of the MIT license above.

package/node_modules/parse-conflict-json/node_modules/json-parse-even-better-errors/README.md

@@ -0,0 +1,96 @@
+# json-parse-even-better-errors
+
+[`json-parse-even-better-errors`](https://github.com/npm/json-parse-even-better-errors)
+is a Node.js library for getting nicer errors out of `JSON.parse()`,
+including context and position of the parse errors.
+
+It also preserves the newline and indentation styles of the JSON data, by
+putting them in the object or array in the `Symbol.for('indent')` and
+`Symbol.for('newline')` properties.
+
+## Install
+
+`$ npm install --save json-parse-even-better-errors`
+
+## Table of Contents
+
+* [Example](#example)
+* [Features](#features)
+* [Contributing](#contributing)
+* [API](#api)
+  * [`parse`](#parse)
+
+### Example
+
+```javascript
+const parseJson = require('json-parse-even-better-errors')
+
+parseJson('"foo"') // returns the string 'foo'
+parseJson('garbage') // more useful error message
+parseJson.noExceptions('garbage') // returns undefined
+```
+
+### Features
+
+* Like JSON.parse, but the errors are better.
+* Strips a leading byte-order-mark that you sometimes get reading files.
+* Has a `noExceptions` method that returns undefined rather than throwing.
+* Attaches the newline character(s) used to the `Symbol.for('newline')`
+  property on objects and arrays.
+* Attaches the indentation character(s) used to the `Symbol.for('indent')`
+  property on objects and arrays.
+
+## Indentation
+
+To preserve indentation when the file is saved back to disk, use
+`data[Symbol.for('indent')]` as the third argument to `JSON.stringify`, and
+if you want to preserve windows `\r\n` newlines, replace the `\n` chars in
+the string with `data[Symbol.for('newline')]`.
+
+For example:
+
+```js
+const txt = await readFile('./package.json', 'utf8')
+const data = parseJsonEvenBetterErrors(txt)
+const indent = Symbol.for('indent')
+const newline = Symbol.for('newline')
+// .. do some stuff to the data ..
+const string = JSON.stringify(data, null, data[indent]) + '\n'
+const eolFixed = data[newline] === '\n' ? string
+  : string.replace(/\n/g, data[newline])
+await writeFile('./package.json', eolFixed)
+```
+
+Indentation is determined by looking at the whitespace between the initial
+`{` and `[` and the character that follows it.  If you have lots of weird
+inconsistent indentation, then it won't track that or give you any way to
+preserve it.  Whether this is a bug or a feature is debatable ;)
+
+### API
+
+#### <a name="parse"></a> `parse(txt, reviver = null, context = 20)`
+
+Works just like `JSON.parse`, but will include a bit more information when
+an error happens, and attaches a `Symbol.for('indent')` and
+`Symbol.for('newline')` on objects and arrays.  This throws a
+`JSONParseError`.
+
+#### <a name="parse"></a> `parse.noExceptions(txt, reviver = null)`
+
+Works just like `JSON.parse`, but will return `undefined` rather than
+throwing an error.
+
+#### <a name="jsonparseerror"></a> `class JSONParseError(er, text, context = 20, caller = null)`
+
+Extends the JavaScript `SyntaxError` class to parse the message and provide
+better metadata.
+
+Pass in the error thrown by the built-in `JSON.parse`, and the text being
+parsed, and it'll parse out the bits needed to be helpful.
+
+`context` defaults to 20.
+
+Set a `caller` function to trim internal implementation details out of the
+stack trace.  When calling `parseJson`, this is set to the `parseJson`
+function.  If not set, then the constructor defaults to itself, so the
+stack trace will point to the spot where you call `new JSONParseError`.