ac-byteconverter 1.0.3

package/.acsemver.js

@@ -0,0 +1,9 @@
+module.exports = {
+  repository: {
+    url: 'https://github.com/mmpro/ac-byteconverter'
+  },
+  changelogFile: __dirname + '/CHANGELOG.md',
+  sections: [
+    {name: 'App' }
+  ],
+}

package/.eslintrc.js

@@ -0,0 +1,26 @@
+const config = {
+  'env': {
+    'commonjs': true,
+    'es6': true,
+    'node': true
+  },
+  'extends': 'eslint:recommended',
+  "rules": {
+    "space-before-function-paren": 0,
+    "no-extra-semi": 0,
+    "object-curly-spacing": ["error", "always"],
+    "brace-style": ["error", "stroustrup", { "allowSingleLine": true }],
+    "no-useless-escape": 0,
+    "standard/no-callback-literal": 0,
+    "new-cap": 0
+  },
+  globals: {
+    describe: true,
+    it: true
+  },
+  'parserOptions': {
+    'ecmaVersion': 2018
+},
+}
+
+module.exports = config

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+<a name="1.0.3"></a>
+
+## [1.0.3](https://github.com/mmpro/ac-byteconverter/compare/v1.0.2..v1.0.3) (2021-10-09 09:39:20)
+
+
+### Bug Fix
+
+* **App:** Package updates | MP | [05f7221570a83779a9f5ede5afa97eaaad8dd825](https://github.com/mmpro/ac-byteconverter/commit/05f7221570a83779a9f5ede5afa97eaaad8dd825)    
+Package updates
+### Chores
+
+* **App:** Updated packages | MP | [d0a043433e5cc4fceb3b52dd6d84d4b949eed62f](https://github.com/mmpro/ac-byteconverter/commit/d0a043433e5cc4fceb3b52dd6d84d4b949eed62f)    
+Updated packages
+* **App:** Updated packages | MP | [5d75c8f618b0458f70764d5bd3bb29f3d89ac720](https://github.com/mmpro/ac-byteconverter/commit/5d75c8f618b0458f70764d5bd3bb29f3d89ac720)    
+Updated packages
+<a name="1.0.2"></a>
+
+## [1.0.2](https://github.com/mmpro/ac-byteconverter/compare/v1.0.1..v1.0.2) (2020-08-16 06:12:24)
+
+
+### Bug Fix
+
+* **App:** Force patch release after version upgrade | MP | [81202a648c5e417d7daecf17e1425c60716218a9](https://github.com/mmpro/ac-byteconverter/commit/81202a648c5e417d7daecf17e1425c60716218a9)    
+Force patch release after version upgrade
+<a name="1.0.1"></a>
+
+## [1.0.1](https://github.com/mmpro/ac-byteconverter/compare/v1.0.0..v1.0.1) (2020-03-29 14:18:08)
+
+
+### Bug Fix
+
+* **App:** Prepare repository for AC semantic release | MP | [ba90dac90e87f0fa48adc7cf4664baad530ec76d](https://github.com/mmpro/ac-byteconverter/commit/ba90dac90e87f0fa48adc7cf4664baad530ec76d)    
+Cleaned up repository and use ac-semantic-release
+<a name="1.0.0"></a>
+# 1.0.0 (2019-08-04 06:40)
+
+
+### Bug Fixes
+
+* **App:** Updated packages and use semver | MP ([79f5264](https://github.com/mmpro/ac-byteconverter/commit/79f5264))    
+  We now use release management
+
+
+

package/Makefile

@@ -0,0 +1,17 @@
+MOCHA_OPTS= --slow 0 -A
+REPORTER = spec
+
+lint-fix:
+	./node_modules/.bin/eslint --fix index.js test/test.js
+
+lint-check:
+	./node_modules/.bin/eslint index.js test/test.js
+
+commit:
+	@node ./node_modules/ac-semantic-release/lib/commit.js
+
+release:
+	@node ./node_modules/ac-semantic-release/lib/release.js
+
+
+.PHONY: check

package/README.md

@@ -0,0 +1,50 @@
+# AC ByteConverter
+This tool converts bytes into units like kB (Kilo byte) or KiB (Kibibytes)
+
+## Usage
+
+***byteConverter.format(value, [unit], [options])***
+
+Converts a value in bytes to a human-readable value.
+
++ value -> bytes (NUMBER) to converts
++ unit -> optional unit (STRING) to convert bytes to (e.g. MB, MiB). If not set, will be auto-detected based on the value (e.g. 10000 will be converted to 10kB)
++ options -> optional object with options
+  + system -> can be "si" or "iec", defaults to si
+  + decimals -> number of decimals to show, defaults to 2
+
+
+***byteConverter.parse(value, [options])***
+
+Converts a human readable value into bytes.
+
++ value -> human readable value (STRING) to convert to bytes
++ options -> optional object with options
+  + system -> can be "si" or "iec", will be auto-detected
+  + decimals -> number of decimals to show, defaults to 2
+
+
+## Examples
+
+```
+const byteConverter = require('ac-byteConverter')
+
+// convert 1000 to 1kb
+byteConverter.format(1000)
+
+// convert 1 MB to 1000000 bytes
+byteConverter.parse('1MB')
+// 1000000
+
+// convert 1 Mebibyte to 1048576 bytes
+byteConverter.parse('1MiB')
+// 1048576
+
+```
+## License
+
+MIT
+
+## Current issues/infos
+2018-07-30 
+We are using this fork mmpro/mocha-jenkins-reporter until the packages has been fixed (outdated version is 0.3.12)

package/index.js

@@ -0,0 +1,168 @@
+const _ = require('lodash')
+
+const byteConverter = function() {
+  const valueMap = [
+    { exp: 0, si: 'B', iec: 'b', iecExp: 1 },
+    { exp: 3, si: 'kB', iec: 'KiB', iecExp: 10 },
+    { exp: 6, si: 'MB', iec: 'MiB', iecExp: 20 },
+    { exp: 9, si: 'GB', iec: 'GiB', iecExp: 30 },
+    { exp: 12, si: 'TB', iec: 'TiB', iecExp: 40 },
+    { exp: 15, si: 'PB', iec: 'PiB', iecExp: 50 },
+    { exp: 18, si: 'EB', iec: 'EiB', iecExp: 60 },
+    { exp: 21, si: 'ZB', iec: 'ZiB', iecExp: 70 },
+    { exp: 24, si: 'YB', iec: 'YiB', iecExp: 80 }
+  ]
+
+  /**
+   * Converts value into unit.
+   * If unit is not given, try to determine based on power of ten
+   * @param value FLOAT byte value
+   */
+  const format = function(value, unit, options) {
+    if (_.isNil(value)) {
+      return { message: 'valueRequired' }
+    }
+
+    if (!_.isNumber(value)) {
+      return { message: 'valueMustBeANumber' }
+    }
+
+    // return 0 value as 0
+    if (value === 0) {
+      return value.toString()
+    }
+
+    if (_.isObject(unit)) {
+      options = unit
+      unit = null
+    }
+
+    // define default options
+    options = options || {}
+    if (!_.get(options, 'system')) {
+      // detect system (check if there is an i)
+      if (unit && _.endsWith(unit, 'iB')) {
+        _.set(options, 'system', 'iec')
+      }
+      else {
+        _.set(options, 'system', 'si')
+      }
+    }
+
+    let base = 10
+
+    if (_.get(options, 'system') === 'iec') {
+      base = 2
+    }
+
+    let map
+
+    if (!unit) {
+      const autoDetectRegex = /(\d.*\+)(\d{1,2})/
+      const autoDetect = value.toExponential() // 5.079899957e+9
+      const expArray = autoDetect.match(autoDetectRegex)
+      const exp = Math.floor(parseInt(_.get(expArray, '[2]')) / 3) * 3
+      map = _.find(valueMap, { exp: exp })
+      unit = _.get(map, _.get(options, 'system'))
+    }
+    else {
+      if (_.get(options, 'system') === 'iec') {
+        map = _.find(valueMap, { iec: unit })
+      }
+      else {
+        map = _.find(valueMap, { si: unit })
+      }
+    }
+
+    if (!map) {
+      return { message: 'unitInvalid' }
+    }
+
+    // convert
+    let exp = _.get(map, 'exp')
+
+    if (_.get(options, 'system') === 'iec') {
+      exp = _.get(map, 'iecExp')
+    }
+
+    const divider = Math.pow(base, exp)
+    value = _.round(value / divider, _.get(options, 'decimals', 2))
+
+    return value + unit
+  }
+
+  /**
+   * Ingests a "human readable" value and returns value in bytes
+   * If you send a non-string value, the value is just returned
+   */
+  const parse = function(value, options) {
+    if (_.isNil(value)) {
+      return { message: 'valueRequired' }
+    }
+
+    if (_.isNumber(value)) {
+      return value
+    }
+
+    if (!_.isString(value)) {
+      return { message: 'valueMustBeAString' }
+    }
+
+    const regex = /([0-9.]*)(\D*)/
+    const res = value.match(regex) // 1KiB
+    const orgValue = _.trim(res[1])
+    const unit = _.trim(res[2])
+
+    // return zero value ('0' -> 0)
+    if (_.parseInt(orgValue) === 0) {
+      return _.parseInt(orgValue)
+    }
+
+    options = options || {}
+
+    if (!_.get(options, 'system')) {
+      if (_.endsWith(unit, 'iB')) {
+        _.set(options, 'system', 'iec')
+      }
+      else {
+        _.set(options, 'system', 'si')
+      }
+    }
+
+    let map
+
+    if (_.get(options, 'system') === 'iec') {
+      map = _.find(valueMap, { iec: unit })
+    }
+    else {
+      map = _.find(valueMap, { si: unit })
+    }
+
+    if (!map) {
+      return { message: 'unitInvalid' }
+    }
+
+    let exp = _.get(map, 'exp')
+
+    if (_.get(options, 'system') === 'iec') {
+      exp = _.get(map, 'iecExp')
+    }
+
+    let base = 10
+
+    if (_.get(options, 'system') === 'iec') {
+      base = 2
+    }
+
+    const byteValue = orgValue * Math.pow(base, exp)
+
+    return byteValue
+  }
+
+  return {
+    format: format,
+    parse: parse
+  }
+}
+
+module.exports = byteConverter()

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "ac-byteconverter",
+  "author": "Mark Poepping (https://www.mmpro.de)",
+  "license": "MIT",
+  "repository": "mmpro/ac-byteconverter",
+  "version": "1.0.3",
+  "dependencies": {
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "ac-semantic-release": "^0.2.6",
+    "eslint": "^7.32.0",
+    "expect": "^27.2.5",
+    "mocha": "^9.1.2"
+  },
+  "scripts": {
+    "test": "mocha --reporter spec"
+  },
+  "engines": {
+    "node": ">=10.0.0"
+  }
+}

package/test/test.js

@@ -0,0 +1,95 @@
+const _ = require('lodash')
+const expect = require('expect')
+const byteConverter = require('../index')
+
+const formatTests = [
+  { name: '10 bytes', value: 10, expected: '10B' },
+  { name: '1.000 bytes to kb', value: 1000, expected: '1kB' },
+  { name: '1.000.000 bytes to MB', value: 1e6, expected: '1MB' },
+  { name: '1.000.000.000 bytes to GB', value: 1e9, expected: '1GB' },
+  { name: '1.000.000.000.000 bytes to TB', value: 1e12, expected: '1TB' },
+  { name: '1024 bytes to KiB', value: 1024, expected: '1KiB', options: { system: 'iec' } },
+  { name: '2^20 bytes to 1 MiB', value: Math.pow(2, 20), expected: '1MiB', options: { system: 'iec' } },
+  { name: '2^30 bytes to 1 GiB', value: Math.pow(2, 30), expected: '1GiB', options: { system: 'iec' } },
+  { name: '2^40 bytes to 1 TiB', value: Math.pow(2, 40), expected: '1TiB', options: { system: 'iec' } },
+  { name: '1GB as 1000MB', value: 1e9, expected: '1000MB', unit: 'MB' },
+  { name: '1GB as 0.001TB', value: 1e9, expected: '0.001TB', unit: 'TB', options: { decimals: 3 } },
+  { name: '1GB as 0TB with default decimals', value: 1e9, expected: '0TB', unit: 'TB' },
+  { name: '2.5e6 as 2.5MB', value: 2.5e6, expected: '2.5MB' },
+  { name: '53.687.091.200 as 50GiB', value: 53687091200, expected: '50GiB', options: { system: 'iec' } }
+
+]
+
+const parseTests = [
+  { name: '1MB to 1e6 bytes', value: '1MB', expected: 1e6 },
+  { name: '1MB to 1e6 bytes with space', value: '1 MB', expected: 1e6 },
+  { name: '100MB to 1e8 bytes with space', value: '100 MB', expected: 1e8 },
+  { name: '1GB to 1e9 bytes', value: '1GB', expected: 1e9 },
+  { name: '1TB to 1e12 bytes', value: '1TB', expected: 1e12 },
+  { name: '50GiB to 53.687.091.200 bytes', value: '50GiB', expected: 53687091200 },
+  { name: 'Parse float value 1.5MB to 1.5e6', value: '1.5MB', expected: 1.5e6 }
+]
+
+const errorFormatTests = [
+  { name: 'no value - error that value is required', value: null, expected: { message: 'valueRequired' } },
+  { name: 'invalid value', value: '1ABB', expected: { message: 'valueMustBeANumber' } },
+  { name: 'non existing unit - try 1000 in ABB', value: 1000, unit: 'ABB', expected: { message: 'unitInvalid' } },
+  { name: 'value as array', value: [1000, '1AABB'], expected: { message: 'valueMustBeANumber' } }
+]
+
+const errorParseTests = [
+  { name: 'no value - error that value is required', value: null, expected: { message: 'valueRequired' } },
+  { name: 'invalid value 1ABB', value: '1ABB', expected: { message: 'unitInvalid' } },
+  { name: 'invalid value 1KB', value: '1KB', expected: { message: 'unitInvalid' } },
+  { name: 'invalid value FAIL', value: 'FAIL', expected: { message: 'unitInvalid' } },
+  { name: 'value without unit', value: 1000, expected: 1000 },
+  { name: 'value as array', value: [1000, '1AABB'], expected: { message: 'valueMustBeAString' } }
+]
+
+describe('TESTING byteConversion', function () {
+  describe('FORMAT Tests', function() {
+    _.forEach(formatTests, (test) => {
+      it(test.name, function(done) {
+        let options = _.get(test, 'options', {})
+        let unit = _.get(test, 'unit')
+        let r = byteConverter.format(test.value, unit, options)
+        expect(r).toEqual(test.expected)
+        return done()
+      })
+    })
+  })
+
+  describe('PARSE Tests', function() {
+    _.forEach(parseTests, (test) => {
+      it(test.name, function(done) {
+        let options = _.get(test, 'options', {})
+        let r = byteConverter.parse(test.value, options)
+        expect(r).toEqual(test.expected)
+        return done()
+      })
+    })
+  })
+
+  describe('ERROR FORMAT Tests', function() {
+    _.forEach(errorFormatTests, (test) => {
+      it(test.name, function(done) {
+        let options = _.get(test, 'options', {})
+        let unit = _.get(test, 'unit')
+        let r = byteConverter.format(test.value, unit, options)
+        expect(r).toEqual(test.expected)
+        return done()
+      })
+    })
+  })
+
+  describe('ERROR PARSE Tests', function() {
+    _.forEach(errorParseTests, (test) => {
+      it(test.name, function(done) {
+        let options = _.get(test, 'options', {})
+        let r = byteConverter.parse(test.value, options)
+        expect(r).toEqual(test.expected)
+        return done()
+      })
+    })
+  })
+})