eslint-plugin-formatjs 6.4.4 → 6.4.6

package/emoji-utils.d.ts

@@ -1,43 +0,0 @@
-/**
-* Emoji detection utilities using Intl.Segmenter
-*/
-import { type EmojiVersion } from "./emoji-data.generated.js";
-export type { EmojiVersion } from "./emoji-data.generated.js";
-/**
-* Check if a string contains any emoji
-* Uses Unicode 17.0.0 Emoji_Presentation data and variation selector (U+FE0F)
-* to properly detect emoji while avoiding false positives from characters like
-* #, *, digits 0-9, and text symbols like © which have \p{Emoji} but are not visual emoji
-*/
-export declare function hasEmoji(text: string): boolean;
-/**
-* Extract all emoji from a string using Intl.Segmenter
-* Returns an array of emoji characters (including multi-codepoint sequences)
-*
-* Uses grapheme segmentation to properly handle:
-* - Emoji with skin tone modifiers (🙋🏻)
-* - ZWJ sequences (👨‍👩‍👧‍👦)
-* - Flag sequences (🇺🇸)
-* - Regional indicator sequences
-* - Any other complex emoji grapheme clusters
-*/
-export declare function extractEmojis(text: string): string[];
-/**
-* Check if a version string is a valid emoji version
-*/
-export declare function isValidEmojiVersion(version: string): boolean;
-/**
-* Get the Unicode version for a given emoji character
-* Returns undefined if the emoji is not found in our data
-*/
-export declare function getEmojiVersion(emoji: string): EmojiVersion | undefined;
-/**
-* Filter function for emoji versions
-* Returns a filter function that checks if an emoji is from version or below
-*/
-export declare function filterEmojis(version: EmojiVersion): (emoji: string) => boolean;
-/**
-* Get all emoji that match the filter
-* Generates emoji from codepoint ranges and filters them
-*/
-export declare function getAllEmojis(filter: (emoji: string) => boolean): string[];

package/emoji-utils.js

@@ -1,145 +0,0 @@
-/**
-* Emoji detection utilities using Intl.Segmenter
-*/
-import { EMOJI_VERSIONS, EMOJI_RANGES } from "./emoji-data.generated.js";
-import * as emojiPresentationRegex from "@unicode/unicode-17.0.0/Binary_Property/Emoji_Presentation/regex.js";
-import * as emojiPropertyRegex from "@unicode/unicode-17.0.0/Binary_Property/Emoji/regex.js";
-/**
-* Cached Intl.Segmenter instance for emoji extraction
-* Reused across all extractEmojis calls for better performance
-*/
-const graphemeSegmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
-/**
-* Regex for detecting emoji using Unicode 17.0.0 Emoji_Presentation data
-* Generated from @unicode/unicode-17.0.0/Binary_Property/Emoji_Presentation
-* This avoids false positives from #, *, digits, and text symbols like ©
-*/
-const emojiPresentationRegexCompiled = emojiPresentationRegex.default ?? emojiPresentationRegex;
-/**
-* Regex for detecting emoji-capable characters using Unicode 17.0.0 Emoji property
-* This includes characters that can have emoji presentation (like ❤, ☀)
-*/
-const emojiPropertyRegexCompiled = emojiPropertyRegex.default ?? emojiPropertyRegex;
-/**
-* Check if a string contains any emoji
-* Uses Unicode 17.0.0 Emoji_Presentation data and variation selector (U+FE0F)
-* to properly detect emoji while avoiding false positives from characters like
-* #, *, digits 0-9, and text symbols like © which have \p{Emoji} but are not visual emoji
-*/
-export function hasEmoji(text) {
-	// First check for Emoji_Presentation characters (always displayed as emoji)
-	if (emojiPresentationRegexCompiled.test(text)) {
-		return true;
-	}
-	// Check for variation selector (U+FE0F) which indicates emoji presentation
-	// But only if it follows an emoji-capable character to avoid false positives
-	// like "Hello\uFE0F" or "A\uFE0F"
-	if (text.includes("️")) {
-		const segments = graphemeSegmenter.segment(text);
-		for (const { segment } of segments) {
-			if (segment.includes("️")) {
-				// Has VS, check if the character before it has the Emoji property
-				const beforeVS = segment.replace(/\uFE0F/g, "");
-				if (emojiPropertyRegexCompiled.test(beforeVS)) {
-					return true;
-				}
-			}
-		}
-	}
-	return false;
-}
-/**
-* Extract all emoji from a string using Intl.Segmenter
-* Returns an array of emoji characters (including multi-codepoint sequences)
-*
-* Uses grapheme segmentation to properly handle:
-* - Emoji with skin tone modifiers (🙋🏻)
-* - ZWJ sequences (👨‍👩‍👧‍👦)
-* - Flag sequences (🇺🇸)
-* - Regional indicator sequences
-* - Any other complex emoji grapheme clusters
-*/
-export function extractEmojis(text) {
-	const segments = graphemeSegmenter.segment(text);
-	const emojis = [];
-	for (const { segment } of segments) {
-		// Check if this grapheme cluster contains emoji
-		// First check for Emoji_Presentation (always displayed as emoji)
-		if (emojiPresentationRegexCompiled.test(segment)) {
-			emojis.push(segment);
-			continue;
-		}
-		// Check for variation selector (U+FE0F) which indicates emoji presentation
-		// But only if it follows an emoji-capable character to avoid false positives
-		if (segment.includes("️")) {
-			const beforeVS = segment.replace(/\uFE0F/g, "");
-			if (emojiPropertyRegexCompiled.test(beforeVS)) {
-				emojis.push(segment);
-			}
-		}
-	}
-	return emojis;
-}
-/**
-* Check if a version string is a valid emoji version
-*/
-export function isValidEmojiVersion(version) {
-	return EMOJI_VERSIONS.includes(version);
-}
-/**
-* Get the Unicode version for a given emoji character
-* Returns undefined if the emoji is not found in our data
-*/
-export function getEmojiVersion(emoji) {
-	// Get the first codepoint from the emoji
-	const codepoint = emoji.codePointAt(0);
-	if (codepoint === undefined) {
-		return undefined;
-	}
-	// Check which range this codepoint falls into
-	for (const range of EMOJI_RANGES) {
-		if (codepoint >= range.start && codepoint <= range.end) {
-			return range.version;
-		}
-	}
-	return undefined;
-}
-/**
-* Filter function for emoji versions
-* Returns a filter function that checks if an emoji is from version or below
-*/
-export function filterEmojis(version) {
-	const maxVersion = parseVersion(version);
-	return (emoji) => {
-		const emojiVersion = getEmojiVersion(emoji);
-		if (!emojiVersion) {
-			// If we don't have version data, assume it's an older emoji
-			// This is a conservative approach for unknown emoji
-			return true;
-		}
-		return parseVersion(emojiVersion) <= maxVersion;
-	};
-}
-/**
-* Get all emoji that match the filter
-* Generates emoji from codepoint ranges and filters them
-*/
-export function getAllEmojis(filter) {
-	const emojis = [];
-	for (const range of EMOJI_RANGES) {
-		for (let codepoint = range.start; codepoint <= range.end; codepoint++) {
-			const emoji = String.fromCodePoint(codepoint);
-			if (filter(emoji)) {
-				emojis.push(emoji);
-			}
-		}
-	}
-	return emojis;
-}
-/**
-* Parse version string to comparable number
-* e.g., "12.0" -> 12.0, "13.1" -> 13.1
-*/
-function parseVersion(version) {
-	return parseFloat(version);
-}

package/messages.d.ts

@@ -1,2 +0,0 @@
-export type CoreMessageIds = "parseError";
-export declare const CORE_MESSAGES: Record<CoreMessageIds, string>;

package/messages.js

@@ -1 +0,0 @@
-export const CORE_MESSAGES = { parseError: `Failed to parse message string {{error}}` };

package/rules/blocklist-elements.d.ts

@@ -1,14 +0,0 @@
-import type { Rule } from "eslint";
-export declare const name = "blocklist-elements";
-export declare enum Element {
-	literal = "literal",
-	argument = "argument",
-	number = "number",
-	date = "date",
-	time = "time",
-	select = "select",
-	selectordinal = "selectordinal",
-	plural = "plural",
-	tag = "tag"
-}
-export declare const rule: Rule.RuleModule;

package/rules/blocklist-elements.js

@@ -1,129 +0,0 @@
-import { isArgumentElement, isDateElement, isLiteralElement, isNumberElement, isPluralElement, isSelectElement, isTagElement, isTimeElement, parse } from "@formatjs/icu-messageformat-parser";
-import { extractMessages, getSettings } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-export const name = "blocklist-elements";
-function getMessage(type) {
-	return {
-		messageId: "blocklist",
-		data: { type }
-	};
-}
-export let Element = /* @__PURE__ */ function(Element) {
-	Element["literal"] = "literal";
-	Element["argument"] = "argument";
-	Element["number"] = "number";
-	Element["date"] = "date";
-	Element["time"] = "time";
-	Element["select"] = "select";
-	Element["selectordinal"] = "selectordinal";
-	Element["plural"] = "plural";
-	Element["tag"] = "tag";
-	return Element;
-}({});
-function verifyAst(blocklist, ast) {
-	const errors = [];
-	for (const el of ast) {
-		if (isLiteralElement(el) && blocklist.includes(Element.literal)) {
-			errors.push(getMessage(Element.literal));
-		}
-		if (isArgumentElement(el) && blocklist.includes(Element.argument)) {
-			errors.push(getMessage(Element.argument));
-		}
-		if (isNumberElement(el) && blocklist.includes(Element.number)) {
-			errors.push(getMessage(Element.number));
-		}
-		if (isDateElement(el) && blocklist.includes(Element.date)) {
-			errors.push(getMessage(Element.date));
-		}
-		if (isTimeElement(el) && blocklist.includes(Element.time)) {
-			errors.push(getMessage(Element.time));
-		}
-		if (isSelectElement(el) && blocklist.includes(Element.select)) {
-			errors.push(getMessage(Element.select));
-		}
-		if (isTagElement(el) && blocklist.includes(Element.tag)) {
-			errors.push(getMessage(Element.tag));
-		}
-		if (isPluralElement(el)) {
-			if (blocklist.includes(Element.plural)) {
-				errors.push(getMessage(Element.argument));
-			}
-			if (el.pluralType === "ordinal" && blocklist.includes(Element.selectordinal)) {
-				errors.push(getMessage(Element.selectordinal));
-			}
-		}
-		if (isSelectElement(el) || isPluralElement(el)) {
-			const { options } = el;
-			for (const selector of Object.keys(options)) {
-				verifyAst(blocklist, options[selector].value);
-			}
-		}
-	}
-	return errors;
-}
-function checkNode(context, node) {
-	const settings = getSettings(context);
-	const msgs = extractMessages(node, settings);
-	if (!msgs.length) {
-		return;
-	}
-	const blocklist = context.options[0];
-	if (!Array.isArray(blocklist) || !blocklist.length) {
-		return;
-	}
-	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
-		if (!defaultMessage || !messageNode) {
-			continue;
-		}
-		let ast;
-		try {
-			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
-		} catch (e) {
-			context.report({
-				node: messageNode,
-				messageId: "parseError",
-				data: { error: e.message }
-			});
-			continue;
-		}
-		const errors = verifyAst(blocklist, ast);
-		for (const error of errors) {
-			context.report({
-				node: messageNode,
-				...error
-			});
-		}
-	}
-}
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow specific elements in ICU message format",
-			url: "https://formatjs.github.io/docs/tooling/linter#blocklist-elements"
-		},
-		fixable: "code",
-		schema: [{
-			type: "array",
-			items: {
-				type: "string",
-				enum: Object.keys(Element)
-			}
-		}],
-		messages: {
-			...CORE_MESSAGES,
-			blocklist: `{{type}} element is blocklisted`
-		}
-	},
-	create(context) {
-		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = context.sourceCode.parserServices;
-		if (parserServices?.defineTemplateBodyVisitor) {
-			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
-		}
-		return {
-			JSXOpeningElement: (node) => checkNode(context, node),
-			CallExpression: callExpressionVisitor
-		};
-	}
-};

package/rules/enforce-default-message.d.ts

@@ -1,7 +0,0 @@
-import type { Rule } from "eslint";
-export declare enum Option {
-	literal = "literal",
-	anything = "anything"
-}
-export declare const name = "enforce-default-message";
-export declare const rule: Rule.RuleModule;

package/rules/enforce-default-message.js

@@ -1,57 +0,0 @@
-import { extractMessages, getSettings } from "../util.js";
-export let Option = /* @__PURE__ */ function(Option) {
-	Option["literal"] = "literal";
-	Option["anything"] = "anything";
-	return Option;
-}({});
-export const name = "enforce-default-message";
-function checkNode(context, node) {
-	const msgs = extractMessages(node, getSettings(context));
-	const { options: [type] } = context;
-	for (const [{ message: { defaultMessage }, messageNode, messageDescriptorNode }] of msgs) {
-		if (!defaultMessage) {
-			if (type === "literal" && messageNode) {
-				context.report({
-					node: messageNode,
-					messageId: "defaultMessageLiteral"
-				});
-			} else if (!messageNode) {
-				context.report({
-					node: messageDescriptorNode,
-					messageId: "defaultMessage"
-				});
-			}
-		}
-	}
-}
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce defaultMessage in message descriptor",
-			url: "https://formatjs.github.io/docs/tooling/linter#enforce-default-message"
-		},
-		fixable: "code",
-		schema: [{
-			type: "string",
-			enum: Object.keys(Option)
-		}],
-		messages: {
-			defaultMessageLiteral: `"defaultMessage" must be:
-- a string literal or
-- template literal without variable`,
-			defaultMessage: "`defaultMessage` has to be specified in message descriptor"
-		}
-	},
-	create(context) {
-		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = context.sourceCode.parserServices;
-		if (parserServices?.defineTemplateBodyVisitor) {
-			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
-		}
-		return {
-			JSXOpeningElement: (node) => checkNode(context, node),
-			CallExpression: callExpressionVisitor
-		};
-	}
-};

package/rules/enforce-description.d.ts

@@ -1,11 +0,0 @@
-import type { Rule } from "eslint";
-export declare enum Option {
-	literal = "literal",
-	anything = "anything"
-}
-export type ObjectOption = {
-	mode?: Option;
-	minLength?: number;
-};
-export declare const name = "enforce-description";
-export declare const rule: Rule.RuleModule;

package/rules/enforce-description.js

@@ -1,97 +0,0 @@
-import { extractMessages, getSettings } from "../util.js";
-export let Option = /* @__PURE__ */ function(Option) {
-	Option["literal"] = "literal";
-	Option["anything"] = "anything";
-	return Option;
-}({});
-function normalizeOptions(raw) {
-	if (typeof raw === "string") {
-		return {
-			mode: raw,
-			minLength: undefined
-		};
-	}
-	if (typeof raw === "object" && raw !== null) {
-		return {
-			mode: raw.mode,
-			minLength: raw.minLength
-		};
-	}
-	return {
-		mode: undefined,
-		minLength: undefined
-	};
-}
-function checkNode(context, node) {
-	const msgs = extractMessages(node, getSettings(context));
-	const { mode: type, minLength } = normalizeOptions(context.options[0]);
-	for (const [{ message: { description }, descriptionNode, messageDescriptorNode }] of msgs) {
-		if (!description) {
-			if (type === "literal" && descriptionNode) {
-				context.report({
-					node: descriptionNode,
-					messageId: "enforceDescriptionLiteral"
-				});
-			} else if (!descriptionNode) {
-				context.report({
-					node: messageDescriptorNode,
-					messageId: "enforceDescription"
-				});
-			}
-		} else if (typeof minLength === "number" && typeof description === "string" && description.length < minLength) {
-			context.report({
-				node: descriptionNode ?? messageDescriptorNode,
-				messageId: "enforceDescriptionMinLength",
-				data: {
-					minLength: String(minLength),
-					length: String(description.length)
-				}
-			});
-		}
-	}
-}
-export const name = "enforce-description";
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce description in message descriptor",
-			url: "https://formatjs.github.io/docs/tooling/linter#enforce-description"
-		},
-		fixable: "code",
-		schema: [{ oneOf: [{
-			type: "string",
-			enum: Object.keys(Option)
-		}, {
-			type: "object",
-			properties: {
-				mode: {
-					type: "string",
-					enum: Object.keys(Option)
-				},
-				minLength: {
-					type: "integer",
-					minimum: 1
-				}
-			},
-			additionalProperties: false,
-			minProperties: 1
-		}] }],
-		messages: {
-			enforceDescription: "`description` has to be specified in message descriptor",
-			enforceDescriptionLiteral: "`description` has to be a string literal (not function call or variable)",
-			enforceDescriptionMinLength: "`description` must be at least {{minLength}} characters long (currently {{length}})"
-		}
-	},
-	create(context) {
-		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = context.sourceCode.parserServices;
-		if (parserServices?.defineTemplateBodyVisitor) {
-			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
-		}
-		return {
-			JSXOpeningElement: (node) => checkNode(context, node),
-			CallExpression: callExpressionVisitor
-		};
-	}
-};

package/rules/enforce-id.d.ts

@@ -1,8 +0,0 @@
-import type { Rule } from "eslint";
-export type Option = {
-	idInterpolationPattern: string;
-	idWhitelist?: string[];
-	quoteStyle?: "single" | "double";
-};
-export declare const name = "enforce-id";
-export declare const rule: Rule.RuleModule;

package/rules/enforce-id.js

@@ -1,135 +0,0 @@
-import { interpolateName } from "@formatjs/ts-transformer";
-import { extractMessages, getSettings } from "../util.js";
-function checkNode(context, node, { idInterpolationPattern, idWhitelistRegexps, quoteStyle }) {
-	const msgs = extractMessages(node, getSettings(context));
-	for (const [{ message: { defaultMessage, description, id }, idPropNode, descriptionNode, messagePropNode, messageDescriptorNode }] of msgs) {
-		if (!idInterpolationPattern && !idPropNode) {
-			context.report({
-				node: messageDescriptorNode ?? node,
-				messageId: "enforceId"
-			});
-			return;
-		}
-		if (idInterpolationPattern) {
-			if (!defaultMessage) {
-				context.report({
-					node: messageDescriptorNode ?? node,
-					messageId: "enforceIdDefaultMessage"
-				});
-			} else if (!description && descriptionNode) {
-				context.report({
-					node: messageDescriptorNode ?? node,
-					messageId: "enforceIdDescription"
-				});
-			} else {
-				if (idWhitelistRegexps && id && idWhitelistRegexps.some((r) => r.test(id))) {
-					// messageId is allowlisted so skip interpolation id check
-					continue;
-				}
-				const correctId = interpolateName({ resourcePath: context.filename }, idInterpolationPattern, { content: description ? `${defaultMessage}#${description}` : defaultMessage });
-				if (id !== correctId) {
-					let messageId = "enforceIdMatching";
-					let messageData = {
-						idInterpolationPattern,
-						expected: correctId,
-						actual: id
-					};
-					if (idWhitelistRegexps) {
-						messageId = "enforceIdMatchingAllowlisted";
-						messageData = {
-							...messageData,
-							idWhitelist: idWhitelistRegexps.map((r) => `"${r.toString()}"`).join(", ")
-						};
-					}
-					const quote = quoteStyle === "double" ? "\"" : "'";
-					context.report({
-						node: idPropNode ?? messageDescriptorNode ?? node,
-						messageId,
-						data: messageData,
-						fix(fixer) {
-							if (idPropNode) {
-								if (idPropNode.type === "JSXAttribute") {
-									// Always use double quotes for JSX attributes
-									return fixer.replaceText(idPropNode, `id="${correctId}"`);
-								}
-								return fixer.replaceText(idPropNode, `id: ${quote}${correctId}${quote}`);
-							}
-							if (messagePropNode) {
-								// Insert after default message node
-								if (messagePropNode.type === "JSXAttribute") {
-									// Always use double quotes for JSX attributes
-									return fixer.insertTextAfter(messagePropNode, ` id="${correctId}"`);
-								}
-								return fixer.insertTextAfter(messagePropNode, `, id: ${quote}${correctId}${quote}`);
-							}
-							return null;
-						}
-					});
-				}
-			}
-		}
-	}
-}
-export const name = "enforce-id";
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce (generated) ID in message descriptor",
-			url: "https://formatjs.github.io/docs/tooling/linter#enforce-id"
-		},
-		fixable: "code",
-		schema: [{
-			type: "object",
-			properties: {
-				idInterpolationPattern: {
-					type: "string",
-					description: "Pattern to verify ID against. Recommended value: [sha512:contenthash:base64:6]"
-				},
-				idWhitelist: {
-					type: "array",
-					description: "An array of strings with regular expressions. This array allows allowlist custom ids for messages. For example '`\\\\.`' allows any id which has dot; `'^payment_.*'` - allows any custom id which has prefix `payment_`. Be aware that any backslash \\ provided via string must be escaped with an additional backslash.",
-					items: { type: "string" }
-				},
-				quoteStyle: {
-					type: "string",
-					enum: ["single", "double"],
-					description: "Quote style for generated IDs. Defaults to single quotes."
-				}
-			},
-			required: ["idInterpolationPattern"],
-			additionalProperties: false
-		}],
-		messages: {
-			enforceId: `id must be specified`,
-			enforceIdDefaultMessage: `defaultMessage must be a string literal to calculate generated IDs`,
-			enforceIdDescription: `description must be a string literal to calculate generated IDs`,
-			enforceIdMatching: `"id" does not match with hash pattern {{idInterpolationPattern}}.
-Expected: {{expected}}
-Actual: {{actual}}`,
-			enforceIdMatchingAllowlisted: `"id" does not match with hash pattern {{idInterpolationPattern}} or allowlisted patterns {{idWhitelist}}.
-Expected: {{expected}}
-Actual: {{actual}}`
-		}
-	},
-	create(context) {
-		const tmp = context.options[0];
-		let opts = {
-			idInterpolationPattern: tmp?.idInterpolationPattern,
-			quoteStyle: tmp?.quoteStyle || "single"
-		};
-		if (Array.isArray(tmp?.idWhitelist)) {
-			const { idWhitelist } = tmp;
-			opts.idWhitelistRegexps = idWhitelist.map((str) => new RegExp(str, "i"));
-		}
-		const callExpressionVisitor = (node) => checkNode(context, node, opts);
-		const parserServices = context.sourceCode.parserServices;
-		if (parserServices?.defineTemplateBodyVisitor) {
-			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
-		}
-		return {
-			JSXOpeningElement: (node) => checkNode(context, node, opts),
-			CallExpression: callExpressionVisitor
-		};
-	}
-};

package/rules/enforce-placeholders.d.ts

@@ -1,3 +0,0 @@
-import type { Rule } from "eslint";
-export declare const name = "enforce-placeholders";
-export declare const rule: Rule.RuleModule;