eslint-plugin-formatjs 6.4.4 → 6.4.5

package/rules/prefer-formatted-message.d.ts

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

package/rules/prefer-formatted-message.js

@@ -1,26 +0,0 @@
-import { isIntlFormatMessageCall } from "../util.js";
-export const name = "prefer-formatted-message";
-export const rule = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description: "Prefer `FormattedMessage` component over `intl.formatMessage` if applicable.",
-			url: "https://formatjs.github.io/docs/tooling/linter#prefer-formatted-message"
-		},
-		messages: { jsxChildren: "Prefer `FormattedMessage` over `intl.formatMessage` in the JSX children expression." },
-		schema: []
-	},
-	create(context) {
-		return { JSXElement: (node) => {
-			node.children.forEach((child) => {
-				if (child.type !== "JSXExpressionContainer" || !isIntlFormatMessageCall(child.expression)) {
-					return;
-				}
-				context.report({
-					node: child,
-					messageId: "jsxChildren"
-				});
-			});
-		} };
-	}
-};

package/rules/prefer-full-sentence.d.ts

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

package/rules/prefer-full-sentence.js

@@ -1,111 +0,0 @@
-import { parse, TYPE } from "@formatjs/icu-messageformat-parser";
-import { extractMessages, getSettings } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-/**
-* Get the first boundary element, recursing into tags since
-* <b>hello</b> starts with the literal "hello".
-*/
-function getFirstBoundaryElement(ast) {
-	if (ast.length === 0) return null;
-	const first = ast[0];
-	if (first.type === TYPE.tag) {
-		return getFirstBoundaryElement(first.children);
-	}
-	return first;
-}
-/**
-* Get the last boundary element, recursing into tags.
-*/
-function getLastBoundaryElement(ast) {
-	if (ast.length === 0) return null;
-	const last = ast[ast.length - 1];
-	if (last.type === TYPE.tag) {
-		return getLastBoundaryElement(last.children);
-	}
-	return last;
-}
-function findWhitespaceIssues(ast) {
-	const issues = [];
-	const first = getFirstBoundaryElement(ast);
-	const last = getLastBoundaryElement(ast);
-	// Ignore messages that are only whitespace (edge case)
-	if (first === last && first?.type === TYPE.literal && ast.length === 1 && first.value.trim() === "") {
-		return issues;
-	}
-	if (first?.type === TYPE.literal && /^\s/.test(first.value)) {
-		issues.push("leadingWhitespace");
-	}
-	if (last?.type === TYPE.literal && /\s$/.test(last.value)) {
-		issues.push("trailingWhitespace");
-	}
-	// Check each plural/select option branch independently
-	for (const element of ast) {
-		switch (element.type) {
-			case TYPE.plural:
-			case TYPE.select: {
-				for (const option of Object.values(element.options)) {
-					issues.push(...findWhitespaceIssues(option.value));
-				}
-				break;
-			}
-		}
-	}
-	return issues;
-}
-function checkNode(context, node) {
-	const msgs = extractMessages(node, getSettings(context));
-	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
-		if (!defaultMessage || !messageNode) {
-			continue;
-		}
-		let ast;
-		try {
-			ast = parse(defaultMessage);
-		} catch (e) {
-			context.report({
-				node: messageNode,
-				messageId: "parseError",
-				data: { error: e instanceof Error ? e.message : String(e) }
-			});
-			return;
-		}
-		const issues = findWhitespaceIssues(ast);
-		// Deduplicate
-		const seen = new Set();
-		for (const issue of issues) {
-			if (seen.has(issue)) continue;
-			seen.add(issue);
-			context.report({
-				node: messageNode,
-				messageId: issue
-			});
-		}
-	}
-}
-export const name = "prefer-full-sentence";
-export const rule = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description: "Detects messages with leading/trailing whitespace, which suggests string concatenation instead of full sentences",
-			url: "https://formatjs.github.io/docs/tooling/linter#prefer-full-sentence"
-		},
-		messages: {
-			...CORE_MESSAGES,
-			leadingWhitespace: "Messages should be full sentences — leading whitespace suggests string concatenation",
-			trailingWhitespace: "Messages should be full sentences — trailing whitespace suggests string concatenation"
-		},
-		schema: []
-	},
-	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/prefer-pound-in-plural.d.ts

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

package/rules/prefer-pound-in-plural.js

@@ -1,163 +0,0 @@
-import { parse, TYPE } from "@formatjs/icu-messageformat-parser";
-import MagicString from "magic-string";
-import { extractMessages, getSettings, patchMessage } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-function verifyAst(context, messageNode, ast) {
-	const patches = [];
-	_verifyAst(ast);
-	if (patches.length > 0) {
-		const patchedMessage = patchMessage(messageNode, ast, (content) => {
-			return patches.reduce((magicString, patch) => {
-				switch (patch.type) {
-					case "prependLeft": return magicString.prependLeft(patch.index, patch.content);
-					case "remove": return magicString.remove(patch.start, patch.end);
-					case "update": return magicString.update(patch.start, patch.end, patch.content);
-				}
-			}, new MagicString(content)).toString();
-		});
-		context.report({
-			node: messageNode,
-			messageId: "preferPoundInPlurals",
-			fix: patchedMessage !== null ? (fixer) => fixer.replaceText(messageNode, patchedMessage) : null
-		});
-	}
-	function _verifyAst(ast) {
-		for (let i = 0; i < ast.length; i++) {
-			const current = ast[i];
-			switch (current.type) {
-				case TYPE.argument:
-				case TYPE.number: {
-					// Applicable to only plain argument or number argument without any style
-					if (current.type === TYPE.number && current.style) {
-						break;
-					}
-					const next = ast[i + 1];
-					const nextNext = ast[i + 2];
-					if (next && nextNext && next.type === TYPE.literal && next.value === " " && nextNext.type === TYPE.plural && nextNext.value === current.value) {
-						// `{A} {A, plural, one {B} other {Bs}}` => `{A, plural, one {# B} other {# Bs}}`
-						_removeRangeAndPrependPluralClauses(current.location.start.offset, next.location.end.offset, nextNext, "# ");
-					} else if (next && next.type === TYPE.plural && next.value === current.value) {
-						// `{A}{A, plural, one {B} other {Bs}}` => `{A, plural, one {#B} other {#Bs}}`
-						_removeRangeAndPrependPluralClauses(current.location.start.offset, current.location.end.offset, next, "#");
-					}
-					break;
-				}
-				case TYPE.plural: {
-					// `{A, plural, one {{A} B} other {{A} Bs}}` => `{A, plural, one {# B} other {# Bs}}`
-					const name = current.value;
-					for (const { value } of Object.values(current.options)) {
-						_replacementArgumentWithPound(name, value);
-					}
-					break;
-				}
-				case TYPE.select: {
-					for (const { value } of Object.values(current.options)) {
-						_verifyAst(value);
-					}
-					break;
-				}
-				case TYPE.tag:
-					_verifyAst(current.children);
-					break;
-				default: break;
-			}
-		}
-	}
-	// Replace plain argument of number argument w/o style option that matches
-	// the name with a pound sign.
-	function _replacementArgumentWithPound(name, ast) {
-		for (const element of ast) {
-			switch (element.type) {
-				case TYPE.argument:
-				case TYPE.number: {
-					if (element.value === name && (element.type !== TYPE.number || !element.style)) {
-						patches.push({
-							type: "update",
-							start: element.location.start.offset,
-							end: element.location.end.offset,
-							content: "#"
-						});
-					}
-					break;
-				}
-				case TYPE.tag: {
-					_replacementArgumentWithPound(name, element.children);
-					break;
-				}
-				case TYPE.select: {
-					for (const { value } of Object.values(element.options)) {
-						_replacementArgumentWithPound(name, value);
-					}
-					break;
-				}
-				default: break;
-			}
-		}
-	}
-	// Helper to remove a certain text range and then prepend the specified text to
-	// each plural clause.
-	function _removeRangeAndPrependPluralClauses(rangeToRemoveStart, rangeToRemoveEnd, pluralElement, prependText) {
-		// Delete both the `{A}` and ` `
-		patches.push({
-			type: "remove",
-			start: rangeToRemoveStart,
-			end: rangeToRemoveEnd
-		});
-		// Insert `# ` to the beginning of every option clause
-		for (const { location } of Object.values(pluralElement.options)) {
-			// location marks the entire clause with the surrounding braces
-			patches.push({
-				type: "prependLeft",
-				index: location.start.offset + 1,
-				content: prependText
-			});
-		}
-	}
-}
-function checkNode(context, node) {
-	const msgs = extractMessages(node, getSettings(context));
-	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
-		if (!defaultMessage || !messageNode) {
-			continue;
-		}
-		let ast;
-		try {
-			ast = parse(defaultMessage, { captureLocation: true });
-		} catch (e) {
-			context.report({
-				node: messageNode,
-				messageId: "parseError",
-				data: { error: e instanceof Error ? e.message : String(e) }
-			});
-			return;
-		}
-		verifyAst(context, messageNode, ast);
-	}
-}
-export const name = "prefer-pound-in-plural";
-export const rule = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description: "Prefer using # to reference the count in the plural argument.",
-			url: "https://formatjs.github.io/docs/tooling/linter#prefer-pound-in-plurals"
-		},
-		messages: {
-			...CORE_MESSAGES,
-			preferPoundInPlurals: "Prefer using # to reference the count in the plural argument instead of repeating the argument."
-		},
-		fixable: "code",
-		schema: []
-	},
-	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
-		};
-	}
-};