eslint-plugin-formatjs 6.6.3 → 7.0.0-rc.0

package/index.js

@@ -16,6 +16,56 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
+//#region packages/eslint-plugin-formatjs/message-types.ts
+function collectMessageArguments(ast) {
+	const argumentsByName = /* @__PURE__ */ new Map();
+	function visit(elements) {
+		for (const element of elements) {
+			if (element.type === TYPE.literal || element.type === TYPE.pound) continue;
+			const types = argumentsByName.get(element.value) ?? /* @__PURE__ */ new Set();
+			argumentsByName.set(element.value, types);
+			switch (element.type) {
+				case TYPE.argument: break;
+				case TYPE.number:
+				case TYPE.plural:
+					types.add("number");
+					break;
+				case TYPE.date:
+				case TYPE.time:
+					types.add("date");
+					break;
+				case TYPE.select:
+					types.add("select");
+					break;
+				case TYPE.tag:
+					types.add("tag");
+					visit(element.children);
+			}
+			if (element.type === TYPE.select || element.type === TYPE.plural) for (const option of Object.values(element.options)) visit(option.value);
+		}
+	}
+	visit(ast);
+	return argumentsByName;
+}
+/** Derive one contract from the runtime parser's AST, including every branch. */
+function messageTypes(ast, module, ignoreList = []) {
+	const argumentsByName = collectMessageArguments(ast);
+	const ignored = new Set(ignoreList);
+	for (const name of ignored) if (!argumentsByName.has(name)) argumentsByName.set(name, /* @__PURE__ */ new Set());
+	const fields = [...argumentsByName].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, types]) => {
+		let type;
+		if (!types.size) type = `import(${JSON.stringify(module)}).MessageValue`;
+		else if (types.size === 2 && types.has("number") && types.has("date")) type = "number";
+		else if (types.size > 1) throw new Error(`Incompatible uses of argument ${JSON.stringify(name)}`);
+		else if (types.has("number")) type = "number | bigint";
+		else if (types.has("date")) type = "number | Date";
+		else if (types.has("select")) type = "string";
+		else type = `import(${JSON.stringify(module)}).MessageTag`;
+		return `readonly ${JSON.stringify(name)}${ignored.has(name) ? "?" : ""}: ${type}`;
+	});
+	return fields.length ? `{ ${fields.join("; ")} }` : "{}";
+}
+//#endregion
 //#region packages/eslint-plugin-formatjs/util.ts
 const FORMAT_FUNCTION_NAMES = /* @__PURE__ */ new Set([
 	"$formatMessage",
@@ -220,11 +270,605 @@ function patchMessage(messageNode, ast, patcher) {
 	return null;
 }
 //#endregion
+//#region packages/eslint-plugin-formatjs/placeholder-checks.ts
+function messageIgnoreTag(context, node) {
+	let ignoreTag = getSettings(context).ignoreTag ?? false;
+	if (node.type !== "CallExpression" || !node.arguments[2]) return ignoreTag;
+	const options = node.arguments[2];
+	if (options.type !== "ObjectExpression") return;
+	for (const property of options.properties) {
+		if (property.type !== "Property" || property.computed || property.method || property.kind !== "init") return;
+		if ((property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? property.key.value : void 0) !== "ignoreTag") continue;
+		if (property.value.type !== "Literal" || typeof property.value.value !== "boolean") return;
+		ignoreTag = property.value.value;
+	}
+	return ignoreTag;
+}
+function checkPlaceholders(context, node) {
+	const settings = getSettings(context);
+	const ignoreTag = messageIgnoreTag(context, node);
+	if (ignoreTag === void 0) return;
+	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") continue;
+		if (values?.properties.find((prop) => prop.type === "SpreadElement")) continue;
+		const literalElementByLiteralKey = /* @__PURE__ */ 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 });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e instanceof Error ? e.message : String(e) }
+			});
+			continue;
+		}
+		const placeholderNames = new Set(collectMessageArguments(ast).keys());
+		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"
+			});
+		});
+	}
+}
+//#endregion
 //#region packages/eslint-plugin-formatjs/messages.ts
 const CORE_MESSAGES = { parseError: `Failed to parse message string {{error}}` };
 //#endregion
+//#region packages/eslint-plugin-formatjs/rules/enforce-placeholders.ts
+const name$23 = "enforce-placeholders";
+const rule$21 = {
+	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) => checkPlaceholders(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkPlaceholders(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/enforce-message-types.ts
+const name$22 = "enforce-message-types";
+const modules = /* @__PURE__ */ new Set([
+	"@formatjs/intl",
+	"react-intl",
+	"react-intl/server",
+	"intl-messageformat"
+]);
+function staticObject(node) {
+	return node?.type === "ObjectExpression" && node.properties.every((property) => property.type === "Property" && !property.computed && property.kind === "init" && !property.method);
+}
+function staticMessage(node) {
+	if (!node) return false;
+	if (node.type === "Literal") return typeof node.value === "string";
+	if (node.type === "TemplateLiteral") return node.expressions.length === 0;
+	if (node.type === "BinaryExpression") return node.operator === "+" && staticMessage(node.left) && staticMessage(node.right);
+	const wrapper = node;
+	if ([
+		"TSAsExpression",
+		"TSSatisfiesExpression",
+		"TSNonNullExpression",
+		"TSTypeAssertion"
+	].includes(wrapper.type)) return staticMessage(wrapper.expression);
+	return false;
+}
+function importedHelper(context, node) {
+	const callee = node.callee;
+	const identifier = callee.type === "Identifier" ? callee : callee.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" ? callee.object : void 0;
+	if (!identifier) return;
+	let scope = context.sourceCode.getScope(node);
+	while (scope) {
+		const variable = scope.set.get(identifier.name);
+		if (variable) {
+			const definition = variable.defs[0];
+			if (definition?.type !== "ImportBinding") return;
+			const module = definition.parent.source.value;
+			if (typeof module !== "string" || !modules.has(module)) return;
+			const specifier = definition.node;
+			let helper;
+			if (callee.type === "Identifier" && specifier.type === "ImportSpecifier") helper = specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+			else if (callee.type === "MemberExpression" && callee.property.type === "Identifier" && specifier.type === "ImportNamespaceSpecifier") helper = callee.property.name;
+			if (node.type === "NewExpression" && module === "intl-messageformat") {
+				if (callee.type === "Identifier" && specifier.type === "ImportDefaultSpecifier" || helper === "IntlMessageFormat" || helper === "default") return {
+					module,
+					helper: "IntlMessageFormat"
+				};
+				return;
+			}
+			if (module === "intl-messageformat") return;
+			if (helper === "defineMessage" || helper === "defineMessages") return {
+				module,
+				helper
+			};
+			return;
+		}
+		scope = scope.upper;
+	}
+}
+function staticString(node) {
+	if (!node) return;
+	if (node.type === "Literal") return typeof node.value === "string" ? node.value : void 0;
+	if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0].value.cooked ?? void 0;
+	if (node.type === "BinaryExpression" && node.operator === "+") {
+		const left = staticString(node.left);
+		const right = staticString(node.right);
+		if (left !== void 0 && right !== void 0) return left + right;
+	}
+	const wrapper = node;
+	if ([
+		"TSAsExpression",
+		"TSSatisfiesExpression",
+		"TSNonNullExpression",
+		"TSTypeAssertion"
+	].includes(wrapper.type)) return staticString(wrapper.expression);
+}
+function renderType(node) {
+	if (!node) return;
+	const keywords = {
+		TSNumberKeyword: "number",
+		TSBigIntKeyword: "bigint",
+		TSStringKeyword: "string"
+	};
+	if (keywords[node.type]) return keywords[node.type];
+	if (node.type === "TSTypeReference" && node.typeName?.type === "Identifier") {
+		const parameters = (node.typeArguments ?? node.typeParameters)?.params;
+		if (!parameters) return node.typeName.name;
+		const types = parameters.map(renderType);
+		if (types.every((type) => type !== void 0)) return node.typeName.name + "<" + types.join(", ") + ">";
+		return;
+	}
+	if (node.type === "TSUnionType") {
+		const types = node.types?.map(renderType);
+		if (types?.every((type) => type !== void 0)) return types.join(" | ");
+	}
+	if (node.type === "TSImportType" && node.qualifier?.type === "Identifier") {
+		const module = node.source?.value ?? node.argument?.literal?.value ?? node.argument?.value;
+		if (typeof module === "string") return `import(${JSON.stringify(module)}).${node.qualifier.name}`;
+	}
+	if (node.type === "TSTypeLiteral" && node.members) {
+		const fields = [];
+		for (const member of node.members) {
+			if (member.type !== "TSPropertySignature" || member.computed) return;
+			const key = member.key?.type === "Identifier" ? member.key.name : member.key?.value;
+			const type = renderType(member.typeAnnotation?.typeAnnotation);
+			if (key === void 0 || type === void 0) return;
+			fields.push(`${member.readonly ? "readonly " : ""}${JSON.stringify(String(key))}${member.optional ? "?" : ""}: ${type}`);
+		}
+		return fields.length ? `{ ${fields.join("; ")} }` : "{}";
+	}
+}
+function hoistTypes(context, node, contract) {
+	const source = context.sourceCode;
+	const imports = /* @__PURE__ */ new Map();
+	const occupied = new Set(source.scopeManager?.scopes.flatMap((scope) => scope.variables.map((variable) => variable.name)));
+	const resolved = /* @__PURE__ */ new Map();
+	return {
+		text: contract.replace(/import\(("(?:[^"\\]|\\.)*")\)\.(MessageTag|MessageValue|TypedMessageDescriptor)/g, (reference, quotedModule, imported) => {
+			if (resolved.has(reference)) return resolved.get(reference);
+			const module = JSON.parse(quotedModule);
+			for (const declaration of source.ast.body) {
+				if (declaration.type !== "ImportDeclaration" || declaration.source.value !== module) continue;
+				for (const specifier of declaration.specifiers) {
+					if (specifier.type !== "ImportSpecifier") continue;
+					if ((specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) !== imported) continue;
+					let scope = source.getScope(node);
+					while (scope && !scope.set.has(specifier.local.name)) scope = scope.upper;
+					if (scope?.set.get(specifier.local.name)?.defs.some((def) => def.node === specifier)) {
+						resolved.set(reference, specifier.local.name);
+						return specifier.local.name;
+					}
+				}
+			}
+			let local = imported;
+			for (let suffix = 1; occupied.has(local); suffix++) local = imported + suffix;
+			occupied.add(local);
+			const specifiers = imports.get(quotedModule) ?? [];
+			specifiers.push(imported + (local === imported ? "" : " as " + local));
+			imports.set(quotedModule, specifiers);
+			resolved.set(reference, local);
+			return local;
+		}),
+		fix(fixer) {
+			if (!imports.size) return [];
+			let anchor = source.ast.body.filter((statement) => statement.type === "ImportDeclaration").at(-1);
+			if (!anchor) for (const statement of source.ast.body) {
+				if (statement.type !== "ExpressionStatement" || statement.expression.type !== "Literal" || typeof statement.expression.value !== "string") break;
+				anchor = statement;
+			}
+			const block = [...imports].map(([module, specifiers]) => "import type {" + specifiers.join(", ") + "} from " + module + ";").join("\n");
+			return anchor ? [fixer.insertTextAfter(anchor, "\n" + block)] : [fixer.insertTextBefore(source.ast.body[0], block + "\n")];
+		}
+	};
+}
+function catalogAnnotation(context, node) {
+	const parent = node.parent;
+	if (parent?.type !== "VariableDeclarator" || parent.init !== node) return;
+	const annotation = parent.id.typeAnnotation?.typeAnnotation;
+	if (!annotation) return;
+	function imported(type, name) {
+		if (type.type !== "TSTypeReference" || type.typeName?.type !== "Identifier") return false;
+		let scope = context.sourceCode.getScope(node);
+		while (scope) {
+			const binding = scope.set.get(type.typeName.name);
+			if (binding) {
+				const definition = binding.defs[0];
+				return definition?.type === "ImportBinding" && descriptorModules.has(String(definition.parent.source.value)) && definition.node.type === "ImportSpecifier" && (definition.node.imported.type === "Identifier" ? definition.node.imported.name : definition.node.imported.value) === name;
+			}
+			scope = scope.upper;
+		}
+		return false;
+	}
+	function broad(type) {
+		if (type.type === "TSTypeLiteral") return !!type.members?.every((member) => member.type === "TSPropertySignature" && !!member.typeAnnotation && imported(member.typeAnnotation.typeAnnotation, "MessageDescriptor"));
+		let scope = context.sourceCode.getScope(node);
+		while (scope) {
+			if (scope.set.get(type.typeName?.name ?? "")?.defs.length) return false;
+			scope = scope.upper;
+		}
+		const parameters = (type.typeArguments ?? type.typeParameters)?.params;
+		if (type.typeName?.name === "Readonly" && parameters?.length === 1) return broad(parameters[0]);
+		return type.typeName?.name === "Record" && parameters?.length === 2 && imported(parameters[1], "MessageDescriptor");
+	}
+	function typedMap(type) {
+		return type.type === "TSTypeLiteral" && !!type.members?.every((member) => member.type === "TSPropertySignature" && !member.computed && !!member.typeAnnotation && imported(member.typeAnnotation.typeAnnotation, "TypedMessageDescriptor"));
+	}
+	let base = annotation;
+	let generated = typedMap(annotation) ? annotation : void 0;
+	if (annotation.type === "TSIntersectionType" && annotation.types?.length === 2) {
+		const [left, right] = annotation.types;
+		if (right.type === "TSTypeLiteral" && right.members?.every((member) => member.type === "TSPropertySignature" && !!member.typeAnnotation && imported(member.typeAnnotation.typeAnnotation, "TypedMessageDescriptor"))) {
+			base = left;
+			generated = right;
+		}
+	}
+	return {
+		annotation,
+		base,
+		generated,
+		supported: broad(base) || typedMap(base)
+	};
+}
+const descriptorModules = /* @__PURE__ */ new Set([
+	"@formatjs/intl",
+	"react-intl",
+	"react-intl/server"
+]);
+function checkInlineMessage(context, node) {
+	if (node.type !== "CallExpression") return;
+	const settings = getSettings(context);
+	if (node.callee.type === "MemberExpression" && node.callee.computed) return;
+	if (!isIntlFormatMessageCall({
+		...node,
+		arguments: [{
+			type: "ObjectExpression",
+			properties: []
+		}]
+	}, settings.additionalFunctionNames)) return;
+	const source = context.sourceCode;
+	const call = node;
+	const generic = call.typeArguments ?? call.typeParameters;
+	if (!generic && !context.options[0]?.generateTypes) return;
+	const generated = !!generic && /^<\s*\/\* @formatjs-generated \*\//.test(source.getText(generic));
+	const descriptor = node.arguments[0];
+	if (!staticObject(descriptor)) {
+		if (generic) context.report({
+			node,
+			messageId: "dynamic"
+		});
+		return;
+	}
+	const existingModule = source.ast.body.find((statement) => statement.type === "ImportDeclaration" && typeof statement.source.value === "string" && descriptorModules.has(statement.source.value));
+	const module = context.options[0]?.moduleSource ?? (existingModule?.type === "ImportDeclaration" ? String(existingModule.source.value) : "@formatjs/intl");
+	const ignoreTag = messageIgnoreTag(context, node);
+	if (ignoreTag === void 0) {
+		if (generic) context.report({
+			node,
+			messageId: "dynamic"
+		});
+		return !!generic;
+	}
+	const messages = extractMessages(node, settings);
+	const message = messages[0]?.[0];
+	if (messages.length !== 1 || !message || typeof message.message.defaultMessage !== "string" || !staticMessage(message.messageNode ?? void 0)) {
+		if (generic) context.report({
+			node,
+			messageId: "dynamic"
+		});
+		return;
+	}
+	let contract;
+	try {
+		contract = messageTypes(parse(message.message.defaultMessage, { ignoreTag }), module, context.options[0]?.ignoreList);
+	} catch (error) {
+		context.report({
+			node,
+			messageId: "invalid",
+			data: { error: error instanceof Error ? error.message : String(error) }
+		});
+		return true;
+	}
+	const imports = hoistTypes(context, node, contract);
+	contract = imports.text;
+	const parameters = generic?.params;
+	if (parameters && parameters.length >= 1 && parameters.length <= 2 && renderType(parameters[0]) === contract && !generated) return true;
+	if (generic && (!parameters || parameters.length > 2)) {
+		context.report({
+			node: generic,
+			messageId: "manual"
+		});
+		return true;
+	}
+	context.report({
+		node,
+		messageId: "contract",
+		fix(fixer) {
+			return [...imports.fix(fixer), generic && parameters?.[0] ? fixer.replaceTextRange([generic.range[0] + 1, parameters[0].range[1]], contract) : fixer.insertTextAfter(node.optional ? source.getTokenAfter(node.callee) : node.callee, "<" + contract + ">")];
+		}
+	});
+	return true;
+}
+const rule$20 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Check ICU placeholders and optionally generate TypeScript argument contracts" },
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: {
+				generateTypes: { type: "boolean" },
+				ignoreList: {
+					type: "array",
+					items: { type: "string" }
+				},
+				moduleSource: {
+					type: "string",
+					enum: [...descriptorModules]
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			...rule$21.meta.messages,
+			contract: "Generate or refresh the ICU argument contract.",
+			invalid: "Cannot generate message types: {{error}}.",
+			manual: "Unsupported number of generic arguments; update the call manually.",
+			annotation: "Catalog annotation may erase ICU contracts; use per-message TypedMessageDescriptor types.",
+			dynamic: "Typed messages require static message strings and parser options for contract verification."
+		}
+	},
+	create(context) {
+		const listeners = {
+			JSXOpeningElement(node) {
+				checkPlaceholders(context, node);
+			},
+			NewExpression(node) {
+				if (node.type !== "NewExpression" || !/\.[cm]?tsx?$/.test(context.filename)) return;
+				const imported = importedHelper(context, node);
+				if (imported?.helper !== "IntlMessageFormat") return;
+				const source = context.sourceCode;
+				const call = node;
+				const generic = call.typeArguments ?? call.typeParameters;
+				if (!generic && !context.options[0]?.generateTypes) return;
+				const generated = !!generic && /^<\s*\/\* @formatjs-generated \*\//.test(source.getText(generic));
+				const message = staticString(node.arguments[0]);
+				const options = node.arguments[3];
+				let ignoreTag = false;
+				if (message === void 0 || node.arguments.some((argument) => argument.type === "SpreadElement") || options && !staticObject(options)) {
+					if (generic) context.report({
+						node,
+						messageId: "dynamic"
+					});
+					return;
+				}
+				if (staticObject(options)) for (const property of options.properties) {
+					if (property.type !== "Property") continue;
+					if ((property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? property.key.value : void 0) !== "ignoreTag") continue;
+					if (property.value.type !== "Literal" || typeof property.value.value !== "boolean") {
+						if (generic) context.report({
+							node,
+							messageId: "dynamic"
+						});
+						return;
+					}
+					ignoreTag = property.value.value;
+				}
+				let contract;
+				try {
+					contract = messageTypes(parse(message, { ignoreTag }), imported.module, context.options[0]?.ignoreList);
+				} catch (error) {
+					context.report({
+						node,
+						messageId: "invalid",
+						data: { error: error instanceof Error ? error.message : String(error) }
+					});
+					return;
+				}
+				const imports = hoistTypes(context, node, contract);
+				contract = imports.text;
+				const parameters = generic?.params;
+				if (parameters?.length === 1 && renderType(parameters[0]) === contract && !generated) return;
+				if (generic && parameters?.length !== 1) {
+					context.report({
+						node: generic,
+						messageId: "manual"
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "contract",
+					fix(fixer) {
+						const expected = `<${contract}>`;
+						return [...imports.fix(fixer), generic ? fixer.replaceText(generic, expected) : fixer.insertTextAfter(node.callee, expected)];
+					}
+				});
+			},
+			CallExpression(node) {
+				if (node.type !== "CallExpression") return;
+				if (!/\.[cm]?tsx?$/.test(context.filename)) {
+					checkPlaceholders(context, node);
+					return;
+				}
+				const imported = importedHelper(context, node);
+				if (!imported) {
+					if (!checkInlineMessage(context, node)) checkPlaceholders(context, node);
+					return;
+				}
+				const source = context.sourceCode;
+				const call = node;
+				const generic = call.typeArguments ?? call.typeParameters;
+				const generated = !!generic && /^<\s*\/\* @formatjs-generated \*\//.test(source.getText(generic));
+				const options = node.arguments[1];
+				const typed = staticObject(options) && options.properties.length === 1 && options.properties.some((p) => p.type === "Property" && (p.key.type === "Identifier" ? p.key.name : p.key.type === "Literal" ? p.key.value : void 0) === "typed" && p.value.type === "Literal" && p.value.value === true);
+				if (!typed && !generated && !context.options[0]?.generateTypes) return;
+				if (!typed && generic && !generated && !context.options[0]?.generateTypes) return;
+				if (node.arguments.length > 2 || options && !typed) return;
+				const descriptor = node.arguments[0];
+				if (!staticObject(descriptor)) {
+					if (typed || generated) context.report({
+						node,
+						messageId: "dynamic"
+					});
+					return;
+				}
+				if (imported.helper === "defineMessages" && !descriptor.properties.every((p) => p.type === "Property" && staticObject(p.value))) {
+					if (typed || generated) context.report({
+						node,
+						messageId: "dynamic"
+					});
+					return;
+				}
+				const messages = extractMessages({
+					...node,
+					callee: {
+						type: "Identifier",
+						name: imported.helper
+					}
+				}, getSettings(context));
+				if (messages.some(([message]) => typeof message.message.defaultMessage !== "string" || !staticMessage(message.messageNode ?? void 0)) || messages.length !== (imported.helper === "defineMessage" ? 1 : descriptor.properties.length)) {
+					if (typed || generated) context.report({
+						node,
+						messageId: "dynamic"
+					});
+					return;
+				}
+				const annotation = imported.helper === "defineMessages" ? catalogAnnotation(context, node) : void 0;
+				if (annotation && !annotation.supported) {
+					context.report({
+						node: annotation.annotation,
+						messageId: "annotation"
+					});
+					return;
+				}
+				let contract;
+				let catalogType;
+				try {
+					const types = messages.map(([message]) => messageTypes(parse(message.message.defaultMessage, { ignoreTag: getSettings(context).ignoreTag }), imported.module, context.options[0]?.ignoreList));
+					if (annotation) {
+						catalogType = "{ " + descriptor.properties.map((property, index) => {
+							if (property.type !== "Property") throw new Error("Unexpected spread");
+							const key = property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? String(property.key.value) : void 0;
+							if (key === void 0) throw new Error("Unsupported catalog key");
+							return "readonly " + JSON.stringify(key) + ": import(" + JSON.stringify(imported.module) + ").TypedMessageDescriptor<" + types[index] + ">";
+						}).join("; ") + " }";
+						if (!descriptor.properties.length) catalogType = "{}";
+					}
+					contract = imported.helper === "defineMessage" ? types[0] : descriptor.properties.length === 0 ? "{}" : `{ ${descriptor.properties.map((p, i) => {
+						if (p.type !== "Property") throw new Error("Unexpected spread");
+						const key = p.key.type === "Identifier" ? p.key.name : p.key.type === "Literal" ? String(p.key.value) : void 0;
+						if (key === void 0) throw new Error("Unsupported catalog key");
+						return `readonly ${JSON.stringify(key)}: ${types[i]}`;
+					}).join("; ")} }`;
+				} catch (error) {
+					context.report({
+						node,
+						messageId: "invalid",
+						data: { error: error instanceof Error ? error.message : String(error) }
+					});
+					return;
+				}
+				const imports = hoistTypes(context, node, contract + (catalogType ? "\n" + catalogType : ""));
+				[contract, catalogType] = imports.text.split("\n");
+				const annotationMatches = !annotation || annotation.annotation === annotation.generated && renderType(annotation.generated) === catalogType;
+				const expected = `<${contract}>`;
+				const parameters = generic?.params;
+				if (parameters && parameters.length >= 1 && parameters.length <= 2 && renderType(parameters[0]) === contract && typed && !generated && annotationMatches) return;
+				if (generic && (!parameters || parameters.length < 1 || parameters.length > 2)) {
+					context.report({
+						node: generic,
+						messageId: "manual"
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "contract",
+					fix(fixer) {
+						const edits = [...imports.fix(fixer), generic && parameters?.[0] ? fixer.replaceTextRange([generic.range[0] + 1, parameters[0].range[1]], contract) : fixer.insertTextAfter(node.optional ? source.getTokenAfter(node.callee) : node.callee, expected)];
+						if (annotation && !annotationMatches) edits.push(fixer.replaceText(annotation.annotation, catalogType));
+						if (!typed) {
+							const close = source.getLastToken(node);
+							const previous = source.getTokenBefore(close);
+							edits.push(fixer.insertTextBefore(close, `${previous.value === "," ? "" : ","} {typed: true}`));
+						}
+						return edits;
+					}
+				});
+			}
+		};
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: listeners.CallExpression }, { CallExpression: listeners.CallExpression });
+		return listeners;
+	}
+};
+//#endregion
 //#region packages/eslint-plugin-formatjs/rules/blocklist-elements.ts
-const name$22 = "blocklist-elements";
+const name$21 = "blocklist-elements";
 function getMessage(type) {
 	return {
 		messageId: "blocklist",
@@ -277,7 +921,7 @@ function verifyAst$7(blocklist, ast) {
 	}
 	return errors;
 }
-function checkNode$17(context, node) {
+function checkNode$16(context, node) {
 	const settings = getSettings(context);
 	const msgs = extractMessages(node, settings);
 	if (!msgs.length) return;
@@ -303,7 +947,7 @@ function checkNode$17(context, node) {
 		});
 	}
 }
-const rule$20 = {
+const rule$19 = {
 	meta: {
 		type: "problem",
 		docs: {
@@ -347,11 +991,11 @@ const rule$20 = {
 		}
 	},
 	create(context) {
-		const callExpressionVisitor = (node) => checkNode$17(context, node);
+		const callExpressionVisitor = (node) => checkNode$16(context, node);
 		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		return {
-			JSXOpeningElement: (node) => checkNode$17(context, node),
+			JSXOpeningElement: (node) => checkNode$16(context, node),
 			CallExpression: callExpressionVisitor
 		};
 	}
@@ -363,8 +1007,8 @@ let Option$1 = /* @__PURE__ */ function(Option) {
 	Option["anything"] = "anything";
 	return Option;
 }({});
-const name$21 = "enforce-default-message";
-function checkNode$16(context, node) {
+const name$20 = "enforce-default-message";
+function checkNode$15(context, node) {
 	const msgs = extractMessages(node, getSettings(context));
 	const { options: [type] } = context;
 	for (const [{ message: { defaultMessage }, messageNode, messageDescriptorNode }] of msgs) if (!defaultMessage) {
@@ -378,7 +1022,7 @@ function checkNode$16(context, node) {
 		});
 	}
 }
-const rule$19 = {
+const rule$18 = {
 	meta: {
 		type: "problem",
 		docs: {
@@ -398,11 +1042,11 @@ const rule$19 = {
 		}
 	},
 	create(context) {
-		const callExpressionVisitor = (node) => checkNode$16(context, node);
+		const callExpressionVisitor = (node) => checkNode$15(context, node);
 		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		return {
-			JSXOpeningElement: (node) => checkNode$16(context, node),
+			JSXOpeningElement: (node) => checkNode$15(context, node),
 			CallExpression: callExpressionVisitor
 		};
 	}
@@ -428,7 +1072,7 @@ function normalizeOptions(raw) {
 		minLength: void 0
 	};
 }
-function checkNode$15(context, node) {
+function checkNode$14(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) {
@@ -449,8 +1093,8 @@ function checkNode$15(context, node) {
 		}
 	});
 }
-const name$20 = "enforce-description";
-const rule$18 = {
+const name$19 = "enforce-description";
+const rule$17 = {
 	meta: {
 		type: "problem",
 		docs: {
@@ -483,18 +1127,18 @@ const rule$18 = {
 		}
 	},
 	create(context) {
-		const callExpressionVisitor = (node) => checkNode$15(context, node);
+		const callExpressionVisitor = (node) => checkNode$14(context, node);
 		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		return {
-			JSXOpeningElement: (node) => checkNode$15(context, node),
+			JSXOpeningElement: (node) => checkNode$14(context, node),
 			CallExpression: callExpressionVisitor
 		};
 	}
 };
 //#endregion
 //#region packages/eslint-plugin-formatjs/rules/enforce-id.ts
-function checkNode$14(context, node, { idInterpolationPattern, idWhitelistRegexps, quoteStyle }) {
+function checkNode$13(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) {
@@ -552,8 +1196,8 @@ function checkNode$14(context, node, { idInterpolationPattern, idWhitelistRegexp
 		}
 	}
 }
-const name$19 = "enforce-id";
-const rule$17 = {
+const name$18 = "enforce-id";
+const rule$16 = {
 	meta: {
 		type: "problem",
 		docs: {
@@ -604,114 +1248,11 @@ Actual: {{actual}}`
 			const { idWhitelist } = tmp;
 			opts.idWhitelistRegexps = idWhitelist.map((str) => new RegExp(str, "i"));
 		}
-		const callExpressionVisitor = (node) => checkNode$14(context, node, opts);
-		const parserServices = context.sourceCode.parserServices;
-		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
-		return {
-			JSXOpeningElement: (node) => checkNode$14(context, node, opts),
-			CallExpression: callExpressionVisitor
-		};
-	}
-};
-//#endregion
-//#region packages/eslint-plugin-formatjs/rules/enforce-placeholders.ts
-function collectPlaceholderNames(ast) {
-	const placeholderNames = /* @__PURE__ */ 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);
-		}
-	}
-}
-function checkNode$13(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") continue;
-		if (values?.properties.find((prop) => prop.type === "SpreadElement")) continue;
-		const literalElementByLiteralKey = /* @__PURE__ */ 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"
-			});
-		});
-	}
-}
-const name$18 = "enforce-placeholders";
-const rule$16 = {
-	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$13(context, node);
+		const callExpressionVisitor = (node) => checkNode$13(context, node, opts);
 		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		return {
-			JSXOpeningElement: (node) => checkNode$13(context, node),
+			JSXOpeningElement: (node) => checkNode$13(context, node, opts),
 			CallExpression: callExpressionVisitor
 		};
 	}
@@ -4583,7 +5124,7 @@ var package_exports = /* @__PURE__ */ __exportAll({
 	version: () => version$1
 });
 var name$1 = "eslint-plugin-formatjs";
-var version$1 = "6.6.3";
+var version$1 = "7.0.0-rc.0";
 var description = "ESLint plugin for formatjs";
 var keywords = [
 	"eslint",
@@ -4644,6 +5185,7 @@ const plugin = {
 		[name$20]: rule$18,
 		[name$19]: rule$17,
 		[name$18]: rule$16,
+		[name$23]: rule$21,
 		[name$17]: rule$15,
 		[name$16]: rule$14,
 		[name$15]: rule$13,