/******/ (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; /******/ /******/ // define getter function for harmony exports /******/ __webpack_require__.d = function(exports, name, getter) { /******/ if(!__webpack_require__.o(exports, name)) { /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); /******/ } /******/ }; /******/ /******/ // define __esModule on exports /******/ __webpack_require__.r = function(exports) { /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); /******/ } /******/ Object.defineProperty(exports, '__esModule', { value: true }); /******/ }; /******/ /******/ // create a fake namespace object /******/ // mode & 1: value is a module id, require it /******/ // mode & 2: merge all properties of value into the ns /******/ // mode & 4: return value when already ns object /******/ // mode & 8|1: behave like require /******/ __webpack_require__.t = function(value, mode) { /******/ if(mode & 1) value = __webpack_require__(value); /******/ if(mode & 8) return value; /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; /******/ var ns = Object.create(null); /******/ __webpack_require__.r(ns); /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); /******/ return ns; /******/ }; /******/ /******/ // 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 = 2); /******/ }) /************************************************************************/ /******/ ({ /***/ "./node_modules/@tentakelfabrik/tiny-validator/src/validator.js": /*!**********************************************************************!*\ !*** ./node_modules/@tentakelfabrik/tiny-validator/src/validator.js ***! \**********************************************************************/ /*! exports provided: default */ /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; __webpack_require__.r(__webpack_exports__); /* harmony import */ var validate_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! validate.js */ "./node_modules/validate.js/validate.js"); /* harmony import */ var validate_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(validate_js__WEBPACK_IMPORTED_MODULE_0__); /* harmony import */ var form_serialize__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! form-serialize */ "./node_modules/form-serialize/index.js"); /* harmony import */ var form_serialize__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(form_serialize__WEBPACK_IMPORTED_MODULE_1__); /** * Validate entire Form or a single Element * * Using validator.js * * @author Björn Hase, Tentakelfabrik, me@tentakelfabrik.de * */ class Validator { /** * * @param {array} rules */ constructor(rules, component) { this._rules = rules this._component = component this._errors = { } } /** * handle validation * * if key not set, * * @param {object} event * @param {object} key * */ handle(event, key) { event.preventDefault() let data = null, rules, errors if (key) { if (event.target.value) { data = event.target.value } } else { data = form_serialize__WEBPACK_IMPORTED_MODULE_1___default()(event.target, { hash: true }) } // validate single if (key) { rules = this._rules[key] errors = validate_js__WEBPACK_IMPORTED_MODULE_0___default.a.single(data, rules, { flat: true }) if (errors) { this._errors[key] = errors } else { delete this._errors[key] } // validate entire form } else { this._errors = validate_js__WEBPACK_IMPORTED_MODULE_0___default()(data, this._rules) } // update component this._component.update() } /** * * * @param {[type]} key * @return {[type]} */ errors(key) { if (key) { return this._errors[key] } return this._errors } } /* harmony default export */ __webpack_exports__["default"] = (Validator); /***/ }), /***/ "./node_modules/form-serialize/index.js": /*!**********************************************!*\ !*** ./node_modules/form-serialize/index.js ***! \**********************************************/ /*! no static exports found */ /***/ (function(module, exports) { // get successful control from form and assemble into object // http://www.w3.org/TR/html401/interact/forms.html#h-17.13.2 // types which indicate a submit action and are not successful controls // these will be ignored var k_r_submitter = /^(?:submit|button|image|reset|file)$/i; // node names which could be successful controls var k_r_success_contrls = /^(?:input|select|textarea|keygen)/i; // Matches bracket notation. var brackets = /(\[[^\[\]]*\])/g; // serializes form fields // @param form MUST be an HTMLForm element // @param options is an optional argument to configure the serialization. Default output // with no options specified is a url encoded string // - hash: [true | false] Configure the output type. If true, the output will // be a js object. // - serializer: [function] Optional serializer function to override the default one. // The function takes 3 arguments (result, key, value) and should return new result // hash and url encoded str serializers are provided with this module // - disabled: [true | false]. If true serialize disabled fields. // - empty: [true | false]. If true serialize empty fields function serialize(form, options) { if (typeof options != 'object') { options = { hash: !!options }; } else if (options.hash === undefined) { options.hash = true; } var result = (options.hash) ? {} : ''; var serializer = options.serializer || ((options.hash) ? hash_serializer : str_serialize); var elements = form && form.elements ? form.elements : []; //Object store each radio and set if it's empty or not var radio_store = Object.create(null); for (var i=0 ; i", error: ""}, ...] runValidations: function(attributes, constraints, options) { var results = [] , attr , validatorName , value , validators , validator , validatorOptions , error; if (v.isDomElement(attributes) || v.isJqueryElement(attributes)) { attributes = v.collectFormValues(attributes); } // Loops through each constraints, finds the correct validator and run it. for (attr in constraints) { value = v.getDeepObjectValue(attributes, attr); // This allows the constraints for an attribute to be a function. // The function will be called with the value, attribute name, the complete dict of // attributes as well as the options and constraints passed in. // This is useful when you want to have different // validations depending on the attribute value. validators = v.result(constraints[attr], value, attributes, attr, options, constraints); for (validatorName in validators) { validator = v.validators[validatorName]; if (!validator) { error = v.format("Unknown validator %{name}", {name: validatorName}); throw new Error(error); } validatorOptions = validators[validatorName]; // This allows the options to be a function. The function will be // called with the value, attribute name, the complete dict of // attributes as well as the options and constraints passed in. // This is useful when you want to have different // validations depending on the attribute value. validatorOptions = v.result(validatorOptions, value, attributes, attr, options, constraints); if (!validatorOptions) { continue; } results.push({ attribute: attr, value: value, validator: validatorName, globalOptions: options, attributes: attributes, options: validatorOptions, error: validator.call(validator, value, validatorOptions, attr, attributes, options) }); } } return results; }, // Takes the output from runValidations and converts it to the correct // output format. processValidationResults: function(errors, options) { errors = v.pruneEmptyErrors(errors, options); errors = v.expandMultipleErrors(errors, options); errors = v.convertErrorMessages(errors, options); var format = options.format || "grouped"; if (typeof v.formatters[format] === 'function') { errors = v.formatters[format](errors); } else { throw new Error(v.format("Unknown format %{format}", options)); } return v.isEmpty(errors) ? undefined : errors; }, // Runs the validations with support for promises. // This function will return a promise that is settled when all the // validation promises have been completed. // It can be called even if no validations returned a promise. async: function(attributes, constraints, options) { options = v.extend({}, v.async.options, options); var WrapErrors = options.wrapErrors || function(errors) { return errors; }; // Removes unknown attributes if (options.cleanAttributes !== false) { attributes = v.cleanAttributes(attributes, constraints); } var results = v.runValidations(attributes, constraints, options); return new v.Promise(function(resolve, reject) { v.waitForResults(results).then(function() { var errors = v.processValidationResults(results, options); if (errors) { reject(new WrapErrors(errors, options, attributes, constraints)); } else { resolve(attributes); } }, function(err) { reject(err); }); }); }, single: function(value, constraints, options) { options = v.extend({}, v.single.options, options, { format: "flat", fullMessages: false }); return v({single: value}, {single: constraints}, options); }, // Returns a promise that is resolved when all promises in the results array // are settled. The promise returned from this function is always resolved, // never rejected. // This function modifies the input argument, it replaces the promises // with the value returned from the promise. waitForResults: function(results) { // Create a sequence of all the results starting with a resolved promise. return results.reduce(function(memo, result) { // If this result isn't a promise skip it in the sequence. if (!v.isPromise(result.error)) { return memo; } return memo.then(function() { return result.error.then(function(error) { result.error = error || null; }); }); }, new v.Promise(function(r) { r(); })); // A resolved promise }, // If the given argument is a call: function the and: function return the value // otherwise just return the value. Additional arguments will be passed as // arguments to the function. // Example: // ``` // result('foo') // 'foo' // result(Math.max, 1, 2) // 2 // ``` result: function(value) { var args = [].slice.call(arguments, 1); if (typeof value === 'function') { value = value.apply(null, args); } return value; }, // Checks if the value is a number. This function does not consider NaN a // number like many other `isNumber` functions do. isNumber: function(value) { return typeof value === 'number' && !isNaN(value); }, // Returns false if the object is not a function isFunction: function(value) { return typeof value === 'function'; }, // A simple check to verify that the value is an integer. Uses `isNumber` // and a simple modulo check. isInteger: function(value) { return v.isNumber(value) && value % 1 === 0; }, // Checks if the value is a boolean isBoolean: function(value) { return typeof value === 'boolean'; }, // Uses the `Object` function to check if the given argument is an object. isObject: function(obj) { return obj === Object(obj); }, // Simply checks if the object is an instance of a date isDate: function(obj) { return obj instanceof Date; }, // Returns false if the object is `null` of `undefined` isDefined: function(obj) { return obj !== null && obj !== undefined; }, // Checks if the given argument is a promise. Anything with a `then` // function is considered a promise. isPromise: function(p) { return !!p && v.isFunction(p.then); }, isJqueryElement: function(o) { return o && v.isString(o.jquery); }, isDomElement: function(o) { if (!o) { return false; } if (!o.querySelectorAll || !o.querySelector) { return false; } if (v.isObject(document) && o === document) { return true; } // http://stackoverflow.com/a/384380/699304 /* istanbul ignore else */ if (typeof HTMLElement === "object") { return o instanceof HTMLElement; } else { return o && typeof o === "object" && o !== null && o.nodeType === 1 && typeof o.nodeName === "string"; } }, isEmpty: function(value) { var attr; // Null and undefined are empty if (!v.isDefined(value)) { return true; } // functions are non empty if (v.isFunction(value)) { return false; } // Whitespace only strings are empty if (v.isString(value)) { return v.EMPTY_STRING_REGEXP.test(value); } // For arrays we use the length property if (v.isArray(value)) { return value.length === 0; } // Dates have no attributes but aren't empty if (v.isDate(value)) { return false; } // If we find at least one property we consider it non empty if (v.isObject(value)) { for (attr in value) { return false; } return true; } return false; }, // Formats the specified strings with the given values like so: // ``` // format("Foo: %{foo}", {foo: "bar"}) // "Foo bar" // ``` // If you want to write %{...} without having it replaced simply // prefix it with % like this `Foo: %%{foo}` and it will be returned // as `"Foo: %{foo}"` format: v.extend(function(str, vals) { if (!v.isString(str)) { return str; } return str.replace(v.format.FORMAT_REGEXP, function(m0, m1, m2) { if (m1 === '%') { return "%{" + m2 + "}"; } else { return String(vals[m2]); } }); }, { // Finds %{key} style patterns in the given string FORMAT_REGEXP: /(%?)%\{([^\}]+)\}/g }), // "Prettifies" the given string. // Prettifying means replacing [.\_-] with spaces as well as splitting // camel case words. prettify: function(str) { if (v.isNumber(str)) { // If there are more than 2 decimals round it to two if ((str * 100) % 1 === 0) { return "" + str; } else { return parseFloat(Math.round(str * 100) / 100).toFixed(2); } } if (v.isArray(str)) { return str.map(function(s) { return v.prettify(s); }).join(", "); } if (v.isObject(str)) { if (!v.isDefined(str.toString)) { return JSON.stringify(str); } return str.toString(); } // Ensure the string is actually a string str = "" + str; return str // Splits keys separated by periods .replace(/([^\s])\.([^\s])/g, '$1 $2') // Removes backslashes .replace(/\\+/g, '') // Replaces - and - with space .replace(/[_-]/g, ' ') // Splits camel cased words .replace(/([a-z])([A-Z])/g, function(m0, m1, m2) { return "" + m1 + " " + m2.toLowerCase(); }) .toLowerCase(); }, stringifyValue: function(value, options) { var prettify = options && options.prettify || v.prettify; return prettify(value); }, isString: function(value) { return typeof value === 'string'; }, isArray: function(value) { return {}.toString.call(value) === '[object Array]'; }, // Checks if the object is a hash, which is equivalent to an object that // is neither an array nor a function. isHash: function(value) { return v.isObject(value) && !v.isArray(value) && !v.isFunction(value); }, contains: function(obj, value) { if (!v.isDefined(obj)) { return false; } if (v.isArray(obj)) { return obj.indexOf(value) !== -1; } return value in obj; }, unique: function(array) { if (!v.isArray(array)) { return array; } return array.filter(function(el, index, array) { return array.indexOf(el) == index; }); }, forEachKeyInKeypath: function(object, keypath, callback) { if (!v.isString(keypath)) { return undefined; } var key = "" , i , escape = false; for (i = 0; i < keypath.length; ++i) { switch (keypath[i]) { case '.': if (escape) { escape = false; key += '.'; } else { object = callback(object, key, false); key = ""; } break; case '\\': if (escape) { escape = false; key += '\\'; } else { escape = true; } break; default: escape = false; key += keypath[i]; break; } } return callback(object, key, true); }, getDeepObjectValue: function(obj, keypath) { if (!v.isObject(obj)) { return undefined; } return v.forEachKeyInKeypath(obj, keypath, function(obj, key) { if (v.isObject(obj)) { return obj[key]; } }); }, // This returns an object with all the values of the form. // It uses the input name as key and the value as value // So for example this: // // would return: // {email: "foo@bar.com"} collectFormValues: function(form, options) { var values = {} , i , j , input , inputs , option , value; if (v.isJqueryElement(form)) { form = form[0]; } if (!form) { return values; } options = options || {}; inputs = form.querySelectorAll("input[name], textarea[name]"); for (i = 0; i < inputs.length; ++i) { input = inputs.item(i); if (v.isDefined(input.getAttribute("data-ignored"))) { continue; } var name = input.name.replace(/\./g, "\\\\."); value = v.sanitizeFormValue(input.value, options); if (input.type === "number") { value = value ? +value : null; } else if (input.type === "checkbox") { if (input.attributes.value) { if (!input.checked) { value = values[name] || null; } } else { value = input.checked; } } else if (input.type === "radio") { if (!input.checked) { value = values[name] || null; } } values[name] = value; } inputs = form.querySelectorAll("select[name]"); for (i = 0; i < inputs.length; ++i) { input = inputs.item(i); if (v.isDefined(input.getAttribute("data-ignored"))) { continue; } if (input.multiple) { value = []; for (j in input.options) { option = input.options[j]; if (option && option.selected) { value.push(v.sanitizeFormValue(option.value, options)); } } } else { var _val = typeof input.options[input.selectedIndex] !== 'undefined' ? input.options[input.selectedIndex].value : /* istanbul ignore next */ ''; value = v.sanitizeFormValue(_val, options); } values[input.name] = value; } return values; }, sanitizeFormValue: function(value, options) { if (options.trim && v.isString(value)) { value = value.trim(); } if (options.nullify !== false && value === "") { return null; } return value; }, capitalize: function(str) { if (!v.isString(str)) { return str; } return str[0].toUpperCase() + str.slice(1); }, // Remove all errors who's error attribute is empty (null or undefined) pruneEmptyErrors: function(errors) { return errors.filter(function(error) { return !v.isEmpty(error.error); }); }, // In // [{error: ["err1", "err2"], ...}] // Out // [{error: "err1", ...}, {error: "err2", ...}] // // All attributes in an error with multiple messages are duplicated // when expanding the errors. expandMultipleErrors: function(errors) { var ret = []; errors.forEach(function(error) { // Removes errors without a message if (v.isArray(error.error)) { error.error.forEach(function(msg) { ret.push(v.extend({}, error, {error: msg})); }); } else { ret.push(error); } }); return ret; }, // Converts the error mesages by prepending the attribute name unless the // message is prefixed by ^ convertErrorMessages: function(errors, options) { options = options || {}; var ret = [] , prettify = options.prettify || v.prettify; errors.forEach(function(errorInfo) { var error = v.result(errorInfo.error, errorInfo.value, errorInfo.attribute, errorInfo.options, errorInfo.attributes, errorInfo.globalOptions); if (!v.isString(error)) { ret.push(errorInfo); return; } if (error[0] === '^') { error = error.slice(1); } else if (options.fullMessages !== false) { error = v.capitalize(prettify(errorInfo.attribute)) + " " + error; } error = error.replace(/\\\^/g, "^"); error = v.format(error, { value: v.stringifyValue(errorInfo.value, options) }); ret.push(v.extend({}, errorInfo, {error: error})); }); return ret; }, // In: // [{attribute: "", ...}] // Out: // {"": [{attribute: "", ...}]} groupErrorsByAttribute: function(errors) { var ret = {}; errors.forEach(function(error) { var list = ret[error.attribute]; if (list) { list.push(error); } else { ret[error.attribute] = [error]; } }); return ret; }, // In: // [{error: "", ...}, {error: "", ...}] // Out: // ["", ""] flattenErrorsToArray: function(errors) { return errors .map(function(error) { return error.error; }) .filter(function(value, index, self) { return self.indexOf(value) === index; }); }, cleanAttributes: function(attributes, whitelist) { function whitelistCreator(obj, key, last) { if (v.isObject(obj[key])) { return obj[key]; } return (obj[key] = last ? true : {}); } function buildObjectWhitelist(whitelist) { var ow = {} , lastObject , attr; for (attr in whitelist) { if (!whitelist[attr]) { continue; } v.forEachKeyInKeypath(ow, attr, whitelistCreator); } return ow; } function cleanRecursive(attributes, whitelist) { if (!v.isObject(attributes)) { return attributes; } var ret = v.extend({}, attributes) , w , attribute; for (attribute in attributes) { w = whitelist[attribute]; if (v.isObject(w)) { ret[attribute] = cleanRecursive(ret[attribute], w); } else if (!w) { delete ret[attribute]; } } return ret; } if (!v.isObject(whitelist) || !v.isObject(attributes)) { return {}; } whitelist = buildObjectWhitelist(whitelist); return cleanRecursive(attributes, whitelist); }, exposeModule: function(validate, root, exports, module, define) { if (exports) { if (module && module.exports) { exports = module.exports = validate; } exports.validate = validate; } else { root.validate = validate; if (validate.isFunction(define) && define.amd) { define([], function () { return validate; }); } } }, warn: function(msg) { if (typeof console !== "undefined" && console.warn) { console.warn("[validate.js] " + msg); } }, error: function(msg) { if (typeof console !== "undefined" && console.error) { console.error("[validate.js] " + msg); } } }); validate.validators = { // Presence validates that the value isn't empty presence: function(value, options) { options = v.extend({}, this.options, options); if (options.allowEmpty !== false ? !v.isDefined(value) : v.isEmpty(value)) { return options.message || this.message || "can't be blank"; } }, length: function(value, options, attribute) { // Empty values are allowed if (!v.isDefined(value)) { return; } options = v.extend({}, this.options, options); var is = options.is , maximum = options.maximum , minimum = options.minimum , tokenizer = options.tokenizer || function(val) { return val; } , err , errors = []; value = tokenizer(value); var length = value.length; if(!v.isNumber(length)) { return options.message || this.notValid || "has an incorrect length"; } // Is checks if (v.isNumber(is) && length !== is) { err = options.wrongLength || this.wrongLength || "is the wrong length (should be %{count} characters)"; errors.push(v.format(err, {count: is})); } if (v.isNumber(minimum) && length < minimum) { err = options.tooShort || this.tooShort || "is too short (minimum is %{count} characters)"; errors.push(v.format(err, {count: minimum})); } if (v.isNumber(maximum) && length > maximum) { err = options.tooLong || this.tooLong || "is too long (maximum is %{count} characters)"; errors.push(v.format(err, {count: maximum})); } if (errors.length > 0) { return options.message || errors; } }, numericality: function(value, options, attribute, attributes, globalOptions) { // Empty values are fine if (!v.isDefined(value)) { return; } options = v.extend({}, this.options, options); var errors = [] , name , count , checks = { greaterThan: function(v, c) { return v > c; }, greaterThanOrEqualTo: function(v, c) { return v >= c; }, equalTo: function(v, c) { return v === c; }, lessThan: function(v, c) { return v < c; }, lessThanOrEqualTo: function(v, c) { return v <= c; }, divisibleBy: function(v, c) { return v % c === 0; } } , prettify = options.prettify || (globalOptions && globalOptions.prettify) || v.prettify; // Strict will check that it is a valid looking number if (v.isString(value) && options.strict) { var pattern = "^-?(0|[1-9]\\d*)"; if (!options.onlyInteger) { pattern += "(\\.\\d+)?"; } pattern += "$"; if (!(new RegExp(pattern).test(value))) { return options.message || options.notValid || this.notValid || this.message || "must be a valid number"; } } // Coerce the value to a number unless we're being strict. if (options.noStrings !== true && v.isString(value) && !v.isEmpty(value)) { value = +value; } // If it's not a number we shouldn't continue since it will compare it. if (!v.isNumber(value)) { return options.message || options.notValid || this.notValid || this.message || "is not a number"; } // Same logic as above, sort of. Don't bother with comparisons if this // doesn't pass. if (options.onlyInteger && !v.isInteger(value)) { return options.message || options.notInteger || this.notInteger || this.message || "must be an integer"; } for (name in checks) { count = options[name]; if (v.isNumber(count) && !checks[name](value, count)) { // This picks the default message if specified // For example the greaterThan check uses the message from // this.notGreaterThan so we capitalize the name and prepend "not" var key = "not" + v.capitalize(name); var msg = options[key] || this[key] || this.message || "must be %{type} %{count}"; errors.push(v.format(msg, { count: count, type: prettify(name) })); } } if (options.odd && value % 2 !== 1) { errors.push(options.notOdd || this.notOdd || this.message || "must be odd"); } if (options.even && value % 2 !== 0) { errors.push(options.notEven || this.notEven || this.message || "must be even"); } if (errors.length) { return options.message || errors; } }, datetime: v.extend(function(value, options) { if (!v.isFunction(this.parse) || !v.isFunction(this.format)) { throw new Error("Both the parse and format functions needs to be set to use the datetime/date validator"); } // Empty values are fine if (!v.isDefined(value)) { return; } options = v.extend({}, this.options, options); var err , errors = [] , earliest = options.earliest ? this.parse(options.earliest, options) : NaN , latest = options.latest ? this.parse(options.latest, options) : NaN; value = this.parse(value, options); // 86400000 is the number of milliseconds in a day, this is used to remove // the time from the date if (isNaN(value) || options.dateOnly && value % 86400000 !== 0) { err = options.notValid || options.message || this.notValid || "must be a valid date"; return v.format(err, {value: arguments[0]}); } if (!isNaN(earliest) && value < earliest) { err = options.tooEarly || options.message || this.tooEarly || "must be no earlier than %{date}"; err = v.format(err, { value: this.format(value, options), date: this.format(earliest, options) }); errors.push(err); } if (!isNaN(latest) && value > latest) { err = options.tooLate || options.message || this.tooLate || "must be no later than %{date}"; err = v.format(err, { date: this.format(latest, options), value: this.format(value, options) }); errors.push(err); } if (errors.length) { return v.unique(errors); } }, { parse: null, format: null }), date: function(value, options) { options = v.extend({}, options, {dateOnly: true}); return v.validators.datetime.call(v.validators.datetime, value, options); }, format: function(value, options) { if (v.isString(options) || (options instanceof RegExp)) { options = {pattern: options}; } options = v.extend({}, this.options, options); var message = options.message || this.message || "is invalid" , pattern = options.pattern , match; // Empty values are allowed if (!v.isDefined(value)) { return; } if (!v.isString(value)) { return message; } if (v.isString(pattern)) { pattern = new RegExp(options.pattern, options.flags); } match = pattern.exec(value); if (!match || match[0].length != value.length) { return message; } }, inclusion: function(value, options) { // Empty values are fine if (!v.isDefined(value)) { return; } if (v.isArray(options)) { options = {within: options}; } options = v.extend({}, this.options, options); if (v.contains(options.within, value)) { return; } var message = options.message || this.message || "^%{value} is not included in the list"; return v.format(message, {value: value}); }, exclusion: function(value, options) { // Empty values are fine if (!v.isDefined(value)) { return; } if (v.isArray(options)) { options = {within: options}; } options = v.extend({}, this.options, options); if (!v.contains(options.within, value)) { return; } var message = options.message || this.message || "^%{value} is restricted"; if (v.isString(options.within[value])) { value = options.within[value]; } return v.format(message, {value: value}); }, email: v.extend(function(value, options) { options = v.extend({}, this.options, options); var message = options.message || this.message || "is not a valid email"; // Empty values are fine if (!v.isDefined(value)) { return; } if (!v.isString(value)) { return message; } if (!this.PATTERN.exec(value)) { return message; } }, { PATTERN: /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i }), equality: function(value, options, attribute, attributes, globalOptions) { if (!v.isDefined(value)) { return; } if (v.isString(options)) { options = {attribute: options}; } options = v.extend({}, this.options, options); var message = options.message || this.message || "is not equal to %{attribute}"; if (v.isEmpty(options.attribute) || !v.isString(options.attribute)) { throw new Error("The attribute must be a non empty string"); } var otherValue = v.getDeepObjectValue(attributes, options.attribute) , comparator = options.comparator || function(v1, v2) { return v1 === v2; } , prettify = options.prettify || (globalOptions && globalOptions.prettify) || v.prettify; if (!comparator(value, otherValue, options, attribute, attributes)) { return v.format(message, {attribute: prettify(options.attribute)}); } }, // A URL validator that is used to validate URLs with the ability to // restrict schemes and some domains. url: function(value, options) { if (!v.isDefined(value)) { return; } options = v.extend({}, this.options, options); var message = options.message || this.message || "is not a valid url" , schemes = options.schemes || this.schemes || ['http', 'https'] , allowLocal = options.allowLocal || this.allowLocal || false , allowDataUrl = options.allowDataUrl || this.allowDataUrl || false; if (!v.isString(value)) { return message; } // https://gist.github.com/dperini/729294 var regex = "^" + // protocol identifier "(?:(?:" + schemes.join("|") + ")://)" + // user:pass authentication "(?:\\S+(?::\\S*)?@)?" + "(?:"; var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))"; if (allowLocal) { tld += "?"; } else { regex += // IP address exclusion // private & local networks "(?!(?:10|127)(?:\\.\\d{1,3}){3})" + "(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})" + "(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})"; } regex += // IP address dotted notation octets // excludes loopback network 0.0.0.0 // excludes reserved space >= 224.0.0.0 // excludes network & broacast addresses // (first & last IP address of each class) "(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])" + "(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}" + "(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))" + "|" + // host name "(?:(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)" + // domain name "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*" + tld + ")" + // port number "(?::\\d{2,5})?" + // resource path "(?:[/?#]\\S*)?" + "$"; if (allowDataUrl) { // RFC 2397 var mediaType = "\\w+\\/[-+.\\w]+(?:;[\\w=]+)*"; var urlchar = "[A-Za-z0-9-_.!~\\*'();\\/?:@&=+$,%]*"; var dataurl = "data:(?:"+mediaType+")?(?:;base64)?,"+urlchar; regex = "(?:"+regex+")|(?:^"+dataurl+"$)"; } var PATTERN = new RegExp(regex, 'i'); if (!PATTERN.exec(value)) { return message; } }, type: v.extend(function(value, originalOptions, attribute, attributes, globalOptions) { if (v.isString(originalOptions)) { originalOptions = {type: originalOptions}; } if (!v.isDefined(value)) { return; } var options = v.extend({}, this.options, originalOptions); var type = options.type; if (!v.isDefined(type)) { throw new Error("No type was specified"); } var check; if (v.isFunction(type)) { check = type; } else { check = this.types[type]; } if (!v.isFunction(check)) { throw new Error("validate.validators.type.types." + type + " must be a function."); } if (!check(value, options, attribute, attributes, globalOptions)) { var message = originalOptions.message || this.messages[type] || this.message || options.message || (v.isFunction(type) ? "must be of the correct type" : "must be of type %{type}"); if (v.isFunction(message)) { message = message(value, originalOptions, attribute, attributes, globalOptions); } return v.format(message, {attribute: v.prettify(attribute), type: type}); } }, { types: { object: function(value) { return v.isObject(value) && !v.isArray(value); }, array: v.isArray, integer: v.isInteger, number: v.isNumber, string: v.isString, date: v.isDate, boolean: v.isBoolean }, messages: {} }) }; validate.formatters = { detailed: function(errors) {return errors;}, flat: v.flattenErrorsToArray, grouped: function(errors) { var attr; errors = v.groupErrorsByAttribute(errors); for (attr in errors) { errors[attr] = v.flattenErrorsToArray(errors[attr]); } return errors; }, constraint: function(errors) { var attr; errors = v.groupErrorsByAttribute(errors); for (attr in errors) { errors[attr] = errors[attr].map(function(result) { return result.validator; }).sort(); } return errors; } }; validate.exposeModule(validate, this, exports, module, __webpack_require__(/*! !webpack amd define */ "./node_modules/webpack/buildin/amd-define.js")); }).call(this, true ? /* istanbul ignore next */ exports : undefined, true ? /* istanbul ignore next */ module : undefined, __webpack_require__(/*! !webpack amd define */ "./node_modules/webpack/buildin/amd-define.js")); /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/module.js */ "./node_modules/webpack/buildin/module.js")(module))) /***/ }), /***/ "./node_modules/webpack/buildin/amd-define.js": /*!***************************************!*\ !*** (webpack)/buildin/amd-define.js ***! \***************************************/ /*! no static exports found */ /***/ (function(module, exports) { module.exports = function() { throw new Error("define cannot be used indirect"); }; /***/ }), /***/ "./node_modules/webpack/buildin/module.js": /*!***********************************!*\ !*** (webpack)/buildin/module.js ***! \***********************************/ /*! no static exports found */ /***/ (function(module, exports) { module.exports = function(module) { if (!module.webpackPolyfill) { module.deprecate = function() {}; module.paths = []; // module.parent = undefined by default if (!module.children) module.children = []; Object.defineProperty(module, "loaded", { enumerable: true, get: function() { return module.l; } }); Object.defineProperty(module, "id", { enumerable: true, get: function() { return module.i; } }); module.webpackPolyfill = 1; } return module; }; /***/ }), /***/ "./resources/js/components/bucket/form.riot": /*!**************************************************!*\ !*** ./resources/js/components/bucket/form.riot ***! \**************************************************/ /*! exports provided: default */ /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; __webpack_require__.r(__webpack_exports__); /* harmony import */ var _tentakelfabrik_tiny_validator_src_validator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @tentakelfabrik/tiny-validator/src/validator */ "./node_modules/@tentakelfabrik/tiny-validator/src/validator.js"); /* harmony import */ var _field_error_riot__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../field-error.riot */ "./resources/js/components/field-error.riot"); riot.register('field-error', _field_error_riot__WEBPACK_IMPORTED_MODULE_1__["default"]) /* harmony default export */ __webpack_exports__["default"] = ({ 'css': null, 'exports': { /** * * @param {[type]} props [description] * @param {[type]} state [description] * */ onBeforeMount(props, state) { state.validator = new _tentakelfabrik_tiny_validator_src_validator__WEBPACK_IMPORTED_MODULE_0__["default"]({ name: { presence: true, length: { maximum: 255 } }, description: { length: { maximum: 255 } } }, this) // const meta = document.querySelector("meta[name='csrf-token']") if (meta) { state.csrfToken = meta.getAttribute("content") } }, /** * * * @param {[type]} key * @param {[type]} defaultClass * @return {[type]} * */ getClasses(key, defaultClass) { const classes = [ defaultClass ] const errors = this.state.validator.errors(key) if (errors && errors.length > 0) { classes.push('is-danger') } return classes.join(' ') } }, 'template': function( template, expressionTypes, bindingTypes, getComponent ) { return template( '

\n path for storage files, if empty default path will be used\n

\n everyone can see bucket, files and download them\n
', [ { 'type': bindingTypes.IF, 'evaluate': function( scope ) { return scope.state.csrfToken; }, 'redundantAttribute': 'expr8', 'selector': '[expr8]', 'template': template( null, [ { 'expressions': [ { 'type': expressionTypes.ATTRIBUTE, 'name': 'value', 'evaluate': function( scope ) { return scope.state.csrfToken; } } ] } ] ) }, { 'redundantAttribute': 'expr9', 'selector': '[expr9]', 'expressions': [ { 'type': expressionTypes.ATTRIBUTE, 'name': 'class', 'evaluate': function( scope ) { return scope.getClasses('name', 'input'); } }, { 'type': expressionTypes.VALUE, 'evaluate': function( scope ) { return scope.props.name; } }, { 'type': expressionTypes.EVENT, 'name': 'onkeyup', 'evaluate': function( scope ) { return (event) => { scope.state.validator.handle(event, 'name') }; } } ] }, { 'type': bindingTypes.TAG, 'getComponent': getComponent, 'evaluate': function( scope ) { return 'field-error'; }, 'slots': [], 'attributes': [ { 'type': expressionTypes.ATTRIBUTE, 'name': 'errors', 'evaluate': function( scope ) { return scope.state.validator.errors('name'); } } ], 'redundantAttribute': 'expr10', 'selector': '[expr10]' }, { 'redundantAttribute': 'expr11', 'selector': '[expr11]', 'expressions': [ { 'type': expressionTypes.ATTRIBUTE, 'name': 'class', 'evaluate': function( scope ) { return scope.getClasses('description', 'textarea'); } }, { 'type': expressionTypes.VALUE, 'evaluate': function( scope ) { return scope.props.description; } }, { 'type': expressionTypes.EVENT, 'name': 'onkeyup', 'evaluate': function( scope ) { return (event) => { scope.state.validator.handle(event, 'description') }; } } ] }, { 'type': bindingTypes.TAG, 'getComponent': getComponent, 'evaluate': function( scope ) { return 'field-error'; }, 'slots': [], 'attributes': [ { 'type': expressionTypes.ATTRIBUTE, 'name': 'errors', 'evaluate': function( scope ) { return scope.state.validator.errors('description'); } } ], 'redundantAttribute': 'expr12', 'selector': '[expr12]' }, { 'redundantAttribute': 'expr13', 'selector': '[expr13]', 'expressions': [ { 'type': expressionTypes.ATTRIBUTE, 'name': 'class', 'evaluate': function( scope ) { return scope.getClasses('path', 'input'); } }, { 'type': expressionTypes.VALUE, 'evaluate': function( scope ) { return scope.props.path; } }, { 'type': expressionTypes.EVENT, 'name': 'onkeyup', 'evaluate': function( scope ) { return (event) => { scope.state.validator.handle(event, 'path') }; } } ] }, { 'type': bindingTypes.TAG, 'getComponent': getComponent, 'evaluate': function( scope ) { return 'field-error'; }, 'slots': [], 'attributes': [ { 'type': expressionTypes.ATTRIBUTE, 'name': 'errors', 'evaluate': function( scope ) { return scope.state.validator.errors('path'); } } ], 'redundantAttribute': 'expr14', 'selector': '[expr14]' }, { 'redundantAttribute': 'expr15', 'selector': '[expr15]', 'expressions': [ { 'type': expressionTypes.ATTRIBUTE, 'name': 'checked', 'evaluate': function( scope ) { return scope.props.public; } } ] }, { 'redundantAttribute': 'expr16', 'selector': '[expr16]', 'expressions': [ { 'type': expressionTypes.ATTRIBUTE, 'name': 'disabled', 'evaluate': function( scope ) { return scope.state.validator.errors().length > 0; } } ] } ] ); }, 'name': 'urban-bucket-form' }); /***/ }), /***/ "./resources/js/components/field-error.riot": /*!**************************************************!*\ !*** ./resources/js/components/field-error.riot ***! \**************************************************/ /*! exports provided: default */ /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; __webpack_require__.r(__webpack_exports__); /* harmony default export */ __webpack_exports__["default"] = ({ 'css': null, 'exports': { state: { errors: [ ] }, /** * check if errors from props has an error, if not reset errors in state * * @param {object} props * @param {object} state * */ onBeforeUpdate(props, state) { if (props.errors && props.errors.length > 0) { state.errors = props.errors } else { state.errors = [] } } }, 'template': function( template, expressionTypes, bindingTypes, getComponent ) { return template( '
', [ { 'type': bindingTypes.IF, 'evaluate': function( scope ) { return scope.state.errors.length > 0; }, 'redundantAttribute': 'expr21', 'selector': '[expr21]', 'template': template( '
', [ { 'type': bindingTypes.EACH, 'getKey': null, 'condition': null, 'template': template( ' ', [ { 'expressions': [ { 'type': expressionTypes.TEXT, 'childNodeIndex': 0, 'evaluate': function( scope ) { return scope.error; } } ] } ] ), 'redundantAttribute': 'expr22', 'selector': '[expr22]', 'itemName': 'error', 'indexName': null, 'evaluate': function( scope ) { return scope.state.errors; } } ] ) } ] ); }, 'name': 'field-error' }); /***/ }), /***/ "./resources/js/views/bucket.js": /*!**************************************!*\ !*** ./resources/js/views/bucket.js ***! \**************************************/ /*! no exports provided */ /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; __webpack_require__.r(__webpack_exports__); /* harmony import */ var _components_bucket_form_riot__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./../components/bucket/form.riot */ "./resources/js/components/bucket/form.riot"); /** * Bucket * * */ // register components riot.register('urban-bucket-form', _components_bucket_form_riot__WEBPACK_IMPORTED_MODULE_0__["default"]); /***/ }), /***/ 2: /*!********************************************!*\ !*** multi ./resources/js/views/bucket.js ***! \********************************************/ /*! no static exports found */ /***/ (function(module, exports, __webpack_require__) { module.exports = __webpack_require__(/*! /home/herrhase/Workspace/herrhase/urban-filehub/resources/js/views/bucket.js */"./resources/js/views/bucket.js"); /***/ }) /******/ });