@machhub-dev/node-red-nodes 1.0.5

package/node_modules/commist/leven.js

@@ -0,0 +1,91 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+ * 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.
+ */
+
+const array = []
+const characterCodeCache = []
+
+module.exports = function leven (first, second) {
+  if (first === second) {
+    return 0
+  }
+
+  const swap = first
+
+  // Swapping the strings if `a` is longer than `b` so we know which one is the
+  // shortest & which one is the longest
+  if (first.length > second.length) {
+    first = second
+    second = swap
+  }
+
+  let firstLength = first.length
+  let secondLength = second.length
+
+  // Performing suffix trimming:
+  // We can linearly drop suffix common to both strings since they
+  // don't increase distance at all
+  // Note: `~-` is the bitwise way to perform a `- 1` operation
+  while (firstLength > 0 && (first.charCodeAt(~-firstLength) === second.charCodeAt(~-secondLength))) {
+    firstLength--
+    secondLength--
+  }
+
+  // Performing prefix trimming
+  // We can linearly drop prefix common to both strings since they
+  // don't increase distance at all
+  let start = 0
+
+  while (start < firstLength && (first.charCodeAt(start) === second.charCodeAt(start))) {
+    start++
+  }
+
+  firstLength -= start
+  secondLength -= start
+
+  if (firstLength === 0) {
+    return secondLength
+  }
+
+  let bCharacterCode
+  let result
+  let temporary
+  let temporary2
+  let index = 0
+  let index2 = 0
+
+  while (index < firstLength) {
+    characterCodeCache[index] = first.charCodeAt(start + index)
+    array[index] = ++index
+  }
+
+  while (index2 < secondLength) {
+    bCharacterCode = second.charCodeAt(start + index2)
+    temporary = index2++
+    result = index2
+
+    for (index = 0; index < firstLength; index++) {
+      temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1
+      temporary = array[index]
+      // eslint-disable-next-line no-multi-assign
+      result = array[index] = temporary > result ? (temporary2 > result ? result + 1 : temporary2) : (temporary2 > temporary ? temporary + 1 : temporary2)
+    }
+  }
+
+  return result
+}

package/node_modules/commist/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "commist",
+  "version": "3.2.0",
+  "description": "Build your commands on minimist!",
+  "main": "index.js",
+  "scripts": {
+    "test": "standard && tape test.js"
+  },
+  "pre-commit": "test",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mcollina/commist.git"
+  },
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mcollina/commist/issues"
+  },
+  "homepage": "https://github.com/mcollina/commist",
+  "dependencies": {
+  },
+  "devDependencies": {
+    "minimist": "^1.1.0",
+    "pre-commit": "^1.0.0",
+    "standard": "^17.0.0",
+    "tape": "^5.0.0"
+  }
+}

package/node_modules/commist/test.js

@@ -0,0 +1,368 @@
+'use strict'
+
+const test = require('tape').test
+
+const commist = require('./')
+const leven = require('./leven')
+
+test('registering a command', function (t) {
+  t.plan(2)
+
+  const program = commist()
+
+  program.register('hello', function (args) {
+    t.deepEqual(args, ['a', '-x', '23'])
+  })
+
+  const result = program.parse(['hello', 'a', '-x', '23'])
+
+  t.notOk(result, 'must return null, the command have been handled')
+})
+
+test('registering two commands', function (t) {
+  t.plan(1)
+
+  const program = commist()
+
+  program.register('hello', function (args) {
+    t.ok(false, 'must pick the right command')
+  })
+
+  program.register('world', function (args) {
+    t.deepEqual(args, ['a', '-x', '23'])
+  })
+
+  program.parse(['world', 'a', '-x', '23'])
+})
+
+test('registering two commands (bis)', function (t) {
+  t.plan(1)
+
+  const program = commist()
+
+  program.register('hello', function (args) {
+    t.deepEqual(args, ['a', '-x', '23'])
+  })
+
+  program.register('world', function (args) {
+    t.ok(false, 'must pick the right command')
+  })
+
+  program.parse(['hello', 'a', '-x', '23'])
+})
+
+test('registering two words commands', function (t) {
+  t.plan(1)
+
+  const program = commist()
+
+  program.register('hello', function (args) {
+    t.ok(false, 'must pick the right command')
+  })
+
+  program.register('hello world', function (args) {
+    t.deepEqual(args, ['a', '-x', '23'])
+  })
+
+  program.parse(['hello', 'world', 'a', '-x', '23'])
+})
+
+test('registering two words commands (bis)', function (t) {
+  t.plan(1)
+
+  const program = commist()
+
+  program.register('hello', function (args) {
+    t.deepEqual(args, ['a', '-x', '23'])
+  })
+
+  program.register('hello world', function (args) {
+    t.ok(false, 'must pick the right command')
+  })
+
+  program.parse(['hello', 'a', '-x', '23'])
+})
+
+test('registering ambiguous commands throws exception', function (t) {
+  const program = commist()
+
+  function noop () {}
+
+  program.register('hello', noop)
+  program.register('hello world', noop)
+  program.register('hello world matteo', noop)
+
+  try {
+    program.register('hello world', noop)
+    t.ok(false, 'must throw if double-registering the same command')
+  } catch (err) {
+  }
+
+  t.end()
+})
+
+test('looking up commands', function (t) {
+  const program = commist()
+
+  function noop1 () {}
+  function noop2 () {}
+  function noop3 () {}
+
+  program.register('hello', noop1)
+  program.register('hello world matteo', noop3)
+  program.register('hello world', noop2)
+
+  t.equal(program.lookup('hello')[0].func, noop1)
+  t.equal(program.lookup('hello world matteo')[0].func, noop3)
+  t.equal(program.lookup('hello world')[0].func, noop2)
+
+  t.end()
+})
+
+test('looking up commands with abbreviations', function (t) {
+  const program = commist()
+
+  function noop1 () {}
+  function noop2 () {}
+  function noop3 () {}
+
+  program.register('hello', noop1)
+  program.register('hello world matteo', noop3)
+  program.register('hello world', noop2)
+
+  t.equal(program.lookup('hel')[0].func, noop1)
+  t.equal(program.lookup('hel wor mat')[0].func, noop3)
+  t.equal(program.lookup('hel wor')[0].func, noop2)
+
+  t.end()
+})
+
+test('looking up strict commands', function (t) {
+  const program = commist()
+
+  function noop1 () {}
+  function noop2 () {}
+
+  program.register({ command: 'restore', strict: true }, noop1)
+  program.register({ command: 'rest', strict: true }, noop2)
+
+  t.equal(program.lookup('restore')[0].func, noop1)
+  t.equal(program.lookup('rest')[0].func, noop2)
+  t.equal(program.lookup('remove')[0], undefined)
+
+  t.end()
+})
+
+test('executing commands from abbreviations', function (t) {
+  t.plan(1)
+
+  const program = commist()
+
+  program.register('hello', function (args) {
+    t.deepEqual(args, ['a', '-x', '23'])
+  })
+
+  program.register('hello world', function (args) {
+    t.ok(false, 'must pick the right command')
+  })
+
+  program.parse(['hel', 'a', '-x', '23'])
+})
+
+test('executing async command', function (t) {
+  t.plan(1)
+
+  const program = commist()
+
+  program.register('hello', async function (args) {
+    t.deepEqual(args, ['a', '-x', '23'])
+  })
+
+  program.parseAsync(['hello', 'a', '-x', '23'])
+})
+
+test('async execution resolves when correctly matched one', function (t) {
+  t.plan(1)
+
+  const program = commist()
+
+  program.register('hello', async function () {
+    return 1337
+  })
+
+  program.parseAsync(['hello', 'a', '-x', '23']).then((result) => {
+    t.equal(result, null)
+  })
+})
+
+test('async execution resolves with args if no commands matched', function (t) {
+  t.plan(1)
+
+  const program = commist()
+
+  program.register('hello', async function () {
+    t.ok(false, 'command should not be picked')
+  })
+
+  program.parseAsync(['whoops', 'a', '-x', '23']).then((args) => {
+    t.deepEqual(args, ['whoops', 'a', '-x', '23'])
+  })
+})
+
+test('async execution should wait intil registered command finishes', function (t) {
+  t.plan(1)
+
+  const program = commist()
+
+  program.register('hello', async function () {
+    const res = await Promise.resolve(42)
+    return res
+  })
+
+  program.parseAsync(['hello', 'a', '-x', '23']).then((result) => {
+    t.equal(result, null)
+  })
+})
+
+test('async execution should work with sync commands', function (t) {
+  t.plan(1)
+
+  const program = commist()
+
+  program.register('hello', function (args) {
+    t.deepEqual(args, ['a', '-x', '23'])
+  })
+
+  program.parseAsync(['hello', 'a', '-x', '23'])
+})
+
+test('sync execution should work with async commands', function (t) {
+  t.plan(1)
+
+  const program = commist()
+
+  program.register('hello', async function (args) {
+    t.deepEqual(args, ['a', '-x', '23'])
+  })
+
+  program.parse(['hello', 'a', '-x', '23'])
+})
+
+test('one char command', function (t) {
+  const program = commist()
+
+  function noop1 () {}
+
+  program.register('h', noop1)
+  t.equal(program.lookup('h')[0].func, noop1)
+
+  t.end()
+})
+
+test('two char command', function (t) {
+  const program = commist()
+
+  function noop1 () {}
+
+  program.register('he', noop1)
+  t.equal(program.lookup('he')[0].func, noop1)
+
+  t.end()
+})
+
+test('a command part must be at least 3 chars', function (t) {
+  const program = commist()
+
+  function noop1 () {}
+
+  program.register('h b', noop1)
+
+  t.equal(program.lookup('h b')[0].func, noop1)
+
+  t.end()
+})
+
+test('short commands match exactly', function (t) {
+  const program = commist()
+
+  function noop1 () {}
+  function noop2 () {}
+
+  program.register('h', noop1)
+  program.register('help', noop2)
+
+  t.equal(program.lookup('h')[0].func, noop1)
+  t.equal(program.lookup('he')[0].func, noop2)
+  t.equal(program.lookup('hel')[0].func, noop2)
+  t.equal(program.lookup('help')[0].func, noop2)
+
+  t.end()
+})
+
+test('leven', function (t) {
+  t.is(leven('a', 'b'), 1)
+  t.is(leven('ab', 'ac'), 1)
+  t.is(leven('ac', 'bc'), 1)
+  t.is(leven('abc', 'axc'), 1)
+  t.is(leven('kitten', 'sitting'), 3)
+  t.is(leven('xabxcdxxefxgx', '1ab2cd34ef5g6'), 6)
+  t.is(leven('cat', 'cow'), 2)
+  t.is(leven('xabxcdxxefxgx', 'abcdefg'), 6)
+  t.is(leven('javawasneat', 'scalaisgreat'), 7)
+  t.is(leven('example', 'samples'), 3)
+  t.is(leven('sturgeon', 'urgently'), 6)
+  t.is(leven('levenshtein', 'frankenstein'), 6)
+  t.is(leven('distance', 'difference'), 5)
+  t.is(leven('因為我是中國人所以我會說中文', '因為我是英國人所以我會說英文'), 2)
+  t.end()
+})
+
+test('max distance', function (t) {
+  const program = commist({ maxDistance: 2 })
+
+  function noop1 () {}
+  function noop2 () {}
+  function noop3 () {}
+
+  program.register('hello', noop1)
+  program.register('hello world matteo', noop3)
+  program.register('hello world', noop2)
+
+  t.equal(program.lookup('hel')[0].func, noop1)
+  t.equal(program.lookup('hel wor mat')[0].func, noop2)
+  t.equal(program.lookup('hello world matt')[0].func, noop3)
+  t.equal(program.lookup('hello wor')[0].func, noop2)
+  t.deepEqual(program.lookup('he wor'), [])
+
+  t.end()
+})
+
+test('help foobar vs start', function (t) {
+  const program = commist({ maxDistance: 2 })
+
+  function noop1 () {}
+  function noop2 () {}
+
+  program.register('help', noop1)
+  program.register('start', noop2)
+
+  t.equal(program.lookup('help')[0].func, noop1)
+  t.deepEqual(program.lookup('help foobar')[0].func, noop1)
+  t.equal(program.lookup('start')[0].func, noop2)
+
+  t.end()
+})
+
+test('registering a command with maxDistance', function (t) {
+  t.plan(2)
+
+  const program = commist({ maxDistance: 2 })
+
+  program.register('hello', function (args) {
+    t.deepEqual(args, ['a', '-x', '23'])
+  })
+
+  const result = program.parse(['hello', 'a', '-x', '23'])
+
+  t.notOk(result, 'must return null, the command have been handled')
+})

package/node_modules/concat-stream/LICENSE

@@ -0,0 +1,24 @@
+The MIT License
+
+Copyright (c) 2013 Max Ogden
+
+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/concat-stream/index.js

@@ -0,0 +1,144 @@
+var Writable = require('readable-stream').Writable
+var inherits = require('inherits')
+var bufferFrom = require('buffer-from')
+
+if (typeof Uint8Array === 'undefined') {
+  var U8 = require('typedarray').Uint8Array
+} else {
+  var U8 = Uint8Array
+}
+
+function ConcatStream(opts, cb) {
+  if (!(this instanceof ConcatStream)) return new ConcatStream(opts, cb)
+
+  if (typeof opts === 'function') {
+    cb = opts
+    opts = {}
+  }
+  if (!opts) opts = {}
+
+  var encoding = opts.encoding
+  var shouldInferEncoding = false
+
+  if (!encoding) {
+    shouldInferEncoding = true
+  } else {
+    encoding =  String(encoding).toLowerCase()
+    if (encoding === 'u8' || encoding === 'uint8') {
+      encoding = 'uint8array'
+    }
+  }
+
+  Writable.call(this, { objectMode: true })
+
+  this.encoding = encoding
+  this.shouldInferEncoding = shouldInferEncoding
+
+  if (cb) this.on('finish', function () { cb(this.getBody()) })
+  this.body = []
+}
+
+module.exports = ConcatStream
+inherits(ConcatStream, Writable)
+
+ConcatStream.prototype._write = function(chunk, enc, next) {
+  this.body.push(chunk)
+  next()
+}
+
+ConcatStream.prototype.inferEncoding = function (buff) {
+  var firstBuffer = buff === undefined ? this.body[0] : buff;
+  if (Buffer.isBuffer(firstBuffer)) return 'buffer'
+  if (typeof Uint8Array !== 'undefined' && firstBuffer instanceof Uint8Array) return 'uint8array'
+  if (Array.isArray(firstBuffer)) return 'array'
+  if (typeof firstBuffer === 'string') return 'string'
+  if (Object.prototype.toString.call(firstBuffer) === "[object Object]") return 'object'
+  return 'buffer'
+}
+
+ConcatStream.prototype.getBody = function () {
+  if (!this.encoding && this.body.length === 0) return []
+  if (this.shouldInferEncoding) this.encoding = this.inferEncoding()
+  if (this.encoding === 'array') return arrayConcat(this.body)
+  if (this.encoding === 'string') return stringConcat(this.body)
+  if (this.encoding === 'buffer') return bufferConcat(this.body)
+  if (this.encoding === 'uint8array') return u8Concat(this.body)
+  return this.body
+}
+
+var isArray = Array.isArray || function (arr) {
+  return Object.prototype.toString.call(arr) == '[object Array]'
+}
+
+function isArrayish (arr) {
+  return /Array\]$/.test(Object.prototype.toString.call(arr))
+}
+
+function isBufferish (p) {
+  return typeof p === 'string' || isArrayish(p) || (p && typeof p.subarray === 'function')
+}
+
+function stringConcat (parts) {
+  var strings = []
+  var needsToString = false
+  for (var i = 0; i < parts.length; i++) {
+    var p = parts[i]
+    if (typeof p === 'string') {
+      strings.push(p)
+    } else if (Buffer.isBuffer(p)) {
+      strings.push(p)
+    } else if (isBufferish(p)) {
+      strings.push(bufferFrom(p))
+    } else {
+      strings.push(bufferFrom(String(p)))
+    }
+  }
+  if (Buffer.isBuffer(parts[0])) {
+    strings = Buffer.concat(strings)
+    strings = strings.toString('utf8')
+  } else {
+    strings = strings.join('')
+  }
+  return strings
+}
+
+function bufferConcat (parts) {
+  var bufs = []
+  for (var i = 0; i < parts.length; i++) {
+    var p = parts[i]
+    if (Buffer.isBuffer(p)) {
+      bufs.push(p)
+    } else if (isBufferish(p)) {
+      bufs.push(bufferFrom(p))
+    } else {
+      bufs.push(bufferFrom(String(p)))
+    }
+  }
+  return Buffer.concat(bufs)
+}
+
+function arrayConcat (parts) {
+  var res = []
+  for (var i = 0; i < parts.length; i++) {
+    res.push.apply(res, parts[i])
+  }
+  return res
+}
+
+function u8Concat (parts) {
+  var len = 0
+  for (var i = 0; i < parts.length; i++) {
+    if (typeof parts[i] === 'string') {
+      parts[i] = bufferFrom(parts[i])
+    }
+    len += parts[i].length
+  }
+  var u8 = new U8(len)
+  for (var i = 0, offset = 0; i < parts.length; i++) {
+    var part = parts[i]
+    for (var j = 0; j < part.length; j++) {
+      u8[offset++] = part[j]
+    }
+  }
+  return u8
+}

package/node_modules/concat-stream/node_modules/readable-stream/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+* (a) The contribution was created in whole or in part by me and I
+  have the right to submit it under the open source license
+  indicated in the file; or
+
+* (b) The contribution is based upon previous work that, to the best
+  of my knowledge, is covered under an appropriate open source
+  license and I have the right under that license to submit that
+  work with modifications, whether created in whole or in part
+  by me, under the same open source license (unless I am
+  permitted to submit under a different license), as indicated
+  in the file; or
+
+* (c) The contribution was provided directly to me by some other
+  person who certified (a), (b) or (c) and I have not modified
+  it.
+
+* (d) I understand and agree that this project and the contribution
+  are public and that a record of the contribution (including all
+  personal information I submit with it, including my sign-off) is
+  maintained indefinitely and may be redistributed consistent with
+  this project or the open source license(s) involved.
+
+## Moderation Policy
+
+The [Node.js Moderation Policy] applies to this WG.
+
+## Code of Conduct
+
+The [Node.js Code of Conduct][] applies to this WG.
+
+[Node.js Code of Conduct]:
+https://github.com/nodejs/node/blob/master/CODE_OF_CONDUCT.md
+[Node.js Moderation Policy]:
+https://github.com/nodejs/TSC/blob/master/Moderation-Policy.md