projen 0.65.49 → 0.65.50

package/node_modules/comment-json/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "comment-json",
+  "version": "4.2.2",
+  "description": "Parse and stringify JSON with comments. It will retain comments even after saved!",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "npm run test:only",
+    "test:only": "npm run test:ts && npm run test:node",
+    "test:ts": "tsc test/ts/test-ts.ts && node test/ts/test-ts.js",
+    "test:node": "NODE_DEBUG=comment-json nyc ava --timeout=10s --verbose",
+    "test:dev": "npm run test:only && npm run report:dev",
+    "lint": "eslint .",
+    "fix": "eslint . --fix",
+    "posttest": "npm run report",
+    "report": "nyc report --reporter=text-lcov > coverage.lcov && codecov",
+    "report:dev": "nyc report --reporter=html && npm run report:open",
+    "report:open": "open coverage/index.html"
+  },
+  "files": [
+    "src/",
+    "index.d.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/kaelzhang/node-comment-json.git"
+  },
+  "keywords": [
+    "comment-json",
+    "comments",
+    "annotations",
+    "json",
+    "json-stringify",
+    "json-parse",
+    "parser",
+    "comments-json",
+    "json-comments"
+  ],
+  "engines": {
+    "node": ">= 6"
+  },
+  "ava": {
+    "files": [
+      "test/*.test.js"
+    ]
+  },
+  "author": "kaelzhang",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/kaelzhang/node-comment-json/issues"
+  },
+  "devDependencies": {
+    "@ostai/eslint-config": "^3.6.0",
+    "ava": "^4.0.1",
+    "codecov": "^3.8.2",
+    "eslint": "^8.8.0",
+    "eslint-plugin-import": "^2.25.4",
+    "nyc": "^15.1.0",
+    "test-fixture": "^2.4.1",
+    "typescript": "^4.5.5"
+  },
+  "dependencies": {
+    "array-timsort": "^1.0.3",
+    "core-util-is": "^1.0.3",
+    "esprima": "^4.0.1",
+    "has-own-prop": "^2.0.0",
+    "repeat-string": "^1.6.1"
+  }
+}

package/node_modules/comment-json/src/array.js

@@ -0,0 +1,288 @@
+const {isArray} = require('core-util-is')
+const {sort} = require('array-timsort')
+
+const {
+  SYMBOL_PREFIXES,
+
+  UNDEFINED,
+
+  symbol,
+  copy_comments,
+  swap_comments
+} = require('./common')
+
+const reverse_comments = array => {
+  const {length} = array
+  let i = 0
+  const max = length / 2
+
+  for (; i < max; i ++) {
+    swap_comments(array, i, length - i - 1)
+  }
+}
+
+const move_comment = (target, source, i, offset, remove) => {
+  copy_comments(target, source, i + offset, i, remove)
+}
+
+const move_comments = (
+  // `Array` target array
+  target,
+  // `Array` source array
+  source,
+  // `number` start index
+  start,
+  // `number` number of indexes to move
+  count,
+  // `number` offset to move
+  offset,
+  // `boolean` whether should remove the comments from source
+  remove
+) => {
+  if (offset > 0) {
+    let i = count
+    //         |   count   | offset |
+    // source: -------------
+    // target:          -------------
+    //         | remove |
+    // => remove === offset
+
+    // From [count - 1, 0]
+    while (i -- > 0) {
+      move_comment(target, source, start + i, offset, remove)
+    }
+    return
+  }
+
+  let i = 0
+  // | remove  |  count    |
+  //           -------------
+  // -------------
+  //             | offset  |
+
+  // From [0, count - 1]
+  while (i < count) {
+    const ii = i ++
+    move_comment(target, source, start + ii, offset, remove)
+  }
+}
+
+const remove_comments = (array, key) => {
+  SYMBOL_PREFIXES.forEach(prefix => {
+    const prop = symbol(prefix, key)
+    delete array[prop]
+  })
+}
+
+const get_mapped = (map, key) => {
+  let mapped = key
+
+  while (mapped in map) {
+    mapped = map[mapped]
+  }
+
+  return mapped
+}
+
+class CommentArray extends Array {
+  // - deleteCount + items.length
+
+  // We should avoid `splice(begin, deleteCount, ...items)`,
+  // because `splice(0, undefined)` is not equivalent to `splice(0)`,
+  // as well as:
+  // - slice
+  splice (...args) {
+    const {length} = this
+    const ret = super.splice(...args)
+
+    // #16
+    // If no element removed, we might still need to move comments,
+    //   because splice could add new items
+
+    // if (!ret.length) {
+    //   return ret
+    // }
+
+    // JavaScript syntax is silly
+    // eslint-disable-next-line prefer-const
+    let [begin, deleteCount, ...items] = args
+
+    if (begin < 0) {
+      begin += length
+    }
+
+    if (arguments.length === 1) {
+      deleteCount = length - begin
+    } else {
+      deleteCount = Math.min(length - begin, deleteCount)
+    }
+
+    const {
+      length: item_length
+    } = items
+
+    // itemsToDelete: -
+    // itemsToAdd: +
+    //        |    dc      |  count   |
+    // =======-------------============
+    // =======++++++============
+    //        | il |
+    const offset = item_length - deleteCount
+    const start = begin + deleteCount
+    const count = length - start
+
+    move_comments(this, this, start, count, offset, true)
+
+    return ret
+  }
+
+  slice (...args) {
+    const {length} = this
+    const array = super.slice(...args)
+    if (!array.length) {
+      return new CommentArray()
+    }
+
+    let [begin, before] = args
+
+    // Ref:
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice
+    if (before === UNDEFINED) {
+      before = length
+    } else if (before < 0) {
+      before += length
+    }
+
+    if (begin < 0) {
+      begin += length
+    } else if (begin === UNDEFINED) {
+      begin = 0
+    }
+
+    move_comments(array, this, begin, before - begin, - begin)
+
+    return array
+  }
+
+  unshift (...items) {
+    const {length} = this
+    const ret = super.unshift(...items)
+    const {
+      length: items_length
+    } = items
+
+    if (items_length > 0) {
+      move_comments(this, this, 0, length, items_length, true)
+    }
+
+    return ret
+  }
+
+  shift () {
+    const ret = super.shift()
+    const {length} = this
+
+    remove_comments(this, 0)
+    move_comments(this, this, 1, length, - 1, true)
+
+    return ret
+  }
+
+  reverse () {
+    super.reverse()
+
+    reverse_comments(this)
+
+    return this
+  }
+
+  pop () {
+    const ret = super.pop()
+
+    // Removes comments
+    remove_comments(this, this.length)
+
+    return ret
+  }
+
+  concat (...items) {
+    let {length} = this
+    const ret = super.concat(...items)
+
+    if (!items.length) {
+      return ret
+    }
+
+    move_comments(ret, this, 0, this.length, 0)
+
+    items.forEach(item => {
+      const prev = length
+      length += isArray(item)
+        ? item.length
+        : 1
+
+      if (!(item instanceof CommentArray)) {
+        return
+      }
+
+      move_comments(ret, item, 0, item.length, prev)
+    })
+
+    return ret
+  }
+
+  sort (...args) {
+    const result = sort(
+      this,
+      // Make sure there is no more than one argument
+      ...args.slice(0, 1)
+    )
+
+    // For example,
+    // if we sort ['b', 'd', 'c', 'a'],
+    // then `result` will be [3, 0, 2, 1], and the array is ['a', 'b', 'c', 'd']
+
+    // First, we swap index 0 (b) and index 3 (a), then the array comments are
+    // ['a.comments', 'd.comments', 'c.comments', 'b.comments']
+    // index 0 is finalized
+    // index 3 is actually mapped to original index 0, we present as 0 -> 3
+
+    // Then swap index 1 (d) and index 0 (-> 3, b)
+    // 1 (index) -> 0 (new index) -> 3 (real_index)
+    // ['d.comments', 'b.comments', 'c.comments', 'd.comments']
+    // index 1 is finalized
+    // index 3 is contains the item of original index 1
+    // - we present as 1 -> 3
+    // - it is ok that we don't remove mapping 0 -> 3
+
+    // Then index 2 should be skipped
+
+    // Then swap index 3 (d) and index 1 (-> 3, b), skipped
+
+    const map = Object.create(null)
+
+    result.forEach((source_index, index) => {
+      if (source_index === index) {
+        return
+      }
+
+      const real_source_index = get_mapped(map, source_index)
+
+      if (real_source_index === index) {
+        return
+      }
+
+      // The item of index `index` gets the final value
+      // delete map[index]
+      map[index] = real_source_index
+
+      swap_comments(this, index, real_source_index)
+    })
+
+    return this
+  }
+}
+
+module.exports = {
+  CommentArray
+}

package/node_modules/comment-json/src/common.js

@@ -0,0 +1,181 @@
+const hasOwnProperty = require('has-own-prop')
+const {
+  isObject,
+  isArray,
+  isString,
+  isNumber
+} = require('core-util-is')
+
+const PREFIX_BEFORE = 'before'
+const PREFIX_AFTER_PROP = 'after-prop'
+const PREFIX_AFTER_COLON = 'after-colon'
+const PREFIX_AFTER_VALUE = 'after-value'
+const PREFIX_AFTER = 'after'
+
+const PREFIX_BEFORE_ALL = 'before-all'
+const PREFIX_AFTER_ALL = 'after-all'
+
+const BRACKET_OPEN = '['
+const BRACKET_CLOSE = ']'
+const CURLY_BRACKET_OPEN = '{'
+const CURLY_BRACKET_CLOSE = '}'
+const COMMA = ','
+const EMPTY = ''
+const MINUS = '-'
+
+const SYMBOL_PREFIXES = [
+  PREFIX_BEFORE,
+  PREFIX_AFTER_PROP,
+  PREFIX_AFTER_COLON,
+  PREFIX_AFTER_VALUE,
+  PREFIX_AFTER
+]
+
+const NON_PROP_SYMBOL_KEYS = [
+  PREFIX_BEFORE,
+  PREFIX_BEFORE_ALL,
+  PREFIX_AFTER_ALL
+].map(Symbol.for)
+
+const COLON = ':'
+const UNDEFINED = undefined
+
+const symbol = (prefix, key) => Symbol.for(prefix + COLON + key)
+
+const define = (target, key, value) => Object.defineProperty(target, key, {
+  value,
+  writable: true,
+  configurable: true
+})
+
+const copy_comments_by_kind = (
+  target, source, target_key, source_key, prefix, remove_source
+) => {
+  const source_prop = symbol(prefix, source_key)
+  if (!hasOwnProperty(source, source_prop)) {
+    return
+  }
+
+  const target_prop = target_key === source_key
+    ? source_prop
+    : symbol(prefix, target_key)
+
+  define(target, target_prop, source[source_prop])
+
+  if (remove_source) {
+    delete source[source_prop]
+  }
+}
+
+const copy_comments = (
+  target, source, target_key, source_key, remove_source
+) => {
+  SYMBOL_PREFIXES.forEach(prefix => {
+    copy_comments_by_kind(
+      target, source, target_key, source_key, prefix, remove_source
+    )
+  })
+}
+
+const swap_comments = (array, from, to) => {
+  if (from === to) {
+    return
+  }
+
+  SYMBOL_PREFIXES.forEach(prefix => {
+    const target_prop = symbol(prefix, to)
+    if (!hasOwnProperty(array, target_prop)) {
+      copy_comments_by_kind(array, array, to, from, prefix, true)
+      return
+    }
+
+    const comments = array[target_prop]
+    delete array[target_prop]
+
+    copy_comments_by_kind(array, array, to, from, prefix, true)
+    define(array, symbol(prefix, from), comments)
+  })
+}
+
+const assign_non_prop_comments = (target, source) => {
+  NON_PROP_SYMBOL_KEYS.forEach(key => {
+    const comments = source[key]
+
+    if (comments) {
+      define(target, key, comments)
+    }
+  })
+}
+
+// Assign keys and comments
+const assign = (target, source, keys) => {
+  keys.forEach(key => {
+    if (!isString(key) && !isNumber(key)) {
+      return
+    }
+
+    if (!hasOwnProperty(source, key)) {
+      return
+    }
+
+    target[key] = source[key]
+    copy_comments(target, source, key, key)
+  })
+
+  return target
+}
+
+module.exports = {
+  SYMBOL_PREFIXES,
+
+  PREFIX_BEFORE,
+  PREFIX_AFTER_PROP,
+  PREFIX_AFTER_COLON,
+  PREFIX_AFTER_VALUE,
+  PREFIX_AFTER,
+
+  PREFIX_BEFORE_ALL,
+  PREFIX_AFTER_ALL,
+
+  BRACKET_OPEN,
+  BRACKET_CLOSE,
+  CURLY_BRACKET_OPEN,
+  CURLY_BRACKET_CLOSE,
+
+  COLON,
+  COMMA,
+  MINUS,
+  EMPTY,
+
+  UNDEFINED,
+
+  symbol,
+  define,
+  copy_comments,
+  swap_comments,
+  assign_non_prop_comments,
+
+  assign (target, source, keys) {
+    if (!isObject(target)) {
+      throw new TypeError('Cannot convert undefined or null to object')
+    }
+
+    if (!isObject(source)) {
+      return target
+    }
+
+    if (keys === UNDEFINED) {
+      keys = Object.keys(source)
+      // We assign non-property comments
+      // if argument `keys` is not specified
+      assign_non_prop_comments(target, source)
+    } else if (!isArray(keys)) {
+      throw new TypeError('keys must be array or undefined')
+    } else if (keys.length === 0) {
+      // Or argument `keys` is an empty array
+      assign_non_prop_comments(target, source)
+    }
+
+    return assign(target, source, keys)
+  }
+}

package/node_modules/comment-json/src/index.js

@@ -0,0 +1,13 @@
+const {parse, tokenize} = require('./parse')
+const stringify = require('./stringify')
+const {CommentArray} = require('./array')
+const {assign} = require('./common')
+
+module.exports = {
+  parse,
+  stringify,
+  tokenize,
+
+  CommentArray,
+  assign
+}