node-pkware 0.7.0 → 1.0.0-alpha.1

package/src/helpers/functions.js

@@ -0,0 +1,125 @@
+const fs = require('fs')
+const { repeat, test } = require('ramda')
+const { isNumber, isString } = require('ramda-adjunct')
+
+const isBetween = (min, max, num) => {
+  if (!isNumber(min) || !isNumber(max) || !isNumber(num)) {
+    return null
+  }
+  if (min > max) {
+    ;[min, max] = [max, min]
+  }
+
+  return num >= min && num <= max
+}
+
+const nBitsOfOnes = numberOfBits => {
+  if (!Number.isInteger(numberOfBits) || numberOfBits < 0) {
+    return null
+  }
+  return (1 << numberOfBits) - 1
+}
+
+const maskBits = (numberOfBits, number) => {
+  const bits = nBitsOfOnes(numberOfBits)
+  if (bits === null) {
+    return null
+  }
+  if (!Number.isInteger(number) || number < 0) {
+    return null
+  }
+  return number & nBitsOfOnes(numberOfBits)
+}
+
+const getLowestNBits = (numberOfBits, number) => {
+  return number & nBitsOfOnes(numberOfBits)
+}
+
+const isDecimalString = test(/^\d+$/)
+
+const isFullHexString = str => {
+  if (isString(str)) {
+    return /^\s*0x[0-9a-f]+\s*$/.test(str)
+  } else {
+    return false
+  }
+}
+
+const toHex = (num, digits = 0, withoutPrefix = false) => {
+  const prefix = withoutPrefix ? '' : '0x'
+  if (!Number.isInteger(digits) || digits < 0) {
+    return null
+  }
+  if (isFullHexString(num)) {
+    const number = num.trim().replace(/^0x0*/, '')
+    return `${prefix}${number.padStart(digits, '0')}`
+  }
+  if (!Number.isInteger(num)) {
+    return null
+  }
+  return `${prefix}${num.toString(16).padStart(digits, '0')}`
+}
+
+const mergeSparseArrays = (a, b) => {
+  if (!Array.isArray(a) || !Array.isArray(b)) {
+    return []
+  }
+
+  const result = [...b, ...(b.length < a.length ? repeat(undefined, a.length - b.length) : [])]
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== undefined) {
+      result[i] = a[i]
+    }
+  }
+  return result
+}
+
+/*
+export const dumpBytes = bytes => {
+  const formattedBytes = Array.from(bytes)
+    .map(byte => toHex(byte, 2, true))
+    .join(' ')
+  return `<${formattedBytes}>`
+}
+*/
+
+const parseNumberString = (n, defaultValue = 0) => {
+  if (isDecimalString(n)) {
+    return parseInt(n)
+  } else if (isFullHexString(n)) {
+    return parseInt(n.replace(/^0x/, ''), 16)
+  } else {
+    return defaultValue
+  }
+}
+
+const getPackageVersion = async () => {
+  try {
+    const { version } = require('../../package.json')
+    return version
+  } catch (error) {
+    return 'unknown'
+  }
+}
+
+const fileExists = async filename => {
+  try {
+    await fs.promises.access(filename, fs.constants.R_OK)
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+module.exports = {
+  isBetween,
+  nBitsOfOnes,
+  maskBits,
+  getLowestNBits,
+  isFullHexString,
+  toHex,
+  mergeSparseArrays,
+  parseNumberString,
+  getPackageVersion,
+  fileExists
+}

package/src/helpers/stream.js

@@ -0,0 +1,190 @@
+const { Transform, Writable } = require('stream')
+const { promisify } = require('util')
+const { isFunction } = require('ramda-adjunct')
+const ExpandingBuffer = require('./ExpandingBuffer.js')
+
+const emptyBuffer = Buffer.from([])
+
+class QuasiTransform {
+  constructor(handler) {
+    this.handler = handler
+  }
+
+  handle(chunk, encoding) {
+    return promisify(this.handler).call(this, chunk, encoding)
+  }
+}
+
+const splitAt = index => {
+  let cntr = 0
+
+  if (!Number.isInteger(index) || index < 0) {
+    return () => {
+      return null
+    }
+  }
+
+  return chunk => {
+    let left
+    let right
+    let isLeftDone = true
+
+    if (!Buffer.isBuffer(chunk)) {
+      return null
+    }
+
+    if (index <= cntr) {
+      // index ..... cntr ..... chunk.length
+      left = emptyBuffer
+      right = chunk
+    } else if (index >= cntr + chunk.length) {
+      // cntr ..... chunk.length ..... index
+      left = chunk
+      right = emptyBuffer
+      isLeftDone = index === cntr + chunk.length
+    } else {
+      // cntr ..... index ..... chunk.length
+      left = chunk.slice(0, index - cntr)
+      right = chunk.slice(index - cntr)
+    }
+
+    cntr += chunk.length
+
+    return [left, right, isLeftDone]
+  }
+}
+
+const transformIdentity = () => {
+  return function (chunk, encoding, callback) {
+    callback(null, chunk)
+  }
+}
+
+const transformEmpty = () => {
+  return function (chunk, encoding, callback) {
+    callback(null, emptyBuffer)
+  }
+}
+
+const through = handler => {
+  return new Transform({
+    transform: handler
+  })
+}
+
+const transformSplitBy = (predicate, leftHandler, rightHandler) => {
+  let isFirstChunk = true
+  let wasLeftFlushCalled = false
+  const damChunkSize = 0x10000
+  const dam = new ExpandingBuffer()
+
+  const leftTransform = new QuasiTransform(leftHandler)
+  const rightTransform = new QuasiTransform(rightHandler)
+
+  return function (chunk, encoding, callback) {
+    const [left, right, isLeftDone] = predicate(chunk)
+
+    const _left = leftTransform.handle(left, encoding)
+    const _right = rightTransform.handle(right, encoding)
+
+    if (isFirstChunk) {
+      isFirstChunk = false
+      this._flush = flushCallback => {
+        if (!dam.isEmpty()) {
+          this.push(dam.read())
+        }
+
+        let leftFiller = Promise.resolve(emptyBuffer)
+        let rightFiller = Promise.resolve(emptyBuffer)
+
+        if (!wasLeftFlushCalled && isFunction(leftTransform._flush)) {
+          leftFiller = new Promise((resolve, reject) => {
+            leftTransform._flush((err, data) => {
+              if (err) {
+                reject(err)
+              } else {
+                resolve(data)
+              }
+            })
+          })
+        }
+
+        if (isFunction(rightTransform._flush)) {
+          rightFiller = new Promise((resolve, reject) => {
+            rightTransform._flush((err, data) => {
+              if (err) {
+                reject(err)
+              } else {
+                resolve(data)
+              }
+            })
+          })
+        }
+
+        Promise.all([leftFiller, rightFiller])
+          .then(buffers => {
+            flushCallback(null, Buffer.concat(buffers))
+          })
+          .catch(err => {
+            flushCallback(err)
+          })
+      }
+    }
+
+    let filler = Promise.resolve(emptyBuffer)
+    if (isLeftDone && !wasLeftFlushCalled && isFunction(leftTransform._flush)) {
+      wasLeftFlushCalled = true
+      filler = new Promise((resolve, reject) => {
+        leftTransform._flush((err, data) => {
+          if (err) {
+            reject(err)
+          } else {
+            resolve(data)
+          }
+        })
+      })
+    }
+
+    Promise.all([_left, filler, _right])
+      .then(buffers => {
+        dam.append(Buffer.concat(buffers))
+        if (dam.size() > damChunkSize) {
+          const chunks = Math.floor(dam.size() / damChunkSize)
+          const data = Buffer.from(dam.read(0, chunks * damChunkSize))
+          dam.flushStart(chunks * damChunkSize)
+          for (let i = 0; i < chunks - 1; i++) {
+            this.push(data.slice(i * damChunkSize, i * damChunkSize + damChunkSize))
+          }
+          callback(null, data.slice((chunks - 1) * damChunkSize))
+        } else {
+          callback(null, emptyBuffer)
+        }
+      })
+      .catch(err => {
+        callback(err)
+      })
+  }
+}
+
+const streamToBuffer = done => {
+  const buffer = new ExpandingBuffer()
+  return new Writable({
+    write(chunk, encoding, callback) {
+      buffer.append(chunk)
+      callback()
+    },
+    final(callback) {
+      done(buffer.getHeap())
+      callback()
+    }
+  })
+}
+
+module.exports = {
+  splitAt,
+  transformIdentity,
+  transformEmpty,
+  through,
+  transformSplitBy,
+  streamToBuffer
+}

package/src/helpers/testing.js

@@ -0,0 +1,78 @@
+// const { EOL } = require('os')
+// const fs = require('fs')
+const assert = require('assert')
+const { compare, report } = require('binary-comparator')
+
+/*
+const isPromise = promise => {
+  return typeof promise === 'object' && promise.constructor.name === 'Promise'
+}
+
+const toConsole = () => (chunk, encoding, callback) => {
+  process.stdout.write(chunk)
+  process.stdout.write(Buffer.from(EOL))
+  callback(null, chunk)
+}
+
+const readToBuffer = (fileName, chunkSizeInBytes = 1024) => {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    fs.createReadStream(fileName, { highWaterMark: chunkSizeInBytes })
+      .on('error', reject)
+      .on('data', chunk => {
+        chunks.push(chunk)
+      })
+      .on('end', function () {
+        resolve(Buffer.concat(chunks))
+      })
+  })
+}
+*/
+
+// source: https://stackoverflow.com/a/43197340/1806628
+const isClass = obj => {
+  const isCtorClass = obj.constructor && obj.constructor.toString().substring(0, 5) === 'class'
+  if (obj.prototype === undefined) {
+    return isCtorClass
+  }
+  const isPrototypeCtorClass =
+    obj.prototype.constructor &&
+    obj.prototype.constructor.toString &&
+    obj.prototype.constructor.toString().substring(0, 5) === 'class'
+  return isCtorClass || isPrototypeCtorClass
+}
+
+// https://stackoverflow.com/a/48845122/1806628
+const bufferToString = (buffer, limit = 20) => {
+  const ellipsisNecessary = buffer.length > limit
+  let hexString = buffer.slice(0, limit).toString('hex')
+  hexString = hexString.length > 2 ? hexString.match(/../g).join(' ') : hexString
+  return `<Buffer ${hexString}${ellipsisNecessary ? '...' : ''}>`
+}
+
+const buffersShouldEqual = (expected, result, offset = 0, displayAsHex = false) => {
+  if (!Buffer.isBuffer(expected)) {
+    throw new Error('expected is not a Buffer')
+  }
+
+  if (!Buffer.isBuffer(result)) {
+    throw new Error('result is not a Buffer')
+  }
+
+  const diff = report(expected, result, compare(expected, result, offset), displayAsHex)
+  assert.ok(expected.equals(result), diff)
+}
+
+const transformToABC = () => {
+  let cntr = 0
+  return function (chunk, encoding, callback) {
+    callback(null, Buffer.from([65 + (cntr++ % 26)]))
+  }
+}
+
+module.exports = {
+  isClass,
+  buffersShouldEqual,
+  bufferToString,
+  transformToABC
+}