eslint-plugin-formatjs 8.0.0 → 8.0.2

package/index.js

@@ -385,6 +385,44 @@ const modules = /* @__PURE__ */ new Set([
 function staticObject(node) {
 	return node?.type === "ObjectExpression" && node.properties.every((property) => property.type === "Property" && !property.computed && property.kind === "init" && !property.method);
 }
+function resolveDescriptor(context, node, seen = /* @__PURE__ */ new Set()) {
+	if (!node || seen.has(node)) return;
+	if (node.type !== "Identifier") return node;
+	seen.add(node);
+	let scope = context.sourceCode.getScope(node);
+	while (scope) {
+		const variable = scope.set.get(node.name);
+		if (variable) {
+			const definition = variable.defs[0];
+			if (definition?.type !== "Variable" || definition.parent?.kind !== "const" || !definition.node.init) return;
+			if (variable.references.some((reference) => {
+				if (reference.init) return false;
+				const parent = reference.identifier.parent;
+				if (parent?.type === "Property" && parent.value === reference.identifier) {
+					const object = parent.parent;
+					const call = object?.parent;
+					if (call?.type === "CallExpression" && call.arguments[0] === object && importedHelper(context, call)?.helper === "defineMessages") return false;
+				}
+				return parent?.type !== "CallExpression" || parent.arguments[0] !== reference.identifier || !importedHelper(context, parent) && !isIntlFormatMessageCall({
+					...parent,
+					arguments: [{
+						type: "ObjectExpression",
+						properties: []
+					}]
+				}, getSettings(context).additionalFunctionNames);
+			})) return;
+			return resolveDescriptor(context, definition.node.init, seen);
+		}
+		scope = scope.upper;
+	}
+}
+function typeQuery(node) {
+	if (node?.type === "Identifier") return node.name;
+	if (node?.type === "MemberExpression" && !node.computed && node.property.type === "Identifier") {
+		const object = typeQuery(node.object);
+		if (object) return object + "." + node.property.name;
+	}
+}
 function staticMessage(node) {
 	if (!node) return false;
 	if (node.type === "Literal") return typeof node.value === "string";
@@ -464,6 +502,16 @@ function renderType(node) {
 		if (types.every((type) => type !== void 0)) return node.typeName.name + "<" + types.join(", ") + ">";
 		return;
 	}
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "TSQualifiedName") {
+		const left = renderType(node.left);
+		const right = renderType(node.right);
+		if (left && right) return left + "." + right;
+	}
+	if (node.type === "TSTypeQuery") {
+		const name = renderType(node.exprName);
+		if (name) return "typeof " + name;
+	}
 	if (node.type === "TSUnionType") {
 		const types = node.types?.map(renderType);
 		if (types?.every((type) => type !== void 0)) return types.join(" | ");
@@ -475,11 +523,11 @@ function renderType(node) {
 	if (node.type === "TSTypeLiteral" && node.members) {
 		const fields = [];
 		for (const member of node.members) {
-			if (member.type !== "TSPropertySignature" || member.computed) return;
+			if (member.type !== "TSPropertySignature") 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}`);
+			if (!member.computed && key === void 0 || type === void 0) return;
+			fields.push(`${member.readonly ? "readonly " : ""}${member.computed ? "[" + (typeQuery(member.key) ?? renderType(member.key)) + "]" : JSON.stringify(String(key))}${member.optional ? "?" : ""}: ${type}`);
 		}
 		return fields.length ? `{ ${fields.join("; ")} }` : "{}";
 	}
@@ -490,7 +538,7 @@ function hoistTypes(context, node, contract) {
 	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) => {
+		text: contract.replace(/import\(("(?:[^"\\]|\\.)*")\)\.(MessageTag|MessageValuesOf|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) {
@@ -527,14 +575,78 @@ function hoistTypes(context, node, contract) {
 		}
 	};
 }
-function catalogAnnotation(context, node) {
+function obsoleteTypes(context, replaced, replacement, fixer) {
+	const source = context.sourceCode;
+	const removed = [...replaced];
+	const declarations = /* @__PURE__ */ new Set();
+	const retainedNames = new Set(replacement.match(/[$\p{ID_Start}][$\p{ID_Continue}]*/gu));
+	const contains = (node) => removed.some((range) => range.range && node.range && range.range[0] <= node.range[0] && range.range[1] >= node.range[1]);
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const scope of source.scopeManager?.scopes ?? []) for (const variable of scope.variables) {
+			if (variable.defs.length !== 1 || !variable.references.length || !variable.references.every((reference) => contains(reference.identifier))) continue;
+			if (retainedNames.has(variable.name)) continue;
+			const definition = variable.defs[0];
+			const declaration = definition.node;
+			if (declarations.has(declaration)) continue;
+			if (declaration.type === "ImportSpecifier") {
+				const imported = declaration.imported.type === "Identifier" ? declaration.imported.name : declaration.imported.value;
+				if (declaration.importKind !== "type" && definition.parent?.importKind !== "type" && !(definition.type === "ImportBinding" && descriptorModules.has(String(definition.parent.source.value)) && ["MessageDescriptor", "TypedMessageDescriptor"].includes(String(imported)))) continue;
+			} else if (declaration.type !== "TSTypeAliasDeclaration" || declaration.parent?.type === "ExportNamedDeclaration") continue;
+			declarations.add(declaration);
+			removed.push(declaration);
+			changed = true;
+		}
+	}
+	const edits = [];
+	for (const scope of source.scopeManager?.scopes ?? []) for (const variable of scope.variables) {
+		if (variable.defs.length !== 1 || retainedNames.has(variable.name) || declarations.has(variable.defs[0].node)) continue;
+		if (variable.references.some((reference) => contains(reference.identifier))) {
+			const identifier = variable.identifiers[0];
+			if (identifier && !contains(identifier)) edits.push(fixer.replaceText(identifier, source.getText(identifier)));
+		}
+	}
+	const imports = /* @__PURE__ */ new Map();
+	for (const declaration of declarations) {
+		if (declaration.type !== "ImportSpecifier") {
+			edits.push(fixer.remove(declaration));
+			continue;
+		}
+		const parent = declaration.parent;
+		const specifiers = imports.get(parent) ?? /* @__PURE__ */ new Set();
+		specifiers.add(declaration);
+		imports.set(parent, specifiers);
+	}
+	for (const [declaration, removedSpecifiers] of imports) {
+		if (declaration.type !== "ImportDeclaration") continue;
+		if (declaration.specifiers.every((specifier) => removedSpecifiers.has(specifier))) {
+			edits.push(fixer.remove(declaration));
+			continue;
+		}
+		for (let i = 0; i < declaration.specifiers.length; i++) {
+			const first = declaration.specifiers[i];
+			if (!removedSpecifiers.has(first)) continue;
+			let last = first;
+			while (i + 1 < declaration.specifiers.length && removedSpecifiers.has(declaration.specifiers[i + 1])) last = declaration.specifiers[++i];
+			const next = source.getTokenAfter(last);
+			if (next.value === ",") edits.push(fixer.removeRange([first.range[0], next.range[1] + (source.text.slice(next.range[1]).match(/^\s*/)?.[0].length ?? 0)]));
+			else {
+				const previous = source.getTokenBefore(first);
+				edits.push(fixer.removeRange([previous.value === "," ? previous.range[0] : first.range[0], last.range[1]]));
+			}
+		}
+	}
+	return edits;
+}
+function messageAnnotation(context, node, catalog) {
 	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);
+		let scope = context.sourceCode.getScope(type);
 		while (scope) {
 			const binding = scope.set.get(type.typeName.name);
 			if (binding) {
@@ -545,23 +657,34 @@ function catalogAnnotation(context, node) {
 		}
 		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);
+	function descriptorType(type) {
+		return imported(type, "MessageDescriptor") || type.type === "TSUnionType" && !!type.types?.every((part) => part.type === "TSUndefinedKeyword" || imported(part, "MessageDescriptor"));
+	}
+	function broad(type, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(type)) return false;
+		seen.add(type);
+		if (!catalog && imported(type, "MessageDescriptor")) return true;
+		if (type.type === "TSTypeLiteral") return catalog && !!type.members?.every((member) => member.type === "TSPropertySignature" && !!member.typeAnnotation && descriptorType(member.typeAnnotation.typeAnnotation));
+		let scope = context.sourceCode.getScope(type);
 		while (scope) {
-			if (scope.set.get(type.typeName?.name ?? "")?.defs.length) return false;
+			const binding = scope.set.get(type.typeName?.name ?? "");
+			if (binding?.defs.length) {
+				const declaration = binding.defs[0].node;
+				return declaration.type === "TSTypeAliasDeclaration" && !declaration.typeParameters && !!declaration.typeAnnotation && broad(declaration.typeAnnotation, seen);
+			}
 			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");
+		if (type.typeName?.name === "Readonly" && parameters?.length === 1) return broad(parameters[0], seen);
+		return catalog && type.typeName?.name === "Record" && parameters?.length === 2 && descriptorType(parameters[1]);
 	}
 	function typedMap(type) {
-		return type.type === "TSTypeLiteral" && !!type.members?.every((member) => member.type === "TSPropertySignature" && !member.computed && !!member.typeAnnotation && imported(member.typeAnnotation.typeAnnotation, "TypedMessageDescriptor"));
+		if (!catalog) return imported(type, "TypedMessageDescriptor");
+		return type.type === "TSTypeLiteral" && !!type.members?.every((member) => member.type === "TSPropertySignature" && !!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) {
+	if (catalog && 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;
@@ -598,7 +721,7 @@ function checkInlineMessage(context, 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];
+	const descriptor = resolveDescriptor(context, node.arguments[0]);
 	if (!staticObject(descriptor)) {
 		if (generic) context.report({
 			node,
@@ -616,7 +739,10 @@ function checkInlineMessage(context, node) {
 		});
 		return !!generic;
 	}
-	const messages = extractMessages(node, settings);
+	const messages = extractMessages({
+		...node,
+		arguments: [descriptor]
+	}, 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({
@@ -692,7 +818,7 @@ const rule$20 = {
 			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.",
+			annotation: "Message annotation may erase ICU contracts; use TypedMessageDescriptor types.",
 			dynamic: "Typed messages require static message strings and parser options for contract verification."
 		}
 	},
@@ -782,36 +908,63 @@ const rule$20 = {
 				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 (!generic && !typed && !context.options[0]?.generateTypes) return;
 				if (node.arguments.length > 2 || options && !typed) return;
-				const descriptor = node.arguments[0];
-				if (!staticObject(descriptor)) {
+				const descriptor = resolveDescriptor(context, node.arguments[0]);
+				const catalog = imported.helper === "defineMessages";
+				if (descriptor?.type !== "ObjectExpression" || !descriptor.properties.every((p) => p.type === "Property" && p.kind === "init" && !p.method && (!p.computed || !!typeQuery(p.key)))) {
 					if (generic || typed) context.report({
 						node,
 						messageId: "dynamic"
 					});
 					return;
 				}
-				if (imported.helper === "defineMessages" && !descriptor.properties.every((p) => p.type === "Property" && staticObject(p.value))) {
-					if (generic || typed) context.report({
-						node,
-						messageId: "dynamic"
-					});
-					return;
-				}
-				const messages = extractMessages({
-					...node,
-					callee: {
-						type: "Identifier",
-						name: imported.helper
+				const entries = catalog ? descriptor.properties.map((p) => {
+					if (p.type !== "Property") return void 0;
+					return {
+						value: resolveDescriptor(context, p.value),
+						reference: typeQuery(p.value),
+						key: p.computed ? "[" + typeQuery(p.key) + "]" : JSON.stringify(p.key.type === "Identifier" ? p.key.name : p.key.type === "Literal" ? String(p.key.value) : "")
+					};
+				}) : [{
+					value: descriptor,
+					reference: void 0,
+					key: ""
+				}];
+				const types = [];
+				for (const entry of entries) {
+					if (entry && staticObject(entry.value)) {
+						const messages = extractMessages({
+							...node,
+							callee: {
+								type: "Identifier",
+								name: "defineMessage"
+							},
+							arguments: [entry.value]
+						}, getSettings(context));
+						const message = messages[0]?.[0];
+						if (messages.length === 1 && typeof message?.message.defaultMessage === "string" && staticMessage(message.messageNode ?? void 0)) {
+							try {
+								types.push(messageTypes(parse(message.message.defaultMessage, { ignoreTag: getSettings(context).ignoreTag }), imported.module, context.options[0]?.ignoreList));
+							} catch (error) {
+								context.report({
+									node,
+									messageId: "invalid",
+									data: { error: error instanceof Error ? error.message : String(error) }
+								});
+								return;
+							}
+							continue;
+						}
+					} else if (catalog && entry?.reference) {
+						types.push("import(" + JSON.stringify(imported.module) + ").MessageValuesOf<typeof " + entry.reference + ">");
+						continue;
 					}
-				}, 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 (generic || typed) context.report({
 						node,
 						messageId: "dynamic"
 					});
 					return;
 				}
-				const annotation = imported.helper === "defineMessages" ? catalogAnnotation(context, node) : void 0;
+				const annotation = imported.helper === "defineMessages" || imported.helper === "defineMessage" ? messageAnnotation(context, node, catalog) : void 0;
 				if (annotation && !annotation.supported) {
 					context.report({
 						node: annotation.annotation,
@@ -822,22 +975,8 @@ const rule$20 = {
 				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("; ")} }`;
+					if (annotation) catalogType = !catalog ? "import(" + JSON.stringify(imported.module) + ").TypedMessageDescriptor<" + types[0] + ">" : entries.length ? "{ " + entries.map((entry, index) => "readonly " + entry.key + ": import(" + JSON.stringify(imported.module) + ").TypedMessageDescriptor<" + types[index] + ">").join("; ") + " }" : "{}";
+					contract = !catalog ? types[0] : entries.length ? "{ " + entries.map((entry, index) => "readonly " + entry.key + ": " + types[index]).join("; ") + " }" : "{}";
 				} catch (error) {
 					context.report({
 						node,
@@ -863,7 +1002,11 @@ const rule$20 = {
 					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)];
+						const edits = [
+							...imports.fix(fixer),
+							...obsoleteTypes(context, [...parameters?.[0] ? [parameters[0]] : [], ...annotation && !annotationMatches ? [annotation.annotation] : []], contract + (catalogType ?? ""), 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));
 						return edits;
 					}
@@ -5122,7 +5265,7 @@ var package_exports = /* @__PURE__ */ __exportAll({
 	version: () => version$1
 });
 var name$1 = "eslint-plugin-formatjs";
-var version$1 = "8.0.0";
+var version$1 = "8.0.2";
 var description = "ESLint plugin for formatjs";
 var keywords = [
 	"eslint",