stahlwerk/lib/index.js

A minimal factory library.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
var factory = exports.factory = function factory(definition) {
  return function () {
    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    var definitionWithoutTraits = removeTraitsFromDefinition(definition);

    return args.reduce(function (result, arg) {
      if (isString(arg) && !isTrait(definition[arg])) {
        throw new Error('Unknown trait');
      }
      return Object.assign(result, isFunction(definition[arg]) ? definition[arg]() : arg);
    }, definitionWithoutTraits);
  };
};

var trait = exports.trait = function trait(definition) {
  var fn = function fn() {
    return definition;
  };
  fn.__isTrait = true;
  return fn;
};

var sequence = exports.sequence = function sequence() {
  var formatter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function (x) {
    return x;
  };

  var count = 0;
  var fn = function fn() {
    count += 1;
    return formatter(count);
  };
  fn.__isCallable = true;
  return fn;
};

var random = exports.random = function random(arg) {
  var fn = function fn() {
    if (isArray(arg)) {
      return arg[Math.floor(Math.random()) % arg.length];
    }
    if (isFunction(arg)) {
      return arg(Math.random());
    }
    return Math.random();
  };
  fn.__isCallable = true;
  return fn;
};

var execute = exports.execute = function execute(callback) {
  if (!isFunction(callback)) {
    throw new Error('a function must be passed to execute');
  }
  var fn = function fn() {
    return callback();
  };
  fn.__isCallable = true;
  return fn;
};

var removeTraitsFromDefinition = function removeTraitsFromDefinition(definition) {
  return Object.keys(definition).reduce(function (result, key) {
    if (isTrait(definition[key])) {
      return result;
    }

    if (isCallable(definition[key])) {
      return addToObject(result, key, definition[key]());
    }

    return addToObject(result, key, definition[key]);
  }, {});
};

var addToObject = function addToObject(object, key, value) {
  object[key] = value; // eslint-disable-line no-param-reassign
  return object;
};

var isArray = function isArray(probablyArray) {
  return Array.isArray(probablyArray);
};

var isString = function isString(probablyString) {
  return typeof probablyString === 'string';
};

var isFunction = function isFunction(probablyFunction) {
  return typeof probablyFunction === 'function';
};

var isTrait = function isTrait(probablyTrait) {
  return isFunction(probablyTrait) && probablyTrait.__isTrait;
};

var isCallable = function isCallable(probablySequence) {
  return isFunction(probablySequence) && probablySequence.__isCallable;
};