@transifex/native 4.0.0 → 4.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transifex/native",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "description": "i18n framework using Transifex Native",
   "keywords": [
     "transifex",

package/src/TxNative.js

@@ -7,7 +7,7 @@ import SourceErrorPolicy from './policies/SourceErrorPolicy';
 import SourceStringPolicy from './policies/SourceStringPolicy';
 import MessageFormatRenderer from './renderers/MessageFormatRenderer';
 import {
-  generateKey, isString, isPluralized, escape, generateHashedKey, sleep,
+  generateKey, isString, escape, generateHashedKey, sleep,
 } from './utils';
 import {
   sendEvent,
@@ -15,6 +15,7 @@ import {
   FETCHING_LOCALES, LOCALES_FETCHED, LOCALES_FETCH_FAILED,
   LOCALE_CHANGED,
 } from './events';
+import { isPluralized } from './plurals';
 
 /**
  * Native instance, combines functionality from
@@ -29,6 +30,8 @@ export default class TxNative {
     this.token = '';
     this.secret = '';
     this.filterTags = '';
+    this.fetchTimeout = 0;
+    this.fetchInterval = 250;
     this.cache = new MemoryCache();
     this.missingPolicy = new SourceStringPolicy();
     this.errorPolicy = new SourceErrorPolicy();
@@ -47,6 +50,8 @@ export default class TxNative {
    * @param {String} params.filterTags
    * @param {String} params.token
    * @param {String} params.secret
+   * @param {Number} params.fetchTimeout
+   * @param {Number} params.fetchInterval
    * @param {Function} params.cache
    * @param {Function} params.missingPolicy
    * @param {Function} params.errorPolicy
@@ -60,6 +65,8 @@ export default class TxNative {
       'secret',
       'cache',
       'filterTags',
+      'fetchTimeout',
+      'fetchInterval',
       'missingPolicy',
       'errorPolicy',
       'stringRenderer',
@@ -182,11 +189,17 @@ export default class TxNative {
       }
     }
 
+    const handleError = (err) => {
+      sendEvent(TRANSLATIONS_FETCH_FAILED, { localeCode, filterTags }, this);
+      return err;
+    };
+
     // contact CDS
     try {
       sendEvent(FETCHING_TRANSLATIONS, { localeCode, filterTags }, this);
       let response;
       let lastResponseStatus = 202;
+      const tsNow = Date.now();
       while (lastResponseStatus === 202) {
         /* eslint-disable no-await-in-loop */
         let url = `${this.cdsHost}/content/${localeCode}`;
@@ -200,8 +213,14 @@ export default class TxNative {
             'X-NATIVE-SDK': `txjs/${__PLATFORM__}/${__VERSION__}`,
           },
         });
-        /* eslint-enable no-await-in-loop */
         lastResponseStatus = response.status;
+        if (this.fetchTimeout > 0 && (Date.now() - tsNow) >= this.fetchTimeout) {
+          throw handleError(new Error('Fetch translations timeout'));
+        }
+        if (lastResponseStatus === 202 && this.fetchInterval > 0) {
+          await sleep(this.fetchInterval);
+        }
+        /* eslint-enable no-await-in-loop */
       }
 
       const { data } = response;
@@ -215,12 +234,10 @@ export default class TxNative {
         this.cache.update(localeCode, hashmap);
         sendEvent(TRANSLATIONS_FETCHED, { localeCode, filterTags }, this);
       } else {
-        sendEvent(TRANSLATIONS_FETCH_FAILED, { localeCode, filterTags }, this);
-        throw new Error('Could not fetch translations');
+        throw handleError(new Error('Could not fetch translations'));
       }
     } catch (err) {
-      sendEvent(TRANSLATIONS_FETCH_FAILED, { localeCode, filterTags }, this);
-      throw err;
+      throw handleError(err);
     }
   }
 
@@ -354,11 +371,17 @@ export default class TxNative {
 
     if (!this.token) return [];
 
+    const handleError = (err) => {
+      sendEvent(LOCALES_FETCH_FAILED, null, this);
+      return err;
+    };
+
     // contact CDS
     try {
       sendEvent(FETCHING_LOCALES, null, this);
       let response;
       let lastResponseStatus = 202;
+      const tsNow = Date.now();
       while (lastResponseStatus === 202) {
         /* eslint-disable no-await-in-loop */
         response = await axios.get(`${this.cdsHost}/languages`, {
@@ -368,8 +391,14 @@ export default class TxNative {
             'X-NATIVE-SDK': `txjs/${__PLATFORM__}/${__VERSION__}`,
           },
         });
-        /* eslint-enable no-await-in-loop */
         lastResponseStatus = response.status;
+        if (this.fetchTimeout > 0 && (Date.now() - tsNow) >= this.fetchTimeout) {
+          throw handleError(new Error('Get locales timeout'));
+        }
+        if (lastResponseStatus === 202 && this.fetchInterval > 0) {
+          await sleep(this.fetchInterval);
+        }
+        /* eslint-enable no-await-in-loop */
       }
 
       const { data } = response;
@@ -378,12 +407,10 @@ export default class TxNative {
         this.locales = this.languages.map((entry) => entry.code);
         sendEvent(LOCALES_FETCHED, null, this);
       } else {
-        sendEvent(LOCALES_FETCH_FAILED, null, this);
-        throw new Error('Could not fetch languages');
+        throw handleError(new Error('Could not fetch languages'));
       }
     } catch (err) {
-      sendEvent(LOCALES_FETCH_FAILED, null, this);
-      throw err;
+      throw handleError(err);
     }
 
     return [...this.locales];

package/src/index.d.ts

@@ -26,5 +26,7 @@ declare module '@transifex/native' {
   export const generateHashedKey: any;
   export const generateKey: any;
   export const isPluralized: any;
+  export const explodePlurals: any;
+  export const implodePlurals: any;
   export const normalizeLocale: any;
 }

package/src/index.js

@@ -17,6 +17,7 @@ function _createNativeInstance(initOptions) {
 }
 
 export * from './utils';
+export * from './plurals';
 export * from './events';
 
 export const PseudoTranslationPolicy = _PseudoTranslationPolicy;

package/src/plurals.js

@@ -0,0 +1,204 @@
+const PLURAL_RULES = ['zero', 'one', 'two', 'few', 'many', 'other'];
+
+// The `_consumeFOO` functions take an input, "consume" a part of it to
+// produce the first return value and return the "unconsumed" part of the input
+// as the second return value
+
+// '{cnt, plural, one {ONE} other {OTHER}}' =>
+//     ['cnt', 'one {ONE} other {OTHER}']
+function consumePreamble(string) {
+  if (!(string.length > 1
+      && string[0] === '{'
+      && string[string.length - 1] === '}')
+  ) {
+    return [null, null];
+  }
+
+  // {cnt, plural, one {foo} other {foos}}
+  //  ^^^^^^^^^^^
+  const firstCommaPos = string.indexOf(',');
+  if (firstCommaPos === -1) { return [null, null]; }
+  const secondCommaPos = string.indexOf(',', firstCommaPos + 1);
+  if (secondCommaPos === -1) { return [null, null]; }
+
+  const varName = string.substring(1, firstCommaPos).trim();
+  const keyword = string
+    .substring(firstCommaPos + 1, secondCommaPos)
+    .trim();
+
+  // Make sure `varName` is a proper variable and that `keyword` is 'plural'
+  if (!/^[\w_]+$/.test(varName) || keyword !== 'plural') {
+    return [null, null];
+  }
+
+  return [
+    varName,
+    string.substring(secondCommaPos + 1, string.length - 1).trim()];
+}
+
+// 'one {ONE} other {OTHER}' => ['one', '{ONE} other {OTHER}']
+// 'other {OTHER}' => ['other', '{OTHER}']
+function consumeRule(string) {
+  // {cnt, plural, one {foo} other {foos}}
+  //              ^^^^^
+  const leftBracketPos = string.indexOf('{');
+  if (leftBracketPos === -1) { return [null, null]; }
+  let rule = string.substring(0, leftBracketPos).trim();
+  if (rule[0] === '=') {
+    rule = rule.substring(1);
+    if (!Number.isNaN(parseInt(rule, 10)) && parseInt(rule, 10) === parseFloat(rule)) {
+      rule = parseInt(rule, 10);
+      rule = PLURAL_RULES[rule];
+      if (rule === undefined) { return [null, null]; }
+    } else { return [null, null]; }
+  } else if (PLURAL_RULES.indexOf(rule) === -1) {
+    return [null, null];
+  }
+  return [rule, string.substring(leftBracketPos)];
+}
+
+// '{ONE} other {OTHER}' => ['ONE', 'other {OTHER}']
+// '{OTHER}' => ['OTHER', '']
+function consumePlural(string) {
+  // {cnt, plural, one {foo} other {foos}}
+  //                   ^^^^^
+  let [bracketCount, escaping] = [0, false];
+  let ptr = 0;
+  while (ptr < string.length) {
+    const char = string[ptr];
+    if (char === "'") {
+      const peek = string[ptr + 1];
+      if (peek === "'") {
+        ptr += 1;
+      } else if (escaping) {
+        escaping = false;
+      } else if (peek === '{' || peek === '}') {
+        escaping = true;
+      }
+    } else if (char === '{') {
+      if (!escaping) {
+        bracketCount += 1;
+      }
+    } else if (char === '}') {
+      if (!escaping) {
+        bracketCount -= 1;
+      }
+      if (bracketCount === 0) {
+        return [string.substring(1, ptr), string.substring(ptr + 1).trim()];
+      }
+    }
+    ptr += 1;
+  }
+  return [null, null];
+}
+
+/* Make an effort to split (explode) an ICU message format string into
+  * plurals. Works on only the simplest case, when a gettext-like statement
+  * like:
+  *
+  *   ngettext("You have %d new message", "You have %d new messages", cnt)
+  *
+  * was converted into an ICU message like:
+  *
+  *   {cnt, plural,
+  *     one {You have # new message}
+  *     other {You have # new messages}}
+  *
+  * The return value is a size-2 array with the name of the variable used and
+  * an object mapping the plural rule to the plural version, eg:
+  *
+  *   ['cnt',
+  *    {one: 'You have # new message',
+  *     other: 'You have # new messages'}]
+  *
+  * If the string can't be converted for any reason, `null` will be used in
+  * place of the variable name and only rule=5 (other) will be returned.
+  *
+  * @function
+  * @param {String} string
+  * @returns {[String, {rule: String}]} variable name and plural forms pair
+  *
+  * */
+export function explodePlurals(string) {
+  const defaultResult = [null, { other: string }];
+
+  // {cnt, plural, one {foo} other {foos}}
+  // ^^^^^^^^^^^^
+  // eslint-disable-next-line prefer-const
+  let [varName, remaining] = consumePreamble(string);
+  if (varName == null) { return defaultResult; }
+
+  // {cnt, plural, one {foo} other {foos}}
+  //               ^^^^^^^^^
+  const plurals = {};
+  let rule;
+  let plural;
+  [rule, remaining] = consumeRule(remaining);
+  if (rule == null) { return defaultResult; }
+
+  [plural, remaining] = consumePlural(remaining.trim());
+  if (plural == null) { return defaultResult; }
+  plurals[rule] = plural;
+
+  while (remaining.trim()) {
+    // {cnt, plural, one {foo} other {foos}}
+    //                         ^^^^^^^^^^^^
+    [rule, remaining] = consumeRule(remaining.trim());
+    if (rule == null) { return defaultResult; }
+    [plural, remaining] = consumePlural(remaining.trim());
+    if (plural == null) { return defaultResult; }
+    plurals[rule] = plural;
+  }
+
+  if ((Object.keys(plurals).length === 1 && !('other' in plurals))
+    || (!('one' in plurals && 'other' in plurals))
+  ) {
+    return defaultResult;
+  }
+
+  return [varName, plurals];
+}
+
+/* Convert a plurals object into an ICU plural statement, eg:
+  *
+  * {one: "ONE", other: "OTHER"} => '{???, plural, one {ONE} other {OTHER}}'
+  *
+  * @function
+  * @param {Object} plurals
+  * @param {string} [count='???']
+  * @returns {String}
+ */
+export function implodePlurals(plurals, count = '???') {
+  const result = [`{${count}, plural,`];
+  // Lets get the rules in order
+  // eslint-disable-next-line no-restricted-syntax
+  for (const rule of PLURAL_RULES) {
+    if (rule in plurals) {
+      const plural = plurals[rule];
+      result.push(` ${rule} {${plural}}`);
+    }
+  }
+  result.push('}');
+  return result.join('');
+}
+
+/**
+ * Determine if a string is an ICU pluralized string. Only works for the
+ * simplest possible case, where the string starts and ends in '{' and '}'
+ * respectively and the root ICU directive is a plural statement. ie This
+ *
+ *   {cnt, plural, one {ONE} other {OTHER}}
+ *
+ * will return 'true' while this
+ *
+ *   hello {cnt, plural, one {ONE} other {OTHER}}
+ *
+ * will return 'false'.
+ *
+ * @param {String} string
+ * @returns {Boolean}
+ */
+export function isPluralized(string) {
+  const plurals = explodePlurals(string)[1];
+  return Object.keys(plurals).length > 1;
+}

package/src/utils.js

@@ -84,138 +84,6 @@ export function normalizeLocale(locale) {
   return normalizedLocale;
 }
 
-const PLURAL_RULES = ['zero', 'one', 'two', 'few', 'many', 'other'];
-
-function _consumePreamble(string) {
-  if (!(string.length > 1
-      && string[0] === '{'
-      && string[string.length - 1] === '}')
-  ) {
-    return [null, null];
-  }
-
-  // {cnt, plural, one {foo} other {foos}}
-  //  ^^^^^^^^^^^
-  const firstCommaPos = string.indexOf(',');
-  if (firstCommaPos === -1) { return [null, null]; }
-  const secondCommaPos = string.indexOf(',', firstCommaPos + 1);
-  if (secondCommaPos === -1) { return [null, null]; }
-
-  const varName = string.substring(1, firstCommaPos).trim();
-  const keyword = string
-    .substring(firstCommaPos + 1, secondCommaPos)
-    .trim();
-
-  // Make sure `keyword` is 'plural'
-  if (keyword !== 'plural') { return [null, null]; }
-
-  return [
-    varName,
-    string.substring(secondCommaPos + 1, string.length - 1).trim()];
-}
-
-function _consumeRule(string) {
-  // {cnt, plural, one {foo} other {foos}}
-  //              ^^^^^
-  const leftBracketPos = string.indexOf('{');
-  if (leftBracketPos === -1) { return [null, null]; }
-  let rule = string.substring(0, leftBracketPos).trim();
-  if (rule[0] === '=') {
-    rule = rule.substring(1);
-    if (!Number.isNaN(parseInt(rule, 10)) && parseInt(rule, 10) === parseFloat(rule)) {
-      rule = parseInt(rule, 10);
-      rule = PLURAL_RULES[rule];
-      if (rule === undefined) { return [null, null]; }
-    } else { return [null, null]; }
-  } else if (PLURAL_RULES.indexOf(rule) === -1) {
-    return [null, null];
-  }
-  return [rule, string.substring(leftBracketPos)];
-}
-
-function _consumePlural(string) {
-  // {cnt, plural, one {foo} other {foos}}
-  //                   ^^^^^
-  let [bracketCount, escaping] = [0, false];
-  let ptr = 0;
-  while (ptr < string.length) {
-    const char = string[ptr];
-    if (char === "'") {
-      const peek = string[ptr + 1];
-      if (peek === "'") {
-        ptr += 1;
-      } else if (escaping) {
-        escaping = false;
-      } else if (peek === '{' || peek === '}') {
-        escaping = true;
-      }
-    } else if (char === '{') {
-      if (!escaping) {
-        bracketCount += 1;
-      }
-    } else if (char === '}') {
-      if (!escaping) {
-        bracketCount -= 1;
-      }
-      if (bracketCount === 0) {
-        return [string.substring(1, ptr), string.substring(ptr + 1).trim()];
-      }
-    }
-    ptr += 1;
-  }
-  return [null, null];
-}
-
-/**
- * Determine if a string is an ICU pluralized string. Only works for the
- * simplest possible case, where the string starts and ends in '{' and '}'
- * respectively and the root ICU directive is a plural statement. ie This
- *
- *   {cnt, plural, one {ONE} other {OTHER}}
- *
- * will return 'true' while this
- *
- *   hello {cnt, plural, one {ONE} other {OTHER}}
- *
- * will return 'false'.
- *
- * @param {String} string
- * @returns {Boolean}
- */
-export function isPluralized(string) {
-  const [varName, rest] = _consumePreamble(string);
-  let remaining = rest;
-  if (varName == null) { return false; }
-
-  const plurals = {};
-  let rule;
-  let plural;
-  [rule, remaining] = _consumeRule(remaining);
-  if (rule == null) { return false; }
-
-  [plural, remaining] = _consumePlural(remaining.trim());
-  if (plural == null) { return false; }
-  plurals[rule] = plural;
-
-  while (remaining.trim()) {
-    // {cnt, plural, one {foo} other {foos}}
-    //                         ^^^^^^^^^^^^
-    [rule, remaining] = _consumeRule(remaining.trim());
-    if (rule == null) { return false; }
-    [plural, remaining] = _consumePlural(remaining.trim());
-    if (plural == null) { return false; }
-    plurals[rule] = plural;
-  }
-
-  if ((Object.keys(plurals).length === 1 && !('other' in plurals))
-    || (!('one' in plurals && 'other' in plurals))
-  ) {
-    return false;
-  }
-
-  return true;
-}
-
 /**
  * Sleep in msec
  *