mirror of
https://github.com/silverstripe/silverstripe-userforms.git
synced 2024-10-22 15:05:42 +00:00
2280 lines
64 KiB
JavaScript
2280 lines
64 KiB
JavaScript
/******/ (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 = "./client/src/bundles/bundle.js");
|
||
/******/ })
|
||
/************************************************************************/
|
||
/******/ ({
|
||
|
||
/***/ "./client/src/bundles/UserForms.js":
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
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 _asyncValidator = __webpack_require__("./node_modules/async-validator/dist-web/index.js");
|
||
|
||
var _asyncValidator2 = _interopRequireDefault(_asyncValidator);
|
||
|
||
var _i18n = __webpack_require__(0);
|
||
|
||
var _i18n2 = _interopRequireDefault(_i18n);
|
||
|
||
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"); } }
|
||
|
||
document.addEventListener("DOMContentLoaded", function () {
|
||
|
||
var forms = document.querySelectorAll('form.userform');
|
||
var _iteratorNormalCompletion = true;
|
||
var _didIteratorError = false;
|
||
var _iteratorError = undefined;
|
||
|
||
try {
|
||
for (var _iterator = forms[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
||
var form = _step.value;
|
||
|
||
var userForm = new UserForm(form);
|
||
userForm.init();
|
||
}
|
||
} catch (err) {
|
||
_didIteratorError = true;
|
||
_iteratorError = err;
|
||
} finally {
|
||
try {
|
||
if (!_iteratorNormalCompletion && _iterator.return) {
|
||
_iterator.return();
|
||
}
|
||
} finally {
|
||
if (_didIteratorError) {
|
||
throw _iteratorError;
|
||
}
|
||
}
|
||
}
|
||
});
|
||
|
||
var isVisible = function isVisible(element) {
|
||
return element.style.display !== 'none' && element.style.visibility !== 'hidden' && !element.classList.contains('hide');
|
||
};
|
||
|
||
var ProgressBar = function () {
|
||
function ProgressBar(dom, userForm) {
|
||
_classCallCheck(this, ProgressBar);
|
||
|
||
this.dom = dom;
|
||
this.userForm = userForm;
|
||
this.progressTitle = this.userForm.dom.querySelector('.progress-title');
|
||
this.buttons = this.dom.querySelectorAll('.step-button-jump');
|
||
this.currentStepNumber = this.dom.querySelector('.current-step-number');
|
||
this.init();
|
||
}
|
||
|
||
_createClass(ProgressBar, [{
|
||
key: 'init',
|
||
value: function init() {
|
||
var _this = this;
|
||
|
||
this.dom.style.display = 'initial';
|
||
var buttons = this.buttons;
|
||
|
||
var _loop = function _loop(button) {
|
||
button.addEventListener('click', function (e) {
|
||
e.preventDefault();
|
||
var stepNumber = parseInt(button.getAttribute('data-step'), 10);
|
||
_this.userForm.jumpToStep(stepNumber);
|
||
return false;
|
||
});
|
||
};
|
||
|
||
var _iteratorNormalCompletion2 = true;
|
||
var _didIteratorError2 = false;
|
||
var _iteratorError2 = undefined;
|
||
|
||
try {
|
||
for (var _iterator2 = buttons[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
|
||
var button = _step2.value;
|
||
|
||
_loop(button);
|
||
}
|
||
} catch (err) {
|
||
_didIteratorError2 = true;
|
||
_iteratorError2 = err;
|
||
} finally {
|
||
try {
|
||
if (!_iteratorNormalCompletion2 && _iterator2.return) {
|
||
_iterator2.return();
|
||
}
|
||
} finally {
|
||
if (_didIteratorError2) {
|
||
throw _iteratorError2;
|
||
}
|
||
}
|
||
}
|
||
|
||
this.userForm.dom.addEventListener('userform.form.changestep', function (e) {
|
||
_this.update(e.detail.stepId);
|
||
});
|
||
|
||
this.update(0);
|
||
}
|
||
}, {
|
||
key: 'update',
|
||
value: function update(stepId) {
|
||
var stepNumber = this.userForm.getCurrentStepID() + 1;
|
||
var newStep = this.userForm.getStep(stepId);
|
||
var newStepElement = newStep.step;
|
||
var barWidth = stepId / (this.buttons.length - 1) * 100;
|
||
|
||
this.currentStepNumber.innerText = stepNumber;
|
||
|
||
var _iteratorNormalCompletion3 = true;
|
||
var _didIteratorError3 = false;
|
||
var _iteratorError3 = undefined;
|
||
|
||
try {
|
||
for (var _iterator3 = this.dom.querySelectorAll('[aria-valuenow]')[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
|
||
var e = _step3.value;
|
||
|
||
e.setAttribute('aria-valuenow', stepNumber);
|
||
}
|
||
} catch (err) {
|
||
_didIteratorError3 = true;
|
||
_iteratorError3 = err;
|
||
} finally {
|
||
try {
|
||
if (!_iteratorNormalCompletion3 && _iterator3.return) {
|
||
_iterator3.return();
|
||
}
|
||
} finally {
|
||
if (_didIteratorError3) {
|
||
throw _iteratorError3;
|
||
}
|
||
}
|
||
}
|
||
|
||
var _iteratorNormalCompletion4 = true;
|
||
var _didIteratorError4 = false;
|
||
var _iteratorError4 = undefined;
|
||
|
||
try {
|
||
for (var _iterator4 = this.buttons[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
|
||
var button = _step4.value;
|
||
|
||
var parent = button.parentNode;
|
||
if (parseInt(button.getAttribute('data-step'), 10) === stepNumber && isVisible(button)) {
|
||
parent.classList.add('current');
|
||
parent.classList.add('viewed');
|
||
|
||
button.disabled = false;
|
||
break;
|
||
}
|
||
parent.classList.remove('current');
|
||
}
|
||
} catch (err) {
|
||
_didIteratorError4 = true;
|
||
_iteratorError4 = err;
|
||
} finally {
|
||
try {
|
||
if (!_iteratorNormalCompletion4 && _iterator4.return) {
|
||
_iterator4.return();
|
||
}
|
||
} finally {
|
||
if (_didIteratorError4) {
|
||
throw _iteratorError4;
|
||
}
|
||
}
|
||
}
|
||
|
||
this.progressTitle.innerText = newStepElement.getAttribute('data-title');
|
||
|
||
barWidth = barWidth ? barWidth + '%' : '';
|
||
this.dom.querySelector('.progress-bar').style.width = barWidth;
|
||
}
|
||
}]);
|
||
|
||
return ProgressBar;
|
||
}();
|
||
|
||
var FormStep = function () {
|
||
function FormStep(step, userForm) {
|
||
_classCallCheck(this, FormStep);
|
||
|
||
this.step = step;
|
||
this.userForm = userForm;
|
||
this.viewed = false;
|
||
this.buttonHolder = null;
|
||
this.id = 0;
|
||
|
||
this.init();
|
||
}
|
||
|
||
_createClass(FormStep, [{
|
||
key: 'init',
|
||
value: function init() {
|
||
var _this2 = this;
|
||
|
||
var id = this.getHTMLId();
|
||
this.buttonHolder = document.querySelector('.step-button-wrapper[data-for=\'' + id + '\']');
|
||
['userform.field.hide', 'userform.field.show'].forEach(function (action) {
|
||
_this2.buttonHolder.addEventListener(action, function () {
|
||
_this2.userForm.dom.trigger('userform.form.conditionalstep');
|
||
});
|
||
});
|
||
}
|
||
}, {
|
||
key: 'setId',
|
||
value: function setId(id) {
|
||
this.id = id;
|
||
}
|
||
}, {
|
||
key: 'getHTMLId',
|
||
value: function getHTMLId() {
|
||
return this.step.getAttribute('id');
|
||
}
|
||
}, {
|
||
key: 'show',
|
||
value: function show() {
|
||
this.step.setAttribute('aria-hidden', false);
|
||
this.step.classList.remove('hide');
|
||
this.step.classList.add('viewed');
|
||
this.viewed = true;
|
||
}
|
||
}, {
|
||
key: 'hide',
|
||
value: function hide() {
|
||
this.step.setAttribute('aria-hidden', true);
|
||
this.step.classList.add('hide');
|
||
}
|
||
}, {
|
||
key: 'conditionallyHidden',
|
||
value: function conditionallyHidden() {
|
||
var button = this.buttonHolder.querySelector('button');
|
||
return !(button.style.display !== 'none' && button.visibility !== 'hidden' && !button.classList.contains('hide'));
|
||
}
|
||
}, {
|
||
key: 'getValidatorType',
|
||
value: function getValidatorType(input) {
|
||
if (input.getAttribute('type') === 'email') {
|
||
return 'email';
|
||
}
|
||
if (input.getAttribute('type') === 'date') {
|
||
return 'date';
|
||
}
|
||
if (input.classList.contains('numeric') || input.getAttribute('type') === 'numeric') {
|
||
return 'number';
|
||
}
|
||
return 'string';
|
||
}
|
||
}, {
|
||
key: 'getValidatorMessage',
|
||
value: function getValidatorMessage(input) {
|
||
if (input.getAttribute('data-msg-required')) {
|
||
return input.getAttribute('data-msg-required');
|
||
}
|
||
return this.getFieldLabel(input) + ' is required';
|
||
}
|
||
}, {
|
||
key: 'getFieldLabel',
|
||
value: function getFieldLabel(input) {
|
||
var holder = window.closest(input, 'div.field');
|
||
if (holder) {
|
||
var label = holder.querySelector('label.left');
|
||
if (label) {
|
||
return label.innerText;
|
||
}
|
||
}
|
||
return input.getAttribute('name');
|
||
}
|
||
}, {
|
||
key: 'getValidationsDescriptors',
|
||
value: function getValidationsDescriptors() {
|
||
var _this3 = this;
|
||
|
||
var descriptors = {};
|
||
var fields = this.step.querySelectorAll('input, textarea, select');
|
||
|
||
var _loop2 = function _loop2(field) {
|
||
|
||
if (!isVisible(field)) {
|
||
return 'continue';
|
||
}
|
||
|
||
var label = _this3.getFieldLabel(field);
|
||
descriptors[field.getAttribute('name')] = {
|
||
title: label,
|
||
type: _this3.getValidatorType(field),
|
||
required: field.getAttribute('required') == 'required',
|
||
message: _this3.getValidatorMessage(field)
|
||
};
|
||
|
||
var min = field.getAttribute('data-rule-min');
|
||
var max = field.getAttribute('data-rule-max');
|
||
if (min !== null || max !== null) {
|
||
descriptors[field.getAttribute('name')]['asyncValidator'] = function (rule, value) {
|
||
return new Promise(function (resolve, reject) {
|
||
if (min !== null && value < min) {
|
||
reject(label + ' cannot be less than ' + min);
|
||
} else if (max !== null && value > max) {
|
||
reject(label + ' cannot be greater than ' + max);
|
||
} else {
|
||
resolve();
|
||
}
|
||
});
|
||
};
|
||
}
|
||
};
|
||
|
||
var _iteratorNormalCompletion5 = true;
|
||
var _didIteratorError5 = false;
|
||
var _iteratorError5 = undefined;
|
||
|
||
try {
|
||
for (var _iterator5 = fields[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
|
||
var field = _step5.value;
|
||
|
||
var _ret2 = _loop2(field);
|
||
|
||
if (_ret2 === 'continue') continue;
|
||
}
|
||
} catch (err) {
|
||
_didIteratorError5 = true;
|
||
_iteratorError5 = err;
|
||
} finally {
|
||
try {
|
||
if (!_iteratorNormalCompletion5 && _iterator5.return) {
|
||
_iterator5.return();
|
||
}
|
||
} finally {
|
||
if (_didIteratorError5) {
|
||
throw _iteratorError5;
|
||
}
|
||
}
|
||
}
|
||
|
||
return descriptors;
|
||
}
|
||
}, {
|
||
key: 'validate',
|
||
value: function validate() {
|
||
var _this4 = this;
|
||
|
||
var descriptors = this.getValidationsDescriptors();
|
||
var validator = new _asyncValidator2.default(descriptors);
|
||
|
||
var formData = new FormData(this.userForm.dom);
|
||
var data = {};
|
||
formData.forEach(function (value, key) {
|
||
data[key] = value;
|
||
});
|
||
|
||
var promise = new Promise(function (resolve, reject) {
|
||
validator.validate(data, function (errors, fields) {
|
||
if (errors && errors.length) {
|
||
_this4.displayErrorMessages(errors);
|
||
reject(errors);
|
||
} else {
|
||
resolve();
|
||
}
|
||
});
|
||
});
|
||
return promise;
|
||
}
|
||
}, {
|
||
key: 'displayErrorMessages',
|
||
value: function displayErrorMessages(errors) {
|
||
var _iteratorNormalCompletion6 = true;
|
||
var _didIteratorError6 = false;
|
||
var _iteratorError6 = undefined;
|
||
|
||
try {
|
||
for (var _iterator6 = errors[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
|
||
var error = _step6.value;
|
||
|
||
var fieldHolder = this.userForm.dom.querySelector('#' + error.field);
|
||
if (fieldHolder) {
|
||
var errorLabel = fieldHolder.querySelector('span.error');
|
||
if (!errorLabel) {
|
||
errorLabel = document.createElement('span');
|
||
errorLabel.classList.add('error');
|
||
}
|
||
errorLabel.innerHTML = error.message;
|
||
fieldHolder.append(errorLabel);
|
||
}
|
||
}
|
||
} catch (err) {
|
||
_didIteratorError6 = true;
|
||
_iteratorError6 = err;
|
||
} finally {
|
||
try {
|
||
if (!_iteratorNormalCompletion6 && _iterator6.return) {
|
||
_iterator6.return();
|
||
}
|
||
} finally {
|
||
if (_didIteratorError6) {
|
||
throw _iteratorError6;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}]);
|
||
|
||
return FormStep;
|
||
}();
|
||
|
||
var FormActions = function () {
|
||
function FormActions(dom, userForm) {
|
||
_classCallCheck(this, FormActions);
|
||
|
||
this.dom = dom;
|
||
this.userForm = userForm;
|
||
this.prevButton = dom.querySelector('.step-button-prev');
|
||
this.nextButton = dom.querySelector('.step-button-next');
|
||
|
||
this.init();
|
||
}
|
||
|
||
_createClass(FormActions, [{
|
||
key: 'init',
|
||
value: function init() {
|
||
var _this5 = this;
|
||
|
||
this.prevButton.addEventListener('click', function (e) {
|
||
e.preventDefault();
|
||
|
||
window.triggerDispatchEvent(_this5.userForm.dom, 'userform.action.prev');
|
||
});
|
||
this.nextButton.addEventListener('click', function (e) {
|
||
e.preventDefault();
|
||
|
||
window.triggerDispatchEvent(_this5.userForm.dom, 'userform.action.next');
|
||
});
|
||
|
||
this.update();
|
||
|
||
this.userForm.dom.addEventListener('userform.form.changestep', function () {
|
||
_this5.update();
|
||
});
|
||
|
||
this.userForm.dom.addEventListener('userform.form.conditionalstep', function () {
|
||
_this5.update();
|
||
});
|
||
}
|
||
}, {
|
||
key: 'update',
|
||
value: function update() {
|
||
var numberOfSteps = this.userForm.getNumberOfSteps();
|
||
var stepId = this.userForm.getCurrentStepID();
|
||
var i = null;
|
||
var lastStep = null;
|
||
for (i = numberOfSteps - 1; i >= 0; i--) {
|
||
lastStep = this.userForm.getStep(i);
|
||
if (!lastStep.conditionallyHidden()) {
|
||
if (stepId >= i) {
|
||
this.nextButton.parentNode.classList.add('hide');
|
||
} else {
|
||
this.nextButton.parentNode.classList.remove('hide');
|
||
}
|
||
|
||
if (stepId > 0 && stepId <= i) {
|
||
this.prevButton.parentNode.classList.remove('hide');
|
||
} else {
|
||
this.prevButton.parentNode.classList.add('hide');
|
||
}
|
||
|
||
if (stepId >= i) {
|
||
this.dom.querySelector('.btn-toolbar').classList.remove('hide');
|
||
} else {
|
||
this.dom.querySelector('.btn-toolbar').classList.add('hide');
|
||
}
|
||
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}]);
|
||
|
||
return FormActions;
|
||
}();
|
||
|
||
var UserForm = function () {
|
||
function UserForm(form) {
|
||
_classCallCheck(this, UserForm);
|
||
|
||
this.dom = form;
|
||
this.CONSTANTS = {};
|
||
this.steps = [];
|
||
this.progressBar = null;
|
||
this.actions = null;
|
||
this.currentStep = null;
|
||
|
||
this.CONSTANTS.ENABLE_LIVE_VALIDATION = this.dom.getAttribute('livevalidation') !== undefined;
|
||
this.CONSTANTS.DISPLAY_ERROR_MESSAGES_AT_TOP = this.dom.getAttribute('toperrors') !== undefined;
|
||
}
|
||
|
||
_createClass(UserForm, [{
|
||
key: 'init',
|
||
value: function init() {
|
||
this.initialiseFormSteps();
|
||
}
|
||
}, {
|
||
key: 'initialiseFormSteps',
|
||
value: function initialiseFormSteps() {
|
||
var _this6 = this;
|
||
|
||
var steps = this.dom.querySelectorAll('.form-step');
|
||
var _iteratorNormalCompletion7 = true;
|
||
var _didIteratorError7 = false;
|
||
var _iteratorError7 = undefined;
|
||
|
||
try {
|
||
for (var _iterator7 = steps[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
|
||
var stepDom = _step7.value;
|
||
|
||
var step = new FormStep(stepDom, this);
|
||
step.hide();
|
||
this.addStep(step);
|
||
}
|
||
} catch (err) {
|
||
_didIteratorError7 = true;
|
||
_iteratorError7 = err;
|
||
} finally {
|
||
try {
|
||
if (!_iteratorNormalCompletion7 && _iterator7.return) {
|
||
_iterator7.return();
|
||
}
|
||
} finally {
|
||
if (_didIteratorError7) {
|
||
throw _iteratorError7;
|
||
}
|
||
}
|
||
}
|
||
|
||
this.setCurrentStep(this.steps[0]);
|
||
|
||
var progressBarDom = this.dom.querySelector('.userform-progress');
|
||
if (progressBarDom) {
|
||
this.progressBar = new ProgressBar(progressBarDom, this);
|
||
}
|
||
|
||
var stepNavigation = this.dom.querySelector('.step-navigation');
|
||
if (stepNavigation) {
|
||
this.formActions = new FormActions(stepNavigation, this);
|
||
this.formActions.update();
|
||
}
|
||
|
||
this.setUpPing();
|
||
|
||
this.dom.addEventListener('userform.action.next', function () {
|
||
_this6.nextStep();
|
||
});
|
||
|
||
this.dom.addEventListener('userform.action.prev', function () {
|
||
_this6.prevStep();
|
||
});
|
||
}
|
||
}, {
|
||
key: 'setCurrentStep',
|
||
value: function setCurrentStep(step) {
|
||
if (!(step instanceof FormStep)) {
|
||
return;
|
||
}
|
||
this.currentStep = step;
|
||
this.currentStep.show();
|
||
}
|
||
}, {
|
||
key: 'addStep',
|
||
value: function addStep(step) {
|
||
if (!(step instanceof FormStep)) {
|
||
return;
|
||
}
|
||
step.setId(this.steps.length);
|
||
this.steps.push(step);
|
||
}
|
||
}, {
|
||
key: 'getNumberOfSteps',
|
||
value: function getNumberOfSteps() {
|
||
return this.steps.length;
|
||
}
|
||
}, {
|
||
key: 'getCurrentStepID',
|
||
value: function getCurrentStepID() {
|
||
return this.currentStep.id ? this.currentStep.id : 0;
|
||
}
|
||
}, {
|
||
key: 'getStep',
|
||
value: function getStep(index) {
|
||
return this.steps[index];
|
||
}
|
||
}, {
|
||
key: 'nextStep',
|
||
value: function nextStep() {
|
||
var _this7 = this;
|
||
|
||
this.currentStep.validate().then(function () {
|
||
_this7.jumpToStep(_this7.steps.indexOf(_this7.currentStep) + 1, true);
|
||
}).catch(function (errors) {});
|
||
}
|
||
}, {
|
||
key: 'prevStep',
|
||
value: function prevStep() {
|
||
this.jumpToStep(this.steps.indexOf(this.currentStep) - 1, true);
|
||
}
|
||
}, {
|
||
key: 'jumpToStep',
|
||
value: function jumpToStep(stepNumber, direction) {
|
||
var targetStep = this.steps[stepNumber];
|
||
var isValid = false;
|
||
var forward = direction === undefined ? true : direction;
|
||
|
||
if (targetStep === undefined) {
|
||
return;
|
||
}
|
||
|
||
if (targetStep.conditionallyHidden()) {
|
||
if (forward) {
|
||
this.jumpToStep(stepNumber + 1, direction);
|
||
} else {
|
||
this.jumpToStep(stepNumber - 1, direction);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (this.currentStep) {
|
||
this.currentStep.hide();
|
||
}
|
||
|
||
this.setCurrentStep(targetStep);
|
||
|
||
window.triggerDispatchEvent(this.dom, 'userform.form.changestep', {
|
||
stepId: targetStep.id
|
||
});
|
||
}
|
||
}, {
|
||
key: 'setUpPing',
|
||
value: function setUpPing() {
|
||
window.setInterval(function () {
|
||
fetch('UserDefinedFormController/ping');
|
||
}, 180 * 1000);
|
||
}
|
||
}]);
|
||
|
||
return UserForm;
|
||
}();
|
||
|
||
/***/ }),
|
||
|
||
/***/ "./client/src/bundles/bundle.js":
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
__webpack_require__("./client/src/bundles/UserForms.js");
|
||
|
||
/***/ }),
|
||
|
||
/***/ "./node_modules/async-validator/dist-web/index.js":
|
||
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
||
|
||
"use strict";
|
||
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
|
||
/* WEBPACK VAR INJECTION */(function(process) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Schema; });
|
||
function _extends() {
|
||
_extends = Object.assign ? Object.assign.bind() : 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;
|
||
};
|
||
return _extends.apply(this, arguments);
|
||
}
|
||
|
||
function _inheritsLoose(subClass, superClass) {
|
||
subClass.prototype = Object.create(superClass.prototype);
|
||
subClass.prototype.constructor = subClass;
|
||
|
||
_setPrototypeOf(subClass, superClass);
|
||
}
|
||
|
||
function _getPrototypeOf(o) {
|
||
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
|
||
return o.__proto__ || Object.getPrototypeOf(o);
|
||
};
|
||
return _getPrototypeOf(o);
|
||
}
|
||
|
||
function _setPrototypeOf(o, p) {
|
||
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
|
||
o.__proto__ = p;
|
||
return o;
|
||
};
|
||
return _setPrototypeOf(o, p);
|
||
}
|
||
|
||
function _isNativeReflectConstruct() {
|
||
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
|
||
if (Reflect.construct.sham) return false;
|
||
if (typeof Proxy === "function") return true;
|
||
|
||
try {
|
||
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
|
||
return true;
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function _construct(Parent, args, Class) {
|
||
if (_isNativeReflectConstruct()) {
|
||
_construct = Reflect.construct.bind();
|
||
} else {
|
||
_construct = function _construct(Parent, args, Class) {
|
||
var a = [null];
|
||
a.push.apply(a, args);
|
||
var Constructor = Function.bind.apply(Parent, a);
|
||
var instance = new Constructor();
|
||
if (Class) _setPrototypeOf(instance, Class.prototype);
|
||
return instance;
|
||
};
|
||
}
|
||
|
||
return _construct.apply(null, arguments);
|
||
}
|
||
|
||
function _isNativeFunction(fn) {
|
||
return Function.toString.call(fn).indexOf("[native code]") !== -1;
|
||
}
|
||
|
||
function _wrapNativeSuper(Class) {
|
||
var _cache = typeof Map === "function" ? new Map() : undefined;
|
||
|
||
_wrapNativeSuper = function _wrapNativeSuper(Class) {
|
||
if (Class === null || !_isNativeFunction(Class)) return Class;
|
||
|
||
if (typeof Class !== "function") {
|
||
throw new TypeError("Super expression must either be null or a function");
|
||
}
|
||
|
||
if (typeof _cache !== "undefined") {
|
||
if (_cache.has(Class)) return _cache.get(Class);
|
||
|
||
_cache.set(Class, Wrapper);
|
||
}
|
||
|
||
function Wrapper() {
|
||
return _construct(Class, arguments, _getPrototypeOf(this).constructor);
|
||
}
|
||
|
||
Wrapper.prototype = Object.create(Class.prototype, {
|
||
constructor: {
|
||
value: Wrapper,
|
||
enumerable: false,
|
||
writable: true,
|
||
configurable: true
|
||
}
|
||
});
|
||
return _setPrototypeOf(Wrapper, Class);
|
||
};
|
||
|
||
return _wrapNativeSuper(Class);
|
||
}
|
||
|
||
/* eslint no-console:0 */
|
||
var formatRegExp = /%[sdj%]/g;
|
||
var warning = function warning() {}; // don't print warning message when in production env or node runtime
|
||
|
||
if (typeof process !== 'undefined' && __webpack_require__.i({"NODE_ENV":"development"}) && "development" !== 'production' && typeof window !== 'undefined' && typeof document !== 'undefined') {
|
||
warning = function warning(type, errors) {
|
||
if (typeof console !== 'undefined' && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === 'undefined') {
|
||
if (errors.every(function (e) {
|
||
return typeof e === 'string';
|
||
})) {
|
||
console.warn(type, errors);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
function convertFieldsError(errors) {
|
||
if (!errors || !errors.length) return null;
|
||
var fields = {};
|
||
errors.forEach(function (error) {
|
||
var field = error.field;
|
||
fields[field] = fields[field] || [];
|
||
fields[field].push(error);
|
||
});
|
||
return fields;
|
||
}
|
||
function format(template) {
|
||
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
||
args[_key - 1] = arguments[_key];
|
||
}
|
||
|
||
var i = 0;
|
||
var len = args.length;
|
||
|
||
if (typeof template === 'function') {
|
||
return template.apply(null, args);
|
||
}
|
||
|
||
if (typeof template === 'string') {
|
||
var str = template.replace(formatRegExp, function (x) {
|
||
if (x === '%%') {
|
||
return '%';
|
||
}
|
||
|
||
if (i >= len) {
|
||
return x;
|
||
}
|
||
|
||
switch (x) {
|
||
case '%s':
|
||
return String(args[i++]);
|
||
|
||
case '%d':
|
||
return Number(args[i++]);
|
||
|
||
case '%j':
|
||
try {
|
||
return JSON.stringify(args[i++]);
|
||
} catch (_) {
|
||
return '[Circular]';
|
||
}
|
||
|
||
break;
|
||
|
||
default:
|
||
return x;
|
||
}
|
||
});
|
||
return str;
|
||
}
|
||
|
||
return template;
|
||
}
|
||
|
||
function isNativeStringType(type) {
|
||
return type === 'string' || type === 'url' || type === 'hex' || type === 'email' || type === 'date' || type === 'pattern';
|
||
}
|
||
|
||
function isEmptyValue(value, type) {
|
||
if (value === undefined || value === null) {
|
||
return true;
|
||
}
|
||
|
||
if (type === 'array' && Array.isArray(value) && !value.length) {
|
||
return true;
|
||
}
|
||
|
||
if (isNativeStringType(type) && typeof value === 'string' && !value) {
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
function asyncParallelArray(arr, func, callback) {
|
||
var results = [];
|
||
var total = 0;
|
||
var arrLength = arr.length;
|
||
|
||
function count(errors) {
|
||
results.push.apply(results, errors || []);
|
||
total++;
|
||
|
||
if (total === arrLength) {
|
||
callback(results);
|
||
}
|
||
}
|
||
|
||
arr.forEach(function (a) {
|
||
func(a, count);
|
||
});
|
||
}
|
||
|
||
function asyncSerialArray(arr, func, callback) {
|
||
var index = 0;
|
||
var arrLength = arr.length;
|
||
|
||
function next(errors) {
|
||
if (errors && errors.length) {
|
||
callback(errors);
|
||
return;
|
||
}
|
||
|
||
var original = index;
|
||
index = index + 1;
|
||
|
||
if (original < arrLength) {
|
||
func(arr[original], next);
|
||
} else {
|
||
callback([]);
|
||
}
|
||
}
|
||
|
||
next([]);
|
||
}
|
||
|
||
function flattenObjArr(objArr) {
|
||
var ret = [];
|
||
Object.keys(objArr).forEach(function (k) {
|
||
ret.push.apply(ret, objArr[k] || []);
|
||
});
|
||
return ret;
|
||
}
|
||
|
||
var AsyncValidationError = /*#__PURE__*/function (_Error) {
|
||
_inheritsLoose(AsyncValidationError, _Error);
|
||
|
||
function AsyncValidationError(errors, fields) {
|
||
var _this;
|
||
|
||
_this = _Error.call(this, 'Async Validation Error') || this;
|
||
_this.errors = errors;
|
||
_this.fields = fields;
|
||
return _this;
|
||
}
|
||
|
||
return AsyncValidationError;
|
||
}( /*#__PURE__*/_wrapNativeSuper(Error));
|
||
function asyncMap(objArr, option, func, callback, source) {
|
||
if (option.first) {
|
||
var _pending = new Promise(function (resolve, reject) {
|
||
var next = function next(errors) {
|
||
callback(errors);
|
||
return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
|
||
};
|
||
|
||
var flattenArr = flattenObjArr(objArr);
|
||
asyncSerialArray(flattenArr, func, next);
|
||
});
|
||
|
||
_pending["catch"](function (e) {
|
||
return e;
|
||
});
|
||
|
||
return _pending;
|
||
}
|
||
|
||
var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
|
||
var objArrKeys = Object.keys(objArr);
|
||
var objArrLength = objArrKeys.length;
|
||
var total = 0;
|
||
var results = [];
|
||
var pending = new Promise(function (resolve, reject) {
|
||
var next = function next(errors) {
|
||
results.push.apply(results, errors);
|
||
total++;
|
||
|
||
if (total === objArrLength) {
|
||
callback(results);
|
||
return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
|
||
}
|
||
};
|
||
|
||
if (!objArrKeys.length) {
|
||
callback(results);
|
||
resolve(source);
|
||
}
|
||
|
||
objArrKeys.forEach(function (key) {
|
||
var arr = objArr[key];
|
||
|
||
if (firstFields.indexOf(key) !== -1) {
|
||
asyncSerialArray(arr, func, next);
|
||
} else {
|
||
asyncParallelArray(arr, func, next);
|
||
}
|
||
});
|
||
});
|
||
pending["catch"](function (e) {
|
||
return e;
|
||
});
|
||
return pending;
|
||
}
|
||
|
||
function isErrorObj(obj) {
|
||
return !!(obj && obj.message !== undefined);
|
||
}
|
||
|
||
function getValue(value, path) {
|
||
var v = value;
|
||
|
||
for (var i = 0; i < path.length; i++) {
|
||
if (v == undefined) {
|
||
return v;
|
||
}
|
||
|
||
v = v[path[i]];
|
||
}
|
||
|
||
return v;
|
||
}
|
||
|
||
function complementError(rule, source) {
|
||
return function (oe) {
|
||
var fieldValue;
|
||
|
||
if (rule.fullFields) {
|
||
fieldValue = getValue(source, rule.fullFields);
|
||
} else {
|
||
fieldValue = source[oe.field || rule.fullField];
|
||
}
|
||
|
||
if (isErrorObj(oe)) {
|
||
oe.field = oe.field || rule.fullField;
|
||
oe.fieldValue = fieldValue;
|
||
return oe;
|
||
}
|
||
|
||
return {
|
||
message: typeof oe === 'function' ? oe() : oe,
|
||
fieldValue: fieldValue,
|
||
field: oe.field || rule.fullField
|
||
};
|
||
};
|
||
}
|
||
function deepMerge(target, source) {
|
||
if (source) {
|
||
for (var s in source) {
|
||
if (source.hasOwnProperty(s)) {
|
||
var value = source[s];
|
||
|
||
if (typeof value === 'object' && typeof target[s] === 'object') {
|
||
target[s] = _extends({}, target[s], value);
|
||
} else {
|
||
target[s] = value;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return target;
|
||
}
|
||
|
||
var required$1 = function required(rule, value, source, errors, options, type) {
|
||
if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type || rule.type))) {
|
||
errors.push(format(options.messages.required, rule.fullField));
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Rule for validating whitespace.
|
||
*
|
||
* @param rule The validation rule.
|
||
* @param value The value of the field on the source object.
|
||
* @param source The source object being validated.
|
||
* @param errors An array of errors that this rule may add
|
||
* validation errors to.
|
||
* @param options The validation options.
|
||
* @param options.messages The validation messages.
|
||
*/
|
||
|
||
var whitespace = function whitespace(rule, value, source, errors, options) {
|
||
if (/^\s+$/.test(value) || value === '') {
|
||
errors.push(format(options.messages.whitespace, rule.fullField));
|
||
}
|
||
};
|
||
|
||
// https://github.com/kevva/url-regex/blob/master/index.js
|
||
var urlReg;
|
||
var getUrlRegex = (function () {
|
||
if (urlReg) {
|
||
return urlReg;
|
||
}
|
||
|
||
var word = '[a-fA-F\\d:]';
|
||
|
||
var b = function b(options) {
|
||
return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=" + word + ")|(?<=" + word + ")(?=\\s|$))" : '';
|
||
};
|
||
|
||
var v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
|
||
var v6seg = '[a-fA-F\\d]{1,4}';
|
||
var v6 = ("\n(?:\n(?:" + v6seg + ":){7}(?:" + v6seg + "|:)| // 1:2:3:4:5:6:7:: 1:2:3:4:5:6:7:8\n(?:" + v6seg + ":){6}(?:" + v4 + "|:" + v6seg + "|:)| // 1:2:3:4:5:6:: 1:2:3:4:5:6::8 1:2:3:4:5:6::8 1:2:3:4:5:6::1.2.3.4\n(?:" + v6seg + ":){5}(?::" + v4 + "|(?::" + v6seg + "){1,2}|:)| // 1:2:3:4:5:: 1:2:3:4:5::7:8 1:2:3:4:5::8 1:2:3:4:5::7:1.2.3.4\n(?:" + v6seg + ":){4}(?:(?::" + v6seg + "){0,1}:" + v4 + "|(?::" + v6seg + "){1,3}|:)| // 1:2:3:4:: 1:2:3:4::6:7:8 1:2:3:4::8 1:2:3:4::6:7:1.2.3.4\n(?:" + v6seg + ":){3}(?:(?::" + v6seg + "){0,2}:" + v4 + "|(?::" + v6seg + "){1,4}|:)| // 1:2:3:: 1:2:3::5:6:7:8 1:2:3::8 1:2:3::5:6:7:1.2.3.4\n(?:" + v6seg + ":){2}(?:(?::" + v6seg + "){0,3}:" + v4 + "|(?::" + v6seg + "){1,5}|:)| // 1:2:: 1:2::4:5:6:7:8 1:2::8 1:2::4:5:6:7:1.2.3.4\n(?:" + v6seg + ":){1}(?:(?::" + v6seg + "){0,4}:" + v4 + "|(?::" + v6seg + "){1,6}|:)| // 1:: 1::3:4:5:6:7:8 1::8 1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::" + v6seg + "){0,5}:" + v4 + "|(?::" + v6seg + "){1,7}|:)) // ::2:3:4:5:6:7:8 ::2:3:4:5:6:7:8 ::8 ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})? // %eth0 %1\n").replace(/\s*\/\/.*$/gm, '').replace(/\n/g, '').trim(); // Pre-compile only the exact regexes because adding a global flag make regexes stateful
|
||
|
||
var v46Exact = new RegExp("(?:^" + v4 + "$)|(?:^" + v6 + "$)");
|
||
var v4exact = new RegExp("^" + v4 + "$");
|
||
var v6exact = new RegExp("^" + v6 + "$");
|
||
|
||
var ip = function ip(options) {
|
||
return options && options.exact ? v46Exact : new RegExp("(?:" + b(options) + v4 + b(options) + ")|(?:" + b(options) + v6 + b(options) + ")", 'g');
|
||
};
|
||
|
||
ip.v4 = function (options) {
|
||
return options && options.exact ? v4exact : new RegExp("" + b(options) + v4 + b(options), 'g');
|
||
};
|
||
|
||
ip.v6 = function (options) {
|
||
return options && options.exact ? v6exact : new RegExp("" + b(options) + v6 + b(options), 'g');
|
||
};
|
||
|
||
var protocol = "(?:(?:[a-z]+:)?//)";
|
||
var auth = '(?:\\S+(?::\\S*)?@)?';
|
||
var ipv4 = ip.v4().source;
|
||
var ipv6 = ip.v6().source;
|
||
var host = "(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)";
|
||
var domain = "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*";
|
||
var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))";
|
||
var port = '(?::\\d{2,5})?';
|
||
var path = '(?:[/?#][^\\s"]*)?';
|
||
var regex = "(?:" + protocol + "|www\\.)" + auth + "(?:localhost|" + ipv4 + "|" + ipv6 + "|" + host + domain + tld + ")" + port + path;
|
||
urlReg = new RegExp("(?:^" + regex + "$)", 'i');
|
||
return urlReg;
|
||
});
|
||
|
||
/* eslint max-len:0 */
|
||
|
||
var pattern$2 = {
|
||
// http://emailregex.com/
|
||
email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
|
||
// url: new RegExp(
|
||
// '^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$',
|
||
// 'i',
|
||
// ),
|
||
hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
|
||
};
|
||
var types = {
|
||
integer: function integer(value) {
|
||
return types.number(value) && parseInt(value, 10) === value;
|
||
},
|
||
"float": function float(value) {
|
||
return types.number(value) && !types.integer(value);
|
||
},
|
||
array: function array(value) {
|
||
return Array.isArray(value);
|
||
},
|
||
regexp: function regexp(value) {
|
||
if (value instanceof RegExp) {
|
||
return true;
|
||
}
|
||
|
||
try {
|
||
return !!new RegExp(value);
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
},
|
||
date: function date(value) {
|
||
return typeof value.getTime === 'function' && typeof value.getMonth === 'function' && typeof value.getYear === 'function' && !isNaN(value.getTime());
|
||
},
|
||
number: function number(value) {
|
||
if (isNaN(value)) {
|
||
return false;
|
||
}
|
||
|
||
return typeof value === 'number';
|
||
},
|
||
object: function object(value) {
|
||
return typeof value === 'object' && !types.array(value);
|
||
},
|
||
method: function method(value) {
|
||
return typeof value === 'function';
|
||
},
|
||
email: function email(value) {
|
||
return typeof value === 'string' && value.length <= 320 && !!value.match(pattern$2.email);
|
||
},
|
||
url: function url(value) {
|
||
return typeof value === 'string' && value.length <= 2048 && !!value.match(getUrlRegex());
|
||
},
|
||
hex: function hex(value) {
|
||
return typeof value === 'string' && !!value.match(pattern$2.hex);
|
||
}
|
||
};
|
||
|
||
var type$1 = function type(rule, value, source, errors, options) {
|
||
if (rule.required && value === undefined) {
|
||
required$1(rule, value, source, errors, options);
|
||
return;
|
||
}
|
||
|
||
var custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'number', 'date', 'url', 'hex'];
|
||
var ruleType = rule.type;
|
||
|
||
if (custom.indexOf(ruleType) > -1) {
|
||
if (!types[ruleType](value)) {
|
||
errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
|
||
} // straight typeof check
|
||
|
||
} else if (ruleType && typeof value !== rule.type) {
|
||
errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
|
||
}
|
||
};
|
||
|
||
var range = function range(rule, value, source, errors, options) {
|
||
var len = typeof rule.len === 'number';
|
||
var min = typeof rule.min === 'number';
|
||
var max = typeof rule.max === 'number'; // 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）
|
||
|
||
var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
|
||
var val = value;
|
||
var key = null;
|
||
var num = typeof value === 'number';
|
||
var str = typeof value === 'string';
|
||
var arr = Array.isArray(value);
|
||
|
||
if (num) {
|
||
key = 'number';
|
||
} else if (str) {
|
||
key = 'string';
|
||
} else if (arr) {
|
||
key = 'array';
|
||
} // if the value is not of a supported type for range validation
|
||
// the validation rule rule should use the
|
||
// type property to also test for a particular type
|
||
|
||
|
||
if (!key) {
|
||
return false;
|
||
}
|
||
|
||
if (arr) {
|
||
val = value.length;
|
||
}
|
||
|
||
if (str) {
|
||
// 处理码点大于U+010000的文字length属性不准确的bug，如"𠮷𠮷𠮷".lenght !== 3
|
||
val = value.replace(spRegexp, '_').length;
|
||
}
|
||
|
||
if (len) {
|
||
if (val !== rule.len) {
|
||
errors.push(format(options.messages[key].len, rule.fullField, rule.len));
|
||
}
|
||
} else if (min && !max && val < rule.min) {
|
||
errors.push(format(options.messages[key].min, rule.fullField, rule.min));
|
||
} else if (max && !min && val > rule.max) {
|
||
errors.push(format(options.messages[key].max, rule.fullField, rule.max));
|
||
} else if (min && max && (val < rule.min || val > rule.max)) {
|
||
errors.push(format(options.messages[key].range, rule.fullField, rule.min, rule.max));
|
||
}
|
||
};
|
||
|
||
var ENUM$1 = 'enum';
|
||
|
||
var enumerable$1 = function enumerable(rule, value, source, errors, options) {
|
||
rule[ENUM$1] = Array.isArray(rule[ENUM$1]) ? rule[ENUM$1] : [];
|
||
|
||
if (rule[ENUM$1].indexOf(value) === -1) {
|
||
errors.push(format(options.messages[ENUM$1], rule.fullField, rule[ENUM$1].join(', ')));
|
||
}
|
||
};
|
||
|
||
var pattern$1 = function pattern(rule, value, source, errors, options) {
|
||
if (rule.pattern) {
|
||
if (rule.pattern instanceof RegExp) {
|
||
// if a RegExp instance is passed, reset `lastIndex` in case its `global`
|
||
// flag is accidentally set to `true`, which in a validation scenario
|
||
// is not necessary and the result might be misleading
|
||
rule.pattern.lastIndex = 0;
|
||
|
||
if (!rule.pattern.test(value)) {
|
||
errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
|
||
}
|
||
} else if (typeof rule.pattern === 'string') {
|
||
var _pattern = new RegExp(rule.pattern);
|
||
|
||
if (!_pattern.test(value)) {
|
||
errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
var rules = {
|
||
required: required$1,
|
||
whitespace: whitespace,
|
||
type: type$1,
|
||
range: range,
|
||
"enum": enumerable$1,
|
||
pattern: pattern$1
|
||
};
|
||
|
||
var string = function string(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value, 'string') && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options, 'string');
|
||
|
||
if (!isEmptyValue(value, 'string')) {
|
||
rules.type(rule, value, source, errors, options);
|
||
rules.range(rule, value, source, errors, options);
|
||
rules.pattern(rule, value, source, errors, options);
|
||
|
||
if (rule.whitespace === true) {
|
||
rules.whitespace(rule, value, source, errors, options);
|
||
}
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var method = function method(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value) && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options);
|
||
|
||
if (value !== undefined) {
|
||
rules.type(rule, value, source, errors, options);
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var number = function number(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (value === '') {
|
||
value = undefined;
|
||
}
|
||
|
||
if (isEmptyValue(value) && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options);
|
||
|
||
if (value !== undefined) {
|
||
rules.type(rule, value, source, errors, options);
|
||
rules.range(rule, value, source, errors, options);
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var _boolean = function _boolean(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value) && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options);
|
||
|
||
if (value !== undefined) {
|
||
rules.type(rule, value, source, errors, options);
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var regexp = function regexp(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value) && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options);
|
||
|
||
if (!isEmptyValue(value)) {
|
||
rules.type(rule, value, source, errors, options);
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var integer = function integer(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value) && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options);
|
||
|
||
if (value !== undefined) {
|
||
rules.type(rule, value, source, errors, options);
|
||
rules.range(rule, value, source, errors, options);
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var floatFn = function floatFn(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value) && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options);
|
||
|
||
if (value !== undefined) {
|
||
rules.type(rule, value, source, errors, options);
|
||
rules.range(rule, value, source, errors, options);
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var array = function array(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if ((value === undefined || value === null) && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options, 'array');
|
||
|
||
if (value !== undefined && value !== null) {
|
||
rules.type(rule, value, source, errors, options);
|
||
rules.range(rule, value, source, errors, options);
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var object = function object(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value) && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options);
|
||
|
||
if (value !== undefined) {
|
||
rules.type(rule, value, source, errors, options);
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var ENUM = 'enum';
|
||
|
||
var enumerable = function enumerable(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value) && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options);
|
||
|
||
if (value !== undefined) {
|
||
rules[ENUM](rule, value, source, errors, options);
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var pattern = function pattern(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value, 'string') && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options);
|
||
|
||
if (!isEmptyValue(value, 'string')) {
|
||
rules.pattern(rule, value, source, errors, options);
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var date = function date(rule, value, callback, source, options) {
|
||
// console.log('integer rule called %j', rule);
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field); // console.log('validate on %s value', value);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value, 'date') && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options);
|
||
|
||
if (!isEmptyValue(value, 'date')) {
|
||
var dateObject;
|
||
|
||
if (value instanceof Date) {
|
||
dateObject = value;
|
||
} else {
|
||
dateObject = new Date(value);
|
||
}
|
||
|
||
rules.type(rule, dateObject, source, errors, options);
|
||
|
||
if (dateObject) {
|
||
rules.range(rule, dateObject.getTime(), source, errors, options);
|
||
}
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var required = function required(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var type = Array.isArray(value) ? 'array' : typeof value;
|
||
rules.required(rule, value, source, errors, options, type);
|
||
callback(errors);
|
||
};
|
||
|
||
var type = function type(rule, value, callback, source, options) {
|
||
var ruleType = rule.type;
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value, ruleType) && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options, ruleType);
|
||
|
||
if (!isEmptyValue(value, ruleType)) {
|
||
rules.type(rule, value, source, errors, options);
|
||
}
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var any = function any(rule, value, callback, source, options) {
|
||
var errors = [];
|
||
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||
|
||
if (validate) {
|
||
if (isEmptyValue(value) && !rule.required) {
|
||
return callback();
|
||
}
|
||
|
||
rules.required(rule, value, source, errors, options);
|
||
}
|
||
|
||
callback(errors);
|
||
};
|
||
|
||
var validators = {
|
||
string: string,
|
||
method: method,
|
||
number: number,
|
||
"boolean": _boolean,
|
||
regexp: regexp,
|
||
integer: integer,
|
||
"float": floatFn,
|
||
array: array,
|
||
object: object,
|
||
"enum": enumerable,
|
||
pattern: pattern,
|
||
date: date,
|
||
url: type,
|
||
hex: type,
|
||
email: type,
|
||
required: required,
|
||
any: any
|
||
};
|
||
|
||
function newMessages() {
|
||
return {
|
||
"default": 'Validation error on field %s',
|
||
required: '%s is required',
|
||
"enum": '%s must be one of %s',
|
||
whitespace: '%s cannot be empty',
|
||
date: {
|
||
format: '%s date %s is invalid for format %s',
|
||
parse: '%s date could not be parsed, %s is invalid ',
|
||
invalid: '%s date %s is invalid'
|
||
},
|
||
types: {
|
||
string: '%s is not a %s',
|
||
method: '%s is not a %s (function)',
|
||
array: '%s is not an %s',
|
||
object: '%s is not an %s',
|
||
number: '%s is not a %s',
|
||
date: '%s is not a %s',
|
||
"boolean": '%s is not a %s',
|
||
integer: '%s is not an %s',
|
||
"float": '%s is not a %s',
|
||
regexp: '%s is not a valid %s',
|
||
email: '%s is not a valid %s',
|
||
url: '%s is not a valid %s',
|
||
hex: '%s is not a valid %s'
|
||
},
|
||
string: {
|
||
len: '%s must be exactly %s characters',
|
||
min: '%s must be at least %s characters',
|
||
max: '%s cannot be longer than %s characters',
|
||
range: '%s must be between %s and %s characters'
|
||
},
|
||
number: {
|
||
len: '%s must equal %s',
|
||
min: '%s cannot be less than %s',
|
||
max: '%s cannot be greater than %s',
|
||
range: '%s must be between %s and %s'
|
||
},
|
||
array: {
|
||
len: '%s must be exactly %s in length',
|
||
min: '%s cannot be less than %s in length',
|
||
max: '%s cannot be greater than %s in length',
|
||
range: '%s must be between %s and %s in length'
|
||
},
|
||
pattern: {
|
||
mismatch: '%s value %s does not match pattern %s'
|
||
},
|
||
clone: function clone() {
|
||
var cloned = JSON.parse(JSON.stringify(this));
|
||
cloned.clone = this.clone;
|
||
return cloned;
|
||
}
|
||
};
|
||
}
|
||
var messages = newMessages();
|
||
|
||
/**
|
||
* Encapsulates a validation schema.
|
||
*
|
||
* @param descriptor An object declaring validation rules
|
||
* for this schema.
|
||
*/
|
||
|
||
var Schema = /*#__PURE__*/function () {
|
||
// ========================= Static =========================
|
||
// ======================== Instance ========================
|
||
function Schema(descriptor) {
|
||
this.rules = null;
|
||
this._messages = messages;
|
||
this.define(descriptor);
|
||
}
|
||
|
||
var _proto = Schema.prototype;
|
||
|
||
_proto.define = function define(rules) {
|
||
var _this = this;
|
||
|
||
if (!rules) {
|
||
throw new Error('Cannot configure a schema with no rules');
|
||
}
|
||
|
||
if (typeof rules !== 'object' || Array.isArray(rules)) {
|
||
throw new Error('Rules must be an object');
|
||
}
|
||
|
||
this.rules = {};
|
||
Object.keys(rules).forEach(function (name) {
|
||
var item = rules[name];
|
||
_this.rules[name] = Array.isArray(item) ? item : [item];
|
||
});
|
||
};
|
||
|
||
_proto.messages = function messages(_messages) {
|
||
if (_messages) {
|
||
this._messages = deepMerge(newMessages(), _messages);
|
||
}
|
||
|
||
return this._messages;
|
||
};
|
||
|
||
_proto.validate = function validate(source_, o, oc) {
|
||
var _this2 = this;
|
||
|
||
if (o === void 0) {
|
||
o = {};
|
||
}
|
||
|
||
if (oc === void 0) {
|
||
oc = function oc() {};
|
||
}
|
||
|
||
var source = source_;
|
||
var options = o;
|
||
var callback = oc;
|
||
|
||
if (typeof options === 'function') {
|
||
callback = options;
|
||
options = {};
|
||
}
|
||
|
||
if (!this.rules || Object.keys(this.rules).length === 0) {
|
||
if (callback) {
|
||
callback(null, source);
|
||
}
|
||
|
||
return Promise.resolve(source);
|
||
}
|
||
|
||
function complete(results) {
|
||
var errors = [];
|
||
var fields = {};
|
||
|
||
function add(e) {
|
||
if (Array.isArray(e)) {
|
||
var _errors;
|
||
|
||
errors = (_errors = errors).concat.apply(_errors, e);
|
||
} else {
|
||
errors.push(e);
|
||
}
|
||
}
|
||
|
||
for (var i = 0; i < results.length; i++) {
|
||
add(results[i]);
|
||
}
|
||
|
||
if (!errors.length) {
|
||
callback(null, source);
|
||
} else {
|
||
fields = convertFieldsError(errors);
|
||
callback(errors, fields);
|
||
}
|
||
}
|
||
|
||
if (options.messages) {
|
||
var messages$1 = this.messages();
|
||
|
||
if (messages$1 === messages) {
|
||
messages$1 = newMessages();
|
||
}
|
||
|
||
deepMerge(messages$1, options.messages);
|
||
options.messages = messages$1;
|
||
} else {
|
||
options.messages = this.messages();
|
||
}
|
||
|
||
var series = {};
|
||
var keys = options.keys || Object.keys(this.rules);
|
||
keys.forEach(function (z) {
|
||
var arr = _this2.rules[z];
|
||
var value = source[z];
|
||
arr.forEach(function (r) {
|
||
var rule = r;
|
||
|
||
if (typeof rule.transform === 'function') {
|
||
if (source === source_) {
|
||
source = _extends({}, source);
|
||
}
|
||
|
||
value = source[z] = rule.transform(value);
|
||
}
|
||
|
||
if (typeof rule === 'function') {
|
||
rule = {
|
||
validator: rule
|
||
};
|
||
} else {
|
||
rule = _extends({}, rule);
|
||
} // Fill validator. Skip if nothing need to validate
|
||
|
||
|
||
rule.validator = _this2.getValidationMethod(rule);
|
||
|
||
if (!rule.validator) {
|
||
return;
|
||
}
|
||
|
||
rule.field = z;
|
||
rule.fullField = rule.fullField || z;
|
||
rule.type = _this2.getType(rule);
|
||
series[z] = series[z] || [];
|
||
series[z].push({
|
||
rule: rule,
|
||
value: value,
|
||
source: source,
|
||
field: z
|
||
});
|
||
});
|
||
});
|
||
var errorFields = {};
|
||
return asyncMap(series, options, function (data, doIt) {
|
||
var rule = data.rule;
|
||
var deep = (rule.type === 'object' || rule.type === 'array') && (typeof rule.fields === 'object' || typeof rule.defaultField === 'object');
|
||
deep = deep && (rule.required || !rule.required && data.value);
|
||
rule.field = data.field;
|
||
|
||
function addFullField(key, schema) {
|
||
return _extends({}, schema, {
|
||
fullField: rule.fullField + "." + key,
|
||
fullFields: rule.fullFields ? [].concat(rule.fullFields, [key]) : [key]
|
||
});
|
||
}
|
||
|
||
function cb(e) {
|
||
if (e === void 0) {
|
||
e = [];
|
||
}
|
||
|
||
var errorList = Array.isArray(e) ? e : [e];
|
||
|
||
if (!options.suppressWarning && errorList.length) {
|
||
Schema.warning('async-validator:', errorList);
|
||
}
|
||
|
||
if (errorList.length && rule.message !== undefined) {
|
||
errorList = [].concat(rule.message);
|
||
} // Fill error info
|
||
|
||
|
||
var filledErrors = errorList.map(complementError(rule, source));
|
||
|
||
if (options.first && filledErrors.length) {
|
||
errorFields[rule.field] = 1;
|
||
return doIt(filledErrors);
|
||
}
|
||
|
||
if (!deep) {
|
||
doIt(filledErrors);
|
||
} else {
|
||
// if rule is required but the target object
|
||
// does not exist fail at the rule level and don't
|
||
// go deeper
|
||
if (rule.required && !data.value) {
|
||
if (rule.message !== undefined) {
|
||
filledErrors = [].concat(rule.message).map(complementError(rule, source));
|
||
} else if (options.error) {
|
||
filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
|
||
}
|
||
|
||
return doIt(filledErrors);
|
||
}
|
||
|
||
var fieldsSchema = {};
|
||
|
||
if (rule.defaultField) {
|
||
Object.keys(data.value).map(function (key) {
|
||
fieldsSchema[key] = rule.defaultField;
|
||
});
|
||
}
|
||
|
||
fieldsSchema = _extends({}, fieldsSchema, data.rule.fields);
|
||
var paredFieldsSchema = {};
|
||
Object.keys(fieldsSchema).forEach(function (field) {
|
||
var fieldSchema = fieldsSchema[field];
|
||
var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
|
||
paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
|
||
});
|
||
var schema = new Schema(paredFieldsSchema);
|
||
schema.messages(options.messages);
|
||
|
||
if (data.rule.options) {
|
||
data.rule.options.messages = options.messages;
|
||
data.rule.options.error = options.error;
|
||
}
|
||
|
||
schema.validate(data.value, data.rule.options || options, function (errs) {
|
||
var finalErrors = [];
|
||
|
||
if (filledErrors && filledErrors.length) {
|
||
finalErrors.push.apply(finalErrors, filledErrors);
|
||
}
|
||
|
||
if (errs && errs.length) {
|
||
finalErrors.push.apply(finalErrors, errs);
|
||
}
|
||
|
||
doIt(finalErrors.length ? finalErrors : null);
|
||
});
|
||
}
|
||
}
|
||
|
||
var res;
|
||
|
||
if (rule.asyncValidator) {
|
||
res = rule.asyncValidator(rule, data.value, cb, data.source, options);
|
||
} else if (rule.validator) {
|
||
try {
|
||
res = rule.validator(rule, data.value, cb, data.source, options);
|
||
} catch (error) {
|
||
console.error == null ? void 0 : console.error(error); // rethrow to report error
|
||
|
||
if (!options.suppressValidatorError) {
|
||
setTimeout(function () {
|
||
throw error;
|
||
}, 0);
|
||
}
|
||
|
||
cb(error.message);
|
||
}
|
||
|
||
if (res === true) {
|
||
cb();
|
||
} else if (res === false) {
|
||
cb(typeof rule.message === 'function' ? rule.message(rule.fullField || rule.field) : rule.message || (rule.fullField || rule.field) + " fails");
|
||
} else if (res instanceof Array) {
|
||
cb(res);
|
||
} else if (res instanceof Error) {
|
||
cb(res.message);
|
||
}
|
||
}
|
||
|
||
if (res && res.then) {
|
||
res.then(function () {
|
||
return cb();
|
||
}, function (e) {
|
||
return cb(e);
|
||
});
|
||
}
|
||
}, function (results) {
|
||
complete(results);
|
||
}, source);
|
||
};
|
||
|
||
_proto.getType = function getType(rule) {
|
||
if (rule.type === undefined && rule.pattern instanceof RegExp) {
|
||
rule.type = 'pattern';
|
||
}
|
||
|
||
if (typeof rule.validator !== 'function' && rule.type && !validators.hasOwnProperty(rule.type)) {
|
||
throw new Error(format('Unknown rule type %s', rule.type));
|
||
}
|
||
|
||
return rule.type || 'string';
|
||
};
|
||
|
||
_proto.getValidationMethod = function getValidationMethod(rule) {
|
||
if (typeof rule.validator === 'function') {
|
||
return rule.validator;
|
||
}
|
||
|
||
var keys = Object.keys(rule);
|
||
var messageIndex = keys.indexOf('message');
|
||
|
||
if (messageIndex !== -1) {
|
||
keys.splice(messageIndex, 1);
|
||
}
|
||
|
||
if (keys.length === 1 && keys[0] === 'required') {
|
||
return validators.required;
|
||
}
|
||
|
||
return validators[this.getType(rule)] || undefined;
|
||
};
|
||
|
||
return Schema;
|
||
}();
|
||
|
||
Schema.register = function register(type, validator) {
|
||
if (typeof validator !== 'function') {
|
||
throw new Error('Cannot register a validator by type, validator is not a function');
|
||
}
|
||
|
||
validators[type] = validator;
|
||
};
|
||
|
||
Schema.warning = warning;
|
||
Schema.messages = messages;
|
||
Schema.validators = validators;
|
||
|
||
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__("./node_modules/process/browser.js")))
|
||
|
||
/***/ }),
|
||
|
||
/***/ "./node_modules/process/browser.js":
|
||
/***/ (function(module, exports) {
|
||
|
||
// shim for using process in browser
|
||
var process = module.exports = {};
|
||
|
||
// cached from whatever global is present so that test runners that stub it
|
||
// don't break things. But we need to wrap it in a try catch in case it is
|
||
// wrapped in strict mode code which doesn't define any globals. It's inside a
|
||
// function because try/catches deoptimize in certain engines.
|
||
|
||
var cachedSetTimeout;
|
||
var cachedClearTimeout;
|
||
|
||
function defaultSetTimout() {
|
||
throw new Error('setTimeout has not been defined');
|
||
}
|
||
function defaultClearTimeout () {
|
||
throw new Error('clearTimeout has not been defined');
|
||
}
|
||
(function () {
|
||
try {
|
||
if (typeof setTimeout === 'function') {
|
||
cachedSetTimeout = setTimeout;
|
||
} else {
|
||
cachedSetTimeout = defaultSetTimout;
|
||
}
|
||
} catch (e) {
|
||
cachedSetTimeout = defaultSetTimout;
|
||
}
|
||
try {
|
||
if (typeof clearTimeout === 'function') {
|
||
cachedClearTimeout = clearTimeout;
|
||
} else {
|
||
cachedClearTimeout = defaultClearTimeout;
|
||
}
|
||
} catch (e) {
|
||
cachedClearTimeout = defaultClearTimeout;
|
||
}
|
||
} ())
|
||
function runTimeout(fun) {
|
||
if (cachedSetTimeout === setTimeout) {
|
||
//normal enviroments in sane situations
|
||
return setTimeout(fun, 0);
|
||
}
|
||
// if setTimeout wasn't available but was latter defined
|
||
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
||
cachedSetTimeout = setTimeout;
|
||
return setTimeout(fun, 0);
|
||
}
|
||
try {
|
||
// when when somebody has screwed with setTimeout but no I.E. maddness
|
||
return cachedSetTimeout(fun, 0);
|
||
} catch(e){
|
||
try {
|
||
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
||
return cachedSetTimeout.call(null, fun, 0);
|
||
} catch(e){
|
||
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
|
||
return cachedSetTimeout.call(this, fun, 0);
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
function runClearTimeout(marker) {
|
||
if (cachedClearTimeout === clearTimeout) {
|
||
//normal enviroments in sane situations
|
||
return clearTimeout(marker);
|
||
}
|
||
// if clearTimeout wasn't available but was latter defined
|
||
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
|
||
cachedClearTimeout = clearTimeout;
|
||
return clearTimeout(marker);
|
||
}
|
||
try {
|
||
// when when somebody has screwed with setTimeout but no I.E. maddness
|
||
return cachedClearTimeout(marker);
|
||
} catch (e){
|
||
try {
|
||
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
||
return cachedClearTimeout.call(null, marker);
|
||
} catch (e){
|
||
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
|
||
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
|
||
return cachedClearTimeout.call(this, marker);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
}
|
||
var queue = [];
|
||
var draining = false;
|
||
var currentQueue;
|
||
var queueIndex = -1;
|
||
|
||
function cleanUpNextTick() {
|
||
if (!draining || !currentQueue) {
|
||
return;
|
||
}
|
||
draining = false;
|
||
if (currentQueue.length) {
|
||
queue = currentQueue.concat(queue);
|
||
} else {
|
||
queueIndex = -1;
|
||
}
|
||
if (queue.length) {
|
||
drainQueue();
|
||
}
|
||
}
|
||
|
||
function drainQueue() {
|
||
if (draining) {
|
||
return;
|
||
}
|
||
var timeout = runTimeout(cleanUpNextTick);
|
||
draining = true;
|
||
|
||
var len = queue.length;
|
||
while(len) {
|
||
currentQueue = queue;
|
||
queue = [];
|
||
while (++queueIndex < len) {
|
||
if (currentQueue) {
|
||
currentQueue[queueIndex].run();
|
||
}
|
||
}
|
||
queueIndex = -1;
|
||
len = queue.length;
|
||
}
|
||
currentQueue = null;
|
||
draining = false;
|
||
runClearTimeout(timeout);
|
||
}
|
||
|
||
process.nextTick = function (fun) {
|
||
var args = new Array(arguments.length - 1);
|
||
if (arguments.length > 1) {
|
||
for (var i = 1; i < arguments.length; i++) {
|
||
args[i - 1] = arguments[i];
|
||
}
|
||
}
|
||
queue.push(new Item(fun, args));
|
||
if (queue.length === 1 && !draining) {
|
||
runTimeout(drainQueue);
|
||
}
|
||
};
|
||
|
||
// v8 likes predictible objects
|
||
function Item(fun, array) {
|
||
this.fun = fun;
|
||
this.array = array;
|
||
}
|
||
Item.prototype.run = function () {
|
||
this.fun.apply(null, this.array);
|
||
};
|
||
process.title = 'browser';
|
||
process.browser = true;
|
||
process.env = {};
|
||
process.argv = [];
|
||
process.version = ''; // empty string to avoid regexp issues
|
||
process.versions = {};
|
||
|
||
function noop() {}
|
||
|
||
process.on = noop;
|
||
process.addListener = noop;
|
||
process.once = noop;
|
||
process.off = noop;
|
||
process.removeListener = noop;
|
||
process.removeAllListeners = noop;
|
||
process.emit = noop;
|
||
process.prependListener = noop;
|
||
process.prependOnceListener = noop;
|
||
|
||
process.listeners = function (name) { return [] }
|
||
|
||
process.binding = function (name) {
|
||
throw new Error('process.binding is not supported');
|
||
};
|
||
|
||
process.cwd = function () { return '/' };
|
||
process.chdir = function (dir) {
|
||
throw new Error('process.chdir is not supported');
|
||
};
|
||
process.umask = function() { return 0; };
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 0:
|
||
/***/ (function(module, exports) {
|
||
|
||
module.exports = i18n;
|
||
|
||
/***/ })
|
||
|
||
/******/ });
|
||
//# sourceMappingURL=userforms.js.map
|