@ultraq/icu-message-formatter 0.12.0-beta.0 → 0.13.0

package/lib/icu-message-formatter.es.js

@@ -1,6 +1,3 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
-import _createClass from '@babel/runtime/helpers/createClass';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { flatten } from '@ultraq/array-utils';
 import { memoize } from '@ultraq/function-utils';
@@ -22,389 +19,380 @@ import { memoize } from '@ultraq/function-utils';
  */
 
 /**
- * Most branch-based type handlers are based around "cases".
- * For example, `select` and `plural` compare compare a value
- * to "case keys" to choose a subtranslation.
+ * @typedef ParseCasesResult
+ * @property {string[]} args
+ *   A list of prepended arguments.
+ * @property {Record<string,string>} cases
+ *   A map of all cases.
+ */
+
+/**
+ * Most branch-based type handlers are based around "cases".  For example,
+ * `select` and `plural` compare compare a value to "case keys" to choose a
+ * subtranslation.
  * 
- * This util splits "matches" portions provided to the aforementioned
- * handlers into case strings, and extracts any prepended arguments
- * (for example, `plural` supports an `offset:n` argument used for
- * populating the magic `#` variable).
+ * This util splits "matches" portions provided to the aforementioned handlers
+ * into case strings, and extracts any prepended arguments (for example,
+ * `plural` supports an `offset:n` argument used for populating the magic `#`
+ * variable).
  * 
- * @param {String} string
- * @return {Object} The `cases` key points to a map of all cases.
- *                  The `arguments` key points to a list of prepended arguments.
+ * @param {string} string
+ * @return {ParseCasesResult}
  */
 function parseCases(string) {
-  var isWhitespace = function isWhitespace(ch) {
-    return /\s/.test(ch);
-  };
-
-  var args = [];
-  var cases = {};
-  var currTermStart = 0;
-  var latestTerm = null;
-  var inTerm = false;
-  var i = 0;
-
+  const isWhitespace = ch => /\s/.test(ch);
+  const args = [];
+  const cases = {};
+  let currTermStart = 0;
+  let latestTerm = null;
+  let inTerm = false;
+  let i = 0;
   while (i < string.length) {
     // Term ended
     if (inTerm && (isWhitespace(string[i]) || string[i] === '{')) {
       inTerm = false;
-      latestTerm = string.slice(currTermStart, i); // We want to process the opening char again so the case will be properly registered.
+      latestTerm = string.slice(currTermStart, i);
 
+      // We want to process the opening char again so the case will be properly registered.
       if (string[i] === '{') {
         i--;
       }
-    } // New term
+    }
+
+    // New term
     else if (!inTerm && !isWhitespace(string[i])) {
-      var caseBody = string[i] === '{'; // If there's a previous term, we can either handle a whole
-      // case, or add that as an argument.
+      const caseBody = string[i] === '{';
 
+      // If there's a previous term, we can either handle a whole
+      // case, or add that as an argument.
       if (latestTerm && caseBody) {
-        var branchEndIndex = findClosingBracket(string, i);
-
+        const branchEndIndex = findClosingBracket(string, i);
         if (branchEndIndex === -1) {
-          throw new Error("Unbalanced curly braces in string: \"".concat(string, "\""));
+          throw new Error(`Unbalanced curly braces in string: "${string}"`);
         }
-
         cases[latestTerm] = string.slice(i + 1, branchEndIndex); // Don't include the braces
 
         i = branchEndIndex; // Will be moved up where needed at end of loop.
-
         latestTerm = null;
       } else {
         if (latestTerm) {
           args.push(latestTerm);
           latestTerm = null;
         }
-
         inTerm = true;
         currTermStart = i;
       }
     }
-
     i++;
   }
-
   if (inTerm) {
     latestTerm = string.slice(currTermStart);
   }
-
   if (latestTerm) {
     args.push(latestTerm);
   }
-
   return {
-    args: args,
-    cases: cases
+    args,
+    cases
   };
 }
+
 /**
  * Finds the index of the matching closing curly bracket, including through
  * strings that could have nested brackets.
  * 
- * @param {String} string
- * @param {Number} fromIndex
- * @return {Number} The index of the matching closing bracket, or -1 if no
- *   closing bracket could be found.
+ * @param {string} string
+ * @param {number} fromIndex
+ * @return {number}
+ *   The index of the matching closing bracket, or -1 if no closing bracket
+ *   could be found.
  */
-
 function findClosingBracket(string, fromIndex) {
-  var depth = 0;
-
-  for (var i = fromIndex + 1; i < string.length; i++) {
-    var char = string.charAt(i);
-
+  let depth = 0;
+  for (let i = fromIndex + 1; i < string.length; i++) {
+    let char = string.charAt(i);
     if (char === '}') {
       if (depth === 0) {
         return i;
       }
-
       depth--;
     } else if (char === '{') {
       depth++;
     }
   }
-
   return -1;
 }
+
 /**
  * Split a `{key, type, format}` block into those 3 parts, taking into account
  * nested message syntax that can exist in the `format` part.
  * 
- * @param {String} block
- * @return {Array}
+ * @param {string} block
+ * @return {string[]}
  *   An array with `key`, `type`, and `format` items in that order, if present
  *   in the formatted argument block.
  */
-
 function splitFormattedArgument(block) {
   return split(block.slice(1, -1), ',', 3);
 }
+
 /**
  * Like `String.prototype.split()` but where the limit parameter causes the
  * remainder of the string to be grouped together in a final entry.
  * 
  * @private
- * @param {String} string
- * @param {String} separator
- * @param {Number} limit
- * @param {Array} [accumulator=[]]
- * @return {Array}
+ * @param {string} string
+ * @param {string} separator
+ * @param {number} limit
+ * @param {string[]} accumulator
+ * @return {string[]}
  */
-
 function split(string, separator, limit) {
-  var accumulator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-
+  let accumulator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
   if (!string) {
     return accumulator;
   }
-
   if (limit === 1) {
     accumulator.push(string);
     return accumulator;
   }
-
-  var indexOfDelimiter = string.indexOf(separator);
-
+  let indexOfDelimiter = string.indexOf(separator);
   if (indexOfDelimiter === -1) {
     accumulator.push(string);
     return accumulator;
   }
-
-  var head = string.substring(0, indexOfDelimiter).trim();
-  var tail = string.substring(indexOfDelimiter + separator.length + 1).trim();
+  let head = string.substring(0, indexOfDelimiter).trim();
+  let tail = string.substring(indexOfDelimiter + separator.length + 1).trim();
   accumulator.push(head);
   return split(tail, separator, limit - 1, accumulator);
 }
 
+/**
+ * @typedef {Record<string,any>} FormatValues
+ */
+
+/**
+ * @callback ProcessFunction
+ * @param {string} message
+ * @param {FormatValues} [values={}]
+ * @return {any[]}
+ */
+
+/**
+ * @callback TypeHandler
+ * @param {any} value
+ *   The object which matched the key of the block being processed.
+ * @param {string} matches
+ *   Any format options associated with the block being processed.
+ * @param {string} locale
+ *   The locale to use for formatting.
+ * @param {FormatValues} values
+ *   The object of placeholder data given to the original `format`/`process`
+ *   call.
+ * @param {ProcessFunction} process
+ *   The `process` function itself so that sub-messages can be processed by type
+ *   handlers.
+ * @return {any | any[]}
+ */
+
 /**
  * The main class for formatting messages.
  * 
  * @author Emanuel Rabina
  */
-
-var MessageFormatter = /*#__PURE__*/function () {
+class MessageFormatter {
   /**
    * Creates a new formatter that can work using any of the custom type handlers
    * you register.
    * 
-   * @param {String} locale
-   * @param {Object} [typeHandlers={}]
+   * @param {string} locale
+   * @param {Record<string,TypeHandler>} [typeHandlers]
    *   Optional object where the keys are the names of the types to register,
    *   their values being the functions that will return a nicely formatted
    *   string for the data and locale they are given.
    */
-  function MessageFormatter(locale) {
+  constructor(locale) {
     var _this = this;
-
-    var typeHandlers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-    _classCallCheck(this, MessageFormatter);
-
+    let typeHandlers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    /**
+     * Formats an ICU message syntax string using `values` for placeholder data
+     * and any currently-registered type handlers.
+     * 
+     * @type {(message: string, values?: FormatValues) => string}
+     */
     _defineProperty(this, "format", memoize(function (message) {
-      var values = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      let values = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       return flatten(_this.process(message, values)).join('');
     }));
-
     this.locale = locale;
     this.typeHandlers = typeHandlers;
   }
   /**
-   * Formats an ICU message syntax string using `values` for placeholder data
-   * and any currently-registered type handlers.
+   * Process an ICU message syntax string using `values` for placeholder data
+   * and any currently-registered type handlers.  The result of this method is
+   * an array of the component parts after they have been processed in turn by
+   * their own type handlers.  This raw output is useful for other renderers,
+   * eg: React where components can be used instead of being forced to return
+   * raw strings.
+   * 
+   * This method is used by {@link MessageFormatter#format} where it acts as a
+   * string renderer.
    * 
-   * @param {String} message
-   * @param {Object} [values={}]
-   * @return {String}
+   * @param {string} message
+   * @param {FormatValues} [values]
+   * @return {any[]}
    */
-
-
-  _createClass(MessageFormatter, [{
-    key: "process",
-    value:
-    /**
-     * Process an ICU message syntax string using `values` for placeholder data
-     * and any currently-registered type handlers.  The result of this method is
-     * an array of the component parts after they have been processed in turn by
-     * their own type handlers.  This raw output is useful for other renderers,
-     * eg: React where components can be used instead of being forced to return
-     * raw strings.
-     * 
-     * This method is used by {@link MessageFormatter#format} where it acts as a
-     * string renderer.
-     * 
-     * @param {String} message
-     * @param {Object} [values={}]
-     * @return {Array}
-     */
-    function process(message) {
-      var values = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-      if (!message) {
-        return [];
-      }
-
-      var blockStartIndex = message.indexOf('{');
-
-      if (blockStartIndex !== -1) {
-        var blockEndIndex = findClosingBracket(message, blockStartIndex);
-
-        if (blockEndIndex !== -1) {
-          var block = message.substring(blockStartIndex, blockEndIndex + 1);
-
-          if (block) {
-            var result = [];
-            var head = message.substring(0, blockStartIndex);
-
-            if (head) {
-              result.push(head);
-            }
-
-            var _splitFormattedArgume = splitFormattedArgument(block),
-                _splitFormattedArgume2 = _slicedToArray(_splitFormattedArgume, 3),
-                key = _splitFormattedArgume2[0],
-                type = _splitFormattedArgume2[1],
-                format = _splitFormattedArgume2[2];
-
-            var body = values[key];
-
-            if (body === null || body === undefined) {
-              body = '';
-            }
-
-            var typeHandler = type && this.typeHandlers[type];
-            result.push(typeHandler ? typeHandler(body, format, this.locale, values, this.process.bind(this)) : body);
-            var tail = message.substring(blockEndIndex + 1);
-
-            if (tail) {
-              result.push(this.process(tail, values));
-            }
-
-            return result;
+  process(message) {
+    let values = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    if (!message) {
+      return [];
+    }
+    let blockStartIndex = message.indexOf('{');
+    if (blockStartIndex !== -1) {
+      let blockEndIndex = findClosingBracket(message, blockStartIndex);
+      if (blockEndIndex !== -1) {
+        let block = message.substring(blockStartIndex, blockEndIndex + 1);
+        if (block) {
+          let result = [];
+          let head = message.substring(0, blockStartIndex);
+          if (head) {
+            result.push(head);
           }
-        } else {
-          throw new Error("Unbalanced curly braces in string: \"".concat(message, "\""));
+          let [key, type, format] = splitFormattedArgument(block);
+          let body = values[key];
+          if (body === null || body === undefined) {
+            body = '';
+          }
+          let typeHandler = type && this.typeHandlers[type];
+          result.push(typeHandler ? typeHandler(body, format, this.locale, values, this.process.bind(this)) : body);
+          let tail = message.substring(blockEndIndex + 1);
+          if (tail) {
+            result.push(this.process(tail, values));
+          }
+          return result;
         }
+      } else {
+        throw new Error(`Unbalanced curly braces in string: "${message}"`);
       }
-
-      return [message];
     }
-  }]);
+    return [message];
+  }
+}
 
-  return MessageFormatter;
-}();
+/* 
+ * Copyright 2019, Emanuel Rabina (http://www.ultraq.net.nz/)
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-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; }
+let pluralFormatter;
+let keyCounter = 0;
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-var pluralFormatter;
-var keyCounter = 0; // All the special keywords that can be used in `plural` blocks for the various branches
+// All the special keywords that can be used in `plural` blocks for the various branches
+const ONE = 'one';
+const OTHER$1 = 'other';
 
-var ONE = 'one';
-var OTHER$1 = 'other';
 /**
  * @private
- * @param {String} caseBody
- * @param {Number} value
- * @return {Object} {caseBody: string, numberValues: object}
+ * @param {string} caseBody
+ * @param {number} value
+ * @return {{caseBody: string, numberValues: object}}
  */
-
 function replaceNumberSign(caseBody, value) {
-  var i = 0;
-  var output = '';
-  var numBraces = 0;
-  var numberValues = {};
-
+  let i = 0;
+  let output = '';
+  let numBraces = 0;
+  const numberValues = {};
   while (i < caseBody.length) {
     if (caseBody[i] === '#' && !numBraces) {
-      var keyParam = "__hashToken".concat(keyCounter++);
-      output += "{".concat(keyParam, ", number}");
+      let keyParam = `__hashToken${keyCounter++}`;
+      output += `{${keyParam}, number}`;
       numberValues[keyParam] = value;
     } else {
       output += caseBody[i];
     }
-
     if (caseBody[i] === '{') {
       numBraces++;
     } else if (caseBody[i] === '}') {
       numBraces--;
     }
-
     i++;
   }
-
   return {
     caseBody: output,
-    numberValues: numberValues
+    numberValues
   };
 }
+
 /**
  * Handler for `plural` statements within ICU message syntax strings.  Returns
  * a formatted string for the branch that closely matches the current value.
  * 
  * See https://formatjs.io/docs/core-concepts/icu-syntax#plural-format for more
  * details on how the `plural` statement works.
- * 
- * @param {String} value
- * @param {String} matches
- * @param {String} locale
- * @param {String} values
- * @param {Function} format
- * @return {String}
+ *
+ * @param {string} value
+ * @param {string} matches
+ * @param {string} locale
+ * @param {Record<string,any>} values
+ * @param {(message: string, values?: Record<string,any>) => any[]} process
+ * @return {any | any[]}
  */
-
-
 function pluralTypeHandler(value) {
-  var matches = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  var locale = arguments.length > 2 ? arguments[2] : undefined;
-  var values = arguments.length > 3 ? arguments[3] : undefined;
-  var format = arguments.length > 4 ? arguments[4] : undefined;
-
-  var _parseCases = parseCases(matches),
-      args = _parseCases.args,
-      cases = _parseCases.cases;
-
-  var intValue = parseInt(value);
-  args.forEach(function (arg) {
+  let matches = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let locale = arguments.length > 2 ? arguments[2] : undefined;
+  let values = arguments.length > 3 ? arguments[3] : undefined;
+  let process = arguments.length > 4 ? arguments[4] : undefined;
+  const {
+    args,
+    cases
+  } = parseCases(matches);
+  let intValue = parseInt(value);
+  args.forEach(arg => {
     if (arg.startsWith('offset:')) {
       intValue -= parseInt(arg.slice('offset:'.length));
     }
   });
-  var keywordPossibilities = [];
-
+  const keywordPossibilities = [];
   if ('PluralRules' in Intl) {
     // Effectively memoize because instantiation of `Int.*` objects is expensive.
     if (pluralFormatter === undefined || pluralFormatter.resolvedOptions().locale !== locale) {
       pluralFormatter = new Intl.PluralRules(locale);
     }
+    const pluralKeyword = pluralFormatter.select(intValue);
 
-    var pluralKeyword = pluralFormatter.select(intValue); // Other is always added last with least priority, so we don't want to add it here.
-
+    // Other is always added last with least priority, so we don't want to add it here.
     if (pluralKeyword !== OTHER$1) {
       keywordPossibilities.push(pluralKeyword);
     }
   }
-
   if (intValue === 1) {
     keywordPossibilities.push(ONE);
   }
-
-  keywordPossibilities.push("=".concat(intValue), OTHER$1);
-
-  for (var i = 0; i < keywordPossibilities.length; i++) {
-    var keyword = keywordPossibilities[i];
-
+  keywordPossibilities.push(`=${intValue}`, OTHER$1);
+  for (let i = 0; i < keywordPossibilities.length; i++) {
+    const keyword = keywordPossibilities[i];
     if (keyword in cases) {
-      var _replaceNumberSign = replaceNumberSign(cases[keyword], intValue),
-          caseBody = _replaceNumberSign.caseBody,
-          numberValues = _replaceNumberSign.numberValues;
-
-      return format(caseBody, _objectSpread(_objectSpread({}, values), numberValues));
+      const {
+        caseBody,
+        numberValues
+      } = replaceNumberSign(cases[keyword], intValue);
+      return process(caseBody, {
+        ...values,
+        ...numberValues
+      });
     }
   }
-
   return value;
 }
 
@@ -423,7 +411,9 @@ function pluralTypeHandler(value) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var OTHER = 'other';
+
+const OTHER = 'other';
+
 /**
  * Handler for `select` statements within ICU message syntax strings.  Returns
  * a formatted string for the branch that closely matches the current value.
@@ -431,28 +421,25 @@ var OTHER = 'other';
  * See https://formatjs.io/docs/core-concepts/icu-syntax#select-format for more
  * details on how the `select` statement works.
  * 
- * @param {String} value
- * @param {String} matches
- * @param {String} locale
- * @param {String} values
- * @param {Function} format
- * @return {String}
+ * @param {string} value
+ * @param {string} matches
+ * @param {string} locale
+ * @param {Record<string,any>} values
+ * @param {(message: string, values?: Record<string,any>) => any[]} process
+ * @return {any | any[]}
  */
-
 function selectTypeHandler(value) {
-  var matches = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  var values = arguments.length > 3 ? arguments[3] : undefined;
-  var format = arguments.length > 4 ? arguments[4] : undefined;
-
-  var _parseCases = parseCases(matches),
-      cases = _parseCases.cases;
-
+  let matches = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let values = arguments.length > 3 ? arguments[3] : undefined;
+  let process = arguments.length > 4 ? arguments[4] : undefined;
+  const {
+    cases
+  } = parseCases(matches);
   if (value in cases) {
-    return format(cases[value], values);
+    return process(cases[value], values);
   } else if (OTHER in cases) {
-    return format(cases[OTHER], values);
+    return process(cases[OTHER], values);
   }
-
   return value;
 }