@machhub-dev/node-red-nodes 1.0.5

package/node_modules/number-allocator/lib/number-allocator.js

@@ -0,0 +1,249 @@
+// Copyright Takatoshi Kondo 2021
+//
+// Distributed under the MIT License
+
+'use strict'
+
+const SortedSet = require('js-sdsl').OrderedSet
+const debugTrace = require('debug')('number-allocator:trace')
+const debugError = require('debug')('number-allocator:error')
+/**
+ * Interval constructor
+ * @constructor
+ * @param {Number} low  - The lowest value of the interval
+ * @param {Number} high - The highest value of the interval
+ */
+function Interval (low, high) {
+  this.low = low
+  this.high = high
+}
+
+Interval.prototype.equals = function (other) {
+  return this.low === other.low && this.high === other.high
+}
+
+Interval.prototype.compare = function (other) {
+  if (this.low < other.low && this.high < other.low) return -1
+  if (other.low < this.low && other.high < this.low) return 1
+  return 0
+}
+
+/**
+ * NumberAllocator constructor.
+ * The all numbers are set to vacant status.
+ * Time Complexity O(1)
+ * @constructor
+ * @param {Number} min  - The maximum number of allocatable. The number must be integer.
+ * @param {Number} maxh - The minimum number of allocatable. The number must be integer.
+ */
+function NumberAllocator (min, max) {
+  if (!(this instanceof NumberAllocator)) {
+    return new NumberAllocator(min, max)
+  }
+
+  this.min = min
+  this.max = max
+
+  this.ss = new SortedSet(
+    [],
+    (lhs, rhs) => {
+      return lhs.compare(rhs)
+    }
+  )
+  debugTrace('Create')
+  this.clear()
+}
+
+/**
+ * Get the first vacant number. The status of the number is not updated.
+ * Time Complexity O(1)
+ * @return {Number} - The first vacant number. If all numbers are occupied, return null.
+ *                    When alloc() is called then the same value will be allocated.
+ */
+NumberAllocator.prototype.firstVacant = function () {
+  if (this.ss.size() === 0) return null
+  return this.ss.front().low
+}
+
+/**
+ * Allocate the first vacant number. The number become occupied status.
+ * Time Complexity O(1)
+ * @return {Number} - The first vacant number. If all numbers are occupied, return null.
+ */
+NumberAllocator.prototype.alloc = function () {
+  if (this.ss.size() === 0) {
+    debugTrace('alloc():empty')
+    return null
+  }
+  const it = this.ss.begin()
+  const low = it.pointer.low
+  const high = it.pointer.high
+  const num = low
+  if (num + 1 <= high) {
+    // x|----|
+    this.ss.updateKeyByIterator(it, new Interval(low + 1, high))
+  } else {
+    this.ss.eraseElementByPos(0)
+  }
+  debugTrace('alloc():' + num)
+  return num
+}
+
+/**
+ * Use the number. The number become occupied status.
+ * If the number has already been occupied, then return false.
+ * Time Complexity O(logN) : N is the number of intervals (not numbers)
+ * @param {Number} num - The number to request use.
+ * @return {Boolean} - If `num` was not occupied, then return true, otherwise return false.
+ */
+NumberAllocator.prototype.use = function (num) {
+  const key = new Interval(num, num)
+  const it = this.ss.lowerBound(key)
+  if (!it.equals(this.ss.end())) {
+    const low = it.pointer.low
+    const high = it.pointer.high
+    if (it.pointer.equals(key)) {
+      // |x|
+      this.ss.eraseElementByIterator(it)
+      debugTrace('use():' + num)
+      return true
+    }
+
+    // x |-----|
+    if (low > num) return false
+
+    // |x----|
+    if (low === num) {
+      // x|----|
+      this.ss.updateKeyByIterator(it, new Interval(low + 1, high))
+      debugTrace('use():' + num)
+      return true
+    }
+
+    // |----x|
+    if (high === num) {
+      // |----|x
+      this.ss.updateKeyByIterator(it, new Interval(low, high - 1))
+      debugTrace('use():' + num)
+      return true
+    }
+
+    // |--x--|
+    // x|--|
+    this.ss.updateKeyByIterator(it, new Interval(num + 1, high))
+    // |--|x|--|
+    this.ss.insert(new Interval(low, num - 1))
+    debugTrace('use():' + num)
+    return true
+  }
+
+  debugTrace('use():failed')
+  return false
+}
+
+/**
+ * Deallocate the number. The number become vacant status.
+ * Time Complexity O(logN) : N is the number of intervals (not numbers)
+ * @param {Number} num - The number to deallocate. The number must be occupied status.
+ *                       In other words, the number must be allocated by alloc() or occupied be use().
+ */
+NumberAllocator.prototype.free = function (num) {
+  if (num < this.min || num > this.max) {
+    debugError('free():' + num + ' is out of range')
+    return
+  }
+  const key = new Interval(num, num)
+  const it = this.ss.upperBound(key)
+  if (it.equals(this.ss.end())) {
+    // ....v
+    if (it.equals(this.ss.begin())) {
+      // Insert new interval
+      this.ss.insert(key)
+      return
+    }
+    it.pre()
+    const low = it.pointer.high
+    const high = it.pointer.high
+    if (high + 1 === num) {
+      // Concat to left
+      this.ss.updateKeyByIterator(it, new Interval(low, num))
+    } else {
+      // Insert new interval
+      this.ss.insert(key)
+    }
+  } else {
+    if (it.equals(this.ss.begin())) {
+      // v....
+      if (num + 1 === it.pointer.low) {
+        // Concat to right
+        const high = it.pointer.high
+        this.ss.updateKeyByIterator(it, new Interval(num, high))
+      } else {
+        // Insert new interval
+        this.ss.insert(key)
+      }
+    } else {
+      // ..v..
+      const rLow = it.pointer.low
+      const rHigh = it.pointer.high
+      it.pre()
+      const lLow = it.pointer.low
+      const lHigh = it.pointer.high
+      if (lHigh + 1 === num) {
+        if (num + 1 === rLow) {
+          // Concat to left and right
+          this.ss.eraseElementByIterator(it)
+          this.ss.updateKeyByIterator(it, new Interval(lLow, rHigh))
+        } else {
+          // Concat to left
+          this.ss.updateKeyByIterator(it, new Interval(lLow, num))
+        }
+      } else {
+        if (num + 1 === rLow) {
+          // Concat to right
+          this.ss.eraseElementByIterator(it.next())
+          this.ss.insert(new Interval(num, rHigh))
+        } else {
+          // Insert new interval
+          this.ss.insert(key)
+        }
+      }
+    }
+  }
+  debugTrace('free():' + num)
+}
+
+/**
+ * Clear all occupied numbers.
+ * The all numbers are set to vacant status.
+ * Time Complexity O(1)
+ */
+NumberAllocator.prototype.clear = function () {
+  debugTrace('clear()')
+  this.ss.clear()
+  this.ss.insert(new Interval(this.min, this.max))
+}
+
+/**
+ * Get the number of intervals. Interval is internal structure of this library.
+ * This function is for debugging.
+ * Time Complexity O(1)
+ * @return {Number} - The number of intervals.
+ */
+NumberAllocator.prototype.intervalCount = function () {
+  return this.ss.size()
+}
+
+/**
+ * Dump the internal structor of the library.
+ * This function is for debugging.
+ * Time Complexity O(N) : N is the number of intervals (not numbers)
+ */
+NumberAllocator.prototype.dump = function () {
+  console.log('length:' + this.ss.size())
+  for (const element of this.ss) {
+    console.log(element)
+  }
+}
+
+module.exports = NumberAllocator

package/node_modules/number-allocator/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "number-allocator",
+  "version": "1.0.14",
+  "description": "A library for the unique number allocator",
+  "main": "index.js",
+  "types": "types/index.d.ts",
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "scripts": {
+    "test": "node_modules/.bin/nyc --reporter=lcov --reporter=text ./node_modules/mocha/bin/_mocha",
+    "pretest": "standard ./*.js ./lib/**/*.js ./test/*.js | snazzy",
+    "codecov": "codecov",
+    "browser-build": "rimraf dist/ && mkdirp dist/ && browserify index.js --standalone number-allocator > dist/number-allocator.js && uglifyjs dist/number-allocator.js --compress --mangle --output dist/number-allocator.min.js",
+    "typescript-compile-test": "tsc -p test/typescript/tsconfig.json",
+    "typescript-compile-execute": "node test/typescript/*.js",
+    "typescript-test": "npm run typescript-compile-test && npm run typescript-compile-execute",
+    "test-web": "karma start",
+    "generate-docs": "node_modules/.bin/jsdoc -d docs lib"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/redboltz/number-allocator.git"
+  },
+  "author": "Takatoshi Kondo",
+  "license": "MIT",
+  "keywords": [
+    "unique",
+    "number",
+    "id",
+    "value",
+    "allocator"
+  ],
+  "bugs": {
+    "url": "https://github.com/redboltz/number-allocator/issues"
+  },
+  "homepage": "https://github.com/redboltz/number-allocator#readme",
+  "dependencies": {
+    "debug": "^4.3.1",
+    "js-sdsl": "4.3.0"
+  },
+  "devDependencies": {
+    "airtap": "^4.0.1",
+    "browserify": "^17.0.0",
+    "chai": "^4.2.0",
+    "codecov": "^3.8.1",
+    "eslint": "^7.18.0",
+    "eslint-config-standard": "16.0.2",
+    "jsdoc": "^3.6.6",
+    "karma": "^6.0.3",
+    "karma-browserify": "^8.0.0",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-mocha": "^2.0.1",
+    "mocha": "^10.2.0",
+    "nyc": "^15.1.0",
+    "snazzy": "^9.0.0",
+    "standard": "^16.0.3",
+    "tslint": "^5.11.0",
+    "tslint-config-standard": "^9.0.0",
+    "typescript": "^4.1.3",
+    "uglify-es": "^3.3.9"
+  },
+  "standard": {
+    "env": [
+      "mocha"
+    ]
+  }
+}

package/node_modules/number-allocator/test/test.js

@@ -0,0 +1,337 @@
+// Copyright Takatoshi Kondo 2021
+//
+// Distributed under the MIT License
+
+'use strict'
+
+const NumberAllocator = require('..').NumberAllocator
+const assert = require('chai').assert
+
+describe('number-allocator', function () {
+  it('should create without number', function (done) {
+    const a = NumberAllocator(0, 0)
+    assert.equal(a.intervalCount(), 1)
+    done()
+  })
+  it('should work with one number', function (done) {
+    const a = new NumberAllocator(0, 0)
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.firstVacant(), 0)
+
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.intervalCount(), 0)
+
+    assert.equal(a.alloc(), null)
+    assert.equal(a.firstVacant(), null)
+
+    a.free(0)
+
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.intervalCount(), 0)
+
+    assert.equal(a.alloc(), null)
+
+    assert.equal(a.use(0), false)
+    assert.equal(a.use(1), false)
+    assert.equal(a.use(-1), false)
+    a.free(0)
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.use(0), true)
+    assert.equal(a.intervalCount(), 0)
+    assert.equal(a.use(1), false)
+
+    assert.equal(a.alloc(), null)
+
+    a.free(0)
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.intervalCount(), 0)
+
+    done()
+  })
+  it('should work with one number (offset)', function (done) {
+    const a = new NumberAllocator(5, 5)
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.firstVacant(), 5)
+
+    assert.equal(a.alloc(), 5)
+    assert.equal(a.intervalCount(), 0)
+
+    assert.equal(a.alloc(), null)
+    assert.equal(a.firstVacant(), null)
+
+    a.free(5)
+
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.alloc(), 5)
+    assert.equal(a.intervalCount(), 0)
+
+    assert.equal(a.alloc(), null)
+
+    assert.equal(a.use(5), false)
+    assert.equal(a.use(1), false)
+    a.free(5)
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.use(5), true)
+    assert.equal(a.intervalCount(), 0)
+    assert.equal(a.use(1), false)
+
+    assert.equal(a.alloc(), null)
+
+    a.free(5)
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.alloc(), 5)
+    assert.equal(a.intervalCount(), 0)
+
+    done()
+  })
+  it('should alloc/free work well on interval', function (done) {
+    const a = new NumberAllocator(0, 4)
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.alloc(), 1)
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.alloc(), 2)
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.alloc(), 3)
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.alloc(), 4)
+    assert.equal(a.intervalCount(), 0)
+
+    assert.equal(a.alloc(), null)
+
+    a.free(2)
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.alloc(), 2)
+    assert.equal(a.intervalCount(), 0)
+
+    done()
+  })
+  it('should use/free work well on interval', function (done) {
+    const a = new NumberAllocator(0, 4)
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.use(0), true)
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.use(4), true)
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.use(2), true)
+    assert.equal(a.intervalCount(), 2)
+    assert.equal(a.use(1), true)
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.use(3), true)
+    assert.equal(a.intervalCount(), 0)
+    assert.equal(a.use(0), false)
+    assert.equal(a.use(1), false)
+    assert.equal(a.use(2), false)
+    assert.equal(a.use(3), false)
+    assert.equal(a.use(4), false)
+    a.free(2)
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.use(2), true)
+    assert.equal(a.intervalCount(), 0)
+    done()
+  })
+  it('should clear work well and interval be updated well', function (done) {
+    const a = new NumberAllocator(0, 4)
+
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.use(1), true)
+
+    assert.equal(a.alloc(), 2)
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.use(3), true)
+
+    assert.equal(a.alloc(), 4)
+    assert.equal(a.intervalCount(), 0)
+
+    a.clear()
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.use(1), true)
+
+    assert.equal(a.alloc(), 2)
+    assert.equal(a.intervalCount(), 1)
+
+    assert.equal(a.use(3), true)
+
+    assert.equal(a.alloc(), 4)
+    assert.equal(a.intervalCount(), 0)
+
+    done()
+  })
+  it('should interval be concatinated well', function (done) {
+    const prepare = function () {
+      const a = new NumberAllocator(0, 4)
+      assert.equal(a.use(0), true)
+      assert.equal(a.use(1), true)
+      assert.equal(a.use(2), true)
+      assert.equal(a.use(3), true)
+      assert.equal(a.use(4), true)
+      return a
+    }
+
+    let a = prepare()
+    a.free(0)
+    assert.equal(a.intervalCount(), 1)
+    a.free(4)
+    assert.equal(a.intervalCount(), 2)
+    a.free(2)
+    assert.equal(a.intervalCount(), 3)
+    a.free(1)
+    assert.equal(a.intervalCount(), 2)
+    // concat left and right
+    a.free(3)
+    assert.equal(a.intervalCount(), 1)
+
+    a = prepare()
+    a.free(3)
+    assert.equal(a.intervalCount(), 1)
+    // ....v
+    // end concat right
+    a.free(4)
+    assert.equal(a.intervalCount(), 1)
+
+    a = prepare()
+    a.free(1)
+    assert.equal(a.intervalCount(), 1)
+    // begin concat left
+    a.free(0)
+    assert.equal(a.intervalCount(), 1)
+
+    a = prepare()
+    a.free(2)
+    assert.equal(a.intervalCount(), 1)
+    // begin no concat
+    a.free(0)
+    assert.equal(a.intervalCount(), 2)
+
+    a = prepare()
+    a.free(1)
+    assert.equal(a.intervalCount(), 1)
+    a.free(4)
+    assert.equal(a.intervalCount(), 2)
+    // concat left
+    a.free(2)
+    assert.equal(a.intervalCount(), 2)
+
+    a = prepare()
+    a.free(4)
+    assert.equal(a.intervalCount(), 1)
+    a.free(1)
+    assert.equal(a.intervalCount(), 2)
+    // concat right
+    a.free(3)
+    assert.equal(a.intervalCount(), 2)
+
+    done()
+  })
+  it('should work well with negative numbers', function (done) {
+    const a = new NumberAllocator(-2, 3)
+    assert.equal(a.intervalCount(), 1)
+    assert.equal(a.use(2), true)
+    assert.equal(a.intervalCount(), 2)
+
+    const value = a.alloc()
+    assert.notEqual(value, null)
+    assert.equal(value, -2)
+    assert.equal(a.intervalCount(), 2)
+
+    assert.equal(a.use(0), true)
+    assert.equal(a.intervalCount(), 3)
+
+    done()
+  })
+  it('should dump', function (done) {
+    const a = new NumberAllocator(0, 4)
+    a.dump()
+    assert.equal(a.use(0), true)
+    a.dump()
+    assert.equal(a.use(1), true)
+    a.dump()
+    assert.equal(a.use(2), true)
+    a.dump()
+    a.free(0)
+    a.dump()
+    a.free(2)
+    a.dump()
+    a.free(1)
+    a.dump()
+    done()
+  })
+  it('should fail use the same number twice in the middle of interval', function (done) {
+    const a = new NumberAllocator(0, 4)
+    assert.equal(a.use(1), true)
+    assert.equal(a.use(1), false)
+    done()
+  })
+  it('should do nothing non allocated free', function (done) {
+    const a = NumberAllocator(0, 1)
+    // if DEBUG="nuber-allocator:error" then output error log
+    a.free(0)
+    a.free(1)
+    a.free(5)
+    done()
+  })
+  it('should concat to right on free', function (done) {
+    const a = NumberAllocator(0, 3)
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.alloc(), 1)
+    a.free(1)
+    assert.equal(a.alloc(), 1)
+    done()
+  })
+  it('should concat to left on free', function (done) {
+    const a = NumberAllocator(0, 3)
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.alloc(), 1)
+    assert.equal(a.alloc(), 2)
+    a.free(0)
+    a.free(1)
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.alloc(), 1)
+    done()
+  })
+  it('should concat to left and right on free', function (done) {
+    const a = NumberAllocator(0, 3)
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.alloc(), 1)
+    assert.equal(a.alloc(), 2)
+    a.free(0)
+    a.free(2)
+    a.free(1)
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.alloc(), 1)
+    assert.equal(a.alloc(), 2)
+    done()
+  })
+  it('should insert new interval on free', function (done) {
+    const a = NumberAllocator(0, 4)
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.alloc(), 1)
+    assert.equal(a.alloc(), 2)
+    assert.equal(a.alloc(), 3)
+    assert.equal(a.alloc(), 4)
+    a.free(0)
+    a.free(4)
+    a.free(2)
+    assert.equal(a.alloc(), 0)
+    assert.equal(a.alloc(), 2)
+    assert.equal(a.alloc(), 4)
+    done()
+  })
+})

package/node_modules/number-allocator/test/typescript/test.ts

@@ -0,0 +1,24 @@
+import { NumberAllocator } from '../..'
+
+const a: NumberAllocator = new NumberAllocator(1, 5)
+
+const num1: Number | null = a.firstVacant()
+console.log(num1)
+
+const num2: Number | null = a.alloc()
+console.log(num2)
+
+const ret: Boolean = a.use(3)
+console.log(ret)
+
+a.free(2)
+
+const ic1: Number = a.intervalCount()
+console.log(ic1)
+
+a.dump()
+
+a.clear()
+
+const ic2: Number = a.intervalCount()
+console.log(ic2)

package/node_modules/number-allocator/test/typescript/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "moduleResolution": "node",
+    "noEmitOnError": true,
+    "noImplicitAny": true,
+    "alwaysStrict": true,
+    "strictNullChecks": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "sourceMap": true
+  }
+}

package/node_modules/number-allocator/types/index.d.ts

@@ -0,0 +1 @@
+export { NumberAllocator } from './lib/number-allocator'