yarfl/lib/helpers/utils.js

Yet Another Redux Forms Library

"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
var _append = require("ramda/src/append");
var _assocPath = require("ramda/src/assocPath");
var _merge = require("ramda/src/merge");
var _mergeDeepRight = require("ramda/src/mergeDeepRight");
var _omit = require("ramda/src/omit");
var _path = require("ramda/src/path");
var _pick = require("ramda/src/pick");
var _remove = require("ramda/src/remove");
var R = {
    assocPath: _assocPath,
    merge: _merge,
    mergeDeepRight: _mergeDeepRight,
    omit: _omit,
    pick: _pick,
    remove: _remove,
    append: _append,
    path: _path,
};
var typings_1 = require("../typings");
var checkers_1 = require("./checkers");
exports.firstDefined = function () {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    for (var i in args) {
        if (typeof args[i] !== 'undefined' && args[i] !== null) {
            return args[i];
        }
    }
};
var caseFnWrapper = function (fn) { return function (str) {
    var seperated = str.replace(/(\d+)/, ' $1 ');
    return fn(seperated);
}; };
// tslint:disable:no-var-requires
exports.capitalize = caseFnWrapper(require('sentence-case'));
exports.titleCase = caseFnWrapper(require('title-case'));
exports.kebabCase = caseFnWrapper(require('param-case'));
exports.camelCase = caseFnWrapper(require('camel-case'));
// tslint:enable:no-var-requires
exports.isNonEmptyArray = function (test) { return !!(test && Array.isArray(test) && test.length); };
var regex = /\[\d+\]/;
exports.parseKey = function (key, endWith) {
    if (key.includes('.') || regex.test(key) || endWith) {
        var split = key.split('.')
            .reduce(function (acc, curr, currIndex, splitArr) {
            var match = regex.test(curr) && curr.match(/\[(\d+)\]/);
            if (match) {
                var index = parseInt(match[1]);
                var noIndex = curr.replace(regex, '');
                return acc.concat([noIndex, 'fields', index]);
            }
            return currIndex < splitArr.length - 1
                ? acc.concat([curr, 'fields']) : acc.concat([curr]);
        }, []);
        return endWith ? split.concat(endWith) : split;
    }
    return [key];
};
exports.removeAt = function (arr, index, count) {
    if (count === void 0) { count = 1; }
    return R.remove(index, count, arr);
};
exports.append = function (arr, value) { return R.append(value, arr); };
exports.getIn = function (obj, path) { return R.path(path, obj); };
exports.setInWithKey = function (state, key, target, value) {
    var fieldPath = ['fields'].concat(exports.parseKey(key), [target]);
    return R.assocPath(fieldPath, value, state);
};
exports.setInWithPath = function (obj, path, value) { return R.assocPath(path, value, obj); };
exports.mergeIn = function (state, key, value) {
    var fieldPath = ['fields'].concat(exports.parseKey(key));
    var target = exports.getIn(state, fieldPath);
    var merged = R.merge(target, value);
    return R.assocPath(fieldPath, merged, state);
};
exports.mergeDeep = R.mergeDeepRight;
exports.mergeDeepIn = function (state, key, value) {
    var fieldPath = ['fields'].concat(exports.parseKey(key));
    var target = exports.getIn(state, fieldPath);
    var merged = exports.mergeDeep(target, value);
    return R.assocPath(fieldPath, merged, state);
};
// recursively merges value up the state tree
exports.mergeUp = function (state, key, value) {
    var updated = !/\[\d+\]$/.test(key)
        ? exports.mergeIn(state, key, value)
        : state;
    if (key.includes('.')) {
        var path = key.split('.');
        var nextKey = path.slice(0, path.length - 1).join('.');
        return exports.mergeUp(updated, nextKey, value);
    }
    return updated;
};
exports.selectField = function (target, key, graceful) {
    if (graceful === void 0) { graceful = false; }
    var path = ['fields'].concat(exports.parseKey(key));
    var field = exports.getIn(target, path);
    if (typeof field === 'undefined' && !graceful) {
        checkers_1.checkPath(path, target, key);
    }
    return field;
};
exports.extract = function (fields, key, options) {
    var defaultOptions = { ignoreEmptyStrings: false, flatten: false };
    var optionsWithDefaults = __assign({}, defaultOptions, options);
    var extraction = Object.entries(fields)
        .reduce(function (acc, _a) {
        var k = _a[0], entry = _a[1];
        var _b, _c, _d, _e;
        switch (entry.fieldType) {
            case typings_1.FieldType.Simple:
                var value = entry[key];
                var ignoreEmptyStrings = optionsWithDefaults.ignoreEmptyStrings;
                var skip = ignoreEmptyStrings && value === '';
                return skip ? acc : __assign({}, acc, (_b = {}, _b[k] = value, _b));
            case typings_1.FieldType.Array:
                var arrayFields = entry.fields;
                var arr = arrayFields.map(function (field) { return exports.extract(field, key, options); });
                return __assign({}, acc, (_c = {}, _c[k] = arr, _c));
            case typings_1.FieldType.Parent:
                var childFields = entry.fields;
                var node = exports.extract(childFields, key, options);
                return __assign({}, acc, (_d = {}, _d[k] = node, _d));
            default:
                // @ts-ignore
                return __assign({}, acc, (_e = {}, _e[k] = exports.extract(entry, key, options), _e));
        }
        return {};
    }, {});
    return optionsWithDefaults.flatten
        ? flattenObj(extraction)
        : extraction;
};
exports.throwError = function () {
    var errorMessage = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        errorMessage[_i] = arguments[_i];
    }
    throw new Error("YARFL: " + errorMessage.join(' '));
};
exports.logError = function () {
    var errorMessage = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        errorMessage[_i] = arguments[_i];
    }
    console.error("YARFL: " + errorMessage.join(' '));
};
exports.logWarning = function () {
    var errorMessage = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        errorMessage[_i] = arguments[_i];
    }
    console.warn("YARFL: " + errorMessage.join(' '));
};
exports.flatten = function (target) {
    return Array.isArray(target)
        ? flattenArray(target)
        : flattenObj(target);
};
var flattenArray = function (arr) { return arr.reduce(function (a, b) {
    return Array.isArray(b)
        ? a.concat(flattenArray(b)) : a.concat([b]);
}, []); };
var flattenObj = function (obj, prefix) {
    return Object.entries(obj).reduce(function (acc, _a) {
        var key = _a[0], entry = _a[1];
        var _b;
        var k = prefix ? prefix + "." + key : key;
        if (exports.isNonEmptyArray(entry)) {
            var map = entry.reduce(function (prev, next, index) {
                var _a;
                return (__assign({}, prev, (_a = {}, _a[k + "[" + index + "]"] = next, _a)));
            }, {});
            return __assign({}, acc, flattenObj(map));
        }
        if (typeof entry === 'object' && !Array.isArray(entry)) {
            return __assign({}, acc, flattenObj(entry, k));
        }
        return __assign({}, acc, (_b = {}, _b[k] = entry, _b));
    }, {});
};
exports.pick = function (target, props) {
    return R.pick(props, target);
};
exports.omit = function (target, props) {
    return R.omit(props, target);
};
exports.isPromise = function (target) {
    if (Promise && Promise.resolve) {
        return Promise.resolve(target) === target;
    }
    throw new Error('Promise not supported in your environment');
};
//# sourceMappingURL=utils.js.map