@formatjs/intl-pluralrules 6.3.1 → 6.3.3

package/abstract/InitializePluralRules.js

@@ -1,31 +0,0 @@
-import { CanonicalizeLocaleList, CoerceOptionsToObject, GetOption, SetNumberFormatDigitOptions } from "@formatjs/ecma402-abstract";
-import { ResolveLocale } from "@formatjs/intl-localematcher";
-export function InitializePluralRules(pl, locales, options, { availableLocales, relevantExtensionKeys, localeData, getDefaultLocale, getInternalSlots }) {
-	const requestedLocales = CanonicalizeLocaleList(locales);
-	const opt = Object.create(null);
-	const opts = CoerceOptionsToObject(options);
-	const internalSlots = getInternalSlots(pl);
-	internalSlots.initializedPluralRules = true;
-	const matcher = GetOption(opts, "localeMatcher", "string", ["best fit", "lookup"], "best fit");
-	opt.localeMatcher = matcher;
-	const r = ResolveLocale(availableLocales, requestedLocales, opt, relevantExtensionKeys, localeData, getDefaultLocale);
-	internalSlots.locale = r.locale;
-	// ECMA-402 Spec: type option ('cardinal' or 'ordinal')
-	internalSlots.type = GetOption(opts, "type", "string", ["cardinal", "ordinal"], "cardinal");
-	// Extension: notation options for compact notation support
-	// Not in ECMA-402 spec, but mirrors Intl.NumberFormat notation option
-	// Enables proper plural selection for compact numbers (e.g., "1.2M")
-	const notation = GetOption(opts, "notation", "string", ["standard", "compact"], "standard");
-	internalSlots.notation = notation;
-	if (notation === "compact") {
-		// Extension: compactDisplay option (mirrors Intl.NumberFormat)
-		internalSlots.compactDisplay = GetOption(opts, "compactDisplay", "string", ["short", "long"], "short");
-		// Implementation: Load NumberFormat locale data if available (soft dependency)
-		// This is needed to calculate compact exponents using ComputeExponentForMagnitude
-		if (typeof Intl !== "undefined" && Intl.NumberFormat && Intl.NumberFormat.localeData) {
-			internalSlots.dataLocaleData = Intl.NumberFormat.localeData[r.locale];
-		}
-	}
-	SetNumberFormatDigitOptions(internalSlots, opts, 0, 3, "standard");
-	return pl;
-}

package/abstract/ResolvePlural.d.ts

@@ -1,43 +0,0 @@
-import { type LDMLPluralRule, type PluralRulesInternal } from "@formatjs/ecma402-abstract";
-import Decimal from "@formatjs/bigdecimal";
-import { type OperandsRecord } from "./GetOperands.js";
-/**
-* Result of ResolvePluralInternal containing both the formatted string and plural category.
-* This corresponds to a Record with [[FormattedString]] and [[PluralCategory]] fields
-* as described in the ECMA-402 spec for ResolvePluralRange.
-*/
-export interface ResolvePluralResult {
-	/** The formatted representation of the number */
-	formattedString: string;
-	/** The LDML plural category (zero, one, two, few, many, or other) */
-	pluralCategory: LDMLPluralRule;
-}
-/**
-* ResolvePluralInternal ( pluralRules, n )
-*
-* Internal version of ResolvePlural that returns both the formatted string and plural category.
-* This is needed for selectRange, which must compare formatted strings to determine if the
-* start and end values are identical.
-*
-* The formatted string is obtained by applying the number formatting options (digit options)
-* from the PluralRules object to the input number. This ensures that formatting-sensitive
-* plural rules work correctly (e.g., rules that depend on visible fraction digits).
-*
-* @param pl - An initialized PluralRules object
-* @param n - Mathematical value to resolve
-* @returns Record containing the formatted string and plural category
-*/
-export declare function ResolvePluralInternal(pl: Intl.PluralRules, n: Decimal, { getInternalSlots, PluralRuleSelect }: {
-	getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal;
-	PluralRuleSelect: (locale: string, type: "cardinal" | "ordinal", n: Decimal, operands: OperandsRecord) => LDMLPluralRule;
-}): ResolvePluralResult;
-/**
-* http://ecma-international.org/ecma-402/7.0/index.html#sec-resolveplural
-* @param pl
-* @param n
-* @param PluralRuleSelect Has to pass in bc it's implementation-specific
-*/
-export declare function ResolvePlural(pl: Intl.PluralRules, n: Decimal, { getInternalSlots, PluralRuleSelect }: {
-	getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal;
-	PluralRuleSelect: (locale: string, type: "cardinal" | "ordinal", n: Decimal, operands: OperandsRecord) => LDMLPluralRule;
-}): LDMLPluralRule;

package/abstract/ResolvePlural.js

@@ -1,75 +0,0 @@
-import { ComputeExponentForMagnitude, FormatNumericToString, invariant, Type } from "@formatjs/ecma402-abstract";
-import Decimal from "@formatjs/bigdecimal";
-import { GetOperands } from "./GetOperands.js";
-/**
-* ResolvePluralInternal ( pluralRules, n )
-*
-* Internal version of ResolvePlural that returns both the formatted string and plural category.
-* This is needed for selectRange, which must compare formatted strings to determine if the
-* start and end values are identical.
-*
-* The formatted string is obtained by applying the number formatting options (digit options)
-* from the PluralRules object to the input number. This ensures that formatting-sensitive
-* plural rules work correctly (e.g., rules that depend on visible fraction digits).
-*
-* @param pl - An initialized PluralRules object
-* @param n - Mathematical value to resolve
-* @returns Record containing the formatted string and plural category
-*/
-export function ResolvePluralInternal(pl, n, { getInternalSlots, PluralRuleSelect }) {
-	const internalSlots = getInternalSlots(pl);
-	invariant(Type(internalSlots) === "Object", "pl has to be an object");
-	invariant("initializedPluralRules" in internalSlots, "pluralrules must be initialized");
-	// Handle non-finite values (Infinity, -Infinity, NaN)
-	if (!n.isFinite()) {
-		return {
-			formattedString: String(n),
-			pluralCategory: "other"
-		};
-	}
-	const { locale, type, notation } = internalSlots;
-	// ECMA-402 Spec: Format the number according to digit options
-	const res = FormatNumericToString(internalSlots, n);
-	const s = res.formattedString;
-	// Extension: Calculate compact exponent if using compact notation
-	// This enables CLDR c/e operands for proper plural selection with compact numbers
-	let exponent = 0;
-	if (notation === "compact" && !n.isZero()) {
-		// Implementation: Only calculate exponent if NumberFormat locale data is available (soft dependency)
-		if (internalSlots.dataLocaleData?.numbers) {
-			try {
-				// Calculate magnitude (floor of log10 of absolute value)
-				const magnitudeNum = Math.floor(Math.log10(Math.abs(n.toNumber())));
-				const magnitude = new Decimal(magnitudeNum);
-				// Use ComputeExponentForMagnitude from ecma402-abstract
-				// This determines which compact notation pattern to use (K, M, B, etc.)
-				// Cast to any since it expects NumberFormatInternal
-				exponent = ComputeExponentForMagnitude(internalSlots, magnitude);
-			} catch {
-				// Gracefully fall back to 0 if exponent calculation fails
-				exponent = 0;
-			}
-		}
-	}
-	// ECMA-402 Spec: Extract CLDR operands from the formatted string
-	// Extension: Pass exponent for c/e operands
-	const operands = GetOperands(s, exponent);
-	// ECMA-402 Spec: Select the appropriate plural category using the locale's plural rules
-	const pluralCategory = PluralRuleSelect(locale, type, n, operands);
-	return {
-		formattedString: s,
-		pluralCategory
-	};
-}
-/**
-* http://ecma-international.org/ecma-402/7.0/index.html#sec-resolveplural
-* @param pl
-* @param n
-* @param PluralRuleSelect Has to pass in bc it's implementation-specific
-*/
-export function ResolvePlural(pl, n, { getInternalSlots, PluralRuleSelect }) {
-	return ResolvePluralInternal(pl, n, {
-		getInternalSlots,
-		PluralRuleSelect
-	}).pluralCategory;
-}

package/abstract/ResolvePluralRange.d.ts

@@ -1,23 +0,0 @@
-import { type LDMLPluralRule, type PluralRulesInternal } from "@formatjs/ecma402-abstract";
-import type Decimal from "@formatjs/bigdecimal";
-import { type OperandsRecord } from "./GetOperands.js";
-/**
-* ResolvePluralRange ( pluralRules, x, y )
-*
-* The ResolvePluralRange abstract operation is called with arguments pluralRules (which must be
-* an object initialized as a PluralRules), x (a mathematical value), and y (a mathematical value).
-* It resolves the appropriate plural form for a range by determining the plural forms of both the
-* start and end values, then consulting locale-specific range data.
-*
-* Specification: https://tc39.es/ecma402/#sec-resolvepluralrange
-*
-* @param pluralRules - An initialized PluralRules object
-* @param x - Mathematical value for the range start
-* @param y - Mathematical value for the range end
-* @returns The plural category for the range (zero, one, two, few, many, or other)
-*/
-export declare function ResolvePluralRange(pluralRules: Intl.PluralRules, x: Decimal, y: Decimal, { getInternalSlots, PluralRuleSelect, PluralRuleSelectRange }: {
-	getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal;
-	PluralRuleSelect: (locale: string, type: "cardinal" | "ordinal", n: Decimal, operands: OperandsRecord) => LDMLPluralRule;
-	PluralRuleSelectRange: (locale: string, type: "cardinal" | "ordinal", xp: LDMLPluralRule, yp: LDMLPluralRule) => LDMLPluralRule;
-}): LDMLPluralRule;

package/abstract/ResolvePluralRange.js

@@ -1,59 +0,0 @@
-import { invariant, Type } from "@formatjs/ecma402-abstract";
-import "./GetOperands.js";
-import { ResolvePluralInternal } from "./ResolvePlural.js";
-/**
-* ResolvePluralRange ( pluralRules, x, y )
-*
-* The ResolvePluralRange abstract operation is called with arguments pluralRules (which must be
-* an object initialized as a PluralRules), x (a mathematical value), and y (a mathematical value).
-* It resolves the appropriate plural form for a range by determining the plural forms of both the
-* start and end values, then consulting locale-specific range data.
-*
-* Specification: https://tc39.es/ecma402/#sec-resolvepluralrange
-*
-* @param pluralRules - An initialized PluralRules object
-* @param x - Mathematical value for the range start
-* @param y - Mathematical value for the range end
-* @returns The plural category for the range (zero, one, two, few, many, or other)
-*/
-export function ResolvePluralRange(pluralRules, x, y, { getInternalSlots, PluralRuleSelect, PluralRuleSelectRange }) {
-	// 1. If x is not-a-number or y is not-a-number, throw a RangeError exception.
-	if (!x.isFinite() || !y.isFinite()) {
-		throw new RangeError("selectRange requires start and end values to be finite numbers");
-	}
-	// Validation: Assert that pluralRules has been initialized
-	const internalSlots = getInternalSlots(pluralRules);
-	invariant(Type(internalSlots) === "Object", "pluralRules has to be an object");
-	invariant("initializedPluralRules" in internalSlots, "pluralrules must be initialized");
-	// 2. Let xp be ResolvePlural(pluralRules, x).
-	// Note: ResolvePlural returns a Record with [[FormattedString]] and [[PluralCategory]]
-	const xp = ResolvePluralInternal(pluralRules, x, {
-		getInternalSlots,
-		PluralRuleSelect
-	});
-	// 3. Let yp be ResolvePlural(pluralRules, y).
-	const yp = ResolvePluralInternal(pluralRules, y, {
-		getInternalSlots,
-		PluralRuleSelect
-	});
-	// 4. If xp.[[FormattedString]] is yp.[[FormattedString]], then
-	//    a. Return xp.[[PluralCategory]].
-	// Note: When the formatted strings are identical (e.g., "1" and "1"), the values are
-	// effectively the same, so we return the plural category of the start value.
-	if (xp.formattedString === yp.formattedString) {
-		return xp.pluralCategory;
-	}
-	// 5. Let locale be pluralRules.[[Locale]].
-	// 6. Let type be pluralRules.[[Type]].
-	const { locale, type } = internalSlots;
-	// 7. Let notation be pluralRules.[[Notation]].
-	// 8. Let compactDisplay be pluralRules.[[CompactDisplay]].
-	// Note: notation and compactDisplay are not yet implemented for PluralRules polyfill.
-	// When implemented, these would affect how the range is formatted and thus which
-	// plural rules apply (see c/e operand support).
-	// 9. Return PluralRuleSelectRange(locale, type, notation, compactDisplay, xp.[[PluralCategory]], yp.[[PluralCategory]]).
-	// Note: PluralRuleSelectRange is implementation-defined and uses CLDR plural range data
-	// to determine the appropriate plural category for a range based on the start and end categories.
-	// Example: In English, "one" to "other" → "other" (e.g., "1-2 items")
-	return PluralRuleSelectRange(locale, type, xp.pluralCategory, yp.pluralCategory);
-}

package/get_internal_slots.d.ts

@@ -1,3 +0,0 @@
-import type { PluralRules } from "./index.js";
-import { type PluralRulesInternal } from "./index.js";
-export default function getInternalSlots(x: PluralRules): PluralRulesInternal;

package/get_internal_slots.js

@@ -1,10 +0,0 @@
-import "./index.js";
-const internalSlotMap = new WeakMap();
-export default function getInternalSlots(x) {
-	let internalSlots = internalSlotMap.get(x);
-	if (!internalSlots) {
-		internalSlots = Object.create(null);
-		internalSlotMap.set(x, internalSlots);
-	}
-	return internalSlots;
-}

package/supported-locales.generated.d.ts

@@ -1 +0,0 @@
-export declare const supportedLocales: string[];

package/supported-locales.generated.js

@@ -1,217 +0,0 @@
-export const supportedLocales = [
-	"af",
-	"ak",
-	"am",
-	"an",
-	"ar",
-	"ars",
-	"as",
-	"asa",
-	"ast",
-	"az",
-	"bal",
-	"be",
-	"bem",
-	"bez",
-	"bg",
-	"bho",
-	"bm",
-	"bn",
-	"bo",
-	"br",
-	"brx",
-	"bs",
-	"ca",
-	"ce",
-	"ceb",
-	"cgg",
-	"chr",
-	"ckb",
-	"cs",
-	"cy",
-	"da",
-	"de",
-	"doi",
-	"dsb",
-	"dv",
-	"dz",
-	"ee",
-	"el",
-	"en",
-	"eo",
-	"es",
-	"et",
-	"eu",
-	"fa",
-	"ff",
-	"fi",
-	"fil",
-	"fo",
-	"fr",
-	"fur",
-	"fy",
-	"ga",
-	"gd",
-	"gl",
-	"gsw",
-	"gu",
-	"guw",
-	"gv",
-	"ha",
-	"haw",
-	"he",
-	"hi",
-	"hnj",
-	"hr",
-	"hsb",
-	"hu",
-	"hy",
-	"ia",
-	"id",
-	"ig",
-	"ii",
-	"io",
-	"is",
-	"it",
-	"iu",
-	"ja",
-	"jbo",
-	"jgo",
-	"jmc",
-	"jv",
-	"jw",
-	"ka",
-	"kab",
-	"kaj",
-	"kcg",
-	"kde",
-	"kea",
-	"kk",
-	"kkj",
-	"kl",
-	"km",
-	"kn",
-	"ko",
-	"ks",
-	"ksb",
-	"ksh",
-	"ku",
-	"kw",
-	"ky",
-	"lag",
-	"lb",
-	"lg",
-	"lij",
-	"lkt",
-	"ln",
-	"lo",
-	"lt",
-	"lv",
-	"mas",
-	"mg",
-	"mgo",
-	"mk",
-	"ml",
-	"mn",
-	"mo",
-	"mr",
-	"ms",
-	"mt",
-	"my",
-	"nah",
-	"naq",
-	"nb",
-	"nd",
-	"ne",
-	"nl",
-	"nn",
-	"nnh",
-	"no",
-	"nqo",
-	"nr",
-	"nso",
-	"ny",
-	"nyn",
-	"om",
-	"or",
-	"os",
-	"osa",
-	"pa",
-	"pap",
-	"pcm",
-	"pl",
-	"prg",
-	"ps",
-	"pt",
-	"pt-PT",
-	"rm",
-	"ro",
-	"rof",
-	"ru",
-	"rwk",
-	"sah",
-	"saq",
-	"sat",
-	"sc",
-	"scn",
-	"sd",
-	"sdh",
-	"se",
-	"seh",
-	"ses",
-	"sg",
-	"sh",
-	"shi",
-	"si",
-	"sk",
-	"sl",
-	"sma",
-	"smi",
-	"smj",
-	"smn",
-	"sms",
-	"sn",
-	"so",
-	"sq",
-	"sr",
-	"ss",
-	"ssy",
-	"st",
-	"su",
-	"sv",
-	"sw",
-	"syr",
-	"ta",
-	"te",
-	"teo",
-	"th",
-	"ti",
-	"tig",
-	"tk",
-	"tl",
-	"tn",
-	"to",
-	"tpi",
-	"tr",
-	"ts",
-	"tzm",
-	"ug",
-	"uk",
-	"und",
-	"ur",
-	"uz",
-	"ve",
-	"vi",
-	"vo",
-	"vun",
-	"wa",
-	"wae",
-	"wo",
-	"xh",
-	"xog",
-	"yi",
-	"yo",
-	"yue",
-	"zh",
-	"zu"
-];