react-i18next 11.4.0 → 11.7.0

package/dist/es/Trans.js

@@ -1,6 +1,6 @@
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _typeof from "@babel/runtime/helpers/typeof";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
@@ -8,11 +8,14 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 import React, { useContext } from 'react';
 import HTML from 'html-parse-stringify2';
-import { getI18n, getHasUsedI18nextProvider, I18nContext, getDefaults } from './context';
+import { getI18n, I18nContext, getDefaults } from './context';
 import { warn, warnOnce } from './utils';
 
-function hasChildren(node) {
-  return node && (node.children || node.props && node.props.children);
+function hasChildren(node, checkLength) {
+  if (!node) return false;
+  var base = node.props ? node.props.children : node.children;
+  if (checkLength) return base.length > 0;
+  return !!base;
 }
 
 function getChildren(node) {
@@ -31,46 +34,48 @@ function getAsArray(data) {
   return Array.isArray(data) ? data : [data];
 }
 
-export function nodesToString(startingString, children, index, i18nOptions) {
+function mergeProps(source, target) {
+  var newTarget = _objectSpread({}, target);
+
+  newTarget.props = Object.assign(source.props, target.props);
+  return newTarget;
+}
+
+export function nodesToString(children, i18nOptions) {
   if (!children) return '';
-  var stringNode = startingString;
+  var stringNode = '';
   var childrenArray = getAsArray(children);
   var keepArray = i18nOptions.transKeepBasicHtmlNodesFor || [];
-  childrenArray.forEach(function (child, i) {
-    var elementKey = "".concat(i);
-
+  childrenArray.forEach(function (child, childIndex) {
     if (typeof child === 'string') {
-      stringNode = "".concat(stringNode).concat(child);
-    } else if (hasChildren(child)) {
-      var elementTag = keepArray.indexOf(child.type) > -1 && Object.keys(child.props).length === 1 && typeof hasChildren(child) === 'string' ? child.type : elementKey;
-
-      if (child.props && child.props.i18nIsDynamicList) {
-        // we got a dynamic list like "<ul>{['a', 'b'].map(item => ( <li key={item}>{item}</li> ))}</ul>""
-        // the result should be "<0></0>" and not "<0><0>a</0><1>b</1></0>"
-        stringNode = "".concat(stringNode, "<").concat(elementTag, "></").concat(elementTag, ">");
-      } else {
-        // regular case mapping the inner children
-        stringNode = "".concat(stringNode, "<").concat(elementTag, ">").concat(nodesToString('', getChildren(child), i + 1, i18nOptions), "</").concat(elementTag, ">");
-      }
+      stringNode += "".concat(child);
     } else if (React.isValidElement(child)) {
-      if (keepArray.indexOf(child.type) > -1 && Object.keys(child.props).length === 0) {
-        stringNode = "".concat(stringNode, "<").concat(child.type, "/>");
+      var childPropsCount = Object.keys(child.props).length;
+      var shouldKeepChild = keepArray.indexOf(child.type) > -1;
+      var childChildren = child.props.children;
+
+      if (!childChildren && shouldKeepChild && childPropsCount === 0) {
+        stringNode += "<".concat(child.type, "/>");
+      } else if (!childChildren && (!shouldKeepChild || childPropsCount !== 0)) {
+        stringNode += "<".concat(childIndex, "></").concat(childIndex, ">");
+      } else if (child.props.i18nIsDynamicList) {
+        stringNode += "<".concat(childIndex, "></").concat(childIndex, ">");
+      } else if (shouldKeepChild && childPropsCount === 1 && typeof childChildren === 'string') {
+        stringNode += "<".concat(child.type, ">").concat(childChildren, "</").concat(child.type, ">");
       } else {
-        stringNode = "".concat(stringNode, "<").concat(elementKey, "></").concat(elementKey, ">");
+        var content = nodesToString(childChildren, i18nOptions);
+        stringNode += "<".concat(childIndex, ">").concat(content, "</").concat(childIndex, ">");
       }
     } else if (_typeof(child) === 'object') {
-      var clone = _objectSpread({}, child);
+      var format = child.format,
+          clone = _objectWithoutProperties(child, ["format"]);
 
-      var format = clone.format;
-      delete clone.format;
       var keys = Object.keys(clone);
 
-      if (format && keys.length === 1) {
-        stringNode = "".concat(stringNode, "{{").concat(keys[0], ", ").concat(format, "}}");
-      } else if (keys.length === 1) {
-        stringNode = "".concat(stringNode, "{{").concat(keys[0], "}}");
+      if (keys.length === 1) {
+        var value = format ? "".concat(keys[0], ", ").concat(format) : keys[0];
+        stringNode += "{{".concat(value, "}}");
       } else {
-        // not a valid interpolation object (can only contain one value plus format)
         warn("react-i18next: the passed in object contained more than one variable - the object should look like {{ value, format }} where format is optional.", child);
       }
     } else {
@@ -81,13 +86,10 @@ export function nodesToString(startingString, children, index, i18nOptions) {
 }
 
 function renderNodes(children, targetString, i18n, i18nOptions, combinedTOpts) {
-  if (targetString === '') return []; // check if contains tags we need to replace from html string to react nodes
-
+  if (targetString === '') return [];
   var keepArray = i18nOptions.transKeepBasicHtmlNodesFor || [];
-  var emptyChildrenButNeedsHandling = targetString && new RegExp(keepArray.join('|')).test(targetString); // no need to replace tags in the targetstring
-
-  if (!children && !emptyChildrenButNeedsHandling) return [targetString]; // v2 -> interpolates upfront no need for "some <0>{{var}}</0>"" -> will be just "some {{var}}" in translation file
-
+  var emptyChildrenButNeedsHandling = targetString && new RegExp(keepArray.join('|')).test(targetString);
+  if (!children && !emptyChildrenButNeedsHandling) return [targetString];
   var data = {};
 
   function getData(childs) {
@@ -99,77 +101,79 @@ function renderNodes(children, targetString, i18n, i18nOptions, combinedTOpts) {
   }
 
   getData(children);
-  var interpolatedString = i18n.services.interpolator.interpolate(targetString, _objectSpread({}, data, {}, combinedTOpts), i18n.language); // parse ast from string with additional wrapper tag
-  // -> avoids issues in parser removing prepending text nodes
-
+  var interpolatedString = i18n.services.interpolator.interpolate(targetString, _objectSpread({}, data, {}, combinedTOpts), i18n.language);
   var ast = HTML.parse("<0>".concat(interpolatedString, "</0>"));
 
-  function mapAST(reactNode, astNode) {
+  function renderInner(child, node, rootReactNode) {
+    var childs = getChildren(child);
+    var mappedChildren = mapAST(childs, node.children, rootReactNode);
+    return hasValidReactChildren(childs) && mappedChildren.length === 0 ? childs : mappedChildren;
+  }
+
+  function pushTranslatedJSX(child, inner, mem, i) {
+    if (child.dummy) child.children = inner;
+    mem.push(React.cloneElement(child, _objectSpread({}, child.props, {
+      key: i
+    }), inner));
+  }
+
+  function mapAST(reactNode, astNode, rootReactNode) {
     var reactNodes = getAsArray(reactNode);
     var astNodes = getAsArray(astNode);
     return astNodes.reduce(function (mem, node, i) {
       var translationContent = node.children && node.children[0] && node.children[0].content;
 
       if (node.type === 'tag') {
-        var child = reactNodes[parseInt(node.name, 10)] || {};
+        var tmp = reactNodes[parseInt(node.name, 10)];
+        if (!tmp && rootReactNode.length === 1 && rootReactNode[0][node.name]) tmp = rootReactNode[0][node.name];
+        if (!tmp) tmp = {};
+        var child = Object.keys(node.attrs).length !== 0 ? mergeProps({
+          props: node.attrs
+        }, tmp) : tmp;
         var isElement = React.isValidElement(child);
+        var isValidTranslationWithChildren = isElement && hasChildren(node, true) && !node.voidElement;
+        var isEmptyTransWithHTML = emptyChildrenButNeedsHandling && _typeof(child) === 'object' && child.dummy && !isElement;
+        var isKnownComponent = _typeof(children) === 'object' && children !== null && Object.hasOwnProperty.call(children, node.name);
 
         if (typeof child === 'string') {
           mem.push(child);
-        } else if (hasChildren(child)) {
-          var childs = getChildren(child);
-          var mappedChildren = mapAST(childs, node.children);
-          var inner = hasValidReactChildren(childs) && mappedChildren.length === 0 ? childs : mappedChildren;
-          if (child.dummy) child.children = inner; // needed on preact!
-
-          mem.push(React.cloneElement(child, _objectSpread({}, child.props, {
-            key: i
-          }), inner));
-        } else if (emptyChildrenButNeedsHandling && _typeof(child) === 'object' && child.dummy && !isElement) {
-          // we have a empty Trans node (the dummy element) with a targetstring that contains html tags needing
-          // conversion to react nodes
-          // so we just need to map the inner stuff
-          var _inner = mapAST(reactNodes
-          /* wrong but we need something */
-          , node.children);
+        } else if (hasChildren(child) || isValidTranslationWithChildren) {
+            var inner = renderInner(child, node, rootReactNode);
+            pushTranslatedJSX(child, inner, mem, i);
+          } else if (isEmptyTransWithHTML) {
+          var _inner = mapAST(reactNodes, node.children, rootReactNode);
 
           mem.push(React.cloneElement(child, _objectSpread({}, child.props, {
             key: i
           }), _inner));
         } else if (Number.isNaN(parseFloat(node.name))) {
-          if (i18nOptions.transSupportBasicHtmlNodes && keepArray.indexOf(node.name) > -1) {
+          if (isKnownComponent) {
+            var _inner2 = renderInner(child, node, rootReactNode);
+
+            pushTranslatedJSX(child, _inner2, mem, i);
+          } else if (i18nOptions.transSupportBasicHtmlNodes && keepArray.indexOf(node.name) > -1) {
             if (node.voidElement) {
               mem.push(React.createElement(node.name, {
                 key: "".concat(node.name, "-").concat(i)
               }));
             } else {
-              var _inner2 = mapAST(reactNodes
-              /* wrong but we need something */
-              , node.children);
+              var _inner3 = mapAST(reactNodes, node.children, rootReactNode);
 
               mem.push(React.createElement(node.name, {
                 key: "".concat(node.name, "-").concat(i)
-              }, _inner2));
+              }, _inner3));
             }
           } else if (node.voidElement) {
             mem.push("<".concat(node.name, " />"));
           } else {
-            var _inner3 = mapAST(reactNodes
-            /* wrong but we need something */
-            , node.children);
+            var _inner4 = mapAST(reactNodes, node.children, rootReactNode);
 
-            mem.push("<".concat(node.name, ">").concat(_inner3, "</").concat(node.name, ">"));
+            mem.push("<".concat(node.name, ">").concat(_inner4, "</").concat(node.name, ">"));
           }
         } else if (_typeof(child) === 'object' && !isElement) {
-          var content = node.children[0] ? translationContent : null; // v1
-          // as interpolation was done already we just have a regular content node
-          // in the translation AST while having an object in reactNodes
-          // -> push the content no need to interpolate again
-
+          var content = node.children[0] ? translationContent : null;
           if (content) mem.push(content);
         } else if (node.children.length === 1 && translationContent) {
-          // If component does not have children, but translation - has
-          // with this in component could be components={[<span class='make-beautiful'/>]} and in translation - 'some text <0>some highlighted message</0>'
           mem.push(React.cloneElement(child, _objectSpread({}, child.props, {
             key: i
           }), translationContent));
@@ -184,15 +188,12 @@ function renderNodes(children, targetString, i18n, i18nOptions, combinedTOpts) {
 
       return mem;
     }, []);
-  } // call mapAST with having react nodes nested into additional node like
-  // we did for the string ast from translation
-  // return the children of that extra node to get expected result
-
+  }
 
   var result = mapAST([{
     dummy: true,
     children: children
-  }], ast);
+  }], ast, getAsArray(children || []));
   return getChildren(result[0]);
 }
 
@@ -210,9 +211,7 @@ export function Trans(_ref) {
       tFromProps = _ref.t,
       additionalProps = _objectWithoutProperties(_ref, ["children", "count", "parent", "i18nKey", "tOptions", "values", "defaults", "components", "ns", "i18n", "t"]);
 
-  var ReactI18nContext = useContext(I18nContext);
-
-  var _ref2 = getHasUsedI18nextProvider() ? ReactI18nContext || {} : {},
+  var _ref2 = useContext(I18nContext) || {},
       i18nFromContext = _ref2.i18n,
       defaultNSFromContext = _ref2.defaultNS;
 
@@ -229,11 +228,9 @@ export function Trans(_ref) {
 
   var reactI18nextOptions = _objectSpread({}, getDefaults(), {}, i18n.options && i18n.options.react);
 
-  var useAsParent = parent !== undefined ? parent : reactI18nextOptions.defaultTransParent; // prepare having a namespace
-
   var namespaces = ns || t.ns || defaultNSFromContext || i18n.options && i18n.options.defaultNS;
   namespaces = typeof namespaces === 'string' ? [namespaces] : namespaces || ['translation'];
-  var defaultValue = defaults || nodesToString('', children, 0, reactI18nextOptions) || reactI18nextOptions.transEmptyNodeValue || i18nKey;
+  var defaultValue = defaults || nodesToString(children, reactI18nextOptions) || reactI18nextOptions.transEmptyNodeValue || i18nKey;
   var hashTransKey = reactI18nextOptions.hashTransKey;
   var key = i18nKey || (hashTransKey ? hashTransKey(defaultValue) : defaultValue);
   var interpolationOverride = values ? {} : {
@@ -251,6 +248,7 @@ export function Trans(_ref) {
   });
 
   var translation = key ? t(key, combinedTOpts) : defaultValue;
-  if (!useAsParent) return renderNodes(components || children, translation, i18n, reactI18nextOptions, combinedTOpts);
-  return React.createElement(useAsParent, additionalProps, renderNodes(components || children, translation, i18n, reactI18nextOptions, combinedTOpts));
+  var content = renderNodes(components || children, translation, i18n, reactI18nextOptions, combinedTOpts);
+  var useAsParent = parent !== undefined ? parent : reactI18nextOptions.defaultTransParent;
+  return useAsParent ? React.createElement(useAsParent, additionalProps, content) : content;
 }

package/dist/es/context.js

@@ -10,22 +10,13 @@ import React from 'react';
 var defaultOptions = {
   bindI18n: 'languageChanged',
   bindI18nStore: '',
-  // nsMode: 'fallback' // loop through all namespaces given to hook, HOC, render prop for key lookup
   transEmptyNodeValue: '',
   transSupportBasicHtmlNodes: true,
   transKeepBasicHtmlNodesFor: ['br', 'strong', 'i', 'p'],
-  // hashTransKey: key => key // calculate a key for Trans component based on defaultValue
   useSuspense: true
 };
 var i18nInstance;
-var hasUsedI18nextProvider;
 export var I18nContext = React.createContext();
-export function usedI18nextProvider(used) {
-  hasUsedI18nextProvider = used;
-}
-export function getHasUsedI18nextProvider() {
-  return hasUsedI18nextProvider;
-}
 export function setDefaults() {
   var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   defaultOptions = _objectSpread({}, defaultOptions, {}, options);
@@ -33,9 +24,7 @@ export function setDefaults() {
 export function getDefaults() {
   return defaultOptions;
 }
-export var ReportNamespaces =
-/*#__PURE__*/
-function () {
+export var ReportNamespaces = function () {
   function ReportNamespaces() {
     _classCallCheck(this, ReportNamespaces);
 
@@ -86,17 +75,7 @@ export function composeInitialProps(ForComponent) {
         resolve(i18nInitialProps);
       }
     });
-  }; // Avoid async for now - so we do not need to pull in regenerator
-  // return async ctx => {
-  //   const componentsInitialProps = ForComponent.getInitialProps
-  //     ? await ForComponent.getInitialProps(ctx)
-  //     : {};
-  //   const i18nInitialProps = getInitialProps();
-  //   return {
-  //     ...componentsInitialProps,
-  //     ...i18nInitialProps,
-  //   };
-  // };
+  };
 }
 export function getInitialProps() {
   var i18n = getI18n();

package/dist/es/useSSR.js

@@ -1,21 +1,17 @@
 import { useContext } from 'react';
-import { getI18n, getHasUsedI18nextProvider, I18nContext } from './context';
+import { getI18n, I18nContext } from './context';
 export function useSSR(initialI18nStore, initialLanguage) {
   var props = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   var i18nFromProps = props.i18n;
-  var ReactI18nContext = useContext(I18nContext);
 
-  var _ref = getHasUsedI18nextProvider() ? ReactI18nContext || {} : {},
+  var _ref = useContext(I18nContext) || {},
       i18nFromContext = _ref.i18n;
 
-  var i18n = i18nFromProps || i18nFromContext || getI18n(); // opt out if is a cloned instance, eg. created by i18next-http-middleware on request
-  // -> do not set initial stuff on server side
-
-  if (i18n.options && i18n.options.isClone) return; // nextjs / SSR: getting data from next.js or other ssr stack
+  var i18n = i18nFromProps || i18nFromContext || getI18n();
+  if (i18n.options && i18n.options.isClone) return;
 
   if (initialI18nStore && !i18n.initializedStoreOnce) {
-    i18n.services.resourceStore.data = initialI18nStore; // add namespaces to the config - so a languageChange call loads all namespaces needed
-
+    i18n.services.resourceStore.data = initialI18nStore;
     i18n.options.ns = Object.values(initialI18nStore).reduce(function (mem, lngResources) {
       Object.keys(lngResources).forEach(function (ns) {
         if (mem.indexOf(ns) < 0) mem.push(ns);

package/dist/es/useTranslation.js

@@ -6,15 +6,13 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 import { useState, useEffect, useContext, useRef } from 'react';
-import { getI18n, getDefaults, ReportNamespaces, getHasUsedI18nextProvider, I18nContext } from './context';
+import { getI18n, getDefaults, ReportNamespaces, I18nContext } from './context';
 import { warnOnce, loadNamespaces, hasLoadedNamespace } from './utils';
 export function useTranslation(ns) {
   var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  // assert we have the needed i18nInstance
   var i18nFromProps = props.i18n;
-  var ReactI18nContext = useContext(I18nContext);
 
-  var _ref = getHasUsedI18nextProvider() ? ReactI18nContext || {} : {},
+  var _ref = useContext(I18nContext) || {},
       i18nFromContext = _ref.i18n,
       defaultNSFromContext = _ref.defaultNS;
 
@@ -37,16 +35,13 @@ export function useTranslation(ns) {
 
   var i18nOptions = _objectSpread({}, getDefaults(), {}, i18n.options.react, {}, props);
 
-  var useSuspense = i18nOptions.useSuspense; // prepare having a namespace
-
+  var useSuspense = i18nOptions.useSuspense;
   var namespaces = ns || defaultNSFromContext || i18n.options && i18n.options.defaultNS;
-  namespaces = typeof namespaces === 'string' ? [namespaces] : namespaces || ['translation']; // report namespaces as used
-
-  if (i18n.reportNamespaces.addUsedNamespaces) i18n.reportNamespaces.addUsedNamespaces(namespaces); // are we ready? yes if all namespaces in first language are loaded already (either with data or empty object on failed load)
-
+  namespaces = typeof namespaces === 'string' ? [namespaces] : namespaces || ['translation'];
+  if (i18n.reportNamespaces.addUsedNamespaces) i18n.reportNamespaces.addUsedNamespaces(namespaces);
   var ready = (i18n.isInitialized || i18n.initializedStoreOnce) && namespaces.every(function (n) {
     return hasLoadedNamespace(n, i18n, i18nOptions);
-  }); // binding t function to namespace (acts also as rerender trigger)
+  });
 
   function getT() {
     return {
@@ -57,15 +52,13 @@ export function useTranslation(ns) {
   var _useState = useState(getT()),
       _useState2 = _slicedToArray(_useState, 2),
       t = _useState2[0],
-      setT = _useState2[1]; // seems we can't have functions as value -> wrap it in obj
-
+      setT = _useState2[1];
 
   var isMounted = useRef(true);
   useEffect(function () {
     var bindI18n = i18nOptions.bindI18n,
         bindI18nStore = i18nOptions.bindI18nStore;
-    isMounted.current = true; // if not ready and not using suspense load the namespaces
-    // in side effect and do not call resetT if unmounted
+    isMounted.current = true;
 
     if (!ready && !useSuspense) {
       loadNamespaces(i18n, namespaces, function () {
@@ -75,12 +68,10 @@ export function useTranslation(ns) {
 
     function boundReset() {
       if (isMounted.current) setT(getT());
-    } // bind events to trigger change, like languageChanged
-
+    }
 
     if (bindI18n && i18n) i18n.on(bindI18n, boundReset);
-    if (bindI18nStore && i18n) i18n.store.on(bindI18nStore, boundReset); // unbinding on unmount
-
+    if (bindI18nStore && i18n) i18n.store.on(bindI18nStore, boundReset);
     return function () {
       isMounted.current = false;
       if (bindI18n && i18n) bindI18n.split(' ').forEach(function (e) {
@@ -90,17 +81,13 @@ export function useTranslation(ns) {
         return i18n.store.off(e, boundReset);
       });
     };
-  }, [namespaces.join()]); // re-run effect whenever list of namespaces changes
-
+  }, [namespaces.join()]);
   var ret = [t.t, i18n, ready];
   ret.t = t.t;
   ret.i18n = i18n;
-  ret.ready = ready; // return hook stuff if ready
-
-  if (ready) return ret; // not yet loaded namespaces -> load them -> and return if useSuspense option set false
-
-  if (!ready && !useSuspense) return ret; // not yet loaded namespaces -> load them -> and trigger suspense
-
+  ret.ready = ready;
+  if (ready) return ret;
+  if (!ready && !useSuspense) return ret;
   throw new Promise(function (resolve) {
     loadNamespaces(i18n, namespaces, function () {
       if (isMounted.current) setT(getT());

package/dist/es/utils.js

@@ -20,23 +20,13 @@ export function warnOnce() {
   if (typeof args[0] === 'string' && alreadyWarned[args[0]]) return;
   if (typeof args[0] === 'string') alreadyWarned[args[0]] = new Date();
   warn.apply(void 0, args);
-} // not needed right now
-//
-// export function deprecated(...args) {
-//   if (process && process.env && (!process.env.NODE_ENV || process.env.NODE_ENV === 'development')) {
-//     if (typeof args[0] === 'string') args[0] = `deprecation warning -> ${args[0]}`;
-//     warnOnce(...args);
-//   }
-// }
-
+}
 export function loadNamespaces(i18n, ns, cb) {
   i18n.loadNamespaces(ns, function () {
-    // delay ready if not yet initialized i18n instance
     if (i18n.isInitialized) {
       cb();
     } else {
       var initialized = function initialized() {
-        // due to emitter removing issue in i18next we need to delay remove
         setTimeout(function () {
           i18n.off('initialized', initialized);
         }, 0);
@@ -57,24 +47,17 @@ export function hasLoadedNamespace(ns, i18n) {
 
   var lng = i18n.languages[0];
   var fallbackLng = i18n.options ? i18n.options.fallbackLng : false;
-  var lastLng = i18n.languages[i18n.languages.length - 1]; // we're in cimode so this shall pass
-
+  var lastLng = i18n.languages[i18n.languages.length - 1];
   if (lng.toLowerCase() === 'cimode') return true;
 
   var loadNotPending = function loadNotPending(l, n) {
     var loadState = i18n.services.backendConnector.state["".concat(l, "|").concat(n)];
     return loadState === -1 || loadState === 2;
-  }; // bound to trigger on event languageChanging
-  // so set ready to false while we are changing the language
-  // and namespace pending (depends on having a backend)
-
-
-  if (options.bindI18n && options.bindI18n.indexOf('languageChanging') > -1 && i18n.services.backendConnector.backend && i18n.isLanguageChangingTo && !loadNotPending(i18n.isLanguageChangingTo, ns)) return false; // loaded -> SUCCESS
-
-  if (i18n.hasResourceBundle(lng, ns)) return true; // were not loading at all -> SEMI SUCCESS
-
-  if (!i18n.services.backendConnector.backend) return true; // failed loading ns - but at least fallback is not pending -> SEMI SUCCESS
+  };
 
+  if (options.bindI18n && options.bindI18n.indexOf('languageChanging') > -1 && i18n.services.backendConnector.backend && i18n.isLanguageChangingTo && !loadNotPending(i18n.isLanguageChangingTo, ns)) return false;
+  if (i18n.hasResourceBundle(lng, ns)) return true;
+  if (!i18n.services.backendConnector.backend) return true;
   if (loadNotPending(lng, ns) && (!fallbackLng || loadNotPending(lastLng, ns))) return true;
   return false;
 }