node-pkware 1.0.2 → 3.0.0

package/src/helpers/functions.js

@@ -1,150 +0,0 @@
-const fs = require('fs')
-const { repeat, test, type } = require('ramda')
-
-const isNumber = (x) => {
-  return typeof x === 'number'
-}
-
-const isString = (x) => {
-  return typeof x === 'string'
-}
-
-const isFunction = (x) => {
-  return type(x) === 'Function'
-}
-
-const noop = () => {}
-
-// https://stackoverflow.com/a/68989785/1806628
-const isPlainObject = (x) => {
-  return x.constructor === Object
-}
-
-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 => {
-      return 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 = {
-  isNumber,
-  isString,
-  isFunction,
-  noop,
-  isPlainObject,
-  isBetween,
-  nBitsOfOnes,
-  maskBits,
-  getLowestNBits,
-  isFullHexString,
-  toHex,
-  mergeSparseArrays,
-  parseNumberString,
-  getPackageVersion,
-  fileExists,
-}

package/src/helpers/stream.js

@@ -1,190 +0,0 @@
-const { Transform, Writable } = require('stream')
-const { promisify } = require('util')
-const ExpandingBuffer = require('./ExpandingBuffer.js')
-const { isFunction } = require('./functions.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

@@ -1,80 +0,0 @@
-// 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 = () => {
-  return (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,
-}