reign/lib-legacy/hash-functions/any/index.js

A persistent, typed-objects implementation.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

exports.default = hashAny;
exports.hashArray = hashArray;
exports.hashObject = hashObject;

var _string = require('../string');

var _string2 = _interopRequireDefault(_string);

var _float = require('../float64');

var _float2 = _interopRequireDefault(_float);

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

function hashAny(input) {
  if (input == null) {
    return 4;
  };
  switch (typeof input === 'undefined' ? 'undefined' : _typeof(input)) {
    case 'boolean':
      return input ? 3 : 5;
    case 'number':
      return (0, _float2.default)(input);
    case 'string':
      return (0, _string2.default)(input);
    case 'object':
      return Array.isArray(input) ? hashArray(input) : hashObject(input);
    default:
      throw new TypeError('Unsupported type: ' + (typeof input === 'undefined' ? 'undefined' : _typeof(input)));
  }
}

function hashArray(input) {
  var length = input.length;
  for (var i = 0; i < length; i++) {
    hash += i;
    hash ^= hashAny(input[i]);
    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
  }
  return hash >>> 0;
}

function hashObject(input) {
  var keys = Object.keys(input);
  var hash = 0x811c9dc5;
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    hash += i;
    hash ^= (0, _string2.default)(key);
    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
    hash ^= hashAny(input[key]);
    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
  }
  return hash >>> 0;
}