angular2-json-schema-form
Version:
Angular 2 JSON Schema Form builder
172 lines • 7.22 kB
JavaScript
;
var validator_functions_1 = require("./validator.functions");
function addClasses(oldClasses, newClasses) {
var badType = function (i) { return !validator_functions_1.isSet(i) && !validator_functions_1.isArray(i) && !validator_functions_1.isString(i); };
if (badType(newClasses))
return oldClasses;
if (badType(oldClasses))
oldClasses = '';
var toSet = function (i) { return validator_functions_1.isSet(i) ? i : validator_functions_1.isArray(i) ? new Set(i) : new Set(i.split(' ')); };
var combinedSet = toSet(oldClasses);
var newSet = toSet(newClasses);
newSet.forEach(function (c) { return combinedSet.add(c); });
if (validator_functions_1.isSet(oldClasses))
return combinedSet;
if (validator_functions_1.isArray(oldClasses))
return Array.from(combinedSet);
return Array.from(combinedSet).join(' ');
}
exports.addClasses = addClasses;
function copy(object) {
if (typeof object !== 'object' || object === null)
return object;
if (validator_functions_1.isObject(object))
return Object.assign({}, object);
if (validator_functions_1.isArray(object))
return [].concat(object);
if (validator_functions_1.isMap(object))
return new Map(object);
if (validator_functions_1.isSet(object))
return new Set(object);
console.error('copy error: Object to copy must be a JavaScript object or value.');
}
exports.copy = copy;
function forEach(object, fn, recurse, rootObject) {
if (recurse === void 0) { recurse = false; }
if (rootObject === void 0) { rootObject = object; }
if (validator_functions_1.isEmpty(object))
return;
if ((validator_functions_1.isObject(object) || validator_functions_1.isArray(object)) && typeof fn === 'function') {
for (var _i = 0, _a = Object.keys(object); _i < _a.length; _i++) {
var key = _a[_i];
var value = object[key];
if (recurse === 'bottom-up' && (validator_functions_1.isObject(value) || validator_functions_1.isArray(value))) {
forEach(value, fn, recurse, rootObject);
}
fn(value, key, object, rootObject);
if (recurse === 'top-down' && (validator_functions_1.isObject(value) || validator_functions_1.isArray(value))) {
forEach(value, fn, recurse, rootObject);
}
}
}
else if (typeof fn !== 'function') {
console.error('forEach error: Iterator must be a function.');
console.error(fn);
}
else {
console.error('forEach error: Input object must be an object or array.');
console.error(object);
}
}
exports.forEach = forEach;
function forEachCopy(object, fn) {
if (!validator_functions_1.hasValue(object))
return;
if ((validator_functions_1.isObject(object) || validator_functions_1.isArray(object)) && typeof fn !== 'function') {
var newObject = validator_functions_1.isArray(object) ? [] : {};
for (var _i = 0, _a = Object.keys(object); _i < _a.length; _i++) {
var key = _a[_i];
newObject[key] = fn(object[key], key, object);
}
return newObject;
}
if (typeof fn !== 'function') {
console.error('forEachCopy error: Iterator must be a function.');
console.error(fn);
}
else {
console.error('forEachCopy error: Input object must be an object or array.');
console.error(object);
}
}
exports.forEachCopy = forEachCopy;
function hasOwn(object, property) {
if (!validator_functions_1.isObject(object) && !validator_functions_1.isArray(object))
return false;
return object.hasOwnProperty(property);
}
exports.hasOwn = hasOwn;
function mergeFilteredObject(targetObject, sourceObject, excludeKeys, keyFn, valueFn) {
if (excludeKeys === void 0) { excludeKeys = []; }
if (keyFn === void 0) { keyFn = function (k) { return k; }; }
if (valueFn === void 0) { valueFn = function (v) { return v; }; }
if (!validator_functions_1.isObject(sourceObject))
return targetObject;
if (!validator_functions_1.isObject(targetObject))
targetObject = {};
for (var _i = 0, _a = Object.keys(sourceObject); _i < _a.length; _i++) {
var key = _a[_i];
if (!validator_functions_1.inArray(key, excludeKeys) && validator_functions_1.isDefined(sourceObject[key])) {
targetObject[keyFn(key)] = valueFn(sourceObject[key]);
}
}
return targetObject;
}
exports.mergeFilteredObject = mergeFilteredObject;
function parseText(text, value, values, index) {
if (text === void 0) { text = ''; }
if (value === void 0) { value = {}; }
if (values === void 0) { values = {}; }
if (index === void 0) { index = null; }
if (!text)
return text;
try {
return text.replace(/{{.+?}}/g, function (exp) { return eval(exp.slice(2, -2)); });
}
catch (error) {
console.error('parseText error: ');
console.error(error);
return text;
}
}
exports.parseText = parseText;
function toTitleCase(input, forceWords) {
if (!validator_functions_1.isString(input))
return input;
var forceArray = ['a', 'an', 'and', 'as', 'at', 'but', 'by', 'en',
'for', 'if', 'in', 'nor', 'of', 'on', 'or', 'per', 'the', 'to', 'v', 'v.',
'vs', 'vs.', 'via'];
if (validator_functions_1.isString(forceWords))
forceWords = forceWords.split('|');
if (validator_functions_1.isArray(forceWords))
forceArray = forceArray.concat(forceWords);
var forceArrayLower = forceArray.map(function (w) { return w.toLowerCase(); });
var noInitialCase = input === input.toUpperCase() || input === input.toLowerCase();
var prevLastChar = '';
input = input.trim();
return input.replace(/[A-Za-z0-9\u00C0-\u00FF]+[^\s-]*/g, function (word, idx) {
if (!noInitialCase && word.slice(1).search(/[A-Z]|\../) !== -1) {
return word;
}
else {
var newWord = void 0;
var forceWord = forceArray[forceArrayLower.indexOf(word.toLowerCase())];
if (!forceWord) {
if (noInitialCase) {
if (word.slice(1).search(/\../) !== -1) {
newWord = word.toLowerCase();
}
else {
newWord = word[0].toUpperCase() + word.slice(1).toLowerCase();
}
}
else {
newWord = word[0].toUpperCase() + word.slice(1);
}
}
else if (forceWord === forceWord.toLowerCase() && (idx === 0 || idx + word.length === input.length ||
prevLastChar === ':' || input[idx - 1].search(/[^\s-]/) !== -1 ||
(input[idx - 1] !== '-' && input[idx + word.length] === '-'))) {
newWord = forceWord[0].toUpperCase() + forceWord.slice(1);
}
else {
newWord = forceWord;
}
prevLastChar = word.slice(-1);
return newWord;
}
});
}
exports.toTitleCase = toTitleCase;
;
//# sourceMappingURL=utility.functions.js.map