@formatjs/icu-messageformat-parser 3.2.0 → 3.3.0

package/manipulator.js

@@ -1,135 +1,177 @@
-import { __spreadArray } from "tslib";
-import { isArgumentElement, isDateElement, isNumberElement, isPluralElement, isSelectElement, isTagElement, isTimeElement, TYPE, } from './types.js';
+import { isArgumentElement, isDateElement, isNumberElement, isPluralElement, isPoundElement, isSelectElement, isTagElement, isTimeElement, TYPE } from "./types.js";
 function cloneDeep(obj) {
-    if (Array.isArray(obj)) {
-        // @ts-expect-error meh
-        return obj.map(cloneDeep);
-    }
-    if (obj !== null && typeof obj === 'object') {
-        // @ts-expect-error meh
-        return Object.keys(obj).reduce(function (cloned, k) {
-            // @ts-expect-error meh
-            cloned[k] = cloneDeep(obj[k]);
-            return cloned;
-        }, {});
-    }
-    return obj;
+	if (Array.isArray(obj)) {
+		// @ts-expect-error meh
+		return obj.map(cloneDeep);
+	}
+	if (obj !== null && typeof obj === "object") {
+		// @ts-expect-error meh
+		return Object.keys(obj).reduce((cloned, k) => {
+			// @ts-expect-error meh
+			cloned[k] = cloneDeep(obj[k]);
+			return cloned;
+		}, {});
+	}
+	return obj;
+}
+/**
+* Replace pound elements with number elements referencing the given variable.
+* This is needed when nesting plurals - the # in the outer plural should become
+* an explicit variable reference when nested inside another plural.
+* GH #4202
+*/
+function replacePoundWithArgument(ast, variableName) {
+	return ast.map((el) => {
+		if (isPoundElement(el)) {
+			// Replace # with {variableName, number}
+			return {
+				type: TYPE.number,
+				value: variableName,
+				style: null,
+				location: el.location
+			};
+		}
+		if (isPluralElement(el) || isSelectElement(el)) {
+			// Recursively process options
+			const newOptions = {};
+			for (const key of Object.keys(el.options)) {
+				newOptions[key] = { value: replacePoundWithArgument(el.options[key].value, variableName) };
+			}
+			return {
+				...el,
+				options: newOptions
+			};
+		}
+		if (isTagElement(el)) {
+			return {
+				...el,
+				children: replacePoundWithArgument(el.children, variableName)
+			};
+		}
+		return el;
+	});
 }
 function hoistPluralOrSelectElement(ast, el, positionToInject) {
-    // pull this out of the ast and move it to the top
-    var cloned = cloneDeep(el);
-    var options = cloned.options;
-    cloned.options = Object.keys(options).reduce(function (all, k) {
-        var newValue = hoistSelectors(__spreadArray(__spreadArray(__spreadArray([], ast.slice(0, positionToInject), true), options[k].value, true), ast.slice(positionToInject + 1), true));
-        all[k] = {
-            value: newValue,
-        };
-        return all;
-    }, {});
-    return cloned;
+	// pull this out of the ast and move it to the top
+	const cloned = cloneDeep(el);
+	const { options } = cloned;
+	// GH #4202: Check if there are other plural/select elements after this one
+	const afterElements = ast.slice(positionToInject + 1);
+	const hasSubsequentPluralOrSelect = afterElements.some(isPluralOrSelectElement);
+	cloned.options = Object.keys(options).reduce((all, k) => {
+		let optionValue = options[k].value;
+		// GH #4202: If there are subsequent plurals/selects and this is a plural,
+		// replace # with explicit variable reference to avoid ambiguity
+		if (hasSubsequentPluralOrSelect && isPluralElement(el)) {
+			optionValue = replacePoundWithArgument(optionValue, el.value);
+		}
+		const newValue = hoistSelectors([
+			...ast.slice(0, positionToInject),
+			...optionValue,
+			...afterElements
+		]);
+		all[k] = { value: newValue };
+		return all;
+	}, {});
+	return cloned;
 }
 function isPluralOrSelectElement(el) {
-    return isPluralElement(el) || isSelectElement(el);
+	return isPluralElement(el) || isSelectElement(el);
 }
 function findPluralOrSelectElement(ast) {
-    return !!ast.find(function (el) {
-        if (isPluralOrSelectElement(el)) {
-            return true;
-        }
-        if (isTagElement(el)) {
-            return findPluralOrSelectElement(el.children);
-        }
-        return false;
-    });
+	return !!ast.find((el) => {
+		if (isPluralOrSelectElement(el)) {
+			return true;
+		}
+		if (isTagElement(el)) {
+			return findPluralOrSelectElement(el.children);
+		}
+		return false;
+	});
 }
 /**
- * Hoist all selectors to the beginning of the AST & flatten the
- * resulting options. E.g:
- * "I have {count, plural, one{a dog} other{many dogs}}"
- * becomes "{count, plural, one{I have a dog} other{I have many dogs}}".
- * If there are multiple selectors, the order of which one is hoisted 1st
- * is non-deterministic.
- * The goal is to provide as many full sentences as possible since fragmented
- * sentences are not translator-friendly
- * @param ast AST
- */
+* Hoist all selectors to the beginning of the AST & flatten the
+* resulting options. E.g:
+* "I have {count, plural, one{a dog} other{many dogs}}"
+* becomes "{count, plural, one{I have a dog} other{I have many dogs}}".
+* If there are multiple selectors, the order of which one is hoisted 1st
+* is non-deterministic.
+* The goal is to provide as many full sentences as possible since fragmented
+* sentences are not translator-friendly
+* @param ast AST
+*/
 export function hoistSelectors(ast) {
-    for (var i = 0; i < ast.length; i++) {
-        var el = ast[i];
-        if (isPluralOrSelectElement(el)) {
-            return [hoistPluralOrSelectElement(ast, el, i)];
-        }
-        if (isTagElement(el) && findPluralOrSelectElement([el])) {
-            throw new Error('Cannot hoist plural/select within a tag element. Please put the tag element inside each plural/select option');
-        }
-    }
-    return ast;
+	for (let i = 0; i < ast.length; i++) {
+		const el = ast[i];
+		if (isPluralOrSelectElement(el)) {
+			return [hoistPluralOrSelectElement(ast, el, i)];
+		}
+		if (isTagElement(el) && findPluralOrSelectElement([el])) {
+			throw new Error("Cannot hoist plural/select within a tag element. Please put the tag element inside each plural/select option");
+		}
+	}
+	return ast;
 }
 /**
- * Collect all variables in an AST to Record<string, TYPE>
- * @param ast AST to collect variables from
- * @param vars Record of variable name to variable type
- */
-function collectVariables(ast, vars) {
-    if (vars === void 0) { vars = new Map(); }
-    ast.forEach(function (el) {
-        if (isArgumentElement(el) ||
-            isDateElement(el) ||
-            isTimeElement(el) ||
-            isNumberElement(el)) {
-            if (el.value in vars && vars.get(el.value) !== el.type) {
-                throw new Error("Variable ".concat(el.value, " has conflicting types"));
-            }
-            vars.set(el.value, el.type);
-        }
-        if (isPluralElement(el) || isSelectElement(el)) {
-            vars.set(el.value, el.type);
-            Object.keys(el.options).forEach(function (k) {
-                collectVariables(el.options[k].value, vars);
-            });
-        }
-        if (isTagElement(el)) {
-            vars.set(el.value, el.type);
-            collectVariables(el.children, vars);
-        }
-    });
+* Collect all variables in an AST to Record<string, TYPE>
+* @param ast AST to collect variables from
+* @param vars Record of variable name to variable type
+*/
+function collectVariables(ast, vars = new Map()) {
+	ast.forEach((el) => {
+		if (isArgumentElement(el) || isDateElement(el) || isTimeElement(el) || isNumberElement(el)) {
+			if (el.value in vars && vars.get(el.value) !== el.type) {
+				throw new Error(`Variable ${el.value} has conflicting types`);
+			}
+			vars.set(el.value, el.type);
+		}
+		if (isPluralElement(el) || isSelectElement(el)) {
+			vars.set(el.value, el.type);
+			Object.keys(el.options).forEach((k) => {
+				collectVariables(el.options[k].value, vars);
+			});
+		}
+		if (isTagElement(el)) {
+			vars.set(el.value, el.type);
+			collectVariables(el.children, vars);
+		}
+	});
 }
 /**
- * Check if 2 ASTs are structurally the same. This primarily means that
- * they have the same variables with the same type
- * @param a
- * @param b
- * @returns
- */
+* Check if 2 ASTs are structurally the same. This primarily means that
+* they have the same variables with the same type
+* @param a
+* @param b
+* @returns
+*/
 export function isStructurallySame(a, b) {
-    var aVars = new Map();
-    var bVars = new Map();
-    collectVariables(a, aVars);
-    collectVariables(b, bVars);
-    if (aVars.size !== bVars.size) {
-        return {
-            success: false,
-            error: new Error("Different number of variables: [".concat(Array.from(aVars.keys()).join(', '), "] vs [").concat(Array.from(bVars.keys()).join(', '), "]")),
-        };
-    }
-    return Array.from(aVars.entries()).reduce(function (result, _a) {
-        var key = _a[0], type = _a[1];
-        if (!result.success) {
-            return result;
-        }
-        var bType = bVars.get(key);
-        if (bType == null) {
-            return {
-                success: false,
-                error: new Error("Missing variable ".concat(key, " in message")),
-            };
-        }
-        if (bType !== type) {
-            return {
-                success: false,
-                error: new Error("Variable ".concat(key, " has conflicting types: ").concat(TYPE[type], " vs ").concat(TYPE[bType])),
-            };
-        }
-        return result;
-    }, { success: true });
+	const aVars = new Map();
+	const bVars = new Map();
+	collectVariables(a, aVars);
+	collectVariables(b, bVars);
+	if (aVars.size !== bVars.size) {
+		return {
+			success: false,
+			error: new Error(`Different number of variables: [${Array.from(aVars.keys()).join(", ")}] vs [${Array.from(bVars.keys()).join(", ")}]`)
+		};
+	}
+	return Array.from(aVars.entries()).reduce((result, [key, type]) => {
+		if (!result.success) {
+			return result;
+		}
+		const bType = bVars.get(key);
+		if (bType == null) {
+			return {
+				success: false,
+				error: new Error(`Missing variable ${key} in message`)
+			};
+		}
+		if (bType !== type) {
+			return {
+				success: false,
+				error: new Error(`Variable ${key} has conflicting types: ${TYPE[type]} vs ${TYPE[bType]}`)
+			};
+		}
+		return result;
+	}, { success: true });
 }

package/no-parser.d.ts

@@ -1,4 +1,4 @@
 export declare function parse(): void;
-export * from './types.js';
+export * from "./types.js";
 export declare const _Parser: undefined;
-export { isStructurallySame } from './manipulator.js';
+export { isStructurallySame } from "./manipulator.js";

package/no-parser.js

@@ -1,6 +1,6 @@
 export function parse() {
-    throw new Error("You're trying to format an uncompiled message with react-intl without parser, please import from 'react-intl' instead");
+	throw new Error("You're trying to format an uncompiled message with react-intl without parser, please import from 'react-intl' instead");
 }
-export * from './types.js';
-export var _Parser = undefined;
-export { isStructurallySame } from './manipulator.js';
+export * from "./types.js";
+export const _Parser = undefined;
+export { isStructurallySame } from "./manipulator.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formatjs/icu-messageformat-parser",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "license": "MIT",
   "type": "module",
   "types": "index.d.ts",
@@ -12,8 +12,8 @@
   },
   "dependencies": {
     "tslib": "^2.8.0",
-    "@formatjs/ecma402-abstract": "3.0.6",
-    "@formatjs/icu-skeleton-parser": "2.0.6"
+    "@formatjs/ecma402-abstract": "3.0.8",
+    "@formatjs/icu-skeleton-parser": "2.0.8"
   },
   "repository": {
     "type": "git",

package/parser.d.ts

@@ -1,147 +1,150 @@
-import { ParserError } from './error.js';
-import { MessageFormatElement } from './types.js';
+import { type ParserError } from "./error.js";
+import { type MessageFormatElement } from "./types.js";
 export interface Position {
-    /** Offset in terms of UTF-16 *code unit*. */
-    offset: number;
-    line: number;
-    /** Column offset in terms of unicode *code point*. */
-    column: number;
+	/** Offset in terms of UTF-16 *code unit*. */
+	offset: number;
+	line: number;
+	/** Column offset in terms of unicode *code point*. */
+	column: number;
 }
 export interface ParserOptions {
-    /**
-     * Whether to treat HTML/XML tags as string literal
-     * instead of parsing them as tag token.
-     * When this is false we only allow simple tags without
-     * any attributes
-     */
-    ignoreTag?: boolean;
-    /**
-     * Should `select`, `selectordinal`, and `plural` arguments always include
-     * the `other` case clause.
-     */
-    requiresOtherClause?: boolean;
-    /**
-     * Whether to parse number/datetime skeleton
-     * into Intl.NumberFormatOptions and Intl.DateTimeFormatOptions, respectively.
-     */
-    shouldParseSkeletons?: boolean;
-    /**
-     * Capture location info in AST
-     * Default is false
-     */
-    captureLocation?: boolean;
-    /**
-     * Instance of Intl.Locale to resolve locale-dependent skeleton
-     */
-    locale?: Intl.Locale;
+	/**
+	* Whether to treat HTML/XML tags as string literal
+	* instead of parsing them as tag token.
+	* When this is false we only allow simple tags without
+	* any attributes
+	*/
+	ignoreTag?: boolean;
+	/**
+	* Should `select`, `selectordinal`, and `plural` arguments always include
+	* the `other` case clause.
+	*/
+	requiresOtherClause?: boolean;
+	/**
+	* Whether to parse number/datetime skeleton
+	* into Intl.NumberFormatOptions and Intl.DateTimeFormatOptions, respectively.
+	*/
+	shouldParseSkeletons?: boolean;
+	/**
+	* Capture location info in AST
+	* Default is false
+	*/
+	captureLocation?: boolean;
+	/**
+	* Instance of Intl.Locale to resolve locale-dependent skeleton
+	*/
+	locale?: Intl.Locale;
 }
-export type Result<T, E> = {
-    val: T;
-    err: null;
+export type Result<
+	T,
+	E
+> = {
+	val: T;
+	err: null;
 } | {
-    val: null;
-    err: E;
+	val: null;
+	err: E;
 };
 export declare class Parser {
-    private message;
-    private position;
-    private locale?;
-    private ignoreTag;
-    private requiresOtherClause;
-    private shouldParseSkeletons?;
-    constructor(message: string, options?: ParserOptions);
-    parse(): Result<MessageFormatElement[], ParserError>;
-    private parseMessage;
-    /**
-     * A tag name must start with an ASCII lower/upper case letter. The grammar is based on the
-     * [custom element name][] except that a dash is NOT always mandatory and uppercase letters
-     * are accepted:
-     *
-     * ```
-     * tag ::= "<" tagName (whitespace)* "/>" | "<" tagName (whitespace)* ">" message "</" tagName (whitespace)* ">"
-     * tagName ::= [a-z] (PENChar)*
-     * PENChar ::=
-     *     "-" | "." | [0-9] | "_" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |
-     *     [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |
-     *     [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
-     * ```
-     *
-     * [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
-     * NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do
-     * since other tag-based engines like React allow it
-     */
-    private parseTag;
-    /**
-     * This method assumes that the caller has peeked ahead for the first tag character.
-     */
-    private parseTagName;
-    private parseLiteral;
-    tryParseLeftAngleBracket(): string | null;
-    /**
-     * Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes
-     * a character that requires quoting (that is, "only where needed"), and works the same in
-     * nested messages as on the top level of the pattern. The new behavior is otherwise compatible.
-     */
-    private tryParseQuote;
-    private tryParseUnquoted;
-    private parseArgument;
-    /**
-     * Advance the parser until the end of the identifier, if it is currently on
-     * an identifier character. Return an empty string otherwise.
-     */
-    private parseIdentifierIfPossible;
-    private parseArgumentOptions;
-    private tryParseArgumentClose;
-    /**
-     * See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659
-     */
-    private parseSimpleArgStyleIfPossible;
-    private parseNumberSkeletonFromString;
-    /**
-     * @param nesting_level The current nesting level of messages.
-     *     This can be positive when parsing message fragment in select or plural argument options.
-     * @param parent_arg_type The parent argument's type.
-     * @param parsed_first_identifier If provided, this is the first identifier-like selector of
-     *     the argument. It is a by-product of a previous parsing attempt.
-     * @param expecting_close_tag If true, this message is directly or indirectly nested inside
-     *     between a pair of opening and closing tags. The nested message will not parse beyond
-     *     the closing tag boundary.
-     */
-    private tryParsePluralOrSelectOptions;
-    private tryParseDecimalInteger;
-    private offset;
-    private isEOF;
-    private clonePosition;
-    /**
-     * Return the code point at the current position of the parser.
-     * Throws if the index is out of bound.
-     */
-    private char;
-    private error;
-    /** Bump the parser to the next UTF-16 code unit. */
-    private bump;
-    /**
-     * If the substring starting at the current position of the parser has
-     * the given prefix, then bump the parser to the character immediately
-     * following the prefix and return true. Otherwise, don't bump the parser
-     * and return false.
-     */
-    private bumpIf;
-    /**
-     * Bump the parser until the pattern character is found and return `true`.
-     * Otherwise bump to the end of the file and return `false`.
-     */
-    private bumpUntil;
-    /**
-     * Bump the parser to the target offset.
-     * If target offset is beyond the end of the input, bump the parser to the end of the input.
-     */
-    private bumpTo;
-    /** advance the parser through all whitespace to the next non-whitespace code unit. */
-    private bumpSpace;
-    /**
-     * Peek at the *next* Unicode codepoint in the input without advancing the parser.
-     * If the input has been exhausted, then this returns null.
-     */
-    private peek;
+	private message;
+	private position;
+	private locale?;
+	private ignoreTag;
+	private requiresOtherClause;
+	private shouldParseSkeletons?;
+	constructor(message: string, options?: ParserOptions);
+	parse(): Result<MessageFormatElement[], ParserError>;
+	private parseMessage;
+	/**
+	* A tag name must start with an ASCII lower/upper case letter. The grammar is based on the
+	* [custom element name][] except that a dash is NOT always mandatory and uppercase letters
+	* are accepted:
+	*
+	* ```
+	* tag ::= "<" tagName (whitespace)* "/>" | "<" tagName (whitespace)* ">" message "</" tagName (whitespace)* ">"
+	* tagName ::= [a-z] (PENChar)*
+	* PENChar ::=
+	*     "-" | "." | [0-9] | "_" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |
+	*     [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |
+	*     [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
+	* ```
+	*
+	* [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
+	* NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do
+	* since other tag-based engines like React allow it
+	*/
+	private parseTag;
+	/**
+	* This method assumes that the caller has peeked ahead for the first tag character.
+	*/
+	private parseTagName;
+	private parseLiteral;
+	tryParseLeftAngleBracket(): string | null;
+	/**
+	* Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes
+	* a character that requires quoting (that is, "only where needed"), and works the same in
+	* nested messages as on the top level of the pattern. The new behavior is otherwise compatible.
+	*/
+	private tryParseQuote;
+	private tryParseUnquoted;
+	private parseArgument;
+	/**
+	* Advance the parser until the end of the identifier, if it is currently on
+	* an identifier character. Return an empty string otherwise.
+	*/
+	private parseIdentifierIfPossible;
+	private parseArgumentOptions;
+	private tryParseArgumentClose;
+	/**
+	* See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659
+	*/
+	private parseSimpleArgStyleIfPossible;
+	private parseNumberSkeletonFromString;
+	/**
+	* @param nesting_level The current nesting level of messages.
+	*     This can be positive when parsing message fragment in select or plural argument options.
+	* @param parent_arg_type The parent argument's type.
+	* @param parsed_first_identifier If provided, this is the first identifier-like selector of
+	*     the argument. It is a by-product of a previous parsing attempt.
+	* @param expecting_close_tag If true, this message is directly or indirectly nested inside
+	*     between a pair of opening and closing tags. The nested message will not parse beyond
+	*     the closing tag boundary.
+	*/
+	private tryParsePluralOrSelectOptions;
+	private tryParseDecimalInteger;
+	private offset;
+	private isEOF;
+	private clonePosition;
+	/**
+	* Return the code point at the current position of the parser.
+	* Throws if the index is out of bound.
+	*/
+	private char;
+	private error;
+	/** Bump the parser to the next UTF-16 code unit. */
+	private bump;
+	/**
+	* If the substring starting at the current position of the parser has
+	* the given prefix, then bump the parser to the character immediately
+	* following the prefix and return true. Otherwise, don't bump the parser
+	* and return false.
+	*/
+	private bumpIf;
+	/**
+	* Bump the parser until the pattern character is found and return `true`.
+	* Otherwise bump to the end of the file and return `false`.
+	*/
+	private bumpUntil;
+	/**
+	* Bump the parser to the target offset.
+	* If target offset is beyond the end of the input, bump the parser to the end of the input.
+	*/
+	private bumpTo;
+	/** advance the parser through all whitespace to the next non-whitespace code unit. */
+	private bumpSpace;
+	/**
+	* Peek at the *next* Unicode codepoint in the input without advancing the parser.
+	* If the input has been exhausted, then this returns null.
+	*/
+	private peek;
 }