eslint-plugin-formatjs 6.4.4 → 6.4.6

package/rules/enforce-placeholders.js

@@ -1,128 +0,0 @@
-import { TYPE, parse } from "@formatjs/icu-messageformat-parser";
-import { extractMessages, getSettings } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-function collectPlaceholderNames(ast) {
-	const placeholderNames = new Set();
-	_traverse(ast);
-	return placeholderNames;
-	function _traverse(ast) {
-		for (const element of ast) {
-			switch (element.type) {
-				case TYPE.literal:
-				case TYPE.pound: break;
-				case TYPE.tag:
-					placeholderNames.add(element.value);
-					_traverse(element.children);
-					break;
-				case TYPE.plural:
-				case TYPE.select:
-					placeholderNames.add(element.value);
-					for (const { value } of Object.values(element.options)) {
-						_traverse(value);
-					}
-					break;
-				default:
-					placeholderNames.add(element.value);
-					break;
-			}
-		}
-	}
-}
-function checkNode(context, node) {
-	const settings = getSettings(context);
-	const msgs = extractMessages(node, {
-		excludeMessageDeclCalls: true,
-		...settings
-	});
-	const { options: [opt] } = context;
-	const ignoreList = new Set(opt?.ignoreList || []);
-	for (const [{ message: { defaultMessage }, messageNode }, values] of msgs) {
-		if (!defaultMessage || !messageNode) {
-			continue;
-		}
-		if (values && values.type !== "ObjectExpression") {
-			// cannot evaluate this
-			continue;
-		}
-		if (values?.properties.find((prop) => prop.type === "SpreadElement")) {
-			// cannot evaluate the spread element
-			continue;
-		}
-		const literalElementByLiteralKey = new Map();
-		if (values) {
-			for (const prop of values.properties) {
-				if (prop.type === "Property" && !prop.computed) {
-					const name = prop.key.type === "Identifier" ? prop.key.name : String(prop.key.value);
-					literalElementByLiteralKey.set(name, prop);
-				}
-			}
-		}
-		let ast;
-		try {
-			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
-		} catch (e) {
-			context.report({
-				node: messageNode,
-				messageId: "parseError",
-				data: { error: e instanceof Error ? e.message : String(e) }
-			});
-			continue;
-		}
-		const placeholderNames = collectPlaceholderNames(ast);
-		const missingPlaceholders = [];
-		placeholderNames.forEach((name) => {
-			if (!ignoreList.has(name) && !literalElementByLiteralKey.has(name)) {
-				missingPlaceholders.push(name);
-			}
-		});
-		if (missingPlaceholders.length > 0) {
-			context.report({
-				node: messageNode,
-				messageId: "missingValue",
-				data: { list: missingPlaceholders.join(", ") }
-			});
-		}
-		literalElementByLiteralKey.forEach((element, key) => {
-			if (!ignoreList.has(key) && !placeholderNames.has(key)) {
-				context.report({
-					node: element,
-					messageId: "unusedValue"
-				});
-			}
-		});
-	}
-}
-export const name = "enforce-placeholders";
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce that all messages with placeholders have enough passed-in values",
-			url: "https://formatjs.github.io/docs/tooling/linter#enforce-placeholders"
-		},
-		schema: [{
-			type: "object",
-			properties: { ignoreList: {
-				type: "array",
-				items: { type: "string" }
-			} },
-			additionalProperties: false
-		}],
-		messages: {
-			...CORE_MESSAGES,
-			missingValue: "Missing value(s) for the following placeholder(s): {{list}}.",
-			unusedValue: "Value not used by the message."
-		}
-	},
-	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-plural-rules.d.ts

@@ -1,14 +0,0 @@
-import type { Rule } from "eslint";
-declare enum LDML {
-	zero = "zero",
-	one = "one",
-	two = "two",
-	few = "few",
-	many = "many",
-	other = "other"
-}
-type PluralConfig = { [key in LDML]? : boolean };
-export type Options = [PluralConfig?];
-export declare const name = "enforce-plural-rules";
-export declare const rule: Rule.RuleModule;
-export {};

package/rules/enforce-plural-rules.js

@@ -1,108 +0,0 @@
-import { isPluralElement, parse } from "@formatjs/icu-messageformat-parser";
-import { extractMessages, getSettings } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-var LDML = /* @__PURE__ */ function(LDML) {
-	LDML["zero"] = "zero";
-	LDML["one"] = "one";
-	LDML["two"] = "two";
-	LDML["few"] = "few";
-	LDML["many"] = "many";
-	LDML["other"] = "other";
-	return LDML;
-}(LDML || {});
-function verifyAst(plConfig, ast) {
-	const errors = [];
-	for (const el of ast) {
-		if (isPluralElement(el)) {
-			const rules = Object.keys(plConfig);
-			for (const rule of rules) {
-				if (plConfig[rule] && !el.options[rule]) {
-					errors.push({
-						messageId: "missingPlural",
-						data: { rule }
-					});
-				}
-				if (!plConfig[rule] && el.options[rule]) {
-					errors.push({
-						messageId: "forbidden",
-						data: { rule }
-					});
-				}
-			}
-			const { options } = el;
-			for (const selector of Object.keys(options)) {
-				errors.push(...verifyAst(plConfig, options[selector].value));
-			}
-		}
-	}
-	return errors;
-}
-function checkNode(context, node) {
-	const settings = getSettings(context);
-	const msgs = extractMessages(node, settings);
-	if (!msgs.length) {
-		return;
-	}
-	const plConfig = context.options[0];
-	if (!plConfig) {
-		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(plConfig, ast);
-		for (const error of errors) {
-			context.report({
-				node: messageNode,
-				...error
-			});
-		}
-	}
-}
-export const name = "enforce-plural-rules";
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce plural rules to always specify certain categories like `one`/`other`",
-			url: "https://formatjs.github.io/docs/tooling/linter#enforce-plural-rules"
-		},
-		fixable: "code",
-		schema: [{
-			type: "object",
-			properties: Object.keys(LDML).reduce((schema, k) => {
-				schema[k] = { type: "boolean" };
-				return schema;
-			}, {}),
-			additionalProperties: false
-		}],
-		messages: {
-			...CORE_MESSAGES,
-			missingPlural: `Missing plural rule "{{rule}}"`,
-			forbidden: `Plural rule "{{rule}}" is forbidden`
-		}
-	},
-	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/no-camel-case.d.ts

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

package/rules/no-camel-case.js

@@ -1,85 +0,0 @@
-import { isArgumentElement, isPluralElement, parse } from "@formatjs/icu-messageformat-parser";
-import { extractMessages, getSettings } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-export const name = "no-camel-case";
-const CAMEL_CASE_REGEX = /[A-Z]/;
-function verifyAst(ast) {
-	const errors = [];
-	for (const el of ast) {
-		if (isArgumentElement(el)) {
-			if (CAMEL_CASE_REGEX.test(el.value)) {
-				errors.push({
-					messageId: "camelcase",
-					data: {}
-				});
-			}
-			continue;
-		}
-		if (isPluralElement(el)) {
-			if (CAMEL_CASE_REGEX.test(el.value)) {
-				errors.push({
-					messageId: "camelcase",
-					data: {}
-				});
-			}
-			const { options } = el;
-			for (const selector of Object.keys(options)) {
-				errors.push(...verifyAst(options[selector].value));
-			}
-		}
-	}
-	return errors;
-}
-function checkNode(context, node) {
-	const settings = getSettings(context);
-	const msgs = extractMessages(node, settings);
-	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(ast);
-		for (const error of errors) {
-			context.report({
-				node: messageNode,
-				...error
-			});
-		}
-	}
-}
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow camel case placeholders in message",
-			url: "https://formatjs.github.io/docs/tooling/linter#no-camel-case"
-		},
-		fixable: "code",
-		schema: [],
-		messages: {
-			...CORE_MESSAGES,
-			camelcase: "Camel case arguments are not allowed"
-		}
-	},
-	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/no-complex-selectors.d.ts

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

package/rules/no-complex-selectors.js

@@ -1,119 +0,0 @@
-import { TYPE, parse } from "@formatjs/icu-messageformat-parser";
-import { extractMessages, getSettings } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-function calculateComplexity(ast) {
-	// Dynamic programming: define a complexity function f, where:
-	//   f(plural | select) = sum(f(option) for each option) * f(next element),
-	//   f(tag) = f(first element of children) * f(next element),
-	//   f(other) = f(next element),
-	//   f(out of bound) = 1.
-	const complexityByNode = new Map();
-	return _calculate(ast, 0);
-	function _calculate(ast, index) {
-		const element = ast[index];
-		if (!element) {
-			return 1;
-		}
-		const cachedComplexity = complexityByNode.get(element);
-		if (cachedComplexity !== undefined) {
-			return cachedComplexity;
-		}
-		let complexity;
-		switch (element.type) {
-			case TYPE.plural:
-			case TYPE.select: {
-				let sumOfOptions = 0;
-				for (const { value } of Object.values(element.options)) {
-					sumOfOptions += _calculate(value, 0);
-				}
-				complexity = sumOfOptions * _calculate(ast, index + 1);
-				break;
-			}
-			case TYPE.tag:
-				complexity = _calculate(element.children, 0) * _calculate(ast, index + 1);
-				break;
-			default:
-				complexity = _calculate(ast, index + 1);
-				break;
-		}
-		complexityByNode.set(element, complexity);
-		return complexity;
-	}
-}
-function checkNode(context, node) {
-	const settings = getSettings(context);
-	const msgs = extractMessages(node, settings);
-	if (!msgs.length) {
-		return;
-	}
-	const config = {
-		limit: 20,
-		...context.options[0]
-	};
-	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 instanceof Error ? e.message : String(e) }
-			});
-			return;
-		}
-		const complexity = calculateComplexity(ast);
-		if (complexity > config.limit) {
-			context.report({
-				node: messageNode,
-				messageId: "tooComplex",
-				data: {
-					complexity,
-					limit: config.limit
-				}
-			});
-		}
-	}
-}
-export const name = "no-complex-selectors";
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: `Make sure a sentence is not too complex.
-Complexity is determined by how many strings are produced when we try to
-flatten the sentence given its selectors. For example:
-"I have {count, plural, one{a dog} other{many dogs}}"
-has the complexity of 2 because flattening the plural selector
-results in 2 sentences: "I have a dog" & "I have many dogs".
-Default complexity limit is 20
-(using Smartling as a reference: https://help.smartling.com/hc/en-us/articles/360008030994-ICU-MessageFormat)
-`,
-			url: "https://formatjs.github.io/docs/tooling/linter#no-complex-selectors"
-		},
-		schema: [{
-			type: "object",
-			properties: { limit: { type: "number" } },
-			additionalProperties: false
-		}],
-		fixable: "code",
-		messages: {
-			...CORE_MESSAGES,
-			tooComplex: `Message complexity is too high ({{complexity}} vs limit at {{limit}})`
-		}
-	},
-	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/no-emoji.d.ts

@@ -1,8 +0,0 @@
-import type { Rule } from "eslint";
-export declare const name = "no-emoji";
-type NoEmojiConfig = {
-	versionAbove: string;
-};
-export type Options = [NoEmojiConfig?];
-export declare const rule: Rule.RuleModule;
-export {};

package/rules/no-emoji.js

@@ -1,88 +0,0 @@
-import { extractEmojis, filterEmojis, hasEmoji, isValidEmojiVersion } from "../emoji-utils.js";
-import { extractMessages, getSettings } from "../util.js";
-export const name = "no-emoji";
-function checkNode(context, node) {
-	const msgs = extractMessages(node, getSettings(context));
-	let versionAbove;
-	const [emojiConfig] = context.options;
-	if (emojiConfig?.versionAbove && isValidEmojiVersion(emojiConfig.versionAbove)) {
-		versionAbove = emojiConfig.versionAbove;
-	}
-	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
-		if (!defaultMessage || !messageNode) {
-			continue;
-		}
-		if (hasEmoji(defaultMessage)) {
-			if (versionAbove) {
-				const filter = filterEmojis(versionAbove);
-				for (const emoji of extractEmojis(defaultMessage)) {
-					// Check if the emoji's version is allowed (filterEmojis returns true for allowed emojis)
-					if (!filter(emoji)) {
-						context.report({
-							node: messageNode,
-							messageId: "notAllowedAboveVersion",
-							data: {
-								versionAbove,
-								emoji
-							}
-						});
-					}
-				}
-			} else {
-				context.report({
-					node: messageNode,
-					messageId: "notAllowed"
-				});
-			}
-		}
-	}
-}
-const versionAboveEnums = [
-	"0.6",
-	"0.7",
-	"1.0",
-	"2.0",
-	"3.0",
-	"4.0",
-	"5.0",
-	"11.0",
-	"12.0",
-	"13.0",
-	"14.0",
-	"15.0",
-	"16.0",
-	"17.0"
-];
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow emojis in message",
-			url: "https://formatjs.github.io/docs/tooling/linter#no-emoji"
-		},
-		fixable: "code",
-		schema: [{
-			type: "object",
-			properties: { versionAbove: {
-				type: "string",
-				enum: versionAboveEnums
-			} },
-			additionalProperties: false
-		}],
-		messages: {
-			notAllowed: "Emojis are not allowed",
-			notAllowedAboveVersion: "Emojis above version {{versionAbove}} are not allowed - Emoji: {{emoji}}"
-		}
-	},
-	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/no-id.d.ts

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

package/rules/no-id.js

@@ -1,48 +0,0 @@
-import { extractMessages, getSettings } from "../util.js";
-function isComment(token) {
-	return !!token && (token.type === "Block" || token.type === "Line");
-}
-export const name = "no-id";
-function checkNode(context, node) {
-	const msgs = extractMessages(node, getSettings(context));
-	for (const [{ idPropNode }] of msgs) {
-		if (idPropNode) {
-			context.report({
-				node: idPropNode,
-				messageId: "noId",
-				fix(fixer) {
-					const src = context.sourceCode;
-					const token = src.getTokenAfter(idPropNode);
-					const fixes = [fixer.remove(idPropNode)];
-					if (token && !isComment(token) && token?.value === ",") {
-						fixes.push(fixer.remove(token));
-					}
-					return fixes;
-				}
-			});
-		}
-	}
-}
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Ban explicit ID from MessageDescriptor",
-			url: "https://formatjs.github.io/docs/tooling/linter#no-id"
-		},
-		fixable: "code",
-		schema: [],
-		messages: { noId: "Manual `id` are not allowed 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/no-invalid-icu.d.ts

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

package/rules/no-invalid-icu.js

@@ -1,56 +0,0 @@
-import { parse } from "@formatjs/icu-messageformat-parser";
-import { extractMessages, getSettings } from "../util.js";
-import { CORE_MESSAGES } from "../messages.js";
-export const name = "no-invalid-icu";
-function checkNode(context, node) {
-	const settings = getSettings(context);
-	let msgs;
-	try {
-		msgs = extractMessages(node, settings);
-	} catch (e) {
-		// GH #5069: Handle errors from extractMessages (e.g., tagged templates with substitutions)
-		context.report({
-			node,
-			messageId: "parseError",
-			data: { error: e.message }
-		});
-		return;
-	}
-	if (!msgs.length) {
-		return;
-	}
-	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
-		if (!defaultMessage || !messageNode) {
-			continue;
-		}
-		try {
-			parse(defaultMessage, { ignoreTag: settings.ignoreTag });
-		} catch (e) {
-			context.report({
-				node: messageNode,
-				messageId: "parseError",
-				data: { error: e.message }
-			});
-		}
-	}
-}
-export const rule = {
-	meta: {
-		type: "problem",
-		docs: { description: `Make sure ICU messages are formatted correctly with no bad select statements, plurals, etc.` },
-		fixable: "code",
-		schema: [],
-		messages: CORE_MESSAGES
-	},
-	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/no-literal-string-in-jsx.d.ts

@@ -1,3 +0,0 @@
-import type { Rule } from "eslint";
-export declare const name = "no-literal-string-in-jsx";
-export declare const rule: Rule.RuleModule;