@cabify/redux-polyglot/dist/selectors.js

Tool for using Polyglot.js with Redux

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.createGetP = exports.getPhrases = exports.getLocale = exports.getP = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _redux = require('redux');

var _reselect = require('reselect');

var _nodePolyglot = require('node-polyglot');

var _nodePolyglot2 = _interopRequireDefault(_nodePolyglot);

var _utils = require('./private/utils');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var path = function path(arrPath) {
    return function (obj) {
        return arrPath.reduce(function (cursor, key) {
            return cursor && cursor[key];
        }, obj);
    };
};
var toUpper = function toUpper(str) {
    return str.toUpperCase();
};
var titleize = function titleize(str) {
    return str.toLowerCase().replace(/(?:^|\s|-)\S/g, function (c) {
        return c.toUpperCase();
    });
};
var adjustString = function adjustString(f, index) {
    return function (str) {
        return str.substr(0, index) + f(str[index]) + str.substr(index + 1);
    };
};
var capitalize = adjustString(toUpper, 0);

var getLocale = path(['polyglot', 'locale']);
var getPhrases = path(['polyglot', 'phrases']);

var getPolyglotScope = function getPolyglotScope(state, _ref) {
    var _ref$polyglotScope = _ref.polyglotScope,
        polyglotScope = _ref$polyglotScope === undefined ? '' : _ref$polyglotScope;
    return polyglotScope !== '' ? polyglotScope + '.' : '';
};

var getPolyglotOwnPhrases = function getPolyglotOwnPhrases(state, _ref2) {
    var _ref2$ownPhrases = _ref2.ownPhrases,
        ownPhrases = _ref2$ownPhrases === undefined ? '' : _ref2$ownPhrases;
    return ownPhrases !== '' ? ownPhrases : '';
};

var getPolyglotOptions = function getPolyglotOptions(state, _ref3) {
    var polyglotOptions = _ref3.polyglotOptions;
    return polyglotOptions;
};

var createGetPolyglot = function createGetPolyglot() {
    return (0, _reselect.createSelector)(getLocale, getPhrases, getPolyglotOptions, function (locale, phrases, polyglotOptions) {
        return new _nodePolyglot2.default(_extends({
            locale: locale,
            phrases: phrases
        }, polyglotOptions));
    });
};

var createGetTranslation = function createGetTranslation() {
    return (0, _reselect.createSelector)(createGetPolyglot(), getPolyglotScope, getPolyglotOwnPhrases, function (p, polyglotScope, ownPhrases) {
        return function (polyglotKey) {
            for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                args[_key - 1] = arguments[_key];
            }

            var fullPath = polyglotScope + polyglotKey;
            var ownPhrase = ownPhrases !== '' ? ownPhrases[fullPath] : null;

            return ownPhrase || p.t.apply(p, [fullPath].concat(args));
        };
    });
};

var createGetScopedHas = function createGetScopedHas() {
    return (0, _reselect.createSelector)(createGetPolyglot(), getPolyglotScope, function (p, polyglotScope) {
        return function (polyglotKey) {
            return p.has(polyglotScope + polyglotKey);
        };
    });
};

var createGetTranslationMorphed = function createGetTranslationMorphed() {
    return (0, _reselect.createSelector)(createGetTranslation(), function (t) {
        return function (f) {
            return (0, _redux.compose)(f, t);
        };
    });
};

var createGetTranslationUpperCased = function createGetTranslationUpperCased() {
    return (0, _reselect.createSelector)(createGetTranslationMorphed(), function (m) {
        return m(toUpper);
    });
};

var createGetTranslationCapitalized = function createGetTranslationCapitalized() {
    return (0, _reselect.createSelector)(createGetTranslationMorphed(), function (m) {
        return m(capitalize);
    });
};

var createGetTranslationTitleized = function createGetTranslationTitleized() {
    return (0, _reselect.createSelector)(createGetTranslationMorphed(), function (m) {
        return m(titleize);
    });
};

var createGetP = function createGetP(polyglotOptions) {
    var options = { polyglotOptions: polyglotOptions };
    var getP = (0, _reselect.createSelector)(getLocale, getPhrases, createGetPolyglot(), createGetTranslation(), createGetTranslationCapitalized(), createGetTranslationTitleized(), createGetTranslationUpperCased(), createGetTranslationMorphed(), createGetScopedHas(), function (_locale, phrases, p, t, tc, tt, tu, tm, has) {
        if (!_locale || !phrases) {
            return {
                t: _utils.identity,
                tc: _utils.identity,
                tt: _utils.identity,
                tu: _utils.identity,
                tm: _utils.identity,
                ut: _utils.identity,
                has: function has() {
                    return false;
                },
                locale: function locale() {
                    return p.locale();
                }
            };
        }
        return _extends({}, p, {
            t: t,
            tc: tc,
            tt: tt,
            tu: tu,
            tm: tm,
            has: has,
            locale: function locale() {
                return _locale;
            },
            extend: p.extend,
            ut: p.t
        });
    });

    var getScopedP = function getScopedP(state) {
        var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        var p = getP(state, _extends({}, props, options));
        var getDeeperScope = function getDeeperScope(deeperScope) {
            return getScopedP(state, _extends({}, props, options, {
                polyglotScope: props.polyglotScope ? props.polyglotScope + '.' + deeperScope : deeperScope
            }));
        };
        p.getDeeperScope = getDeeperScope;
        return p;
    };

    return getScopedP;
};

var getP = createGetP();

exports.getP = getP;
exports.getLocale = getLocale;
exports.getPhrases = getPhrases;
exports.createGetP = createGetP;