@airyrooms/catela/dist/catela.build.framework.js

exports["framework"] =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 16);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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

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

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

  _createClass(Validator, [{
    key: "apply",
    value: function apply(value) {}
  }, {
    key: "configure",
    value: function configure(option) {}
  }]);

  return Validator;
}();

exports.default = Validator;
module.exports = exports["default"];

/***/ }),
/* 1 */
/***/ (function(module, exports) {

module.exports = require("moment");

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = {
  HttpMethod: {
    POST: 'POST',
    GET: 'DELETE',
    PUT: 'PUT',
    DELETE: 'DELETE'
  },
  Protocol: {
    HTTP: 'HTTP'
  }
};
module.exports = exports['default'];

/***/ }),
/* 3 */
/***/ (function(module, exports) {

var g;

// This works in non-strict mode
g = (function() {
	return this;
})();

try {
	// This works if eval is allowed (see CSP)
	g = g || Function("return this")() || (1,eval)("this");
} catch(e) {
	// This works if the window reference is available
	if(typeof window === "object")
		g = window;
}

// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}

module.exports = g;


/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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

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

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

  _createClass(DataFetch, [{
    key: "fetch",
    value: function fetch(store, context, callback) {}
  }]);

  return DataFetch;
}();

exports.default = DataFetch;
module.exports = exports["default"];

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {

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

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 _ModelProperty = __webpack_require__(6);

var _ModelProperty2 = _interopRequireDefault(_ModelProperty);

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

if (global.__MODEL_REGISTRY__ == null || typeof global.__MODEL_REGISTRY__ === 'undefined') {
  global.__MODEL_SPEC_REGISTRY__ = {};
}

var Model = function () {
  function Model(spec) {
    _classCallCheck(this, Model);

    this.props = {};
    this._initFromSpec(spec);
  }

  _createClass(Model, [{
    key: '_initFromSpec',
    value: function _initFromSpec(spec) {
      var _this = this;

      this._key = '' + spec.key;
      this._option = spec.option || {};
      Object.keys(spec.props).forEach(function (k) {
        var field = spec.props[k];
        var defaultValue = null;
        if (field.defaultValue != null && typeof field.defaultValue !== 'undefined') {
          defaultValue = field.defaultValue;
        }
        _this.props[k] = new _ModelProperty2.default(_this, k, field.display, field.validators, defaultValue);
        if (field.defaultValue != null && typeof field.defaultValue !== 'undefined') {
          _this.props[k].setValue(field.defaultValue);
          _this.props[k].defaultValidation();
        }
        _this[k] = _this.props[k];
      });
    }
  }, {
    key: 'set',
    value: function set(data) {
      var _this2 = this;

      Object.keys(this.props).forEach(function (pk) {
        if (typeof data[pk] === 'undefined') {
          throw new Error('[CATELA_MODEL] [' + pk + '] property is not found in data.');
        } else {
          _this2.props[pk].setValue(data[pk].value);
        }
      });
      return this;
    }
  }, {
    key: 'bind',
    value: function bind(data) {
      var _this3 = this;

      Object.keys(this.props).forEach(function (pk) {
        if (typeof data[pk] === 'undefined') {
          throw new Error('[CATELA_MODEL] [' + pk + '] property is not found in data.');
        } else {
          if (data[pk] != null && typeof data[pk] !== 'undefined') {
            // TODO: data[pk].value?
            _this3.props[pk].set(data[pk]);
          }
        }
      });
      return this;
    }
  }, {
    key: 'get',
    value: function get() {
      var _this4 = this;

      var data = {};
      Object.keys(this.props).forEach(function (pk) {
        var props = _this4.props[pk];
        data[pk] = {
          value: props.getValue(),
          validation: props.getValidation()
        };
      });
      data.__MODEL_KEY__ = this._key;
      return data;
    }
  }, {
    key: 'getValue',
    value: function getValue() {
      var _this5 = this;

      var data = {};
      Object.keys(this.props).forEach(function (pk) {
        var props = _this5.props[pk];
        data[pk] = props.getValue();
      });
      return data;
    }
  }, {
    key: 'value',
    value: function value(field) {
      if (this.props[field] == null || typeof this.props[field] === 'undefined') {
        throw new Error('[CATELA_MODEL] [' + field + '] property is not found in data.');
      } else {
        return this.props[field].getValue();
      }
    }
  }, {
    key: 'clearValidation',
    value: function clearValidation() {
      var _this6 = this;

      Object.keys(this.props).forEach(function (pk) {
        var props = _this6.props[pk];
        props.defaultValidation();
      });
      return this;
    }
  }, {
    key: 'default',
    value: function _default() {
      var _this7 = this;

      Object.keys(this.props).forEach(function (pk) {
        var props = _this7.props[pk];
        props.default();
      });
      return this;
    }
  }, {
    key: 'validate',
    value: function validate() {
      var _this8 = this;

      var valid = true;
      var validations = {};
      Object.keys(this.props).forEach(function (pk) {
        var propsValidationResult = _this8.props[pk].validate(_this8.props[pk].getValue());
        valid = valid && propsValidationResult.valid;
        validations[pk] = propsValidationResult;
      });
      return {
        valid: valid,
        validations: validations
      };
    }
  }], [{
    key: 'fromSpec',
    value: function fromSpec(spec) {
      if (global.__MODEL_SPEC_REGISTRY__[spec.key] == null || typeof global.__MODEL_SPEC_REGISTRY__[spec.key] === 'undefined') {
        global.__MODEL_SPEC_REGISTRY__[spec.key] = spec;
      }
      return new Model(global.__MODEL_SPEC_REGISTRY__[spec.key]);
    }
  }, {
    key: 'fromData',
    value: function fromData(modelData) {
      if (modelData.__MODEL_KEY__ != null && typeof modelData.__MODEL_KEY__ !== 'undefined') {
        var spec = global.__MODEL_SPEC_REGISTRY__[modelData.__MODEL_KEY__];
        var model = new Model(spec);
        model.bind(Model.dataOf(modelData));
        return model;
      } else {
        throw new Error('[CATELA_MODEL] Model is not properly constructed (no __MODEL_KEY__ property in the object). You may need to specify get() when getting the model data.');
      }
    }
  }, {
    key: 'valueOf',
    value: function valueOf(data) {
      var dataValue = {};
      Object.keys(data).forEach(function (pk) {
        dataValue[pk] = {
          value: data[pk]
        };
      });
      return dataValue;
    }
  }, {
    key: 'dataOf',
    value: function dataOf(modelData) {
      var dataValue = {};
      Object.keys(modelData).forEach(function (pk) {
        if (typeof modelData[pk].value !== 'undefined') {
          dataValue[pk] = modelData[pk].value;
        }
      });
      return dataValue;
    }
  }]);

  return Model;
}();

exports.default = Model;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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

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

var ModelProperty = function () {
  function ModelProperty(model, key, display, validators, defaultValue) {
    _classCallCheck(this, ModelProperty);

    this._model = model;
    this._key = key;
    this._display = display;
    this._validators = validators;
    this._defaultValue = defaultValue;
    this.validation = {
      message: '',
      messages: [],
      valid: true,
      dirty: false
    };
    this.value = null;
  }

  _createClass(ModelProperty, [{
    key: 'check',
    value: function check() {
      return this.validate(this.value);
    }
  }, {
    key: 'validate',
    value: function validate(value) {
      var _this = this;

      var validators = this._validators;
      var messages = [];
      var allValid = true;
      if (validators != null && typeof validators !== 'undefined') {
        validators.forEach(function (v) {
          var validatorResult = v.apply(_this, value);
          if (!validatorResult.valid) {
            allValid = false;
            messages.push(validatorResult.message);
          }
        });
      }
      this.validation = {
        valid: allValid,
        messages: messages,
        message: messages[0] || '',
        dirty: true
      };
      return this.validation;
    }
  }, {
    key: 'default',
    value: function _default() {
      this.value = this._defaultValue;
      this.validation = {
        message: '',
        messages: [],
        valid: true,
        dirty: false
      };
    }
  }, {
    key: 'defaultValidation',
    value: function defaultValidation() {
      this.validation = {
        message: '',
        messages: [],
        valid: true,
        dirty: false
      };
    }
  }, {
    key: 'getValidation',
    value: function getValidation() {
      return this.validation;
    }
  }, {
    key: 'setValidation',
    value: function setValidation(validation) {
      this.validation = validation;
    }
  }, {
    key: 'getModel',
    value: function getModel() {
      return this._model;
    }
  }, {
    key: 'getValue',
    value: function getValue() {
      return this.value;
    }
  }, {
    key: 'setValue',
    value: function setValue(value) {
      var validationResult = this.validate(value);
      this.value = value;
      this.validation = validationResult;
      this.dirty = true;
    }
  }, {
    key: 'set',
    value: function set(value) {
      this.value = value;
    }
  }, {
    key: 'getDisplay',
    value: function getDisplay() {
      return this._display;
    }
  }, {
    key: 'getKey',
    value: function getKey() {
      return this._key;
    }
  }]);

  return ModelProperty;
}();

exports.default = ModelProperty;
module.exports = exports['default'];

/***/ }),
/* 7 */
/***/ (function(module, exports) {

module.exports = require("async");

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {

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

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

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

var DependencyInjection = {};

var Injectable = function () {
  function Injectable(name, container) {
    _classCallCheck(this, Injectable);

    this._name = name;
    this._getter = null;
    this._scope = null;
    this._by = null;
    this._container = container;
    this._singletonInstance = null;
  }

  _createClass(Injectable, [{
    key: 'toInstance',
    value: function toInstance(instance) {
      this._by = 'INSTANCE';
      this._getter = function () {
        return instance;
      };
      return this;
    }
  }, {
    key: 'to',
    value: function to(clazz) {
      this._by = 'CLASS';
      this._getter = clazz;
      return this;
    }
  }, {
    key: 'in',
    value: function _in(scope) {
      this._scope = scope;
    }
  }, {
    key: '_resolveAndRetrieveInstance',
    value: function _resolveAndRetrieveInstance(dependencies) {
      var _this = this;

      if (dependencies != null && typeof dependencies !== 'undefined') {
        var instanceDependencies = [null];
        dependencies.forEach(function (dependency) {
          var instanceDependency = _this._container.get(dependency);
          instanceDependencies.push(instanceDependency);
        });
        switch (this._by) {
          case 'INSTANCE':
            return this._getter();
          case 'CLASS':
            if (this._scope === DependencyInjection.Scope.SINGLETON) {
              if (this._singletonInstance == null || typeof this._singletonInstance === 'undefined') {
                this._singletonInstance = new (Function.prototype.bind.apply(this._getter, instanceDependencies))();
              }
              return this._singletonInstance;
            } else if (this._scope === DependencyInjection.Scope.LOCAL) {
              return new (Function.prototype.bind.apply(this._getter, instanceDependencies))();
            } else {
              return null;
            }
            return null;
          default:
            return null;
        }
      } else {
        switch (this._by) {
          case 'INSTANCE':
            return this._getter();
          case 'CLASS':
            if (this._scope === DependencyInjection.Scope.SINGLETON) {
              if (this._singletonInstance == null || typeof this._singletonInstance === 'undefined') {
                this._singletonInstance = new this._getter();
              }
              return this._singletonInstance;
            } else if (this._scope === DependencyInjection.Scope.LOCAL) {
              return new this._getter();
            } else {
              return null;
            }
            return null;
          default:
            return null;
        }
      }
    }
  }, {
    key: 'get',
    value: function get() {
      if (this._getter != null && typeof this._getter !== 'undefined') {
        var injections = this._getter.__INJECTION__;
        return this._resolveAndRetrieveInstance(injections);
      }
      return null;
    }
  }]);

  return Injectable;
}();

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

  _createClass(Module, [{
    key: 'configure',
    value: function configure(binder) {}
  }]);

  return Module;
}();

var DependencyInjectionBinder = function () {
  function DependencyInjectionBinder(container) {
    _classCallCheck(this, DependencyInjectionBinder);

    this._container = container;
  }

  _createClass(DependencyInjectionBinder, [{
    key: 'bind',
    value: function bind(name) {
      return this._container._bind(name);
    }
  }]);

  return DependencyInjectionBinder;
}();

var DependencyInjectionContainer = function () {
  function DependencyInjectionContainer() {
    _classCallCheck(this, DependencyInjectionContainer);

    this._bindables = {};
    this._binder = new DependencyInjectionBinder(this);
  }

  _createClass(DependencyInjectionContainer, [{
    key: '_bind',
    value: function _bind(name) {
      this._bindables[name] = new Injectable(name, this);
      return this._bindables[name];
    }
  }, {
    key: 'get',
    value: function get(name) {
      if (this._bindables[name] != null && typeof this._bindables[name] !== 'undefined') {
        return this._bindables[name].get();
      } else {
        throw new Error('[Ncuz] Dependency configuration not found for NAME -> ' + name);
      }
    }
  }, {
    key: 'install',
    value: function install(module) {
      if (module instanceof Module) {
        module.install(this._binder);
      }
    }
  }]);

  return DependencyInjectionContainer;
}();

if (global.__CONTAINER_REGISTRY__ == null || typeof global.__CONTAINER_REGISTRY__ === 'undefined') {
  global.__CONTAINER_REGISTRY__ = {};
}

DependencyInjection.createContainer = function (containerName) {
  if (global.__CONTAINER_REGISTRY__[containerName] == null || typeof global.__CONTAINER_REGISTRY__[containerName] === 'undefined') {
    global.__CONTAINER_REGISTRY__[containerName] = new DependencyInjectionContainer();
  }
  return DependencyInjection.getContainer(containerName);
};

DependencyInjection.getContainer = function (containerName) {
  return global.__CONTAINER_REGISTRY__[containerName];
};

DependencyInjection.Scope = {
  SINGLETON: 'SINGLETON',
  LOCAL: 'LOCAL'
};

var inject = function inject() {
  var _arguments = arguments;

  var FORBIDDEN_KEYS = ['length'];
  var args = [];
  Object.keys(arguments).forEach(function (i) {
    var isKeyForbidden = FORBIDDEN_KEYS.indexOf(i) >= 0;
    if (!isKeyForbidden) {
      args.push(_arguments[i]);
    }
  });
  return function wrapWithInject(WrappedClass) {
    WrappedClass.__INJECTION__ = args;
    return WrappedClass;
  };
};

exports.default = {
  DI: DependencyInjection,
  inject: inject,
  Module: Module
};
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {

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 _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 _PromiseHttpResourceExecutor = __webpack_require__(15);

var _PromiseHttpResourceExecutor2 = _interopRequireDefault(_PromiseHttpResourceExecutor);

var _const = __webpack_require__(2);

var _async = __webpack_require__(7);

var _async2 = _interopRequireDefault(_async);

var _querystring = __webpack_require__(39);

var _querystring2 = _interopRequireDefault(_querystring);

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

if (global.__RESOURCE_GROUP_REGISTRY__ == null || typeof global.__RESOURCE_GROUP_REGISTRY__ === 'undefined') {
  global.__RESOURCE_GROUP_REGISTRY__ = {};
}

var RemoteResourceExecution = function () {
  function RemoteResourceExecution(resource, resourceGroup, apiCaller) {
    _classCallCheck(this, RemoteResourceExecution);

    this._resource = resource;
    this._resourceGroup = resourceGroup;
    this._data = null;
    this._onProgressListener = null;
    this._attachments = null;
    this._configuration = {
      context: {},
      trackingContext: {},
      http: {
        headers: {},
        method: _const.HttpMethod.POST,
        contentType: 'application/json'
      },
      protocol: _const.Protocol.HTTP
    };
    this._apiCaller = apiCaller;
    this._successHandler = null;
    this._errorHandler = null;
    this._offlineHandler = null;
  }

  _createClass(RemoteResourceExecution, [{
    key: 'data',
    value: function data(_data) {
      this._data = _data;
      return this;
    }
  }, {
    key: 'onProgress',
    value: function onProgress(fn) {
      this._onProgressListener = fn;
      return this;
    }
  }, {
    key: 'attach',
    value: function attach(attachments) {
      this._attachments = attachments;
      return this;
    }
  }, {
    key: 'contentType',
    value: function contentType(_contentType) {
      this._configuration.http.contentType = _contentType;
      return this;
    }
  }, {
    key: 'context',
    value: function context(key, value) {
      this._configuration.context[key] = value;
      return this;
    }
  }, {
    key: 'trackingContext',
    value: function trackingContext(key, value) {
      this._configuration.trackingContext[key] = value;
      return this;
    }
  }, {
    key: 'setTrackingContext',
    value: function setTrackingContext(trackingContext) {
      var combinedTrackingContext = _extends({}, this._configuration.trackingContext, trackingContext);
      try {
        // TODO this is hack
        var fiz = global.__CONFIG__.fiz;
        combinedTrackingContext['ipAddress'] = fiz.ip('https://concierge-api.airyrooms.com/getIp');
      } catch (e) {}

      this._configuration.trackingContext = combinedTrackingContext;
      return this;
    }
  }, {
    key: 'method',
    value: function method(_method) {
      this._configuration.http.method = _method;
      return this;
    }
  }, {
    key: 'header',
    value: function header(key, value) {
      this._configuration.http.headers[key] = value;
      return this;
    }
  }, {
    key: 'protocol',
    value: function protocol(_protocol) {
      this._configuration.protocol = _protocol;
      return this;
    }
  }, {
    key: 'timeout',
    value: function timeout(_timeout) {
      this._configuration.http.timeout = _timeout;
      return this;
    }
  }, {
    key: '_createHttpAPIExecutionSpec',
    value: function _createHttpAPIExecutionSpec(data, context, trackingContext) {
      var url = this._resource.getUrl();
      if (this._resource._query) {
        url += this._resource._query;
      }
      return {
        uri: url,
        body: {
          data: data,
          context: context,
          trackingContext: trackingContext
        },
        headers: this._configuration.http.headers,
        method: this._configuration.http.method,
        contentType: this._configuration.http.contentType,
        timeout: this._configuration.http.timeout
      };
    }
  }, {
    key: '_executeHttpAPI',
    value: function _executeHttpAPI() {
      var resourceGroupContext = this._resourceGroup.getContext();
      var resourceContext = this._resource.getContext();
      var resourceExecutionContext = this._configuration.context;
      var resourceExecutionTrackingContext = this._configuration.trackingContext;

      var finalContext = {};
      var finalTrackingContext = {};

      finalTrackingContext = _extends({}, finalTrackingContext, resourceExecutionTrackingContext);
      finalContext = _extends({}, finalContext, resourceGroupContext);

      finalContext = _extends({}, finalContext, resourceContext);

      finalContext = _extends({}, finalContext, resourceExecutionContext);

      var apiSpec = this._createHttpAPIExecutionSpec(this._data, finalContext, finalTrackingContext);
      this._apiCaller.execute(apiSpec, this._offlineHandler, this._errorHandler, this._successHandler, this._attachments, this._onProgressListener);
    }
  }, {
    key: 'execute',
    value: function execute() {
      var _this = this,
          _arguments = arguments;

      var beforeExecuteFilterFn = [];
      if (this._resourceGroup.getOnBeforeExecuteFilters() != null) {
        if (this._resourceGroup.getOnBeforeExecuteFilters().length > 0) {
          this._resourceGroup.getOnBeforeExecuteFilters().forEach(function (f) {
            beforeExecuteFilterFn.push(f);
          });
        }
      }

      if (this._resource.getOnBeforeExecuteFilters() != null) {
        if (this._resource.getOnBeforeExecuteFilters().length > 0) {
          this._resource.getOnBeforeExecuteFilters().forEach(function (f) {
            beforeExecuteFilterFn.push(f);
          });
        }
      }

      if (beforeExecuteFilterFn.length > 0) {
        var beforeExecuteFilterFnCallQueue = [];
        var idx = 0;
        beforeExecuteFilterFn.forEach(function (beff) {
          if (idx === 0) {
            beforeExecuteFilterFnCallQueue.push(function (callback) {
              // TODO handle short circuit
              return beff(_this, callback);
            });
          } else {
            beforeExecuteFilterFnCallQueue.push(function (result, callback) {
              // TODO handle short circuit
              console.log(_arguments, result);
              return beff(_this, callback);
            });
          }
          idx += 1;
        });

        _async2.default.waterfall(beforeExecuteFilterFnCallQueue, function (err, results) {
          if (err) {
            // TODO handle error
          } else {
            if (_this._configuration.protocol === _const.Protocol.HTTP) {
              _this._executeHttpAPI();
            } else {
              // TODO should we call / handle additional protocol?
            }
          }
        });
      } else {
        if (this._configuration.protocol === _const.Protocol.HTTP) {
          this._executeHttpAPI();
        } else {
          // TODO should we call / handle additional protocol?
        }
      }
    }
  }, {
    key: 'success',
    value: function success(fn) {
      this._successHandler = fn;
      return this;
    }
  }, {
    key: 'error',
    value: function error(fn) {
      this._errorHandler = fn;
      return this;
    }
  }, {
    key: 'offline',
    value: function offline(fn) {
      this._offlineHandler = fn;
      return this;
    }
  }]);

  return RemoteResourceExecution;
}();

var RemoteResource = function () {
  function RemoteResource(resourceGroup, url) {
    _classCallCheck(this, RemoteResource);

    this._resourceGroup = resourceGroup;
    this._url = url;
    this._originalUrl = url;
    this._query = '';
    this._configuration = {
      context: {}
    };
    this._onBeforeExecuteFilters = [];
    this._onAfterExecuteFilters = [];
    this._resourceExecutor = resourceGroup.getResourceExecutor();
  }

  _createClass(RemoteResource, [{
    key: 'onBeforeExecute',
    value: function onBeforeExecute(filterFn) {
      this._onBeforeExecuteFilters.push(filterFn);
    }
  }, {
    key: 'onAfterExecute',
    value: function onAfterExecute(filterFn) {
      this._onAfterExecuteFilters.push(filterFn);
    }
  }, {
    key: 'context',
    value: function context(key, value) {
      this._configuration.context[key] = value;
    }
  }, {
    key: 'prepare',
    value: function prepare() {
      return new RemoteResourceExecution(this, this._resourceGroup, this._resourceExecutor);
    }
  }, {
    key: 'param',
    value: function param(_param) {
      var _this2 = this;

      if (_param) {
        Object.keys(_param).forEach(function (key) {
          var value = _param[key];
          _this2._url = _this2._originalUrl.replace(':' + key, value);
        });
      }
      return this;
    }
  }, {
    key: 'use',
    value: function use(resourceExecutor) {
      this._resourceExecutor = resourceExecutor;
    }
  }, {
    key: 'getContext',
    value: function getContext() {
      return this._configuration.context;
    }
  }, {
    key: 'getOnBeforeExecuteFilters',
    value: function getOnBeforeExecuteFilters() {
      return this._onBeforeExecuteFilters;
    }
  }, {
    key: 'getOnAfterExecuteFilters',
    value: function getOnAfterExecuteFilters() {
      return this._onAfterExecuteFilters;
    }
  }, {
    key: 'getUrl',
    value: function getUrl() {
      return this._url;
    }
  }, {
    key: 'getQuery',
    value: function getQuery() {
      return this._query;
    }
  }, {
    key: 'setQuery',
    value: function setQuery(q) {
      this._query = q;
    }
  }]);

  return RemoteResource;
}();

var RemoteResourceGroup = function () {
  function RemoteResourceGroup(name) {
    _classCallCheck(this, RemoteResourceGroup);

    this._name = name;
    this._configuration = {
      context: {}
    };
    this._onBeforeExecuteFilters = [];
    this._onAfterExecuteFilters = [];
    this._resourceExecutor = new _PromiseHttpResourceExecutor2.default();
  }

  _createClass(RemoteResourceGroup, [{
    key: 'use',
    value: function use(resourceExecutor) {
      this._resourceExecutor = resourceExecutor;
    }
  }, {
    key: 'create',
    value: function create(url) {
      return new RemoteResource(this, url);
    }
  }, {
    key: 'createWithQuery',
    value: function createWithQuery(url, query) {
      var q = "?" + _querystring2.default.stringify(query);
      this._query = q;
      var remoteResource = new RemoteResource(this, url);
      remoteResource.setQuery(q);
      return remoteResource;
    }
  }, {
    key: 'context',
    value: function context(key, value) {
      this._configuration.context[key] = value;
    }
  }, {
    key: 'onBeforeExecute',
    value: function onBeforeExecute(filterFn) {
      this._onBeforeExecuteFilters.push(filterFn);
    }
  }, {
    key: 'onAfterExecute',
    value: function onAfterExecute(filterFn) {
      this._onAfterExecuteFilters.push(filterFn);
    }
  }, {
    key: 'getContext',
    value: function getContext() {
      return this._configuration.context;
    }
  }, {
    key: 'getOnBeforeExecuteFilters',
    value: function getOnBeforeExecuteFilters() {
      return this._onBeforeExecuteFilters;
    }
  }, {
    key: 'getOnAfterExecuteFilters',
    value: function getOnAfterExecuteFilters() {
      return this._onAfterExecuteFilters;
    }
  }, {
    key: 'getResourceExecutor',
    value: function getResourceExecutor() {
      return this._resourceExecutor;
    }
  }]);

  return RemoteResourceGroup;
}();

RemoteResource.group = function (groupName) {
  if (global.__RESOURCE_GROUP_REGISTRY__[groupName] == null || typeof global.__RESOURCE_GROUP_REGISTRY__[groupName] === 'undefined') {
    global.__RESOURCE_GROUP_REGISTRY__[groupName] = new RemoteResourceGroup(groupName);
  }
  return global.__RESOURCE_GROUP_REGISTRY__[groupName];
};

exports.default = {
  RemoteResource: RemoteResource
};
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

"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 _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 _async = __webpack_require__(7);

var _async2 = _interopRequireDefault(_async);

var _FetchableInstanceFactory = __webpack_require__(18);

var _FetchableInstanceFactory2 = _interopRequireDefault(_FetchableInstanceFactory);

var _hoistNonReactStatics = __webpack_require__(38);

var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);

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

var fetchableInstanceFactory = new _FetchableInstanceFactory2.default();

function getDisplayName(WrappedComponent) {
  return WrappedComponent.displayName || WrappedComponent.name || 'Component';
}

function fetch(fetchClasses) {
  return function wrapWithFetch(WrappedComponent) {
    var fetchableDisplayName = 'Fetchable(' + getDisplayName(WrappedComponent) + ')';

    var FetchableWrappedComponent = function (_WrappedComponent) {
      _inherits(FetchableWrappedComponent, _WrappedComponent);

      function FetchableWrappedComponent(props, context) {
        _classCallCheck(this, FetchableWrappedComponent);

        var _this = _possibleConstructorReturn(this, (FetchableWrappedComponent.__proto__ || Object.getPrototypeOf(FetchableWrappedComponent)).call(this, props, context));

        _this.fetch = {};
        _this.model = _this.context.model;
        return _this;
      }

      _createClass(FetchableWrappedComponent, [{
        key: 'render',
        value: function render() {
          return this.__innerRender();
        }
      }]);

      return FetchableWrappedComponent;
    }(WrappedComponent);

    FetchableWrappedComponent.displayName = fetchableDisplayName;
    FetchableWrappedComponent.prototype.__innerRender = WrappedComponent.prototype.render;
    FetchableWrappedComponent.__fetchData = function (store, context, callback) {
      if (typeof fetchClasses !== 'undefined' && fetchClasses != null) {
        var asyncCalls = {};
        Object.keys(fetchClasses).forEach(function (kc) {
          asyncCalls[kc] = function (callback) {
            var fetchDataInstance = fetchableInstanceFactory.getFetchableInstance(fetchClasses[kc]);
            if (fetchDataInstance.disableClient() && !context.server) {
              callback(null, []);
            } else {
              fetchDataInstance.fetch(store, context, function (err, results) {
                if (err) {
                  console.log('[' + kc + '] Unknown error occurred when trying to fetch data. ', err);
                  callback(err, null);
                } else {
                  store[kc] = results;
                  callback(null, results);
                }
              });
            }
          };
        });
        _async2.default.series(asyncCalls, function (err, results) {
          if (err) {
            callback(err, null);
          } else {
            callback(null, results);
          }
        });
      } else {
        callback(null, store);
      }
    };
    return (0, _hoistNonReactStatics2.default)(FetchableWrappedComponent, WrappedComponent);
  };
}

function simpleReducer() {
  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var action = arguments[1];

  switch (action.type) {
    case '__SET_VIEW_STATE__':
      var newState = _extends({}, state, action.data);
      return newState;
    default:
      return state;
  }
  return state;
}

exports.default = {
  fetch: fetch,
  serverFetchReducer: simpleReducer
};
module.exports = exports['default'];

/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
function preFetch(filterFunction) {
  return function wrapWithFilter(WrappedComponent) {
    if (WrappedComponent.__preFetchFilter == null || typeof WrappedComponent.__preFetchFilter === 'undefined') {
      WrappedComponent.__preFetchFilter = [];
    }
    WrappedComponent.__preFetchFilter.push(function (filterContext) {
      filterFunction(filterContext);
    });
    return WrappedComponent;
  };
}

function postFetch(filterFunction) {
  return function wrapWithFilter(WrappedComponent) {
    if (WrappedComponent.__postFetchFilter == null || typeof WrappedComponent.__postFetchFilter === 'undefined') {
      WrappedComponent.__postFetchFilter = [];
    }
    WrappedComponent.__postFetchFilter.push(function (filterContext) {
      filterFunction(filterContext);
    });
    return WrappedComponent;
  };
}

exports.default = {
  preFetch: preFetch,
  postFetch: postFetch
};
module.exports = exports['default'];

/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Model = __webpack_require__(5);

var _Model2 = _interopRequireDefault(_Model);

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

var ModelFunction = function () {
  function ModelFunction(model, onChangeListener, onCollectListener) {
    _classCallCheck(this, ModelFunction);

    this._model = _Model2.default.fromSpec(model);
    this._onChangeListener = onChangeListener;
    this._onCollectListener = onCollectListener;
  }

  _createClass(ModelFunction, [{
    key: 'getModel',
    value: function getModel() {
      return this._model;
    }
  }, {
    key: 'listenInput',
    value: function listenInput(field) {
      var _this = this;

      var self = this;
      return function (e) {
        self._model[field].setValue(e.target.value);
        if (self._onChangeListener != null && typeof self._onChangeListener !== 'undefined') {
          self._onChangeListener(self._model, field, e.target.value, _this);
        }
      };
    }
  }, {
    key: 'listenInputOnly',
    value: function listenInputOnly(field) {
      var _this2 = this;

      var self = this;
      return function (e) {
        if (self._onChangeListener != null && typeof self._onChangeListener !== 'undefined') {
          self._onChangeListener(self._model, field, e.target.value, _this2);
        }
      };
    }
  }, {
    key: 'listen',
    value: function listen(field) {
      var _this3 = this;

      var self = this;
      return function (value) {
        self._model[field].setValue(value);
        if (self._onChangeListener != null && typeof self._onChangeListener !== 'undefined') {
          self._onChangeListener(self._model, field, value, _this3);
        }
      };
    }
  }, {
    key: 'listenOnly',
    value: function listenOnly(field) {
      var _this4 = this;

      var self = this;
      return function (value) {
        if (self._onChangeListener != null && typeof self._onChangeListener !== 'undefined') {
          self._onChangeListener(self._model, field, value, _this4);
        }
      };
    }
  }, {
    key: 'value',
    value: function value(field) {
      if (this._model[field] != null && typeof this._model[field] !== 'undefined') {
        return this._model[field].value;
      } else {
        return null;
      }
    }
  }, {
    key: 'set',
    value: function set(field, value) {
      if (this._model[field] != null && typeof this._model[field] !== 'undefined') {
        this._model[field].set(value);
      }
    }
  }, {
    key: 'validation',
    value: function validation(field) {
      if (this._model[field] != null && typeof this._model[field] !== 'undefined') {
        return this._model[field].validation;
      } else {
        return {
          message: ''
        };
      }
    }
  }, {
    key: 'bind',
    value: function bind(value) {
      this._model.bind(value);
    }
  }, {
    key: 'updateAction',
    value: function updateAction() {
      return {
        type: '__MODEL_UPDATE__',
        data: this._model.getValue()
      };
    }
  }, {
    key: 'collect',
    value: function collect() {
      var self = this;
      return function () {
        self._onCollectListener(self._model);
      };
    }
  }], [{
    key: 'setup',
    value: function setup(model, onChange, onCollect) {
      return new ModelFunction(model, onChange, onCollect);
    }
  }]);

  return ModelFunction;
}();

exports.default = ModelFunction;
module.exports = exports['default'];

/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

var _EmailValidator = __webpack_require__(23);

var _EmailValidator2 = _interopRequireDefault(_EmailValidator);

var _LengthRangeValidator = __webpack_require__(24);

var _LengthRangeValidator2 = _interopRequireDefault(_LengthRangeValidator);

var _NumberValidator = __webpack_require__(28);

var _NumberValidator2 = _interopRequireDefault(_NumberValidator);

var _PhoneNumberValidator = __webpack_require__(30);

var _PhoneNumberValidator2 = _interopRequireDefault(_PhoneNumberValidator);

var _RequiredValidator = __webpack_require__(31);

var _RequiredValidator2 = _interopRequireDefault(_RequiredValidator);

var _ValueRangeValidator = __webpack_require__(37);

var _ValueRangeValidator2 = _interopRequireDefault(_ValueRangeValidator);

var _AlphanumericValidator = __webpack_require__(19);

var _AlphanumericValidator2 = _interopRequireDefault(_AlphanumericValidator);

var _StrongPasswordValidator = __webpack_require__(32);

var _StrongPasswordValidator2 = _interopRequireDefault(_StrongPasswordValidator);

var _MatchValidator = __webpack_require__(25);

var _MatchValidator2 = _interopRequireDefault(_MatchValidator);

var _DateValidator = __webpack_require__(22);

var _DateValidator2 = _interopRequireDefault(_DateValidator);

var _DateGreaterThanValidator = __webpack_require__(20);

var _DateGreaterThanValidator2 = _interopRequireDefault(_DateGreaterThanValidator);

var _DateLesserThanValidator = __webpack_require__(21);

var _DateLesserThanValidator2 = _interopRequireDefault(_DateLesserThanValidator);

var _NumberGreaterThanValidator = __webpack_require__(26);

var _NumberGreaterThanValidator2 = _interopRequireDefault(_NumberGreaterThanValidator);

var _NumberLesserThanValidator = __webpack_require__(27);

var _NumberLesserThanValidator2 = _interopRequireDefault(_NumberLesserThanValidator);

var _ObjectRequiredValidator = __webpack_require__(29);

var _ObjectRequiredValidator2 = _interopRequireDefault(_ObjectRequiredValidator);

var _TimeGreaterThanOrEqualToValidator = __webpack_require__(33);

var _TimeGreaterThanOrEqualToValidator2 = _interopRequireDefault(_TimeGreaterThanOrEqualToValidator);

var _TimeGreaterThanValidator = __webpack_require__(34);

var _TimeGreaterThanValidator2 = _interopRequireDefault(_TimeGreaterThanValidator);

var _TimeLessThanOrEqualToValidator = __webpack_require__(35);

var _TimeLessThanOrEqualToValidator2 = _interopRequireDefault(_TimeLessThanOrEqualToValidator);

var _TimeLessThanValidator = __webpack_require__(36);

var _TimeLessThanValidator2 = _interopRequireDefault(_TimeLessThanValidator);

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

exports.default = {
  EmailValidator: _EmailValidator2.default,
  LengthRangeValidator: _LengthRangeValidator2.default,
  NumberValidator: _NumberValidator2.default,
  PhoneNumberValidator: _PhoneNumberValidator2.default,
  RequiredValidator: _RequiredValidator2.default,
  ValueRangeValidator: _ValueRangeValidator2.default,
  AlphanumericValidator: _AlphanumericValidator2.default,
  StrongPasswordValidator: _StrongPasswordValidator2.default,
  MatchValidator: _MatchValidator2.default,
  DateValidator: _DateValidator2.default,
  DateGreaterThanValidator: _DateGreaterThanValidator2.default,
  DateLesserThanValidator: _DateLesserThanValidator2.default,
  NumberGreaterThanValidator: _NumberGreaterThanValidator2.default,
  NumberLesserThanValidator: _NumberLesserThanValidator2.default,
  ObjectRequiredValidator: _ObjectRequiredValidator2.default,
  TimeGreaterThanOrEqualToValidator: _TimeGreaterThanOrEqualToValidator2.default,
  TimeGreaterThanValidator: _TimeGreaterThanValidator2.default,
  TimeLessThanOrEqualToValidator: _TimeLessThanOrEqualToValidator2.default,
  TimeLessThanValidator: _TimeLessThanValidator2.default
};
module.exports = exports['default'];

/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
function render(renderHtmlPath, bindFn) {
  return function (WrappedComponent) {
    WrappedComponent.__renderPage = renderHtmlPath;
    if (bindFn != null && typeof bindFn !== 'undefined') {
      WrappedComponent.__renderBindFn = bindFn;
    }
    return WrappedComponent;
  };
}

exports.default = {
  render: render
};
module.exports = exports['default'];

/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _superagentBluebirdPromise = __webpack_require__(40);

var _superagentBluebirdPromise2 = _interopRequireDefault(_superagentBluebirdPromise);

var _const = __webpack_require__(2);

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

var PromiseHttpResourceExecutor = function () {
  function PromiseHttpResourceExecutor() {
    _classCallCheck(this, PromiseHttpResourceExecutor);

    this._forbiddenHeadersInClient = ['cookie'];
  }

  _createClass(PromiseHttpResourceExecutor, [{
    key: 'validate',
    value: function validate(resourceExecutionSpec) {
      return true;
    }
  }, {
    key: 'execute',
    value: function execute(resourceExecutionSpec, offlineCallback, errorCallback, successCallback, attachments, onProgressListener) {
      switch (resourceExecutionSpec.method) {
        case _const.HttpMethod.POST:
          return this._executePOSTResourceExecution(resourceExecutionSpec, offlineCallback, errorCallback, successCallback, attachments, onProgressListener);
        case _const.HttpMethod.GET:
          return this._executeGETResourceExecution(resourceExecutionSpec, offlineCallback, errorCallback, successCallback);
      }
    }
  }, {
    key: '_handleBadGateway',
    value: function _handleBadGateway(err, result, offlineCallback, errorCallback, successCallback) {
      if (err) {
        errorCallback(err, null);
      } else {
        errorCallback(new Error('[ERROR_CODE_502] An error occurred when trying to execute resource. Error code: 502 - Bad Gateway.', null));
      }
    }
  }, {
    key: '_handleServerError',
    value: function _handleServerError(err, result, offlineCallback, errorCallback, successCallback) {
      if (err) {
        errorCallback(err, null);
      } else {
        errorCallback(new Error('[ERROR_CODE_500] An error occurred when trying to execute resource. Error code: 500 - Internal server error.', null));
      }
    }
  }, {
    key: '_handleServerUnavailable',
    value: function _handleServerUnavailable(err, result, offlineCallback, errorCallback, successCallback) {
      if (err) {
        errorCallback(err, null);
      } else {
        errorCallback(new Error('[ERROR_CODE_503] An error occurred when trying to execute resource. Error code: 503 - Server Unavailable.', null));
      }
    }
  }, {
    key: '_handleBadRequest',
    value: function _handleBadRequest(err, result, offlineCallback, errorCallback, successCallback) {
      if (err) {
        errorCallback(err, null);
      } else {
        errorCallback(new Error('[ERROR_CODE_400] An error occurred when trying to execute resource. Error code: 400 - Bad Request.', null));
      }
    }
  }, {
    key: '_handleUnauthorized',
    value: function _handleUnauthorized(err, result, offlineCallback, errorCallback, successCallback) {
      if (err) {
        errorCallback(err, null);
      } else {
        errorCallback(new Error('[ERROR_CODE_401] An error occurred when trying to execute resource. Error code: 401 - Bad Gateway.', null));
      }
    }
  }, {
    key: '_handleForbidden',
    value: function _handleForbidden(err, result, offlineCallback, errorCallback, successCallback) {
      if (err) {
        errorCallback(err, null);
      } else {
        errorCallback(new Error('[ERROR_CODE_403] An error occurred when trying to execute resource. Error code: 403 - Forbidden.', null));
      }
    }
  }, {
    key: '_handleSuccess',
    value: function _handleSuccess(err, result, offlineCallback, errorCallback, successCallback) {
      if (err) {
        errorCallback(err, null);
      } else {
        var resourceExecutionResult = {
          status: result.status,
          body: result.body,
          headers: result.headers
        };
        successCallback(null, resourceExecutionResult);
      }
    }
  }, {
    key: '_handleNoContent',
    value: function _handleNoContent(err, result, offlineCallback, errorCallback, successCallback) {
      if (err) {
        errorCallback(err, null);
      } else {
        var resourceExecutionResult = {
          status: result.status,
          data: null,
          headers: result.headers
        };
        successCallback(null, resourceExecutionResult);
      }
    }
  }, {
    key: '_handleUnprocessableEntity',
    value: function _handleUnprocessableEntity(err, result, offlineCallback, errorCallback, successCallback) {
      if (err) {
        errorCallback(err, null);
      } else {
        errorCallback(new Error('[ERROR_CODE_422] An error occurred when trying to execute resource. Error code: 422 - Unprocessable entity.', null));
      }
    }
  }, {
    key: '_handleUnsupportedMediaType',
    value: function _handleUnsupportedMediaType(err, result, offlineCallback, errorCallback, successCallback) {
      if (err) {
        errorCallback(err, null);
      } else {
        errorCallback(new Error('[ERROR_CODE_415] An error occurred when trying to execute resource. Error code: 415 - Unsupported media type.', null));
      }
    }
  }, {
    key: '_executeGETResourceExecution',
    value: function _executeGETResourceExecution(resourceExecutionSpec, offlineCallback, errorCallback, successCallback) {
      var _this = this;

      var getRequest = _superagentBluebirdPromise2.default.get(resourceExecutionSpec.uri).withCredentials();

      if (resourceExecutionSpec.headers != null && typeof resourceExecutionSpec !== 'undefined') {
        if (__SERVER__) {
          Object.keys(resourceExecutionSpec.headers).forEach(function (h) {
            getRequest.set(h, resourceExecutionSpec.headers[h]);
          });
        } else {
          Object.keys(resourceExecutionSpec.headers).forEach(function (h) {
            if (_this._forbiddenHeadersInClient.indexOf(h.toLowerCase()) < 0) {
              getRequest.set(h, resourceExecutionSpec.headers[h]);
            }
          });
        }
      }

      if (resourceExecutionSpec.timeout != null && typeof resourceExecutionSpec.timeout !== 'undefined') {
        getRequest.timeout(resourceExecutionSpec.timeout);
      }

      getRequest.end(function (err, result) {
        if (err) {
          return _this._handleServerError(err, result, offlineCallback, errorCallback, successCallback);
        } else {
          switch (result.status) {
            case 502:
              return _this._handleBadGateway(err, result, offlineCallback, errorCallback, successCallback);
            case 500:
              return _this._handleServerError(err, result, offlineCallback, errorCallback, successCallback);
            case 503:
              return _this._handleServerUnavailable(err, result, offlineCallback, errorCallback, successCallback);
            case 400:
              return _this._handleBadRequest(err, result, offlineCallback, errorCallback, successCallback);
            case 401:
              return _this._handleUnauthorized(err, result, offlineCallback, errorCallback, successCallback);
            case 403:
              return _this._handleForbidden(err, result, offlineCallback, errorCallback, successCallback);
            case 200:
              return _this._handleSuccess(null, result, offlineCallback, errorCallback, successCallback);
            case 204:
              return _this._handleNoContent(err, result, offlineCallback, errorCallback, successCallback);
            case 422:
              return _this._handleUnprocessableEntity(err, result, offlineCallback, errorCallback, successCallback);
            case 415:
              return _this._handleUnsupportedMediaType(err, result, offlineCallback, errorCallback, successCallback);
          }
        }
      });
    }
  }, {
    key: '_executePOSTResourceExecution',
    value: function _executePOSTResourceExecution(resourceExecutionSpec, offlineCallback, errorCallback, successCallback, attachments, onProgressListener) {
      var _this2 = this;

      var postRequest = _superagentBluebirdPromise2.default.post(resourceExecutionSpec.uri).withCredentials();

      if (attachments) {
        Object.keys(attachments).forEach(function (key) {
          postRequest.attach(key, attachments[key]);
        });
      }

      if (onProgressListener) {
        postRequest.on('progress', onProgressListener);
      }

      if (resourceExecutionSpec.body != null && typeof resourceExecutionSpec.body !== 'undefined') {
        if (!attachments) {
          postRequest.send(JSON.stringify(resourceExecutionSpec.body));
        }
      }
      if (resourceExecutionSpec.contentType != null && typeof resourceExecutionSpec.contentType !== 'undefined') {
        postRequest.set('Content-Type', resourceExecutionSpec.contentType);
      }
      if (resourceExecutionSpec.timeout != null && typeof resourceExecutionSpec.timeout !== 'undefined') {
        postRequest.timeout(resourceExecutionSpec.timeout);
      }

      if (resourceExecutionSpec.headers != null && typeof resourceExecutionSpec !== 'undefined') {
        if (__SERVER__) {
          Object.keys(resourceExecutionSpec.headers).forEach(function (h) {
            postRequest.set(h, resourceExecutionSpec.headers[h]);
          });
        } else {
          Object.keys(resourceExecutionSpec.headers).forEach(function (h) {
            if (_this2._forbiddenHeadersInClient.indexOf(h.toLowerCase()) < 0) {
              postRequest.set(h, resourceExecutionSpec.headers[h]);
            }
          });
        }
      }

      postRequest.end(function (err, result) {
        if (err) {
          return _this2._handleServerError(err, result, offlineCallback, errorCallback, successCallback);
        } else {
          switch (result.status) {
            case 502:
              return _this2._handleBadGateway(err, result, offlineCallback, errorCallback, successCallback);
            case 500:
              return _this2._handleServerError(err, result, offlineCallback, errorCallback, successCallback);
            case 503:
              return _this2._handleServerUnavailable(err, result, offlineCallback, errorCallback, successCallback);
            case 400:
              return _this2._handleBadRequest(err, result, offlineCallback, errorCallback, successCallback);
            case 401:
              return _this2._handleUnauthorized(err, result, offlineCallback, errorCallback, successCallback);
            case 403:
              return _this2._handleForbidden(err, result, offlineCallback, errorCallback, successCallback);
            case 200:
              return _this2._handleSuccess(null, result, offlineCallback, errorCallback, successCallback);
            case 204:
              return _this2._handleNoContent(err, result, offlineCallback, errorCallback, successCallback);
            case 422:
              return _this2._handleUnprocessableEntity(err, result, offlineCallback, errorCallback, successCallback);
            case 415:
              return _this2._handleUnsupportedMediaType(err, result, offlineCallback, errorCallback, successCallback);
          }
        }
      });
    }
  }]);

  return PromiseHttpResourceExecutor;
}();

exports.default = PromiseHttpResourceExecutor;
module.exports = exports['default'];

/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

"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 _core = __webpack_require__(10);

var _DataFetch = __webpack_require__(4);

var _DataFetch2 = _interopRequireDefault(_DataFetch);

var _Model = __webpack_require__(5);

var _Model2 = _interopRequireDefault(_Model);

var _ModelProperty = __webpack_require__(6);

var _ModelProperty2 = _interopRequireDefault(_ModelProperty);

var _ModelFunction = __webpack_require__(12);

var _ModelFunction2 = _interopRequireDefault(_ModelFunction);

var _validation = __webpack_require__(13);

var _validation2 = _interopRequireDefault(_validation);

var _Resource = __webpack_require__(9);

var _filter = __webpack_require__(11);

var _Ncuz = __webpack_require__(8);

var _render = __webpack_require__(14);

var _const = __webpack_require__(2);

var _const2 = _interopRequireDefault(_const);

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

exports.default = {
  HttpMethod: _const2.default.HttpMethod,
  Protocol: _const2.default.Protocol,
  render: _render.render,
  fetch: _core.fetch,
  preFetch: _filter.preFetch,
  postFetch: _filter.postFetch,
  DataFetch: _DataFetch2.default,
  model: {
    Model: _Model2.default,
    ModelProperty: _ModelProperty2.default,
    ModelFunction: _ModelFunction2.default,
    validation: _extends({}, _validation2.default)
  },
  resource: {
    RemoteResource: _Resource.RemoteResource
  },
  ncuz: {
    DI: _Ncuz.DI,
    inject: _Ncuz.inject,
    Module: _Ncuz.Module
  }
};
module.exports = exports['default'];

/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _DataFetch2 = __webpack_require__(4);

var _DataFetch3 = _interopRequireDefault(_DataFetch2);

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

var FetchableInstance = function (_DataFetch) {
  _inherits(FetchableInstance, _DataFetch);

  function FetchableInstance(FetchClass) {
    _classCallCheck(this, FetchableInstance);

    var _this = _possibleConstructorReturn(this, (FetchableInstance.__proto__ || Object.getPrototypeOf(FetchableInstance)).call(this));

    _this._innerFetchInstance = new FetchClass();
    _this._innerFetchInstance.disableClient = FetchClass.disableClient;
    return _this;
  }

  _createClass(FetchableInstance, [{
    key: 'fetch',
    value: function fetch(store, context, callback) {
      this._innerFetchInstance.fetch(store, context, function (err, results) {
        callback(err, results);
      });
    }
  }, {
    key: 'disableClient',
    value: function disableClient() {
      return this._innerFetchInstance.disableClient;
    }
  }]);

  return FetchableInstance;
}(_DataFetch3.default);

exports.default = FetchableInstance;
module.exports = exports['default'];

/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _FetchableInstance = __webpack_require__(17);

var _FetchableInstance2 = _interopRequireDefault(_FetchableInstance);

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

var FetchableInstanceFactory = function () {
  function FetchableInstanceFactory() {
    _classCallCheck(this, FetchableInstanceFactory);

    this._dataFetchInstanceCache = new Map();
  }

  _createClass(FetchableInstanceFactory, [{
    key: 'getFetchableInstance',
    value: function getFetchableInstance(FetchClass) {
      var construct = true;
      if (FetchClass.KeyProperty != null && typeof FetchClass.KeyProperty !== 'undefined') {
        if (FetchClass.EnableCache === true) {
          if (this._dataFetchInstanceCache.get(FetchClass.Key) != null && typeof FetchClass.Key !== 'undefined') {
            construct = false;
          }
        }
      }
      if (construct) {
        var fetchableInstance = new _FetchableInstance2.default(FetchClass);
        this._dataFetchInstanceCache.set(FetchClass.KeyProperty, fetchableInstance);
        return fetchableInstance;
      } else {
        return this._dataFetchInstanceCache.get(FetchClass.Key);
      }
    }
  }]);

  return FetchableInstanceFactory;
}();

exports.default = FetchableInstanceFactory;
module.exports = exports['default'];

/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var AlphanumericValidator = function (_Validator) {
  _inherits(AlphanumericValidator, _Validator);

  function AlphanumericValidator(field, display, option) {
    _classCallCheck(this, AlphanumericValidator);

    var _this = _possibleConstructorReturn(this, (AlphanumericValidator.__proto__ || Object.getPrototypeOf(AlphanumericValidator)).call(this));

    _this._alphaNumericRegex = /^\w+$/;
    return _this;
  }

  _createClass(AlphanumericValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      var valid = this._alphaNumericRegex.test(value);
      if (valid) {
        return {
          valid: true,
          message: ''
        };
      } else {
        return {
          valid: false,
          message: field.getDisplay() + ' hanya bisa berisikan angka, huruf, dan _.'
        };
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {}
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new AlphanumericValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return AlphanumericValidator;
}(_Validator3.default);

exports.default = AlphanumericValidator;
module.exports = exports['default'];

/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

var _moment = __webpack_require__(1);

var _moment2 = _interopRequireDefault(_moment);

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

var DateGreaterThanValidator = function (_Validator) {
  _inherits(DateGreaterThanValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (DateGreaterThanValidator.__proto__ || Object.getPrototypeOf(DateGreaterThanValidator)).call(this));

    _this._target = null;
    return _this;
  }

  _createClass(DateGreaterThanValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      var model = field.getModel();
      var targetField = model[this._target];
      if (value == null || targetField.getValue() == null) {
        return {
          valid: false,
          message: 'Tanggal ' + field.getDisplay() + ' harus lebih besar dari tanggal ' + targetField.getDisplay() + ' dan kedua tanggal tidak boleh kosong.'
        };
      } else {
        var fieldMomentValue = (0, _moment2.default)(value);
        var targetFieldMomentValue = (0, _moment2.default)(targetField.getValue());
        var diff = targetFieldMomentValue.diff(fieldMomentValue, 'days');
        if (diff < 0) {
          return {
            valid: true,
            message: ''
          };
        } else {
          return {
            valid: false,
            message: 'Tanggal ' + field.getDisplay() + ' harus lebih besar dari tanggal ' + targetField.getDisplay() + '.'
          };
        }
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {
      if (option != null && typeof option !== 'undefined') {
        this._target = option.target;
      }
    }
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new DateGreaterThanValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return DateGreaterThanValidator;
}(_Validator3.default);

exports.default = DateGreaterThanValidator;
module.exports = exports['default'];

/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

var _moment = __webpack_require__(1);

var _moment2 = _interopRequireDefault(_moment);

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

var DateLesserThanValidator = function (_Validator) {
  _inherits(DateLesserThanValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (DateLesserThanValidator.__proto__ || Object.getPrototypeOf(DateLesserThanValidator)).call(this));

    _this._target = null;
    return _this;
  }

  _createClass(DateLesserThanValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      var model = field.getModel();
      var targetField = model[this._target];
      if (value == null || targetField.getValue() == null) {
        return {
          valid: false,
          message: 'Tanggal ' + field.getDisplay() + ' harus lebih kecil dari tanggal ' + targetField.getDisplay() + ' dan kedua tanggal tidak boleh kosong.'
        };
      } else {
        var fieldMomentValue = (0, _moment2.default)(value);
        var targetFieldMomentValue = (0, _moment2.default)(targetField.getValue());
        var diff = fieldMomentValue.diff(targetFieldMomentValue, 'days');
        if (diff < 0) {
          return {
            valid: true,
            message: ''
          };
        } else {
          return {
            valid: false,
            message: 'Tanggal ' + field.getDisplay() + ' harus lebih kecil dari tanggal ' + targetField.getDisplay() + '.'
          };
        }
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {
      if (option != null && typeof option !== 'undefined') {
        this._target = option.target;
      }
    }
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new DateLesserThanValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return DateLesserThanValidator;
}(_Validator3.default);

exports.default = DateLesserThanValidator;
module.exports = exports['default'];

/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

var _moment = __webpack_require__(1);

var _moment2 = _interopRequireDefault(_moment);

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

var DateValidator = function (_Validator) {
  _inherits(DateValidator, _Validator);

  function DateValidator(field, display, option) {
    _classCallCheck(this, DateValidator);

    var _this = _possibleConstructorReturn(this, (DateValidator.__proto__ || Object.getPrototypeOf(DateValidator)).call(this));

    _this._dateFormatRegex = /^\d{4}-\d{2}-\d{2}$/;
    return _this;
  }

  _createClass(DateValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      if (value == null) {
        return {
          valid: false,
          message: field.getDisplay() + ' bukan merupakan tanggal yang valid.'
        };
      } else {
        var momentValue = (0, _moment2.default)(value).format('YYYY-MM-DD');
        var valid = this._dateFormatRegex.test(momentValue);
        if (valid) {
          return {
            valid: true,
            message: ''
          };
        } else {
          return {
            valid: false,
            message: field.getDisplay() + ' bukan merupakan tanggal yang valid.'
          };
        }
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {}
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new DateValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return DateValidator;
}(_Validator3.default);

exports.default = DateValidator;
module.exports = exports['default'];

/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var EmailValidator = function (_Validator) {
  _inherits(EmailValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (EmailValidator.__proto__ || Object.getPrototypeOf(EmailValidator)).call(this));

    _this._emailRegex = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
    return _this;
  }

  _createClass(EmailValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      var valid = this._emailRegex.test(value);
      if (valid) {
        return {
          valid: true,
          message: ''
        };
      } else {
        return {
          valid: false,
          message: field.getDisplay() + ' bukan merupakan email yang valid.'
        };
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {}
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new EmailValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return EmailValidator;
}(_Validator3.default);

exports.default = EmailValidator;
module.exports = exports['default'];

/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var LengthRangeValidator = function (_Validator) {
  _inherits(LengthRangeValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (LengthRangeValidator.__proto__ || Object.getPrototypeOf(LengthRangeValidator)).call(this));

    _this._min = 0;
    _this._max = 1024;
    return _this;
  }

  _createClass(LengthRangeValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      if (value != null && typeof value !== 'undefined') {
        if (value.length >= this._min && value.length <= this._max) {
          return {
            valid: true,
            message: ''
          };
        } else {
          return {
            valid: false,
            message: field.getDisplay() + ' harus memiliki panjang ' + this._min + '-' + this._max + ' karakter.'
          };
        }
      } else {
        return {
          valid: false,
          message: field.getDisplay() + ' harus memiliki panjang ' + this._min + '-' + this._max + ' karakter.'
        };
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {
      if (option != null && typeof option !== 'undefined') {
        this._max = option.max;
        this._min = option.min;
      }
    }
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new LengthRangeValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return LengthRangeValidator;
}(_Validator3.default);

exports.default = LengthRangeValidator;
module.exports = exports['default'];

/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var MatchValidator = function (_Validator) {
  _inherits(MatchValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (MatchValidator.__proto__ || Object.getPrototypeOf(MatchValidator)).call(this));

    _this._target = null;
    return _this;
  }

  _createClass(MatchValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      var model = field.getModel();
      var targetField = model[this._target];
      if (targetField.getValue() === value) {
        return {
          valid: true,
          message: ''
        };
      } else {
        return {
          valid: false,
          message: field.getDisplay() + ' harus memiliki nilai yang sama dengan ' + targetField.getDisplay() + '.'
        };
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {
      if (option != null && typeof option !== 'undefined') {
        this._target = option.target;
      }
    }
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new MatchValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return MatchValidator;
}(_Validator3.default);

exports.default = MatchValidator;
module.exports = exports['default'];

/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var NumberGreaterThanValidator = function (_Validator) {
  _inherits(NumberGreaterThanValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (NumberGreaterThanValidator.__proto__ || Object.getPrototypeOf(NumberGreaterThanValidator)).call(this));

    _this._minValue = -2147483645;
    return _this;
  }

  _createClass(NumberGreaterThanValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      if (value == null || value === '') {
        return {
          valid: false,
          message: field.getDisplay() + ' harus berisikan angka dan tidak boleh kosong.'
        };
      } else {
        if (value > this._minValue) {
          return {
            valid: true,
            message: ''
          };
        } else {
          return {
            valid: false,
            message: field.getDisplay() + ' harus lebih besar dari ' + this._minValue + '.'
          };
        }
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {
      if (option != null && typeof option !== 'undefined') {
        this._minValue = option.minValue;
      }
    }
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new NumberGreaterThanValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return NumberGreaterThanValidator;
}(_Validator3.default);

exports.default = NumberGreaterThanValidator;
module.exports = exports['default'];

/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var NumberLesserThanValidator = function (_Validator) {
  _inherits(NumberLesserThanValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (NumberLesserThanValidator.__proto__ || Object.getPrototypeOf(NumberLesserThanValidator)).call(this));

    _this._maxValue = 2147483645;
    return _this;
  }

  _createClass(NumberLesserThanValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      if (value == null || value === '') {
        return {
          valid: false,
          message: field.getDisplay() + ' harus berisikan angka dan tidak boleh kosong.'
        };
      } else {
        if (value < this._maxValue) {
          return {
            valid: true,
            message: ''
          };
        } else {
          return {
            valid: false,
            message: field.getDisplay() + ' harus lebih kecil dari ' + this._maxValue + '.'
          };
        }
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {
      if (option != null && typeof option !== 'undefined') {
        this._maxValue = option.maxValue;
      }
    }
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new NumberLesserThanValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return NumberLesserThanValidator;
}(_Validator3.default);

exports.default = NumberLesserThanValidator;
module.exports = exports['default'];

/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var NumberValidator = function (_Validator) {
  _inherits(NumberValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (NumberValidator.__proto__ || Object.getPrototypeOf(NumberValidator)).call(this));

    _this._numberRegex = /^-?[0-9]\d*(\.\d+)?$/i;
    return _this;
  }

  _createClass(NumberValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      var valid = this._numberRegex.test(value);
      if (valid) {
        return {
          valid: true,
          message: ''
        };
      } else {
        return {
          valid: false,
          message: field.getDisplay() + ' hanya bisa berisikan angka.'
        };
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {}
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new NumberValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return NumberValidator;
}(_Validator3.default);

exports.default = NumberValidator;
module.exports = exports['default'];

/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var ObjectRequiredValidator = function (_Validator) {
  _inherits(ObjectRequiredValidator, _Validator);

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

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

  _createClass(ObjectRequiredValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      if (value === null || typeof value === 'undefined') {
        return {
          valid: false,
          message: field.getDisplay() + ' dibutuhkan'
        };
      } else {
        if (value === '' || value.length === 0) {
          return {
            valid: false,
            message: field.getDisplay() + ' dibutuhkan'
          };
        } else {
          if (Object.keys(value).length > 0) {
            return {
              valid: true,
              message: ''
            };
          } else {
            return {
              valid: false,
              message: field.getDisplay() + ' dibutuhkan'
            };
          }
        }
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {}
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new ObjectRequiredValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return ObjectRequiredValidator;
}(_Validator3.default);

exports.default = ObjectRequiredValidator;
module.exports = exports['default'];

/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var PhoneNumberValidator = function (_Validator) {
  _inherits(PhoneNumberValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (PhoneNumberValidator.__proto__ || Object.getPrototypeOf(PhoneNumberValidator)).call(this));

    _this._phoneRegex = /^(?:(?:\(?(?:00|\+)([1-4]\d\d|[1-9]\d?)\)?)?[\-\.\ \\\/]?)?((?:\(?\d{1,}\)?[\-\.\ \\\/]?){0,})(?:[\-\.\ \\\/]?(?:#|ext\.?|extension|x)[\-\.\ \\\/]?(\d+))?$/i;
    return _this;
  }

  _createClass(PhoneNumberValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      var valid = this._phoneRegex.test(value);
      if (valid) {
        return {
          valid: true,
          message: ''
        };
      } else {
        return {
          valid: false,
          message: field.getDisplay() + ' tidak berisikan nomor telepon yang valid.'
        };
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {}
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new PhoneNumberValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return PhoneNumberValidator;
}(_Validator3.default);

exports.default = PhoneNumberValidator;
module.exports = exports['default'];

/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var RequiredValidator = function (_Validator) {
  _inherits(RequiredValidator, _Validator);

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

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

  _createClass(RequiredValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      if (value === null || typeof value === 'undefined') {
        return {
          valid: false,
          message: field.getDisplay() + ' dibutuhkan'
        };
      } else {
        if (value === '' || value.length === 0) {
          return {
            valid: false,
            message: field.getDisplay() + ' dibutuhkan'
          };
        } else {
          return {
            valid: true,
            message: ''
          };
        }
      }
    }
  }, {
    key: 'configure',
    value: function configure(option) {}
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new RequiredValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return RequiredValidator;
}(_Validator3.default);

exports.default = RequiredValidator;
module.exports = exports['default'];

/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var StrongPasswordValidator = function (_Validator) {
  _inherits(StrongPasswordValidator, _Validator);

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

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

  _createClass(StrongPasswordValidator, [{
    key: 'apply',
    value: function apply(value) {
      return {
        valid: false,
        message: ''
      };
    }
  }, {
    key: 'configure',
    value: function configure(option) {}
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new StrongPasswordValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return StrongPasswordValidator;
}(_Validator3.default);

exports.default = StrongPasswordValidator;
module.exports = exports['default'];

/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

var _moment = __webpack_require__(1);

var _moment2 = _interopRequireDefault(_moment);

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

var TimeGreaterThanOrEqualToValidator = function (_Validator) {
  _inherits(TimeGreaterThanOrEqualToValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (TimeGreaterThanOrEqualToValidator.__proto__ || Object.getPrototypeOf(TimeGreaterThanOrEqualToValidator)).call(this));

    _this._target = null;
    return _this;
  }

  _createClass(TimeGreaterThanOrEqualToValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      var model = field.getModel();
      var targetField = model[this._target];
      if (value == null || targetField.getValue() == null) {
        return {
          valid: true,
          message: ''
        };
      }
      var fieldMomentValue = (0, _moment2.default)(value);
      var targetFieldMomentValue = (0, _moment2.default)(targetField.getValue());
      var diff = fieldMomentValue.diff(targetFieldMomentValue, 'milliseconds');
      if (diff >= 0) {
        return {
          valid: true,
          message: ''
        };
      }
      return {
        valid: false,
        message: 'Waktu ' + field.getDisplay() + ' harus lebih besar atau sama dengan waktu ' + targetField.getDisplay() + '.'
      };
    }
  }, {
    key: 'configure',
    value: function configure(option) {
      if (option != null && typeof option !== 'undefined') {
        this._target = option.target;
      }
    }
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new TimeGreaterThanOrEqualToValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return TimeGreaterThanOrEqualToValidator;
}(_Validator3.default);

exports.default = TimeGreaterThanOrEqualToValidator;
module.exports = exports['default'];

/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

var _moment = __webpack_require__(1);

var _moment2 = _interopRequireDefault(_moment);

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

var TimeGreaterThanValidator = function (_Validator) {
  _inherits(TimeGreaterThanValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (TimeGreaterThanValidator.__proto__ || Object.getPrototypeOf(TimeGreaterThanValidator)).call(this));

    _this._target = null;
    return _this;
  }

  _createClass(TimeGreaterThanValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      var model = field.getModel();
      var targetField = model[this._target];
      if (value == null || targetField.getValue() == null) {
        return {
          valid: true,
          message: ''
        };
      }
      var fieldMomentValue = (0, _moment2.default)(value);
      var targetFieldMomentValue = (0, _moment2.default)(targetField.getValue());
      var diff = fieldMomentValue.diff(targetFieldMomentValue, 'milliseconds');
      if (diff > 0) {
        return {
          valid: true,
          message: ''
        };
      }
      return {
        valid: false,
        message: 'Waktu ' + field.getDisplay() + ' harus lebih besar dari waktu ' + targetField.getDisplay() + '.'
      };
    }
  }, {
    key: 'configure',
    value: function configure(option) {
      if (option != null && typeof option !== 'undefined') {
        this._target = option.target;
      }
    }
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new TimeGreaterThanValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return TimeGreaterThanValidator;
}(_Validator3.default);

exports.default = TimeGreaterThanValidator;
module.exports = exports['default'];

/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

var _moment = __webpack_require__(1);

var _moment2 = _interopRequireDefault(_moment);

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

var TimeLessThanOrEqualToValidator = function (_Validator) {
  _inherits(TimeLessThanOrEqualToValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (TimeLessThanOrEqualToValidator.__proto__ || Object.getPrototypeOf(TimeLessThanOrEqualToValidator)).call(this));

    _this._target = null;
    return _this;
  }

  _createClass(TimeLessThanOrEqualToValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      var model = field.getModel();
      var targetField = model[this._target];
      if (value == null || targetField.getValue() == null) {
        return {
          valid: true,
          message: ''
        };
      }
      var fieldMomentValue = (0, _moment2.default)(value);
      var targetFieldMomentValue = (0, _moment2.default)(targetField.getValue());
      var diff = fieldMomentValue.diff(targetFieldMomentValue, 'milliseconds');
      if (diff <= 0) {
        return {
          valid: true,
          message: ''
        };
      }
      return {
        valid: false,
        message: 'Waktu ' + field.getDisplay() + ' harus lebih kecil dari atau sama dengan waktu ' + targetField.getDisplay() + '.'
      };
    }
  }, {
    key: 'configure',
    value: function configure(option) {
      if (option != null && typeof option !== 'undefined') {
        this._target = option.target;
      }
    }
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new TimeLessThanOrEqualToValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return TimeLessThanOrEqualToValidator;
}(_Validator3.default);

exports.default = TimeLessThanOrEqualToValidator;
module.exports = exports['default'];

/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

var _moment = __webpack_require__(1);

var _moment2 = _interopRequireDefault(_moment);

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

var TimeLessThanValidator = function (_Validator) {
  _inherits(TimeLessThanValidator, _Validator);

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

    var _this = _possibleConstructorReturn(this, (TimeLessThanValidator.__proto__ || Object.getPrototypeOf(TimeLessThanValidator)).call(this));

    _this._target = null;
    return _this;
  }

  _createClass(TimeLessThanValidator, [{
    key: 'apply',
    value: function apply(field, value) {
      var model = field.getModel();
      var targetField = model[this._target];
      if (value == null || targetField.getValue() == null) {
        return {
          valid: true,
          message: ''
        };
      }
      var fieldMomentValue = (0, _moment2.default)(value);
      var targetFieldMomentValue = (0, _moment2.default)(targetField.getValue());
      var diff = fieldMomentValue.diff(targetFieldMomentValue, 'milliseconds');
      if (diff < 0) {
        return {
          valid: true,
          message: ''
        };
      }
      return {
        valid: false,
        message: 'Waktu ' + field.getDisplay() + ' harus lebih kecil dari waktu ' + targetField.getDisplay() + '.'
      };
    }
  }, {
    key: 'configure',
    value: function configure(option) {
      if (option != null && typeof option !== 'undefined') {
        this._target = option.target;
      }
    }
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new TimeLessThanValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return TimeLessThanValidator;
}(_Validator3.default);

exports.default = TimeLessThanValidator;
module.exports = exports['default'];

/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


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

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 _Validator2 = __webpack_require__(0);

var _Validator3 = _interopRequireDefault(_Validator2);

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

var ValueRangeValidator = function (_Validator) {
  _inherits(ValueRangeValidator, _Validator);

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

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

  _createClass(ValueRangeValidator, [{
    key: 'apply',
    value: function apply(value) {
      return {
        valid: false,
        message: ''
      };
    }
  }, {
    key: 'configure',
    value: function configure(option) {}
  }], [{
    key: 'create',
    value: function create(option) {
      var instance = new ValueRangeValidator();
      instance.configure(option);
      return instance;
    }
  }]);

  return ValueRangeValidator;
}(_Validator3.default);

exports.default = ValueRangeValidator;
module.exports = exports['default'];

/***/ }),
/* 38 */
/***/ (function(module, exports) {

module.exports = require("hoist-non-react-statics");

/***/ }),
/* 39 */
/***/ (function(module, exports) {

module.exports = require("querystring");

/***/ }),
/* 40 */
/***/ (function(module, exports) {

module.exports = require("superagent-bluebird-promise");

/***/ })
/******/ ]);
//# sourceMappingURL=catela.build.framework.js.map