class-o-mat/lib/methods/build-class.js

ALPHA VERSION ONLY: class-o-mats will help to create getter-setter functionality with validations that can be attached to a container class for easier coding. Some basic validations are included. class-o-mats also has the ability to store params as bloc

'use strict';

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

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

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

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _bunyan = require('bunyan');

var _bunyan2 = _interopRequireDefault(_bunyan);

var _mixinDecorator = require('mixin-decorator');

var _mixinDecorator2 = _interopRequireDefault(_mixinDecorator);

var _lodash = require('lodash.merge');

var _lodash2 = _interopRequireDefault(_lodash);

var _namedDepCounter = require('named-dep-counter');

var _namedDepCounter2 = _interopRequireDefault(_namedDepCounter);

var _types = require('../constants/types');

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

var log = _bunyan2.default.createLogger({ name: "buildClass" });

var buildFieldMixins = function buildFieldMixins(_ref, buildMethods) {
  var classOMat = _ref.classOMat,
      mixins = _ref.mixins,
      defaults = _ref.defaults,
      params = _ref.params;
  var key = params.key,
      fieldOMats = params.fieldOMats,
      paramKeyPrefix = params.paramKeyPrefix,
      paramObjectKey = params.paramObjectKey,
      ON_GET = params.ON_GET,
      ON_SET = params.ON_SET;


  if (ON_GET !== _types.NONE) {
    fieldOMats.forEach(function (field) {
      field._appendEvent(ON_GET, key, 'ON_GET');
    });
  }

  if (ON_SET !== _types.NONE) {
    fieldOMats.forEach(function (field) {
      return field._appendEvent(ON_SET, key, 'ON_SET');
    });
  }

  var ___fields = [];
  var required = [];

  fieldOMats.forEach(function (fieldOMat) {
    var _fieldOMat$_params = fieldOMat._params,
        key = _fieldOMat$_params.key,
        _default = _fieldOMat$_params._default,
        isRequired = _fieldOMat$_params.isRequired;

    ___fields.push(key);

    if (isRequired === true) {
      required.push(key);
      fieldOMat.onSet(function (self, key, value) {
        self.___markReady(key);
      });
    }
    mixins = fieldOMat.addToClassMixins(mixins, paramObjectKey, paramKeyPrefix);

    defaults[fieldOMat._params.key] = fieldOMat._params._default;
  });

  if (required.length !== 0) {
    var depCounter = new _namedDepCounter2.default(key + '_required');
    depCounter.deps(required);

    mixins.___required = function () {
      depCounter.self(this);
      this.___required = function () {
        return depCounter;
      };
      return depCounter;
    };

    mixins.___ready = function () {
      depCounter.self(this);
      this.___ready = function () {
        return depCounter.ready();
      };
      return depCounter.ready();
    };

    mixins.___markReady = function (key) {
      depCounter.self(this);
      this.___markReady = function (key) {
        return depCounter.mark(key);
      };
      depCounter.mark(key);
    };
  }

  mixins.___fields = ___fields;
  return [{ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods];
};

var buildParamObjectAccessor = function buildParamObjectAccessor(_ref2, buildMethods) {
  var classOMat = _ref2.classOMat,
      mixins = _ref2.mixins,
      defaults = _ref2.defaults,
      params = _ref2.params;
  var paramObjectKey = params.paramObjectKey;

  if (paramObjectKey === false) return { classOMat: classOMat, mixins: mixins, defaults: defaults, params: params };

  if (paramObjectKey !== false) {
    mixins[paramObjectKey.slice(1)] = function () {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;
      var merge = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _types.NONE;

      var thisParams = this[paramObjectKey];
      if (params === _types.NONE) return thisParams;

      this[paramObjectKey] = merge === _types.NONE ? params : merge === true ? _extends({}, params, thisParams) : _extends({}, thisParams, params);
      return this;
    };
  }
  return [{ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods];
};

var buildNestingAccessors = function buildNestingAccessors(_ref3, buildMethods) {
  var classOMat = _ref3.classOMat,
      mixins = _ref3.mixins,
      defaults = _ref3.defaults,
      params = _ref3.params;
  var paramObjectKey = params.paramObjectKey;


  var getChildren = paramObjectKey === false ? function (self) {
    return self.___children;
  } : function (self) {
    return self[paramObjectKey].___children;
  };

  var setChildren = paramObjectKey === false ? function (self, value) {
    return self.___children = value;
  } : function (self, value) {
    return self[paramObjectKey].___children = value;
  };

  defaults.___children = {};
  mixins.___children = function () {
    return getChildren(this);
  };

  mixins.___child = function () {
    var key = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;

    var ___children = getChildren(this);

    if (___children === undefined) return false;

    if (key === _types.NONE) return ___children;

    return key in ___children === true ? ___children[key] : false;
  };

  mixins.___deleteChild = function () {
    var key = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;

    var ___children = getChildren(this);
    if (key === _types.NONE || key in ___children === false) {
      setChildren(this, {});
      return true;
    }

    delete ___children[key];
    setChildren(this, ___children);
    return true;
  };
  return [{ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods];
};

var buildKeysAccessor = function buildKeysAccessor(_ref4, buildMethods) {
  var classOMat = _ref4.classOMat,
      mixins = _ref4.mixins,
      defaults = _ref4.defaults,
      params = _ref4.params;

  if (params.createKeysAccessor !== true) return { classOMat: classOMat, mixins: mixins, defaults: defaults, params: params };

  var keys = params.fieldOMats.map(function (fieldOMat) {
    return fieldOMat.key();
  });
  mixins.keys = function () {
    return keys;
  };

  return [{ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods];
};

var buildConstructorNoParamsObject = function buildConstructorNoParamsObject(_ref5, buildMethods) {
  var classOmat = _ref5.classOmat,
      mixins = _ref5.mixins,
      defaults = _ref5.defaults,
      params = _ref5.params;
  var key = params.key,
      uid = params.uid;

  mixins.constructor = function () {
    var _this = this;

    this.___uid = uid;
    this.___minionKey = key;
    var defaultKeys = Object.keys(defaults);
    defaultKeys.forEach(function (key) {
      var v = defaults[key];
      _this['___' + key] = (typeof v === 'undefined' ? 'undefined' : _typeof(v)) === 'object' ? clonedeep(v) : v;
    });
  };
  return [{ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods];
};

var buildConstructorParamsObject = function buildConstructorParamsObject(_ref6, buildMethods) {
  var classOMat = _ref6.classOMat,
      mixins = _ref6.mixins,
      defaults = _ref6.defaults,
      params = _ref6.params;
  var key = params.key,
      paramObjectKey = params.paramObjectKey,
      uid = params.uid;

  mixins.constructor = function () {
    this.___uid = uid;
    this.___minionKey = key;
    this[paramObjectKey] = (0, _lodash2.default)({}, defaults, this[paramObjectKey] || {});
  };
  return [{ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods];
};

var buildConstructor = function buildConstructor(_ref7, buildMethods) {
  var classOMat = _ref7.classOMat,
      mixins = _ref7.mixins,
      defaults = _ref7.defaults,
      params = _ref7.params;

  return params.paramObjectKey === false ? buildMethods.buildConstructorNoParamsObject({ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods) : buildMethods.buildConstructorParamsObject({ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods);
};

var buildClass = function buildClass(_ref8, buildMethods) {
  var _dec, _class;

  var classOMat = _ref8.classOMat,
      mixins = _ref8.mixins,
      defaults = _ref8.defaults,
      params = _ref8.params;
  var BaseClass = params.BaseClass,
      key = params.key,
      paramObjectKey = params.paramObjectKey,
      uid = params.uid;

  var workingArguments = void 0;

  var _buildMethods$buildCo = buildMethods.buildConstructor({ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods);

  var _buildMethods$buildCo2 = _slicedToArray(_buildMethods$buildCo, 2);

  workingArguments = _buildMethods$buildCo2[0];
  buildMethods = _buildMethods$buildCo2[1];

  var _workingArguments$mix = workingArguments.mixins,
      constructor = _workingArguments$mix.constructor,
      ___fields = _workingArguments$mix.___fields,
      workingMixins = _objectWithoutProperties(_workingArguments$mix, ['constructor', '___fields']);

  var WorkingClass = (_dec = (0, _mixinDecorator2.default)(workingMixins), _dec(_class = function (_BaseClass) {
    _inherits(WorkingClass, _BaseClass);

    function WorkingClass() {
      var _ref9;

      _classCallCheck(this, WorkingClass);

      for (var _len = arguments.length, p = Array(_len), _key = 0; _key < _len; _key++) {
        p[_key] = arguments[_key];
      }

      var _this2 = _possibleConstructorReturn(this, (_ref9 = WorkingClass.__proto__ || Object.getPrototypeOf(WorkingClass)).call.apply(_ref9, [this].concat(p)));

      _this2.___fields = ___fields;

      constructor.call.apply(constructor, [_this2].concat(p));
      return _this2;
    }

    return WorkingClass;
  }(BaseClass)) || _class);

  return [WorkingClass, buildMethods];
};

var buildMixins = function buildMixins(_ref10, buildMethods) {
  var classOMat = _ref10.classOMat,
      mixins = _ref10.mixins,
      defaults = _ref10.defaults,
      params = _ref10.params;
  var cacheOMats = params.cacheOMats,
      classOMatGroup = params.classOMatGroup,
      childOMatInfos = params.childOMatInfos,
      needsParentAccessor = params.needsParentAccessor,
      paramObjectKey = params.paramObjectKey,
      parentKey = params.parentKey;

  var workingArguments = void 0;

  mixins.___classGroup = function () {
    return classGroup;
  };

  if (Object.keys(childOMatInfos).length !== 0) {
    var _buildMethods$buildNe = buildMethods.buildNestingAccessors({ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods);

    var _buildMethods$buildNe2 = _slicedToArray(_buildMethods$buildNe, 2);

    workingArguments = _buildMethods$buildNe2[0];
    buildMethods = _buildMethods$buildNe2[1];
  } else {
    workingArguments = { classOMat: classOMat, mixins: mixins, defaults: defaults, params: params };
  }

  if (cacheOMats === true) {
    workingArguments.mixins.___classOMats = function () {
      return clasSOMatGroup;
    };
  }

  var _buildMethods$buildPa = buildMethods.buildParamObjectAccessor(workingArguments, buildMethods);

  var _buildMethods$buildPa2 = _slicedToArray(_buildMethods$buildPa, 2);

  workingArguments = _buildMethods$buildPa2[0];
  buildMethods = _buildMethods$buildPa2[1];

  var _buildMethods$buildKe = buildMethods.buildKeysAccessor(workingArguments, buildMethods);

  var _buildMethods$buildKe2 = _slicedToArray(_buildMethods$buildKe, 2);

  workingArguments = _buildMethods$buildKe2[0];
  buildMethods = _buildMethods$buildKe2[1];

  return [workingArguments, buildMethods];
};

var build = function build(_ref11, buildMethods) {
  var classOMat = _ref11.classOMat,
      mixins = _ref11.mixins,
      defaults = _ref11.defaults,
      params = _ref11.params;

  if (params.needsParentAccessor === true || 1 === 1) {
    classOMat.field(params.parentKey);
  }

  var workingArguments = void 0;

  var _buildMethods$buildFi = buildMethods.buildFieldMixins({ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods);

  var _buildMethods$buildFi2 = _slicedToArray(_buildMethods$buildFi, 2);

  workingArguments = _buildMethods$buildFi2[0];
  buildMethods = _buildMethods$buildFi2[1];

  var _buildMethods$buildMi = buildMethods.buildMixins(workingArguments, buildMethods);

  var _buildMethods$buildMi2 = _slicedToArray(_buildMethods$buildMi, 2);

  workingArguments = _buildMethods$buildMi2[0];
  buildMethods = _buildMethods$buildMi2[1];

  return buildClass(workingArguments, buildMethods);
};

var buildClassMethods = {
  build: build,
  buildKeysAccessor: buildKeysAccessor,
  buildClass: buildClass,
  buildConstructor: buildConstructor,
  buildConstructorParamsObject: buildConstructorParamsObject,
  buildConstructorNoParamsObject: buildConstructorNoParamsObject,
  buildFieldMixins: buildFieldMixins,
  buildMixins: buildMixins,
  buildNestingAccessors: buildNestingAccessors,
  buildParamObjectAccessor: buildParamObjectAccessor
};

exports.default = buildClassMethods;
//# sourceMappingURL=build-class.js.map