@bpanel/bpanel-utils/dist/helpers.js

Utilities for bpanel

'use strict';

exports.__esModule = true;
exports.preventDefault = exports.safeSet = exports.camelize = exports.now = undefined;

var _stringify = require('babel-runtime/core-js/json/stringify');

var _stringify2 = _interopRequireDefault(_stringify);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

exports.getHash = getHash;
exports.isU8 = isU8;
exports.isU16 = isU16;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*!
 * index.js - basic utilities for bpanel
 * Copyright (c) 2018, Bcoin Devs(MIT License).
 * https://github.com/bcoin-org/bpanel-utils
 */

var bio = require('bufio');
var bcrypto = require('bcrypto');
var assert = require('bsert');

'use strict';

var now = exports.now = function now() {
  return Math.floor(Date.now() / 1000);
};

var camelize = exports.camelize = function camelize(str) {
  return str.replace(/_/g, '-').replace(/(?:^\w|[A-Z]|\b\w)/g, function (letter, index) {
    return index == 0 ? letter.toLowerCase() : letter.toUpperCase();
  }).replace(/[^\w]/gi, '');
};

// safely set a value nested deeply in an objects
var safeSet = exports.safeSet = function safeSet(obj, dotpath, data) {
  var path = dotpath.split('.');
  var copy = (0, _extends3.default)({}, obj);
  var target = copy;
  path.forEach(function (el, i) {
    // create an object if it doesn't exist
    if (!(el in target)) {
      target[el] = {};
    }
    // if we are at last iteration
    // set data
    if (i === path.length - 1) {
      target[el] = data;
    }
    target = target[el];
  });
  return copy;
};

// preventDefault can be passed an object
// with an event property or an event itself
var preventDefault = exports.preventDefault = function preventDefault(e) {
  if (e instanceof Event) {
    e.preventDefault();
  } else if (e.event instanceof Event) {
    e.event.preventDefault();
  }
  return e;
};

/* Return a hash string of a given preimage
 * @param {(Buffer|string|Object)} preimage - preimage to be hashed. Strings will be converted to buffers
 * and everything else will be stringified and turned to a buffer
 * @param {string} [algo=SHA256] - hashing algo to use. Supports anything from bcrypto library.
 * @param {number} [offset] - offset to start slice of final hex string
 * @param {number} [_len] - length of hex string from offset
 * @returns {string} hash - sliced string of resulting hash
 */
function getHash(preimage) {
  var algo = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'SHA256';
  var offset = arguments[2];
  var _len = arguments[3];

  var data = preimage;

  if (!Buffer.isBuffer(data)) {
    var string = preimage;
    if (typeof string !== 'string') string = (0, _stringify2.default)(preimage);
    var bw = bio.write();
    var buffer = bw.writeString(string, 'ascii');
    data = buffer.render();
  }
  assert(bcrypto.hasOwnProperty(algo), 'Unknown hashing function ' + algo);
  var hashBuffer = bcrypto[algo].digest(data);
  var hash = hashBuffer.toString('hex');
  var len = _len ? offset + _len : hash.length;
  return hash.slice(offset, len);
}

/**
 * Check if number is U8 integer
 * @param {Number} value
 * @returns {Boolean}
 */
function isU8(value) {
  return (value & 0xff) === value;
};

/**
 * Check if number is U16 integer
 * @param {Number} value
 * @returns {Boolean}
 */
function isU16(value) {
  return (value & 0xffff) === value;
};

exports.default = {
  now: now,
  camelize: camelize,
  safeSet: safeSet,
  preventDefault: preventDefault,
  getHash: getHash,
  isU8: isU8,
  isU16: isU16
};