@ultraq/icu-message-formatter 0.14.1 → 0.14.3

package/dist/icu-message-formatter.js

@@ -37,63 +37,72 @@ import { memoize } from '@ultraq/function-utils';
  * @param {string} string
  * @return {ParseCasesResult}
  */
-function parseCases() {
-  let string = arguments.length > 0 && arguments[0] !== undefined ? arguments[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.
-      if (string[i] === '{') {
-        i--;
-      }
-    }
-
-    // New term
-    else if (!inTerm && !isWhitespace(string[i])) {
-      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) {
-        const branchEndIndex = findClosingBracket(string, i);
-        if (branchEndIndex === -1) {
-          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,
-    cases
-  };
+function parseCases(string = '') {
+	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.
+			if (string[i] === '{') {
+				i--;
+			}
+		}
+
+		// New term
+		else if (!inTerm && !isWhitespace(string[i])) {
+			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) {
+				const branchEndIndex = findClosingBracket(string, i);
+
+				if (branchEndIndex === -1) {
+					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,
+		cases
+	};
 }
 
 /**
@@ -107,19 +116,20 @@ function parseCases() {
  *   could be found.
  */
 function findClosingBracket(string, fromIndex) {
-  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;
+	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;
 }
 
 /**
@@ -132,7 +142,7 @@ function findClosingBracket(string, fromIndex) {
  *   in the formatted argument block.
  */
 function splitFormattedArgument(block) {
-  return split(block.slice(1, -1), ',', 3);
+	return split(block.slice(1, -1), ',', 3);
 }
 
 /**
@@ -146,24 +156,23 @@ function splitFormattedArgument(block) {
  * @param {string[]} accumulator
  * @return {string[]}
  */
-function split(string, separator, limit) {
-  let accumulator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-  if (!string) {
-    return accumulator;
-  }
-  if (limit === 1) {
-    accumulator.push(string);
-    return accumulator;
-  }
-  let indexOfDelimiter = string.indexOf(separator);
-  if (indexOfDelimiter === -1) {
-    accumulator.push(string);
-    return accumulator;
-  }
-  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);
+function split(string, separator, limit, accumulator = []) {
+	if (!string) {
+		return accumulator;
+	}
+	if (limit === 1) {
+		accumulator.push(string);
+		return accumulator;
+	}
+	let indexOfDelimiter = string.indexOf(separator);
+	if (indexOfDelimiter === -1) {
+		accumulator.push(string);
+		return accumulator;
+	}
+	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);
 }
 
 /*
@@ -217,86 +226,88 @@ function split(string, separator, limit) {
  * @author Emanuel Rabina
  */
 class MessageFormatter {
-  /**
-   * Creates a new formatter that can work using any of the custom type handlers
-   * you register.
-   *
-   * @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.
-   */
-  constructor(locale) {
-    let typeHandlers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    this.locale = locale;
-    this.typeHandlers = typeHandlers;
-  }
-
-  /**
-   * Formats an ICU message syntax string using `values` for placeholder data
-   * and any currently-registered type handlers.
-   *
-   * @type {(message: string, values?: FormatValues) => string}
-   */
-  format = memoize((() => {
-    var _this = this;
-    return function (message) {
-      let values = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      return _this.process(message, values).flat(Infinity).join('');
-    };
-  })());
-
-  /**
-   * 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 {FormatValues} [values]
-   * @return {any[]}
-   */
-  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);
-          }
-          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];
-  }
+
+	/**
+	 * Creates a new formatter that can work using any of the custom type handlers
+	 * you register.
+	 *
+	 * @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.
+	 */
+	constructor(locale, typeHandlers = {}) {
+
+		this.locale = locale;
+		this.typeHandlers = typeHandlers;
+	}
+
+	/**
+	 * Formats an ICU message syntax string using `values` for placeholder data
+	 * and any currently-registered type handlers.
+	 *
+	 * @type {(message: string, values?: FormatValues) => string}
+	 */
+	format = memoize((message, values = {}) => {
+
+		return this.process(message, values).flat(Infinity).join('');
+	});
+
+	/**
+	 * 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 {FormatValues} [values]
+	 * @return {any[]}
+	 */
+	process(message, values = {}) {
+
+		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);
+					}
+					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];
+	}
 }
 
 /*
@@ -315,11 +326,13 @@ class MessageFormatter {
  * limitations under the License.
  */
 
+
 let pluralFormatter;
+
 let keyCounter = 0;
 
 // All the special keywords that can be used in `plural` blocks for the various branches
-const ONE = 'one';
+const ONE   = 'one';
 const OTHER$1 = 'other';
 
 /**
@@ -329,29 +342,35 @@ const OTHER$1 = 'other';
  * @return {{caseBody: string, numberValues: object}}
  */
 function replaceNumberSign(caseBody, value) {
-  let i = 0;
-  let output = '';
-  let numBraces = 0;
-  const numberValues = {};
-  while (i < caseBody.length) {
-    if (caseBody[i] === '#' && !numBraces) {
-      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
-  };
+	let i = 0;
+	let output = '';
+	let numBraces = 0;
+	const numberValues = {};
+
+	while (i < caseBody.length) {
+		if (caseBody[i] === '#' && !numBraces) {
+			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
+	};
 }
 
 /**
@@ -369,47 +388,48 @@ function replaceNumberSign(caseBody, value) {
  * @return {any | any[]}
  */
 function pluralTypeHandler(value, matches, locale, values, process) {
-  const {
-    args,
-    cases
-  } = parseCases(matches);
-  let intValue = parseInt(value);
-  args.forEach(arg => {
-    if (arg.startsWith('offset:')) {
-      intValue -= parseInt(arg.slice('offset:'.length));
-    }
-  });
-  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);
-
-    // 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(`=${intValue}`, OTHER$1);
-  for (let i = 0; i < keywordPossibilities.length; i++) {
-    const keyword = keywordPossibilities[i];
-    if (keyword in cases) {
-      const {
-        caseBody,
-        numberValues
-      } = replaceNumberSign(cases[keyword], intValue);
-      return process(caseBody, {
-        ...values,
-        ...numberValues
-      });
-    }
-  }
-  return value;
+	const {args, cases} = parseCases(matches);
+
+	let intValue = parseInt(value);
+
+	args.forEach((arg) => {
+		if (arg.startsWith('offset:')) {
+			intValue -= parseInt(arg.slice('offset:'.length));
+		}
+	});
+
+	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);
+
+		// 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(`=${intValue}`, OTHER$1);
+
+	for (let i = 0; i < keywordPossibilities.length; i++) {
+		const keyword = keywordPossibilities[i];
+		if (keyword in cases) {
+			const {caseBody, numberValues} = replaceNumberSign(cases[keyword], intValue);
+			return process(caseBody, {
+				...values,
+				...numberValues
+			});
+		}
+	}
+
+	return value;
 }
 
 /*
@@ -428,6 +448,7 @@ function pluralTypeHandler(value, matches, locale, values, process) {
  * limitations under the License.
  */
 
+
 const OTHER = 'other';
 
 /**
@@ -445,15 +466,16 @@ const OTHER = 'other';
  * @return {any | any[]}
  */
 function selectTypeHandler(value, matches, locale, values, process) {
-  const {
-    cases
-  } = parseCases(matches);
-  if (value in cases) {
-    return process(cases[value], values);
-  } else if (OTHER in cases) {
-    return process(cases[OTHER], values);
-  }
-  return value;
+	const {cases} = parseCases(matches);
+
+	if (value in cases) {
+		return process(cases[value], values);
+	}
+	else if (OTHER in cases) {
+		return process(cases[OTHER], values);
+	}
+
+	return value;
 }
 
 export { MessageFormatter, findClosingBracket, parseCases, pluralTypeHandler, selectTypeHandler, splitFormattedArgument };