projen 0.91.28 → 0.91.29

package/node_modules/just-diff/index.mjs

@@ -0,0 +1,227 @@
+/*
+  const obj1 = {a: 4, b: 5};
+  const obj2 = {a: 3, b: 5};
+  const obj3 = {a: 4, c: 5};
+
+  diff(obj1, obj2);
+  [
+    { "op": "replace", "path": ['a'], "value": 3 }
+  ]
+
+  diff(obj2, obj3);
+  [
+    { "op": "remove", "path": ['b'] },
+    { "op": "replace", "path": ['a'], "value": 4 }
+    { "op": "add", "path": ['c'], "value": 5 }
+  ]
+
+  // using converter to generate jsPatch standard paths
+  // see http://jsonpatch.com
+  import {diff, jsonPatchPathConverter} from 'just-diff'
+  diff(obj1, obj2, jsonPatchPathConverter);
+  [
+    { "op": "replace", "path": '/a', "value": 3 }
+  ]
+
+  diff(obj2, obj3, jsonPatchPathConverter);
+  [
+    { "op": "remove", "path": '/b' },
+    { "op": "replace", "path": '/a', "value": 4 }
+    { "op": "add", "path": '/c', "value": 5 }
+  ]
+
+  // arrays
+  const obj4 = {a: 4, b: [1, 2, 3]};
+  const obj5 = {a: 3, b: [1, 2, 4]};
+  const obj6 = {a: 3, b: [1, 2, 4, 5]};
+
+  diff(obj4, obj5);
+  [
+    { "op": "replace", "path": ['a'], "value": 3 }
+    { "op": "replace", "path": ['b', 2], "value": 4 }
+  ]
+
+  diff(obj5, obj6);
+  [
+    { "op": "add", "path": ['b', 3], "value": 5 }
+  ]
+
+  // nested paths
+  const obj7 = {a: 4, b: {c: 3}};
+  const obj8 = {a: 4, b: {c: 4}};
+  const obj9 = {a: 5, b: {d: 4}};
+
+  diff(obj7, obj8);
+  [
+    { "op": "replace", "path": ['b', 'c'], "value": 4 }
+  ]
+
+  diff(obj8, obj9);
+  [
+    { "op": "replace", "path": ['a'], "value": 5 }
+    { "op": "remove", "path": ['b', 'c']}
+    { "op": "add", "path": ['b', 'd'], "value": 4 }
+  ]
+*/
+
+function diff(obj1, obj2, pathConverter) {
+  if (!obj1 || typeof obj1 != 'object' || !obj2 || typeof obj2 != 'object') {
+    throw new Error('both arguments must be objects or arrays');
+  }
+
+  pathConverter ||
+    (pathConverter = function(arr) {
+      return arr;
+    });
+
+  function getDiff({obj1, obj2, basePath, basePathForRemoves, diffs}) {
+    var obj1Keys = Object.keys(obj1);
+    var obj1KeysLength = obj1Keys.length;
+    var obj2Keys = Object.keys(obj2);
+    var obj2KeysLength = obj2Keys.length;
+    var path;
+
+    var lengthDelta = obj1.length - obj2.length;
+
+    if (trimFromRight(obj1, obj2)) {
+      for (var i = 0; i < obj1KeysLength; i++) {
+        var key = Array.isArray(obj1) ? Number(obj1Keys[i]) : obj1Keys[i];
+        if (!(key in obj2)) {
+          path = basePathForRemoves.concat(key);
+          diffs.remove.push({
+            op: 'remove',
+            path: pathConverter(path),
+          });
+        }
+      }
+
+      for (var i = 0; i < obj2KeysLength; i++) {
+        var key = Array.isArray(obj2) ? Number(obj2Keys[i]) : obj2Keys[i];
+        pushReplaces({
+          key,
+          obj1,
+          obj2,
+          path: basePath.concat(key),
+          pathForRemoves: basePath.concat(key),
+          diffs,
+        });
+      }
+    } else {
+      // trim from left, objects are both arrays
+      for (var i = 0; i < lengthDelta; i++) {
+        path = basePathForRemoves.concat(i);
+        diffs.remove.push({
+          op: 'remove',
+          path: pathConverter(path),
+        });
+      }
+
+      // now make a copy of obj1 with excess elements left trimmed and see if there any replaces
+      var obj1Trimmed = obj1.slice(lengthDelta);;
+      for (var i = 0; i < obj2KeysLength; i++) {
+        pushReplaces({
+          key: i,
+          obj1: obj1Trimmed,
+          obj2,
+          path: basePath.concat(i),
+          // since list of removes are reversed before presenting result,
+          // we need to ignore existing parent removes when doing nested removes
+          pathForRemoves: basePath.concat(i + lengthDelta),
+          diffs,
+        });
+      }
+    }
+  }
+
+  var diffs = {remove: [], replace: [], add: []};
+  getDiff({
+    obj1,
+    obj2,
+    basePath: [],
+    basePathForRemoves: [],
+    diffs,
+  });
+
+  // reverse removes since we want to maintain indexes
+  return diffs.remove
+    .reverse()
+    .concat(diffs.replace)
+    .concat(diffs.add);
+
+  function pushReplaces({key, obj1, obj2, path, pathForRemoves, diffs}) {
+    var obj1AtKey = obj1[key];
+    var obj2AtKey = obj2[key];
+
+    if(!(key in obj1) && (key in obj2)) {
+      var obj2Value = obj2AtKey;
+      diffs.add.push({
+        op: 'add',
+        path: pathConverter(path),
+        value: obj2Value,
+      });
+    } else if(obj1AtKey !== obj2AtKey) {
+      if(Object(obj1AtKey) !== obj1AtKey ||
+        Object(obj2AtKey) !== obj2AtKey || differentTypes(obj1AtKey, obj2AtKey)
+      ) {
+        pushReplace(path, diffs, obj2AtKey);
+      } else {
+        if(!Object.keys(obj1AtKey).length &&
+          !Object.keys(obj2AtKey).length &&
+          String(obj1AtKey) != String(obj2AtKey)) {
+          pushReplace(path, diffs, obj2AtKey);
+        } else {
+          getDiff({
+            obj1: obj1[key],
+            obj2: obj2[key],
+            basePath: path,
+            basePathForRemoves: pathForRemoves,
+            diffs});
+        }
+      }
+    }
+  }
+
+  function pushReplace(path, diffs, newValue) {
+    diffs.replace.push({
+      op: 'replace',
+      path: pathConverter(path),
+      value: newValue,
+    });
+  }
+}
+
+function jsonPatchPathConverter(arrayPath) {
+  return [''].concat(arrayPath).join('/');
+}
+
+function differentTypes(a, b) {
+  return Object.prototype.toString.call(a) != Object.prototype.toString.call(b);
+}
+
+function trimFromRight(obj1, obj2) {
+  var lengthDelta = obj1.length - obj2.length;
+  if (Array.isArray(obj1) && Array.isArray(obj2) && lengthDelta > 0) {
+    var leftMatches = 0;
+    var rightMatches = 0;
+    for (var i = 0; i < obj2.length; i++) {
+      if (String(obj1[i]) === String(obj2[i])) {
+        leftMatches++;
+      } else {
+        break;
+      }
+    }
+    for (var j = obj2.length; j > 0; j--) {
+      if (String(obj1[j + lengthDelta]) === String(obj2[j])) {
+        rightMatches++;
+      } else {
+        break;
+      }
+    }
+
+    // bias to trim right becase it requires less index shifting
+    return leftMatches >= rightMatches;
+  }
+  return true;
+}
+
+export {diff, jsonPatchPathConverter};

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

@@ -0,0 +1,65 @@
+import * as diffObj from './index'
+
+const {diff, jsonPatchPathConverter} = diffObj;
+const obj1 = {a: 2, b: 3};
+const obj2 = {a: 2, c: 1};
+const arr1 = [1, 'bee'];
+const arr2 = [2, 'bee'];
+
+
+//OK
+diff(obj1, obj2);
+diff(arr1, arr2);
+diff(obj1, arr1);
+diff(obj2, arr2);
+diff(/yes/, arr1);
+diff(new Date(), arr2);
+
+
+diff(obj1, obj2, jsonPatchPathConverter);
+diff(arr1, arr2, jsonPatchPathConverter);
+diff(obj1, arr1, jsonPatchPathConverter);
+diff(obj2, arr2, jsonPatchPathConverter);
+
+// not OK
+// @ts-expect-error
+diff(obj1);
+// @ts-expect-error
+diff(arr2);
+// @ts-expect-error
+diff('a');
+// @ts-expect-error
+diff(true);
+
+// @ts-expect-error
+diff(obj1, 1);
+// @ts-expect-error
+diff(3, arr2);
+// @ts-expect-error
+diff(obj1, 'a');
+// @ts-expect-error
+diff('b', arr2);
+
+// @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/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "just-diff",
+  "version": "6.0.2",
+  "description": "Return an object representing the diffs between two objects. 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",
+    "jsonPatch",
+    "no-dependencies",
+    "just"
+  ],
+  "author": "Angus Croll",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/angus-c/just/issues"
+  }
+}

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

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

package/node_modules/just-diff-apply/CHANGELOG.md

@@ -0,0 +1,43 @@
+# just-diff-apply
+
+## 5.5.0
+
+### Minor Changes
+
+- Rename node module .js -> .cjs
+
+## 5.4.1
+
+### Patch Changes
+
+- fix: reorder exports to set default last #488
+
+## 5.4.0
+
+### Minor Changes
+
+- package.json updates to fix #467 and #483
+
+## 5.3.1
+
+### Patch Changes
+
+- Fix README
+
+## 5.3.0
+
+### Minor Changes
+
+- Update .mjs module and d.ts
+
+## 5.2.0
+
+### Minor Changes
+
+- Add support for 'move' op (https://datatracker.ietf.org/doc/html/rfc6902#section-4.4)
+
+## 5.0.0
+
+### Major Changes
+
+- Disallow prototype updates

package/node_modules/just-diff-apply/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 angus croll
+
+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.

package/node_modules/just-diff-apply/README.md

@@ -0,0 +1,69 @@
+<!-- DO NOT EDIT THIS FILE! THIS FILE WAS AUTOGENERATED BY TEMPLATE-MATE -->
+<!-- SEE https://github.com/angus-c/just/blob/master/CONTRIBUTING.md#readme-template -->
+
+## just-diff-apply
+
+Part of a [library](https://anguscroll.com/just) of zero-dependency npm modules that do just do one thing.
+Guilt-free utilities for every occasion.
+
+[`🍦 Try it`](https://anguscroll.com/just/just-diff-apply)
+
+```shell
+npm install just-diff-apply
+```
+```shell
+yarn add just-diff-apply
+```
+
+Apply a diff object to an object. Pass converter to apply a http://jsonpatch.com standard patch
+
+```js
+  import {diffApply} from 'just-diff-apply';
+
+  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}
+
+  const obj2 = {a: 3, b: 5};
+  diffApply(obj2,
+    [
+      { "op": "move", "from": ['a'], "path": ['c']},
+    ]
+  );
+  obj2; // {b: 5, c: 3}
+
+  // using converter to apply jsPatch standard paths
+  // see http://jsonpatch.com
+  import {diffApply, jsonPatchPathConverter} from 'just-diff-apply'
+  const obj3 = {a: 3, b: 5};
+  diffApply(obj3, [
+    { "op": "remove", "path": '/b' },
+    { "op": "replace", "path": '/a', "value": 4 }
+    { "op": "add", "path": '/c', "value": 5 }
+  ], jsonPatchPathConverter);
+  obj3; // {a: 4, c: 5}
+
+  // arrays (array key can be string or numeric)
+  const obj4 = {a: 4, b: [1, 2, 3]};
+  diffApply(obj4, [
+    { "op": "replace", "path": ['a'], "value": 3 }
+    { "op": "replace", "path": ['b', 2], "value": 4 }
+    { "op": "add", "path": ['b', 3], "value": 9 }
+  ]);
+  obj4; // {a: 3, b: [1, 2, 4, 9]}
+
+  // nested paths
+  const obj5 = {a: 4, b: {c: 3}};
+  diffApply(obj5, [
+    { "op": "replace", "path": ['a'], "value": 5 }
+    { "op": "remove", "path": ['b', 'c']}
+    { "op": "add", "path": ['b', 'd'], "value": 4 }
+  ]);
+  obj5; // {a: 5, b: {d: 4}}
+```

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

@@ -0,0 +1,161 @@
+module.exports = {
+  diffApply: diffApply,
+  jsonPatchPathConverter: jsonPatchPathConverter,
+};
+
+/*
+  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');
+  }
+}

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

@@ -0,0 +1,17 @@
+// Definitions by: Eddie Atkinson <https://github.com/eddie-atkinson>
+
+type Operation = "add" | "replace" | "remove" | "move";
+
+type DiffOps = Array<{
+  op: Operation;
+  path: Array<string | number>;
+  value?: any;
+}>;
+type PathConverter = (path: string) => string[];
+
+export function diffApply<T extends object>(
+  obj: T,
+  diff: DiffOps,
+  pathConverter?: PathConverter
+): T;
+export const jsonPatchPathConverter: PathConverter;