1194 lines
37 KiB
JavaScript
1194 lines
37 KiB
JavaScript
//////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// This is a generated file. You can view the original //
|
|
// source in your browser if your browser supports source maps. //
|
|
// Source maps are supported by all recent versions of Chrome, Safari, //
|
|
// and Firefox, and by Internet Explorer 11. //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
(function () {
|
|
|
|
/* Imports */
|
|
var Meteor = Package.meteor.Meteor;
|
|
var global = Package.meteor.global;
|
|
var meteorEnv = Package.meteor.meteorEnv;
|
|
var meteorInstall = Package.modules.meteorInstall;
|
|
var meteorBabelHelpers = Package['babel-runtime'].meteorBabelHelpers;
|
|
var Promise = Package.promise.Promise;
|
|
var Symbol = Package['ecmascript-runtime-client'].Symbol;
|
|
var Map = Package['ecmascript-runtime-client'].Map;
|
|
var Set = Package['ecmascript-runtime-client'].Set;
|
|
|
|
/* Package-scope variables */
|
|
var validate;
|
|
|
|
var require = meteorInstall({"node_modules":{"meteor":{"validatejs":{"lib":{"validate.js":function(require,exports,module){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/validatejs/lib/validate.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
|
|
|
|
/*!
|
|
* validate.js 0.9.0
|
|
*
|
|
* (c) 2013-2015 Nicklas Ansman, 2013 Wrapp
|
|
* Validate.js may be freely distributed under the MIT license.
|
|
* For all details and documentation:
|
|
* http://validatejs.org/
|
|
*/
|
|
(function (exports, module, define) {
|
|
"use strict"; // The main function that calls the validators specified by the constraints.
|
|
// The options are the following:
|
|
// - format (string) - An option that controls how the returned value is formatted
|
|
// * flat - Returns a flat array of just the error messages
|
|
// * grouped - Returns the messages grouped by attribute (default)
|
|
// * detailed - Returns an array of the raw validation data
|
|
// - fullMessages (boolean) - If `true` (default) the attribute name is prepended to the error.
|
|
//
|
|
// Please note that the options are also passed to each validator.
|
|
|
|
var validate = function (attributes, constraints, options) {
|
|
options = v.extend({}, v.options, options);
|
|
var results = v.runValidations(attributes, constraints, options),
|
|
attr,
|
|
validator;
|
|
|
|
for (attr in meteorBabelHelpers.sanitizeForInObject(results)) {
|
|
for (validator in meteorBabelHelpers.sanitizeForInObject(results[attr])) {
|
|
if (v.isPromise(results[attr][validator])) {
|
|
throw new Error("Use validate.async if you want support for promises");
|
|
}
|
|
}
|
|
}
|
|
|
|
return validate.processValidationResults(results, options);
|
|
};
|
|
|
|
var v = validate; // Copies over attributes from one or more sources to a single destination.
|
|
// Very much similar to underscore's extend.
|
|
// The first argument is the target object and the remaining arguments will be
|
|
// used as sources.
|
|
|
|
v.extend = function (obj) {
|
|
[].slice.call(arguments, 1).forEach(function (source) {
|
|
for (var attr in meteorBabelHelpers.sanitizeForInObject(source)) {
|
|
obj[attr] = source[attr];
|
|
}
|
|
});
|
|
return obj;
|
|
};
|
|
|
|
v.extend(validate, {
|
|
// This is the version of the library as a semver.
|
|
// The toString function will allow it to be coerced into a string
|
|
version: {
|
|
major: 0,
|
|
minor: 9,
|
|
patch: 0,
|
|
metadata: "development",
|
|
toString: function () {
|
|
var version = v.format("%{major}.%{minor}.%{patch}", v.version);
|
|
|
|
if (!v.isEmpty(v.version.metadata)) {
|
|
version += "+" + v.version.metadata;
|
|
}
|
|
|
|
return version;
|
|
}
|
|
},
|
|
// Below is the dependencies that are used in validate.js
|
|
// The constructor of the Promise implementation.
|
|
// If you are using Q.js, RSVP or any other A+ compatible implementation
|
|
// override this attribute to be the constructor of that promise.
|
|
// Since jQuery promises aren't A+ compatible they won't work.
|
|
Promise: typeof Promise !== "undefined" ? Promise :
|
|
/* istanbul ignore next */
|
|
null,
|
|
EMPTY_STRING_REGEXP: /^\s*$/,
|
|
// Runs the validators specified by the constraints object.
|
|
// Will return an array of the format:
|
|
// [{attribute: "<attribute name>", error: "<validation result>"}, ...]
|
|
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 meteorBabelHelpers.sanitizeForInObject(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 meteorBabelHelpers.sanitizeForInObject(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) {
|
|
var attr;
|
|
errors = v.pruneEmptyErrors(errors, options);
|
|
errors = v.expandMultipleErrors(errors, options);
|
|
errors = v.convertErrorMessages(errors, options);
|
|
|
|
switch (options.format || "grouped") {
|
|
case "detailed":
|
|
// Do nothing more to the errors
|
|
break;
|
|
|
|
case "flat":
|
|
errors = v.flattenErrorsToArray(errors);
|
|
break;
|
|
|
|
case "grouped":
|
|
errors = v.groupErrorsByAttribute(errors);
|
|
|
|
for (attr in meteorBabelHelpers.sanitizeForInObject(errors)) {
|
|
errors[attr] = v.flattenErrorsToArray(errors[attr]);
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
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;
|
|
}, function (error) {
|
|
if (error instanceof Error) {
|
|
throw error;
|
|
}
|
|
|
|
v.error("Rejecting promises with the result is deprecated. Please use the resolve callback instead.");
|
|
result.error = error;
|
|
});
|
|
});
|
|
}, 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;
|
|
},
|
|
// 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 (!v.isFunction(o.querySelectorAll) || !v.isFunction(o.querySelector)) {
|
|
return false;
|
|
}
|
|
|
|
if (v.isObject(document) && o === document) {
|
|
return true;
|
|
} // http://stackoverflow.com/a/384380/699304
|
|
|
|
/* istanbul ignore else */
|
|
|
|
|
|
if ((typeof HTMLElement === "undefined" ? "undefined" : (0, _typeof2.default)(HTMLElement)) === "object") {
|
|
return o instanceof HTMLElement;
|
|
} else {
|
|
return o && (0, _typeof2.default)(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 meteorBabelHelpers.sanitizeForInObject(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)) {
|
|
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) {
|
|
return v.prettify(value);
|
|
},
|
|
isString: function (value) {
|
|
return typeof value === 'string';
|
|
},
|
|
isArray: function (value) {
|
|
return {}.toString.call(value) === '[object Array]';
|
|
},
|
|
contains: function (obj, value) {
|
|
if (!v.isDefined(obj)) {
|
|
return false;
|
|
}
|
|
|
|
if (v.isArray(obj)) {
|
|
return obj.indexOf(value) !== -1;
|
|
}
|
|
|
|
return value in obj;
|
|
},
|
|
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:
|
|
// <input type="text" name="email" value="foo@bar.com" />
|
|
// would return:
|
|
// {email: "foo@bar.com"}
|
|
collectFormValues: function (form, options) {
|
|
var values = {},
|
|
i,
|
|
input,
|
|
inputs,
|
|
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;
|
|
}
|
|
|
|
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[input.name] || null;
|
|
}
|
|
} else {
|
|
value = input.checked;
|
|
}
|
|
} else if (input.type === "radio") {
|
|
if (!input.checked) {
|
|
value = values[input.name] || null;
|
|
}
|
|
}
|
|
|
|
values[input.name] = value;
|
|
}
|
|
|
|
inputs = form.querySelectorAll("select[name]");
|
|
|
|
for (i = 0; i < inputs.length; ++i) {
|
|
input = inputs.item(i);
|
|
value = v.sanitizeFormValue(input.options[input.selectedIndex].value, 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 = [];
|
|
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(v.prettify(errorInfo.attribute)) + " " + error;
|
|
}
|
|
|
|
error = error.replace(/\\\^/g, "^");
|
|
error = v.format(error, {
|
|
value: v.stringifyValue(errorInfo.value)
|
|
});
|
|
ret.push(v.extend({}, errorInfo, {
|
|
error: error
|
|
}));
|
|
});
|
|
return ret;
|
|
},
|
|
// In:
|
|
// [{attribute: "<attributeName>", ...}]
|
|
// Out:
|
|
// {"<attributeName>": [{attribute: "<attributeName>", ...}]}
|
|
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: "<message 1>", ...}, {error: "<message 2>", ...}]
|
|
// Out:
|
|
// ["<message 1>", "<message 2>"]
|
|
flattenErrorsToArray: function (errors) {
|
|
return errors.map(function (error) {
|
|
return error.error;
|
|
});
|
|
},
|
|
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 meteorBabelHelpers.sanitizeForInObject(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 meteorBabelHelpers.sanitizeForInObject(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 (v.isEmpty(value)) {
|
|
return options.message || this.message || "can't be blank";
|
|
}
|
|
},
|
|
length: function (value, options, attribute) {
|
|
// Empty values are allowed
|
|
if (v.isEmpty(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)) {
|
|
v.error(v.format("Attribute %{attr} has a non numeric value for `length`", {
|
|
attr: attribute
|
|
}));
|
|
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) {
|
|
// Empty values are fine
|
|
if (v.isEmpty(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;
|
|
}
|
|
}; // Coerce the value to a number unless we're being strict.
|
|
|
|
if (options.noStrings !== true && v.isString(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 || "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 || "must be an integer";
|
|
}
|
|
|
|
for (name in meteorBabelHelpers.sanitizeForInObject(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] || "must be %{type} %{count}";
|
|
errors.push(v.format(msg, {
|
|
count: count,
|
|
type: v.prettify(name)
|
|
}));
|
|
}
|
|
}
|
|
|
|
if (options.odd && value % 2 !== 1) {
|
|
errors.push(options.notOdd || this.notOdd || "must be odd");
|
|
}
|
|
|
|
if (options.even && value % 2 !== 0) {
|
|
errors.push(options.notEven || this.notEven || "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.isEmpty(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 seconds in a day, this is used to remove
|
|
// the time from the date
|
|
|
|
if (isNaN(value) || options.dateOnly && value % 86400000 !== 0) {
|
|
return options.message || this.notValid || "must be a valid date";
|
|
}
|
|
|
|
if (!isNaN(earliest) && value < earliest) {
|
|
err = this.tooEarly || "must be no earlier than %{date}";
|
|
err = v.format(err, {
|
|
date: this.format(earliest, options)
|
|
});
|
|
errors.push(err);
|
|
}
|
|
|
|
if (!isNaN(latest) && value > latest) {
|
|
err = this.tooLate || "must be no later than %{date}";
|
|
err = v.format(err, {
|
|
date: this.format(latest, options)
|
|
});
|
|
errors.push(err);
|
|
}
|
|
|
|
if (errors.length) {
|
|
return options.message || 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.isEmpty(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.isEmpty(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.isEmpty(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";
|
|
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.isEmpty(value)) {
|
|
return;
|
|
}
|
|
|
|
if (!v.isString(value)) {
|
|
return message;
|
|
}
|
|
|
|
if (!this.PATTERN.exec(value)) {
|
|
return message;
|
|
}
|
|
}, {
|
|
PATTERN: /^[a-z0-9\u007F-\uffff!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9\u007F-\uffff!#$%&'*+\/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/i
|
|
}),
|
|
equality: function (value, options, attribute, attributes) {
|
|
if (v.isEmpty(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;
|
|
};
|
|
|
|
if (!comparator(value, otherValue, options, attribute, attributes)) {
|
|
return v.format(message, {
|
|
attribute: v.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.isEmpty(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;
|
|
|
|
if (!v.isString(value)) {
|
|
return message;
|
|
} // https://gist.github.com/dperini/729294
|
|
|
|
|
|
var regex = "^" + // schemes
|
|
"(?:(?:" + schemes.join("|") + "):\\/\\/)" + // credentials
|
|
"(?:\\S+(?::\\S*)?@)?";
|
|
regex += "(?:";
|
|
var hostname = "(?:(?:[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,})))"; // This ia a special case for the localhost hostname
|
|
|
|
if (allowLocal) {
|
|
hostname = "(?:localhost|" + hostname + ")";
|
|
} else {
|
|
// private & local addresses
|
|
regex += "(?!10(?:\\.\\d{1,3}){3})" + "(?!127(?:\\.\\d{1,3}){3})" + "(?!169\\.254(?:\\.\\d{1,3}){2})" + "(?!192\\.168(?:\\.\\d{1,3}){2})" + "(?!172" + "\\.(?:1[6-9]|2\\d|3[0-1])" + "(?:\\.\\d{1,3})" + "{2})";
|
|
} // reserved addresses
|
|
|
|
|
|
regex += "(?:[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]))" + "|" + hostname + // port number
|
|
"(?::\\d{2,5})?" + // path
|
|
"(?:\\/[^\\s]*)?" + "$";
|
|
var PATTERN = new RegExp(regex, 'i');
|
|
|
|
if (!PATTERN.exec(value)) {
|
|
return message;
|
|
}
|
|
}
|
|
};
|
|
validate.exposeModule(validate, this, exports, module, define);
|
|
}).call(this, typeof exports !== 'undefined' ?
|
|
/* istanbul ignore next */
|
|
exports : null, typeof module !== 'undefined' ?
|
|
/* istanbul ignore next */
|
|
module : null, typeof define !== 'undefined' ?
|
|
/* istanbul ignore next */
|
|
define : null);
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}},"load.js":function(require,exports,module){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/validatejs/load.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
var v;
|
|
module.watch(require("./lib/validate.js"), {
|
|
validate: function (_v) {
|
|
v = _v;
|
|
}
|
|
}, 0);
|
|
|
|
v.validators.equals = function (value, options, key, attributes) {
|
|
if (options && value !== options.value) {
|
|
return key + 'must equal ' + options.value;
|
|
}
|
|
};
|
|
|
|
v.validators.doesNotEqual = function (value, options, key) {
|
|
if (options && value === options.value) {
|
|
return key + 'cannot equal ' + options.value;
|
|
}
|
|
};
|
|
|
|
v.validators.contains = function (value, options, key) {
|
|
if (options && value.indexOf && value.indexOf(options.value) === -1) {
|
|
return key + 'must contain ' + options.value;
|
|
}
|
|
};
|
|
|
|
v.validators.doesNotContain = function (value, options, key) {
|
|
if (options && value.indexOf && value.indexOf(options.value) !== -1) {
|
|
return key + 'cannot contain ' + options.value;
|
|
}
|
|
};
|
|
|
|
v.validators.startsWith = function (value, options, key) {
|
|
if (options && value.startsWith && !value.startsWith(options.value)) {
|
|
return key + 'must start with ' + options.value;
|
|
}
|
|
};
|
|
|
|
v.validators.endsWith = function (value, options, key) {
|
|
if (options && value.endsWith && !value.endsWith(options.value)) {
|
|
return key + 'must end with ' + options.value;
|
|
}
|
|
};
|
|
|
|
validate = v;
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}}}}},{
|
|
"extensions": [
|
|
".js",
|
|
".json"
|
|
]
|
|
});
|
|
require("/node_modules/meteor/validatejs/lib/validate.js");
|
|
require("/node_modules/meteor/validatejs/load.js");
|
|
|
|
/* Exports */
|
|
Package._define("validatejs", {
|
|
validate: validate
|
|
});
|
|
|
|
})();
|