class-o-mat/lib/class-o-mat/class-o-mat.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 _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 _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 _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _dec, _class, _class2, _temp;

var _bunyan = require('bunyan');

var _bunyan2 = _interopRequireDefault(_bunyan);

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

var _mixinDecorator2 = _interopRequireDefault(_mixinDecorator);

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

var _lodash2 = _interopRequireDefault(_lodash);

var _v = require('uuid/v4');

var _v2 = _interopRequireDefault(_v);

var _eventMethodsOMat = require('./_event-methods-o-mat');

var _eventMethodsOMat2 = _interopRequireDefault(_eventMethodsOMat);

var _apiMethodsOMat = require('./_api-methods-o-mat');

var _apiMethodsOMat2 = _interopRequireDefault(_apiMethodsOMat);

var _classOMatFieldFunctions = require('./class-o-mat-field-functions');

var _fieldFunctions = require('../methods/field-functions');

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

var _classOMatGroup = require('./class-o-mat-group');

var _classOMatGroup2 = _interopRequireDefault(_classOMatGroup);

var _fieldOMat = require('./field-o-mat');

var _fieldOMat2 = _interopRequireDefault(_fieldOMat);

var _apiFieldOMat = require('./api-field-o-mat');

var _apiFieldOMat2 = _interopRequireDefault(_apiFieldOMat);

var _apiMethodOMat = require('./api-method-o-mat');

var _apiMethodOMat2 = _interopRequireDefault(_apiMethodOMat);

var _childOMatAdder = require('./child-o-mat-adder');

var _childOMatAdder2 = _interopRequireDefault(_childOMatAdder);

var _radioOMat = require('./radio-o-mat');

var _radioOMat2 = _interopRequireDefault(_radioOMat);

var _buildClass = require('../methods/build-class');

var _buildClass2 = _interopRequireDefault(_buildClass);

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

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

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; }

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

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

var ClassOMat = (_dec = (0, _mixinDecorator2.default)(_eventMethodsOMat2.default, _apiMethodsOMat2.default), _dec(_class = (_temp = _class2 = function () {
  function ClassOMat() {
    var key = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'classOMat that needs a key';
    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _types.NONE;

    _classCallCheck(this, ClassOMat);

    this.TYPE = _types.CLASS_O_MAT;
    this.VERSION = '0.6.1';

    var group = parent === _types.NONE ? new _classOMatGroup2.default() : parent.group();

    var ClassOMatDefaultBaseClass = function ClassOMatDefaultBaseClass() {
      _classCallCheck(this, ClassOMatDefaultBaseClass);
    };

    ;
    this._params = {
      key: key,
      id: _types.NONE,
      uid: (0, _v2.default)(),

      pluginKeys: [],

      cacheOMats: false,

      accessorGetter: _fieldFunctions.getterSetter,

      FieldOMat: _fieldOMat2.default,
      fieldOMats: [],
      fieldOMatsIndex: {},
      apiFields: [],
      paramObjectKey: '_params',
      paramKeyPrefix: '___',
      createParamsAccessor: true,
      createKeysAccessor: true,

      group: group,

      childOMats: {},
      childOMatInfos: {},
      copyToChildFields: [],

      parentKey: '___parent',
      needsParentAccessor: false,
      parentId: parent === _types.NONE ? _types.NONE : parent.id(),

      BaseClass: ClassOMatDefaultBaseClass,
      BuiltClass: _types.NONE,

      defaults: { ___pending: [] },
      mixins: {
        ___isClassOMat: function ___isClassOMat() {
          return true;
        }
      },
      buildMethods: _buildClass2.default,

      ON_GET: _types.NONE,
      ON_SET: _types.NONE,
      ON_DELETE: _types.NONE
    };

    var _group$add = group.add(this),
        _group$add2 = _slicedToArray(_group$add, 2),
        isNew = _group$add2[0],
        id = _group$add2[1];

    this._params = _extends({}, this._params, {
      id: id,
      group: group
    });
  }

  // API TO BUILD THE CLASS TO BE GENERATED
  /**
   * builds the class for this param and all the 
   * child params .. returns all as an object.
   * @return {[type]} [description]
   */


  _createClass(ClassOMat, [{
    key: '$',
    value: function $() {
      var classGroup = this._params.group.$();
      var Class = classGroup.get(this.id());
      var test = new Class();
      return classGroup.get(this.id());
    }

    /**
     * Build the class with the FieldSets in the ClassOMat
     * This should be used by Group but it available in case.
     * @param  {Class} BaseClass The base class to have the methods added.
     * @return {Class} The base class with the methods added.
     */

  }, {
    key: 'buildClass',
    value: function buildClass() {
      var classGroup = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;
      var classOMatGroup = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _types.NONE;
      var _params = this._params;
      var buildMethods = _params.buildMethods,
          defaults = _params.defaults,
          mixins = _params.mixins;

      var workingArguments = { classOMat: this, mixins: mixins, defaults: defaults, params: _params };
      var WorkingClass = void 0;

      var _buildMethods$build = buildMethods.build(workingArguments, buildMethods);

      var _buildMethods$build2 = _slicedToArray(_buildMethods$build, 2);

      WorkingClass = _buildMethods$build2[0];
      buildMethods = _buildMethods$build2[1];

      var BuiltClass = WorkingClass;
      this.BuiltClass(BuiltClass);
      return BuiltClass;
    }

    // API FOR DEFINING THIS CLASS_O_MAT
    /**
     * getter setter for id
     * @param {number} id
     * @return {number|ClassOMat} 
     key,
     */

  }, {
    key: 'id',
    value: function id() {
      for (var _len = arguments.length, p = Array(_len), _key = 0; _key < _len; _key++) {
        p[_key] = arguments[_key];
      }

      return _classOMatFieldFunctions.getterSetter.apply(undefined, [this, 'id'].concat(p));
    }
  }, {
    key: 'uid',
    value: function uid() {
      for (var _len2 = arguments.length, p = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        p[_key2] = arguments[_key2];
      }

      return _classOMatFieldFunctions.getterSetter.apply(undefined, [this, 'uid'].concat(p));
    }
  }, {
    key: 'cacheOMats',


    /**
     * If true, this class will have a reference 
     * to the ClassOMatGroup that this ClassOMat belongs to.
     * This is needed to modify 
     * @param  {[type]} cacheChildOMats [description]
     * @return {[type]}                 [description]
     */
    value: function cacheOMats() {
      var _cacheOMats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;

      if (_cacheOMats === _types.NONE) return this._params.cacheOMats;

      this._params.cacheOMats = _cacheOMats === true ? true : false;
      return this;
    }

    // API TO SPECIFY THE CLASS TO BE GENERATED
    /**
     * Set the BaseClass for this ClassOMat
     * @param {Class} BaseClass
     */

  }, {
    key: 'BaseClass',
    value: function BaseClass() {
      var _BaseClass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;

      return (0, _classOMatFieldFunctions.getterSetter)(this, 'BaseClass', _BaseClass);
    }

    /**
     * Set the BuiltClass for this ClassOMat
     * @param {Class} BuiltClass
     */

  }, {
    key: 'BuiltClass',
    value: function BuiltClass() {
      var _BuiltClass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;

      return (0, _classOMatFieldFunctions.getterSetter)(this, 'BuiltClass', _BuiltClass);
    }
  }, {
    key: 'defaultAccessor',
    value: function defaultAccessor(accessorGetter) {
      return (0, _classOMatFieldFunctions.getterSetter)(this, 'accessor', accessorGetter);
    }

    /**
     * toggler for createParamsAccessor
     * This will create a parameters accessor in the BuiltClass 
     * default = true
     * under the function name __params
     * @return {object|ClassOMat}   
     */

  }, {
    key: 'createParamsAccessor',
    value: function createParamsAccessor() {
      return (0, _classOMatFieldFunctions.toggler)(this, 'createParamsAccessor');
    }
  }, {
    key: 'createKeyAccesor',


    /**
     * toggler for createKeyAccesor
     * This will create a parameter keys accessor in the BuiltClass
     * defalut = true
     * @return {object|ClassOMat}      
     */
    value: function createKeyAccesor() {
      return (0, _classOMatFieldFunctions.toggler)(this, 'createKeyAccesor');
    }
  }, {
    key: 'apiField',


    /**
     * Lets you attach a field to a Minion instance
     * AFTER it is created.  It otherwise works 
     * just like classOMat.field
     * @param  {[type]} key [description]
     * @return {[type]}     [description]
     */
    value: function apiField(key) {
      var apiFieldOMat = new _apiFieldOMat2.default(this, key);
      this._params.fieldOMats.push(apiFieldOMat);
      return apiFieldOMat;
    }

    /**
     * lets you attach a method to the classOMat 
     * that will add that method to the minion class api.
     * @return {ApiMethod}     [description]
     */

  }, {
    key: 'apiMethod',
    value: function apiMethod(method) {
      var apiMethodOMat = new _apiMethodOMat2.default(this, method);
      this._params.fields.push(apiMethodOMat);
      return apiMethodOMat;
    }
  }, {
    key: 'deleteField',
    value: function deleteField(key) {
      var _params2 = this._params,
          fieldsIndex = _params2.fieldsIndex,
          fields = _params2.fields;

      if (key in fieldsIndex === false) {
        throw new Error('Tried to delete non-existent field ' + key + ' from classOMat ' + this._params.key + '.');
      }

      var fieldIndex = fieldsIndex[key];
      fields.splice(fieldIndex, 1);
      delete fieldIndex[key];
      this._params.fieldsIndex = fieldsIndex;
      this._params.fields = fields;
      return this;
    }

    /**
     * Get a FieldOMat.
     * @param  {string} key    the key for this field. 
     * This will be the function name of the class instance.
     * @return {FieldOMat} The field param builder        
     */

  }, {
    key: 'field',
    value: function field(key) {
      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _types.NONE;

      if (this._params.fieldOMatsIndex[key]) {
        return this._params.fieldOMats[this._params.fieldOMatsIndex[key]];
      }
      var field = new this._params.FieldOMat().init(this, key);
      if (params !== _types.NONE) {
        var parent = params.parent,
            transferParams = _objectWithoutProperties(params, ['parent']);

        field.params(transferParams, true);
      }

      this._params.fieldOMats.push(field);
      this._params.fieldOMatsIndex[key] = this._params.fieldOMats.length - 1;
      return field;
    }

    /**
     * get or set all the fields to be defined in this classOMat
     * @param  {Array} fields
     * @return {Array} fields
     */

  }, {
    key: 'fields',
    value: function fields() {
      var fieldOMats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;

      if (fieldOMats === _types.NONE) return this._params.fieldOMats;

      this._params.fieldOMats = fieldOMats;
      return this;
    }
  }, {
    key: 'fieldNames',
    value: function fieldNames() {
      return this._params.fieldOMats.map(function (f) {
        return f.key();
      });
    }

    /**
     * getter setter for group
     * @param  {Group} group
     * @return {Group|ClassOMat}      
     */

  }, {
    key: 'group',
    value: function group() {
      for (var _len3 = arguments.length, p = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
        p[_key3] = arguments[_key3];
      }

      return _classOMatFieldFunctions.getterSetter.apply(undefined, [this, 'group'].concat(p));
    }
  }, {
    key: 'parentKey',
    value: function parentKey() {
      for (var _len4 = arguments.length, p = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
        p[_key4] = arguments[_key4];
      }

      return _classOMatFieldFunctions.getterSetter.apply(undefined, [this, 'parentKey'].concat(p));
    }
  }, {
    key: 'pluginKeys',
    value: function pluginKeys() {
      return this._params.pluginKeys;
    }

    /**
     * getter setter for paramObjectKey
     * @param  {object} p
     * @return {object|ClassOMat}      
     */

  }, {
    key: 'paramObjectKey',
    value: function paramObjectKey() {
      var _paramObjectKey = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;

      if (_paramObjectKey === false) return (0, _classOMatFieldFunctions.getterSetter)(this, 'paramObjectKey', _paramObjectKey);

      if (_paramObjectKey !== _types.NONE) {
        if (typeof _paramObjectKey !== 'string') {
          throw new Error('ClassOMat: Invalid paramObjectKey');
        }
        if (_paramObjectKey.slice(0, 1) !== '_') {
          _paramObjectKey = '_' + _paramObjectKey;
        }
      }
      return (0, _classOMatFieldFunctions.getterSetter)(this, 'paramObjectKey', _paramObjectKey);
    }
  }, {
    key: 'radio',
    value: function radio(key) {
      return new _radioOMat2.default(this, key);
    }

    // FOR NEW CLASS-O-MATS.
    /**
     * create a copy of this paramset but with the new key
     * @param  {string} key 
     * @return {ClassOMat} the cloned set.
     */

  }, {
    key: 'clone',
    value: function clone() {
      var key = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.key();

      var clone = new ClassOMat(key, this);
      var cloneParams = (0, _lodash2.default)(this.params());
      clone.params(cloneParams);
      clone.key(key);
      clone.uid((0, _v2.default)());
      return clone;
    }
  }, {
    key: 'subOMat',
    value: function subOMat(key) {
      var subOMat = new ClassOMat(key);
      var subOMatParams = (0, _lodash2.default)(this._params);

      delete subOMatParams.group;
      delete subOMatParams.key;
      delete subOMatParams.uid;
      delete subOMatParams.childOMats;
      delete subOMatParams.childInfoOMats;

      subOMat.params(subOMatParams, true);

      var _params3 = this._params,
          childOMats = _params3.childOMats,
          childOMatInfos = _params3.childOMatInfos;

      var childOMatInfoKeys = Object.keys(childOMatInfos);

      childOMatInfoKeys.forEach(function (childInfoKey) {
        var childOMatInfo = childOMatInfos[childInfoKey];

        var childOMatKey = childOMatInfo.childOMatKey,
            childOMatInfoToAdder = _objectWithoutProperties(childOMatInfo, ['childOMatKey']);

        var childOMat = childOMats[childOMatInfo.childOMatUid];
        subOMat._addChildFromAdder(_extends({ childOMat: childOMat }, childOMatInfoToAdder));
      });

      return subOMat;
    }

    // API FOR NESTING SETS and NAVIGATING SAME
    /**
     * add a set as a child of this one.
     * @param {ClassOMat} set default is NONE which means "self"
     * @return {ClassOMat} this;
     */

  }, {
    key: 'addChild',
    value: function addChild() {
      var childOMat = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;

      return new _childOMatAdder2.default().init(this, childOMat);
    }

    /**
     * getterSetter for  all the childOMats of this classOMat
     * @param  {Object|NONE} p
     * @return {Object|ClassOMat} the Object of childOMats or this 
     */

  }, {
    key: 'childOMats',
    value: function childOMats() {
      for (var _len5 = arguments.length, p = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
        p[_key5] = arguments[_key5];
      }

      return _classOMatFieldFunctions.getterSetter.apply(undefined, [this, 'childOMats'].concat(p));
    }
  }, {
    key: 'getChild',


    /**
     * get a classOMat nested within this one.
     * @param  {string} key
     * @return {ClassOMat} the child set
     */
    value: function getChild(key) {
      var _params4 = this._params,
          childOMats = _params4.childOMats,
          childOMatInfos = _params4.childOMatInfos;

      if (key in childOMatInfos === false) {
        throw new Error('Invalid Set Name: ' + key);
      }

      return childOMats[childOMatInfos[key].childOMatUid];
    }

    /**
     * If this ClassOMat is nested within a parent, get that parent
     * or set it.. this is a getter/setter function 
     * get the parent.
     *
     * adding a parent forces adding the parent accessor to the child class
     * if one is needed.
     * @param  {ClassOMat|NONE} parent
     * @return {ClassOMat}
     */

  }, {
    key: 'parent',
    value: function parent() {
      var _parent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _types.NONE;

      if (_parent === _types.NONE) return this._params.parent;

      this._params.parent = _parent;
      return this;
    }
  }, {
    key: 'needsParentAccessor',
    value: function needsParentAccessor() {
      this._params.needsParentAccessor = true;
      return this;
    }
  }, {
    key: 'reGroupChildren',
    value: function reGroupChildren() {
      var _params5 = this._params,
          childOMats = _params5.childOMats,
          childOMatInfos = _params5.childOMatInfos,
          group = _params5.group;

      var childKeys = Object.keys(childOMatInfos);

      if (childKeys.length === 0) return;

      childKeys.forEach(function (childKey) {
        var childOMatInfo = childOMatInfos[childKey];
        var childOMatUid = childOMatInfo.childOMatUid;

        var childOMat = childOMats[childOMatUid];
        var childOMatGroup = childOMat.group();
        if (childOMatGroup.uid() === group.uid()) return;

        var _group$add3 = group.add(childOMat),
            _group$add4 = _slicedToArray(_group$add3, 2),
            isNew = _group$add4[0],
            id = _group$add4[1];

        if (isNew === false) return;

        childOMat.id(id);
        childOMat.reGroupChildren();
      });
    }
  }, {
    key: 'addChildAccessors',
    value: function addChildAccessors(classGroup) {
      var _this = this,
          _dec2,
          _class3;

      var _params6 = this._params,
          childOMats = _params6.childOMats,
          childOMatInfos = _params6.childOMatInfos,
          BuiltClass = _params6.BuiltClass;

      var childKeys = Object.keys(childOMatInfos);
      if (childKeys.length === 0) return BuiltClass;

      var childAccessorsMixins = {};

      childKeys.forEach(function (childKey) {
        var childOMatInfo = childOMatInfos[childKey];
        var childOMat = childOMats[childOMatInfo.childOMatUid];
        var childClassId = childOMat.id();
        var ChildClass = classGroup.get(childClassId);
        childAccessorsMixins[childKey] = _this._childAccessorFunction(_extends({
          childKey: childKey,
          classGroup: classGroup,
          childClassId: childClassId
        }, childOMatInfo));

        var accessChildAs = childOMatInfo.accessChildAs,
            namedChildren = childOMatInfo.namedChildren,
            singleton = childOMatInfo.singleton;


        var _defaultChild = singleton === true ? _types.NONE : namedChildren === true ? {} : [];

        if (accessChildAs !== _types.NONE) {
          childAccessorsMixins[accessChildAs] = function () {
            return this.___child(childKey) || _defaultChild;
          };
          childAccessorsMixins['delete_' + accessChildAs] = function () {
            return this.___deleteChild(childKey);
          };
        }
      });

      var WorkingClass = (_dec2 = (0, _mixinDecorator2.default)(childAccessorsMixins), _dec2(_class3 = function (_BuiltClass2) {
        _inherits(WorkingClass, _BuiltClass2);

        function WorkingClass() {
          _classCallCheck(this, WorkingClass);

          return _possibleConstructorReturn(this, (WorkingClass.__proto__ || Object.getPrototypeOf(WorkingClass)).apply(this, arguments));
        }

        return WorkingClass;
      }(BuiltClass)) || _class3);
      ;

      this.BuiltClass(WorkingClass);
      return WorkingClass;
    }
  }, {
    key: '_childAccessorFunction',
    value: function _childAccessorFunction(_ref) {
      var accessChildAs = _ref.accessChildAs,
          cacheChild = _ref.cacheChild,
          classGroup = _ref.classGroup,
          childClassId = _ref.childClassId,
          childUid = _ref.childUid,
          copyToChildFields = _ref.copyToChildFields,
          initializer = _ref.initializer,
          internalKey = _ref.internalKey,
          childKey = _ref.childKey,
          namedChildren = _ref.namedChildren,
          parentKey = _ref.parentKey,
          singleton = _ref.singleton;
      var _params7 = this._params,
          fields = _params7.fields,
          paramObjectKey = _params7.paramObjectKey;


      var getStoredChildObject = namedChildren === false ? function (___children, childKey, childInstance) {
        var storedChild = ___children[childKey];
        if (storedChild === undefined) return childInstance;

        if (Array.isArray(storedChild) === true) return storedChild.concat([childInstance]);

        return [storedChild, childInstance];
      } : function (___children, childKey, childInstance, instanceKey) {
        var storedChild = ___children[childKey];
        if (storedChild === undefined) return _defineProperty({}, instanceKey, childInstance);

        return _extends({}, storedChild, _defineProperty({}, instanceKey, childInstance));
      };

      var nonInitializerWrapper = function nonInitializerWrapper(childInstance, self) {
        for (var _len6 = arguments.length, p = Array(_len6 > 2 ? _len6 - 2 : 0), _key6 = 2; _key6 < _len6; _key6++) {
          p[_key6 - 2] = arguments[_key6];
        }

        return childInstance[parentKey].apply(childInstance, [self].concat(p));
      };

      var initializerWrapper = function initializerWrapper(childInstance, self) {
        for (var _len7 = arguments.length, p = Array(_len7 > 2 ? _len7 - 2 : 0), _key7 = 2; _key7 < _len7; _key7++) {
          p[_key7 - 2] = arguments[_key7];
        }

        var minion = childInstance[parentKey].apply(childInstance, [self].concat(p));

        initializer.apply(undefined, [minion, self].concat(p));
        return minion;
      };

      var copyFieldsWrapper = function copyFieldsWrapper(childInstance, self) {
        var parentParams = self.params();
        var childParams = childInstance.params();

        copyToChildFields.forEach(function (_ref3) {
          var key = _ref3.key,
              as = _ref3.as;

          childParams[as] = parentParams[key];
        });
        return childInstance;
      };

      var copyToChildFieldsCount = copyToChildFields.length;
      var initWrapper = void 0;
      if (initializer === _types.NONE) {
        if (copyToChildFieldsCount === 0) {
          initWrapper = nonInitializerWrapper;
        } else {
          initWrapper = copyFieldsWrapper;
        }
      } else {
        if (copyToChildFieldsCount === 0) {
          initWrapper = initializerWrapper;
        } else {
          initWrapper = function initWrapper(childInstance, self) {
            for (var _len8 = arguments.length, p = Array(_len8 > 2 ? _len8 - 2 : 0), _key8 = 2; _key8 < _len8; _key8++) {
              p[_key8 - 2] = arguments[_key8];
            }

            childInstance = copyFieldsWrapper(childInstance, self);
            return initializerWrapper.apply(undefined, [childInstance, self].concat(p));
          };
        }
      }

      if (cacheChild === false) {
        return function () {
          for (var _len9 = arguments.length, p = Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
            p[_key9] = arguments[_key9];
          }

          return initWrapper.apply(undefined, [new (classGroup.get(childClassId))()[parentKey](this), this].concat(p));
        };
      }

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

      if (singleton === true) {
        var workingInitWrapper = initWrapper;
        initWrapper = function initWrapper(childInstance, self) {
          for (var _len10 = arguments.length, p = Array(_len10 > 2 ? _len10 - 2 : 0), _key10 = 2; _key10 < _len10; _key10++) {
            p[_key10 - 2] = arguments[_key10];
          }

          var result = workingInitWrapper.apply(undefined, [childInstance, self].concat(p));
          self[childKey] = function () {
            return childInstance;
          };
          return childInstance;
        };
      }

      if (namedChildren === false) {
        return function () {
          var childInstance = new (classGroup.get(childClassId))()[parentKey](this);
          var ___children = getChildren(this);
          ___children[childKey] = getStoredChildObject(___children, childKey, childInstance);

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

          return initWrapper.apply(undefined, [childInstance, this].concat(p));
        };
      }

      return function () {
        for (var _len12 = arguments.length, p = Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
          p[_key12] = arguments[_key12];
        }

        var instanceKey = p[0],
            params = p.slice(1);

        var childInstance = new (classGroup.get(childClassId))()[parentKey](this);
        var ___children = getChildren(this);
        ___children[childKey] = getStoredChildObject(___children, childKey, childInstance, instanceKey);
        return initWrapper.apply(undefined, [childInstance, this].concat(_toConsumableArray(params)));
      };
    }

    // INTERNAL COMMANDS FOR ADDING CHILDREN AND THEIR FEATURES

  }, {
    key: '_addChildFromAdder',
    value: function _addChildFromAdder(adderParams) {
      var _params8 = this._params,
          childOMats = _params8.childOMats,
          group = _params8.group;
      var accessChildAs = adderParams.accessChildAs,
          cacheChild = adderParams.cacheChild,
          childOMat = adderParams.childOMat,
          childIsSelf = adderParams.childIsSelf,
          copyToChildFields = adderParams.copyToChildFields,
          internalKey = adderParams.internalKey,
          initializer = adderParams.initializer,
          childKey = adderParams.childKey,
          namedChildren = adderParams.namedChildren,
          parentKey = adderParams.parentKey,
          singleton = adderParams.singleton;


      var newChildOMat = childIsSelf === true ? this : childOMat;

      newChildOMat.needsParentAccessor();
      newChildOMat.parent(this);
      newChildOMat.parentKey(parentKey);

      var childOMatUid = newChildOMat.uid();

      this._params.childOMats[childOMatUid] = newChildOMat;

      this._params.childOMatInfos[childKey] = {
        accessChildAs: accessChildAs,
        cacheChild: cacheChild,
        childOMatUid: childOMatUid,
        childIsSelf: childIsSelf,
        copyToChildFields: copyToChildFields,
        internalKey: internalKey,
        initializer: initializer,
        childKey: childKey,
        namedChildren: namedChildren,
        parentKey: parentKey,
        singleton: singleton
      };

      if (childIsSelf === true) {
        newChildOMat.childOMats(this.childOMats());
        this.field(parentKey);
      }

      this.reGroupChildren();
      newChildOMat.needsParentAccessor();

      return this;
    }
  }, {
    key: '_addFieldCopier',
    value: function _addFieldCopier(copy) {
      var _copy$_params = copy._params,
          key = _copy$_params.key,
          as = _copy$_params.as;

      this._params.copyToChildFields.push([key, as]);
    }
  }, {
    key: '_acceptFieldOMat',
    value: function _acceptFieldOMat(fieldOMat) {
      this._params.fieldOMats.push(fieldOMat);
    }
  }]);

  return ClassOMat;
}(), _class2.TYPE = _types.CLASS_O_MAT, _class2.VERSION = '0.6.1', _temp)) || _class);
exports.default = ClassOMat;
//# sourceMappingURL=class-o-mat.js.map