@transifex/native 3.2.2 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transifex/native",
-  "version": "3.2.2",
+  "version": "4.1.0",
   "description": "i18n framework using Transifex Native",
   "keywords": [
     "transifex",
@@ -31,31 +31,30 @@
     "url": "https://github.com/transifex/transifex-javascript/issues"
   },
   "engines": {
-    "node": ">=12.0.0"
+    "node": ">=14.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.17.8",
-    "@babel/plugin-transform-runtime": "^7.14.5",
-    "@babel/preset-env": "^7.14.5",
-    "@babel/runtime": "^7.17.8",
+    "@babel/core": "^7.17.10",
+    "@babel/plugin-transform-runtime": "^7.17.10",
+    "@babel/preset-env": "^7.17.10",
+    "@babel/runtime": "^7.17.9",
     "babel-eslint": "^10.1.0",
-    "babel-loader": "^8.1.0",
+    "babel-loader": "^8.2.5",
     "chai": "^4.3.4",
     "eslint": "^7.28.0",
     "eslint-config-airbnb-base": "^14.2.0",
-    "eslint-loader": "^4.0.2",
-    "eslint-plugin-import": "^2.23.4",
-    "glob": "^7.1.7",
-    "mocha": "^9.1.3",
+    "eslint-plugin-import": "^2.26.0",
+    "glob": "^8.0.1",
+    "mocha": "^10.0.0",
     "nock": "^13.1.0",
     "nyc": "^15.1.0",
     "source-map-support": "^0.5.19",
-    "webpack": "^4.46.0",
-    "webpack-cli": "^3.3.12"
+    "webpack": "^5.72.0",
+    "webpack-cli": "^4.9.2"
   },
   "dependencies": {
     "@messageformat/core": "^3.0.0",
-    "axios": "^0.26.1",
+    "axios": "^0.27.2",
     "md5": "^2.3.0"
   }
 }

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

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
  *

package/webpack.browser.js

@@ -21,22 +21,6 @@ module.exports = {
   ],
   module: {
     rules: [
-      {
-        test: /\.(js|jsx)$/,
-        enforce: 'pre',
-        use: [
-          {
-            options: {
-              cache: true,
-              configFile: '.eslintrc.json',
-              formatter: 'eslint-formatter-pretty',
-              emitWarning: true,
-              failOnError: true,
-            },
-            loader: 'eslint-loader',
-          },
-        ],
-      },
       {
         test: /\.(js|jsx)$/,
         exclude: /(node_modules)/,

package/webpack.node.js

@@ -20,23 +20,6 @@ module.exports = {
     }),
   ],
   module: {
-    rules: [
-      {
-        test: /\.(js|jsx)$/,
-        enforce: 'pre',
-        use: [
-          {
-            options: {
-              cache: true,
-              configFile: '.eslintrc.json',
-              formatter: 'eslint-formatter-pretty',
-              emitWarning: true,
-              failOnError: true,
-            },
-            loader: 'eslint-loader',
-          },
-        ],
-      },
-    ],
+    rules: [],
   },
 };