@nxtedition/lib 28.0.3 → 28.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "28.0.3",
+  "version": "28.0.6",
   "license": "UNLICENSED",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -92,5 +92,5 @@
     "pino": ">=7.0.0",
     "rxjs": "^7.0.0"
   },
-  "gitHead": "15f4fd00f86a558ae56672b1efa3e909b23feb3f"
+  "gitHead": "008526f8d31968edaa2e642998deaa3880a34bb8"
 }

package/sequence.js

@@ -1,4 +1,5 @@
 import assert from 'node:assert'
+import util from 'node:util'
 
 export const ID_SEP = '~'
 
@@ -25,14 +26,14 @@ export class Sequence {
   #identity
   #count = 0
 
-  // TODO (perf): Optimize
   /**
    *
    * @param {string|Sequence|null|undefined} a
    * @param {string|Sequence|null|undefined} b
    * @param {boolean} [strict=true]
-   * @returns
+   * @returns {-1|0|1}
    */
+  /** @deprecated */
   static compare(a, b, strict) {
     if (!a && !b) {
       return 0
@@ -46,17 +47,28 @@ export class Sequence {
       return -1
     }
 
-    if (a && typeof a === 'string') {
-      a = new Sequence(a)
+    if (a === b) {
+      return 0
     }
 
-    if (typeof b === 'string') {
-      b = new Sequence(b)
+    if (typeof a === 'string') {
+      a = new Sequence(a)
     }
 
     return a.compare(b, strict)
   }
 
+  /**
+   *
+   * @param {string|Sequence|null|undefined} a
+   * @param {string|Sequence|null|undefined} b
+   * @param {boolean} [strict=true]
+   * @returns {boolean}
+   */
+  static has(a, b, strict) {
+    return Sequence.compare(a, b, strict) >= 0
+  }
+
   /**
    *
    * @param {string} seq
@@ -74,6 +86,10 @@ export class Sequence {
     }
   }
 
+  /**
+   * @param {null|undefined|string|Sequence|Array<string|number|{id:string,sequence:number}>>} value
+   * @param {null|undefined|number|Array<string|{id:string}>>} [identity]
+   */
   constructor(value, identity) {
     try {
       if (!value) {
@@ -173,6 +189,9 @@ export class Sequence {
     }
   }
 
+  /**
+   * @returns {number}
+   */
   get identity() {
     if (this.#identity == null) {
       if (this.#parts.length === 0) {
@@ -189,6 +208,9 @@ export class Sequence {
     return this.#identity
   }
 
+  /**
+   * @returns {number}
+   */
   get count() {
     if (this.#count == null) {
       let count = 0
@@ -200,18 +222,45 @@ export class Sequence {
     return this.#count
   }
 
+  /**
+   * @returns {number}
+   */
   get length() {
     return this.#parts.length / 2
   }
 
+  /**
+   * @param {number} index
+   * @returns {number}
+   */
   at(index) {
-    assert(Number.isFinite(index) && index >= 0 && index * 2 < this.#parts.length)
+    if (!Number.isInteger(index)) {
+      throw new TypeError('index must be an integer')
+    }
+    if (index < 0 || index >= this.#parts.length / 2) {
+      throw new RangeError('index out of range')
+    }
+
     return this.#parts[index * 2 + 1]
   }
 
+  /**
+   * @param {number} index
+   * @param {number} sequence
+   */
   set(index, sequence) {
-    assert(Number.isFinite(index) && index >= 0 && index < this.#parts.length)
-    assert(Number.isFinite(sequence) && sequence >= 0)
+    if (!Number.isInteger(index)) {
+      throw new TypeError('index must be an integer')
+    }
+    if (index < 0 || index >= this.#parts.length / 2) {
+      throw new RangeError('index out of range')
+    }
+    if (!Number.isInteger(sequence)) {
+      throw new TypeError('sequence must be an integer')
+    }
+    if (sequence < 0) {
+      throw new RangeError('sequence must be non-negative')
+    }
     if (this.#parts[index * 2 + 1] !== sequence) {
       this.#parts[index * 2 + 1] = sequence
       this.#value = ''
@@ -219,16 +268,29 @@ export class Sequence {
     }
   }
 
+  /** @deprecated */
   compare(other, strict) {
     if (strict === undefined) {
       strict = true
     }
 
-    assert(other instanceof Sequence)
-    assert(typeof strict === 'boolean')
+    if (typeof other === 'string') {
+      if (this.#value && this.#value === other) {
+        return 0
+      }
+      other = new Sequence(other)
+    }
 
-    if (strict && other.identity && this.identity) {
-      assert.strictEqual(other.identity, this.identity)
+    if (!(other instanceof Sequence)) {
+      throw new TypeError('Can only compare with another Sequence')
+    }
+
+    if (typeof strict !== 'boolean') {
+      throw new TypeError('strict must be a boolean')
+    }
+
+    if (strict && (other.identity || this.identity) && other.identity !== this.identity) {
+      throw new Error('Cannot compare sequences with different identities')
     }
 
     if (this.#parts.length !== other.#parts.length) {
@@ -244,6 +306,19 @@ export class Sequence {
     return 0
   }
 
+  /**
+   *
+   * @param {string|Sequence|null|undefined} other
+   * @param {boolean} [strict=true]
+   * @returns {boolean}
+   */
+  has(other, strict = true) {
+    return this.compare(other, strict) >= 0
+  }
+
+  /**
+   * @returns {string}
+   */
   toString() {
     if (!this.#value) {
       let count = 0
@@ -256,4 +331,18 @@ export class Sequence {
     }
     return this.#value
   }
+
+  /**
+   * @returns {string}
+   */
+  [Symbol.toStringTag]() {
+    return this.toString()
+  }
+
+  /**
+   * @returns {string}
+   */
+  [util.inspect.custom](depth, options, inspect) {
+    return `Sequence: "${this.toString()}"`
+  }
 }

package/slice.js

@@ -60,6 +60,22 @@ export class Slice {
       maxByteLength = byteLength
     }
 
+    if (byteOffset < 0) {
+      throw new RangeError('byteOffset must be non-negative')
+    }
+
+    if (byteLength < 0) {
+      throw new RangeError('byteLength must be non-negative')
+    }
+
+    if (byteLength > maxByteLength) {
+      throw new RangeError('byteLength cannot be greater than maxByteLength')
+    }
+
+    if (byteOffset + maxByteLength > buffer.byteLength) {
+      throw new RangeError('Slice exceeds buffer length')
+    }
+
     const slice = POOL.pop()
 
     if (slice) {