eslint-plugin-formatjs 6.1.2 → 6.1.4

package/package.json

@@ -1,20 +1,19 @@
 {
   "name": "eslint-plugin-formatjs",
   "description": "ESLint plugin for formatjs",
-  "version": "6.1.2",
+  "version": "6.1.4",
   "license": "MIT",
   "author": "Long Ho <holevietlong@gmail.com>",
   "type": "module",
   "types": "index.d.ts",
   "dependencies": {
     "@types/picomatch": "^4.0.0",
-    "@typescript-eslint/utils": "^8.52.0",
     "@unicode/unicode-17.0.0": "^1.6.16",
     "magic-string": "^0.30.0",
     "picomatch": "2 || 3 || 4",
     "tslib": "^2.8.1",
     "@formatjs/icu-messageformat-parser": "3.5.1",
-    "@formatjs/ts-transformer": "4.3.2"
+    "@formatjs/ts-transformer": "4.4.0"
   },
   "peerDependencies": {
     "eslint": "9"

package/rules/blocklist-elements.d.ts

@@ -1,6 +1,4 @@
-import { ESLintUtils } from "@typescript-eslint/utils";
-import { type CoreMessageIds } from "../messages.js";
-type MessageIds = "blocklist" | CoreMessageIds;
+import type { Rule } from "eslint";
 export declare const name = "blocklist-elements";
 export declare enum Element {
 	literal = "literal",
@@ -13,5 +11,4 @@ export declare enum Element {
 	plural = "plural",
 	tag = "tag"
 }
-export declare const rule: ESLintUtils.RuleModule<MessageIds, Element[][], unknown, ESLintUtils.RuleListener>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/blocklist-elements.js

@@ -1,7 +1,4 @@
 import { isArgumentElement, isDateElement, isLiteralElement, isNumberElement, isPluralElement, isSelectElement, isTagElement, isTimeElement, parse } from "@formatjs/icu-messageformat-parser";
-import { ESLintUtils } from "@typescript-eslint/utils";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 export const name = "blocklist-elements";
@@ -98,9 +95,7 @@ function checkNode(context, node) {
 		}
 	}
 }
-const createRule = ESLintUtils.RuleCreator((_) => "https://formatjs.github.io/docs/tooling/linter#blocklist-elements");
-export const rule = createRule({
-	name,
+export const rule = {
 	meta: {
 		type: "problem",
 		docs: {
@@ -120,13 +115,10 @@ export const rule = createRule({
 			blocklist: `{{type}} element is blocklisted`
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {
@@ -134,4 +126,4 @@ export const rule = createRule({
 			CallExpression: callExpressionVisitor
 		};
 	}
-});
+};

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

@@ -1,10 +1,7 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
+import type { Rule } from "eslint";
 export declare enum Option {
 	literal = "literal",
 	anything = "anything"
 }
-type MessageIds = "defaultMessage" | "defaultMessageLiteral";
-type Options = [`${Option}`?];
 export declare const name = "enforce-default-message";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/enforce-default-message.js

@@ -1,5 +1,3 @@
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 export let Option = /* @__PURE__ */ function(Option) {
 	Option["literal"] = "literal";
@@ -45,13 +43,10 @@ export const rule = {
 			defaultMessage: "`defaultMessage` has to be specified in message descriptor"
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/enforce-description.d.ts

@@ -1,10 +1,7 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
+import type { Rule } from "eslint";
 export declare enum Option {
 	literal = "literal",
 	anything = "anything"
 }
-type MessageIds = "enforceDescription" | "enforceDescriptionLiteral";
-type Options = [`${Option}`?];
 export declare const name = "enforce-description";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/enforce-description.js

@@ -1,5 +1,3 @@
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 export let Option = /* @__PURE__ */ function(Option) {
 	Option["literal"] = "literal";
@@ -43,13 +41,10 @@ export const rule = {
 			enforceDescriptionLiteral: "`description` has to be a string literal (not function call or variable)"
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/enforce-id.d.ts

@@ -1,11 +1,8 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
+import type { Rule } from "eslint";
 export type Option = {
 	idInterpolationPattern: string;
 	idWhitelist?: string[];
 	quoteStyle?: "single" | "double";
 };
-type MessageIds = "enforceId" | "enforceIdDefaultMessage" | "enforceIdDescription" | "enforceIdMatching" | "enforceIdMatchingAllowlisted";
-type Options = [Option];
 export declare const name = "enforce-id";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/enforce-id.js

@@ -1,6 +1,4 @@
 import { interpolateName } from "@formatjs/ts-transformer";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 function checkNode(context, node, { idInterpolationPattern, idWhitelistRegexps, quoteStyle }) {
 	const msgs = extractMessages(node, getSettings(context));
@@ -114,10 +112,6 @@ Expected: {{expected}}
 Actual: {{actual}}`
 		}
 	},
-	defaultOptions: [{
-		idInterpolationPattern: "[sha512:contenthash:base64:6]",
-		quoteStyle: "single"
-	}],
 	create(context) {
 		const tmp = context.options[0];
 		let opts = {
@@ -129,10 +123,8 @@ Actual: {{actual}}`
 			opts.idWhitelistRegexps = idWhitelist.map((str) => new RegExp(str, "i"));
 		}
 		const callExpressionVisitor = (node) => checkNode(context, node, opts);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/enforce-placeholders.d.ts

@@ -1,9 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-import { type CoreMessageIds } from "../messages.js";
-type MessageIds = "missingValue" | "unusedValue" | CoreMessageIds;
-type Options = [{
-	ignoreList: string[];
-}?];
+import type { Rule } from "eslint";
 export declare const name = "enforce-placeholders";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/enforce-placeholders.js

@@ -1,6 +1,4 @@
 import { TYPE, parse } from "@formatjs/icu-messageformat-parser";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 function collectPlaceholderNames(ast) {
@@ -116,13 +114,10 @@ export const rule = {
 			unusedValue: "Value not used by the message."
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/enforce-plural-rules.d.ts

@@ -1,5 +1,4 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-import { type CoreMessageIds } from "../messages.js";
+import type { Rule } from "eslint";
 declare enum LDML {
 	zero = "zero",
 	one = "one",
@@ -10,7 +9,6 @@ declare enum LDML {
 }
 type PluralConfig = { [key in LDML]? : boolean };
 export type Options = [PluralConfig?];
-type MessageIds = "missingPlural" | "forbidden" | CoreMessageIds;
 export declare const name = "enforce-plural-rules";
-export declare const rule: RuleModule<MessageIds, Options>;
+export declare const rule: Rule.RuleModule;
 export {};

package/rules/enforce-plural-rules.js

@@ -1,6 +1,4 @@
 import { isPluralElement, parse } from "@formatjs/icu-messageformat-parser";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 var LDML = /* @__PURE__ */ function(LDML) {
@@ -96,13 +94,10 @@ export const rule = {
 			forbidden: `Plural rule "{{rule}}" is forbidden`
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/no-camel-case.d.ts

@@ -1,6 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-import { type CoreMessageIds } from "../messages.js";
-type MessageIds = "camelcase" | CoreMessageIds;
+import type { Rule } from "eslint";
 export declare const name = "no-camel-case";
-export declare const rule: RuleModule<MessageIds>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/no-camel-case.js

@@ -1,6 +1,4 @@
 import { isArgumentElement, isPluralElement, parse } from "@formatjs/icu-messageformat-parser";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 export const name = "no-camel-case";
@@ -73,13 +71,10 @@ export const rule = {
 			camelcase: "Camel case arguments are not allowed"
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/no-complex-selectors.d.ts

@@ -1,10 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-import { type CoreMessageIds } from "../messages.js";
-interface Config {
-	limit: number;
-}
-type MessageIds = "tooComplex" | CoreMessageIds;
-type Options = [Config?];
+import type { Rule } from "eslint";
 export declare const name = "no-complex-selectors";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/no-complex-selectors.js

@@ -1,6 +1,4 @@
 import { TYPE, parse } from "@formatjs/icu-messageformat-parser";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 function calculateComplexity(ast) {
@@ -107,13 +105,10 @@ Default complexity limit is 20
 			tooComplex: `Message complexity is too high ({{complexity}} vs limit at {{limit}})`
 		}
 	},
-	defaultOptions: [{ limit: 20 }],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/no-emoji.d.ts

@@ -1,9 +1,8 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
+import type { Rule } from "eslint";
 export declare const name = "no-emoji";
-type MessageIds = "notAllowed" | "notAllowedAboveVersion";
 type NoEmojiConfig = {
 	versionAbove: string;
 };
 export type Options = [NoEmojiConfig?];
-export declare const rule: RuleModule<MessageIds, Options>;
+export declare const rule: Rule.RuleModule;
 export {};

package/rules/no-emoji.js

@@ -1,6 +1,4 @@
-import "@typescript-eslint/utils/ts-eslint";
 import { extractEmojis, filterEmojis, hasEmoji, isValidEmojiVersion } from "../emoji-utils.js";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 export const name = "no-emoji";
 function checkNode(context, node) {
@@ -76,13 +74,10 @@ export const rule = {
 			notAllowedAboveVersion: "Emojis above version {{versionAbove}} are not allowed - Emoji: {{emoji}}"
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/no-id.d.ts

@@ -1,5 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-type MessageIds = "noId";
+import type { Rule } from "eslint";
 export declare const name = "no-id";
-export declare const rule: RuleModule<MessageIds>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/no-id.js

@@ -1,5 +1,3 @@
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 function isComment(token) {
 	return !!token && (token.type === "Block" || token.type === "Line");
@@ -36,13 +34,10 @@ export const rule = {
 		schema: [],
 		messages: { noId: "Manual `id` are not allowed in message descriptor" }
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/no-invalid-icu.d.ts

@@ -1,4 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-import { type CoreMessageIds } from "../messages.js";
+import type { Rule } from "eslint";
 export declare const name = "no-invalid-icu";
-export declare const rule: RuleModule<CoreMessageIds>;
+export declare const rule: Rule.RuleModule;

package/rules/no-invalid-icu.js

@@ -1,6 +1,4 @@
 import { parse } from "@formatjs/icu-messageformat-parser";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 export const name = "no-invalid-icu";
@@ -44,13 +42,10 @@ export const rule = {
 		schema: [],
 		messages: CORE_MESSAGES
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/no-literal-string-in-jsx.d.ts

@@ -1,13 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-type PropMatcher = readonly [TagNamePattern: string, PropNamePattern: string][];
-type Config = {
-	props?: {
-		include?: PropMatcher;
-		exclude?: PropMatcher;
-	};
-};
-type MessageIds = "noLiteralStringInJsx";
-type Options = [Config?];
+import type { Rule } from "eslint";
 export declare const name = "no-literal-string-in-jsx";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/no-literal-string-in-jsx.js

@@ -1,6 +1,3 @@
-import { TSESTree } from "@typescript-eslint/utils";
-import "@typescript-eslint/utils/json-schema";
-import "@typescript-eslint/utils/ts-eslint";
 import * as picomatchNs from "picomatch";
 const picomatch = picomatchNs.default ?? picomatchNs;
 const propMatcherSchema = {
@@ -18,9 +15,9 @@ const defaultPropIncludePattern = [
 const defaultPropExcludePattern = [];
 function stringifyJsxTagName(tagName) {
 	switch (tagName.type) {
-		case TSESTree.AST_NODE_TYPES.JSXIdentifier: return tagName.name;
-		case TSESTree.AST_NODE_TYPES.JSXMemberExpression: return `${stringifyJsxTagName(tagName.object)}.${tagName.property.name}`;
-		case TSESTree.AST_NODE_TYPES.JSXNamespacedName: return `${tagName.namespace.name}:${tagName.name.name}`;
+		case "JSXIdentifier": return tagName.name;
+		case "JSXMemberExpression": return `${stringifyJsxTagName(tagName.object)}.${tagName.property.name}`;
+		case "JSXNamespacedName": return `${tagName.namespace.name}:${tagName.name.name}`;
 	}
 }
 function compilePropMatcher(propMatcher) {
@@ -50,7 +47,6 @@ export const rule = {
 		}],
 		messages: { noLiteralStringInJsx: "Cannot have untranslated text in JSX" }
 	},
-	defaultOptions: [],
 	create(context) {
 		const userConfig = context.options[0] || {};
 		const propIncludePattern = compilePropMatcher([...defaultPropIncludePattern, ...userConfig.props?.include ?? []]);

package/rules/no-literal-string-in-object.d.ts

@@ -1,9 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-type MessageIds = "untranslatedProperty";
-type PropertyConfig = {
-	include: string[];
-};
-type Options = [PropertyConfig?];
+import type { Rule } from "eslint";
 export declare const name = "no-literal-string-in-object";
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/no-literal-string-in-object.js

@@ -1,6 +1,3 @@
-import { TSESTree } from "@typescript-eslint/utils";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 export const name = "no-literal-string-in-object";
 export const rule = {
 	meta: {
@@ -20,15 +17,12 @@ export const rule = {
 		}],
 		messages: { untranslatedProperty: "Object property: `{{propertyKey}}` might contain an untranslated literal string" }
 	},
-	defaultOptions: [],
 	create(context) {
 		const propertyVisitor = (node) => {
 			checkProperty(context, node);
 		};
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ Property: propertyVisitor }, { Property: propertyVisitor });
 		}
 		return { Property: propertyVisitor };
@@ -39,7 +33,7 @@ function checkProperty(context, node) {
 		include: ["label"],
 		...context.options[0]
 	};
-	const propertyKey = node.key.type === TSESTree.AST_NODE_TYPES.Identifier ? node.key.name : node.key.type === TSESTree.AST_NODE_TYPES.Literal && typeof node.key.value === "string" ? node.key.value : null;
+	const propertyKey = node.key.type === "Identifier" ? node.key.name : node.key.type === "Literal" && typeof node.key.value === "string" ? node.key.value : null;
 	if (!propertyKey || !config.include.includes(propertyKey)) {
 		return;
 	}

package/rules/no-missing-icu-plural-one-placeholders.d.ts

@@ -1,7 +1,5 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
+import type { Rule } from "eslint";
 import { type CoreMessageIds } from "../messages.js";
 export declare const name = "no-missing-icu-plural-one-placeholders";
 export type MessageIds = "noMissingIcuPluralOnePlaceholders" | CoreMessageIds;
-type Options = [];
-export declare const rule: RuleModule<MessageIds, Options>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/no-missing-icu-plural-one-placeholders.js

@@ -1,7 +1,5 @@
 import { isLiteralElement, isPluralElement, isSelectElement, isTagElement, parse } from "@formatjs/icu-messageformat-parser";
-import "@typescript-eslint/utils/ts-eslint";
 import MagicString from "magic-string";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, patchMessage } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 export const name = "no-missing-icu-plural-one-placeholders";
@@ -82,13 +80,10 @@ export const rule = {
 		},
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/no-multiple-plurals.d.ts

@@ -1,6 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-import { type CoreMessageIds } from "../messages.js";
-type MessageIds = "noMultiplePlurals" | CoreMessageIds;
+import type { Rule } from "eslint";
 export declare const name = "no-multiple-plurals";
-export declare const rule: RuleModule<MessageIds>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/no-multiple-plurals.js

@@ -1,6 +1,4 @@
 import { isPluralElement, parse } from "@formatjs/icu-messageformat-parser";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 function verifyAst(ast, pluralCount = { count: 0 }) {
@@ -64,13 +62,10 @@ export const rule = {
 			noMultiplePlurals: "Multiple plural rules in the same message"
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/no-multiple-whitespaces.d.ts

@@ -1,6 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-import { type CoreMessageIds } from "../messages.js";
-type MessageIds = "noMultipleWhitespaces" | CoreMessageIds;
+import type { Rule } from "eslint";
 export declare const name = "no-multiple-whitespaces";
-export declare const rule: RuleModule<MessageIds>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/no-multiple-whitespaces.js

@@ -1,6 +1,4 @@
 import { parse, TYPE } from "@formatjs/icu-messageformat-parser";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings, patchMessage } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 function isAstValid(ast) {
@@ -114,13 +112,10 @@ export const rule = {
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/no-offset.d.ts

@@ -1,6 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-import { type CoreMessageIds } from "../messages.js";
-type MessageIds = "noOffset" | CoreMessageIds;
+import type { Rule } from "eslint";
 export declare const name = "no-offset";
-export declare const rule: RuleModule<MessageIds>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/no-offset.js

@@ -1,6 +1,4 @@
 import { isPluralElement, parse } from "@formatjs/icu-messageformat-parser";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 function verifyAst(ast) {
@@ -63,13 +61,10 @@ export const rule = {
 		},
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/rules/no-useless-message.d.ts

@@ -1,6 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-import { type CoreMessageIds } from "../messages.js";
-type MessageIds = "unnecessaryFormat" | "unnecessaryFormatNumber" | "unnecessaryFormatDate" | "unnecessaryFormatTime" | CoreMessageIds;
+import type { Rule } from "eslint";
 export declare const name = "no-useless-message";
-export declare const rule: RuleModule<MessageIds>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/no-useless-message.js

@@ -1,6 +1,4 @@
 import { parse, TYPE } from "@formatjs/icu-messageformat-parser";
-import "@typescript-eslint/utils/ts-eslint";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 function verifyAst(ast) {
@@ -57,13 +55,10 @@ export const rule = {
 			unnecessaryFormatTime: "Unnecessary formatted message: just use FormattedTime or intl.formatTime."
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

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

@@ -1,5 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-type MessageIds = "jsxChildren";
+import type { Rule } from "eslint";
 export declare const name = "prefer-formatted-message";
-export declare const rule: RuleModule<MessageIds>;
-export {};
+export declare const rule: Rule.RuleModule;

package/rules/prefer-formatted-message.js

@@ -1,4 +1,3 @@
-import "@typescript-eslint/utils/ts-eslint";
 import { isIntlFormatMessageCall } from "../util.js";
 export const name = "prefer-formatted-message";
 export const rule = {
@@ -11,7 +10,6 @@ export const rule = {
 		messages: { jsxChildren: "Prefer `FormattedMessage` over `intl.formatMessage` in the JSX children expression." },
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { JSXElement: (node) => {
 			node.children.forEach((child) => {

package/rules/prefer-pound-in-plural.d.ts

@@ -1,6 +1,3 @@
-import { type RuleModule } from "@typescript-eslint/utils/ts-eslint";
-import { type CoreMessageIds } from "../messages.js";
-type MessageIds = "preferPoundInPlurals" | CoreMessageIds;
+import type { Rule } from "eslint";
 export declare const name = "prefer-pound-in-plural";
-export declare const rule: RuleModule<MessageIds>;
-export {};
+export declare const rule: Rule.RuleModule;

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

@@ -1,7 +1,5 @@
 import { parse, TYPE } from "@formatjs/icu-messageformat-parser";
-import "@typescript-eslint/utils/ts-eslint";
 import MagicString from "magic-string";
-import { getParserServices } from "../context-compat.js";
 import { extractMessages, getSettings, patchMessage } from "../util.js";
 import { CORE_MESSAGES } from "../messages.js";
 function verifyAst(context, messageNode, ast) {
@@ -151,13 +149,10 @@ export const rule = {
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		const callExpressionVisitor = (node) => checkNode(context, node);
-		const parserServices = getParserServices(context);
-		//@ts-expect-error defineTemplateBodyVisitor exists in Vue parser
+		const parserServices = context.sourceCode.parserServices;
 		if (parserServices?.defineTemplateBodyVisitor) {
-			//@ts-expect-error
 			return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
 		}
 		return {

package/util.d.ts

@@ -1,6 +1,7 @@
 import type { MessageFormatElement } from "@formatjs/icu-messageformat-parser";
-import type { TSESTree } from "@typescript-eslint/utils";
-import { type RuleContext } from "@typescript-eslint/utils/ts-eslint";
+import type { Rule } from "eslint";
+import type { Expression, Node, ObjectExpression, Property } from "estree-jsx";
+import type { JSXAttribute, JSXOpeningElement } from "estree-jsx";
 export interface MessageDescriptor {
 	id?: string;
 	defaultMessage?: string;
@@ -14,23 +15,20 @@ export interface Settings {
 }
 export interface MessageDescriptorNodeInfo {
 	message: MessageDescriptor;
-	messageDescriptorNode: TSESTree.ObjectExpression | TSESTree.JSXOpeningElement;
-	messageNode?: TSESTree.Property["value"] | TSESTree.JSXAttribute["value"];
-	messagePropNode?: TSESTree.Property | TSESTree.JSXAttribute;
-	descriptionNode?: TSESTree.Property["value"] | TSESTree.JSXAttribute["value"];
-	idValueNode?: TSESTree.Property["value"] | TSESTree.JSXAttribute["value"];
-	idPropNode?: TSESTree.Property | TSESTree.JSXAttribute;
+	messageDescriptorNode: ObjectExpression | JSXOpeningElement;
+	messageNode?: Property["value"] | JSXAttribute["value"];
+	messagePropNode?: Property | JSXAttribute;
+	descriptionNode?: Property["value"] | JSXAttribute["value"];
+	idValueNode?: Property["value"] | JSXAttribute["value"];
+	idPropNode?: Property | JSXAttribute;
 }
-export declare function getSettings<
-	TMessageIds extends string,
-	TOptions extends readonly unknown[]
->({ settings }: RuleContext<TMessageIds, TOptions>): Settings;
-export declare function isIntlFormatMessageCall(node: TSESTree.Node): node is TSESTree.CallExpression;
-export declare function extractMessageDescriptor(node?: TSESTree.Expression): MessageDescriptorNodeInfo | undefined;
-export declare function extractMessages(node: TSESTree.Node, { additionalComponentNames, additionalFunctionNames, excludeMessageDeclCalls }?: Settings): Array<[MessageDescriptorNodeInfo, TSESTree.Expression | undefined]>;
+export declare function getSettings({ settings }: Rule.RuleContext): Settings;
+export declare function isIntlFormatMessageCall(node: Node): boolean;
+export declare function extractMessageDescriptor(node?: Expression): MessageDescriptorNodeInfo | undefined;
+export declare function extractMessages(node: Node, { additionalComponentNames, additionalFunctionNames, excludeMessageDeclCalls }?: Settings): Array<[MessageDescriptorNodeInfo, Expression | undefined]>;
 /**
 * Apply changes to the ICU message in code. The return value can be used in
 * `fixer.replaceText(messageNode, <return value>)`. If the return value is null,
 * it means that the patch cannot be applied.
 */
-export declare function patchMessage(messageNode: TSESTree.Node, ast: MessageFormatElement[], patcher: (messageContent: string, ast: MessageFormatElement[]) => string): string | null;
+export declare function patchMessage(messageNode: Node, ast: MessageFormatElement[], patcher: (messageContent: string, ast: MessageFormatElement[]) => string): string | null;

package/util.js

@@ -1,4 +1,3 @@
-import "@typescript-eslint/utils/ts-eslint";
 const FORMAT_FUNCTION_NAMES = new Set([
 	"$formatMessage",
 	"formatMessage",
@@ -16,15 +15,17 @@ function isTemplateLiteralWithoutVar(node) {
 	return node.type === "TemplateLiteral" && node.quasis.length === 1;
 }
 function staticallyEvaluateStringConcat(node) {
-	if (!isStringLiteral(node.right)) {
+	const right = node.right;
+	const left = node.left;
+	if (!isStringLiteral(right)) {
 		return ["", false];
 	}
-	if (isStringLiteral(node.left)) {
-		return [String(node.left.value) + node.right.value, true];
+	if (isStringLiteral(left)) {
+		return [left.value + right.value, true];
 	}
 	if (node.left.type === "BinaryExpression") {
 		const [result, isStaticallyEvaluatable] = staticallyEvaluateStringConcat(node.left);
-		return [result + node.right.value, isStaticallyEvaluatable];
+		return [result + right.value, isStaticallyEvaluatable];
 	}
 	return ["", false];
 }
@@ -80,13 +81,13 @@ export function extractMessageDescriptor(node) {
 		if (isStringLiteral(valueNode)) {
 			value = valueNode.value;
 		} else if (isTemplateLiteralWithoutVar(valueNode)) {
-			value = valueNode.quasis[0].value.cooked;
+			value = valueNode.quasis[0].value.cooked ?? undefined;
 		} else if (valueNode.type === "TaggedTemplateExpression") {
 			const { quasi } = valueNode;
 			if (!isTemplateLiteralWithoutVar(quasi)) {
 				throw new Error("Tagged template expression must be no substitution");
 			}
-			value = quasi.quasis[0].value.cooked;
+			value = quasi.quasis[0].value.cooked ?? undefined;
 		} else if (valueNode.type === "BinaryExpression") {
 			const [result, isStatic] = staticallyEvaluateStringConcat(valueNode);
 			if (isStatic) {
@@ -154,13 +155,13 @@ function extractMessageDescriptorFromJSXElement(node) {
 						value = result;
 					}
 				} else if (isTemplateLiteralWithoutVar(expression)) {
-					value = expression.quasis[0].value.cooked;
+					value = expression.quasis[0].value.cooked ?? undefined;
 				} else if (expression.type === "TaggedTemplateExpression") {
 					const { quasi } = expression;
 					if (!isTemplateLiteralWithoutVar(quasi)) {
 						throw new Error("Tagged template expression must be no substitution");
 					}
-					value = quasi.quasis[0].value.cooked;
+					value = quasi.quasis[0].value.cooked ?? undefined;
 				}
 			}
 		}
@@ -221,9 +222,8 @@ export function extractMessages(node, { additionalComponentNames, additionalFunc
 	const allFormatFunctionNames = Array.isArray(additionalFunctionNames) ? new Set([...Array.from(FORMAT_FUNCTION_NAMES), ...additionalFunctionNames]) : FORMAT_FUNCTION_NAMES;
 	const allComponentNames = Array.isArray(additionalComponentNames) ? new Set([...Array.from(COMPONENT_NAMES), ...additionalComponentNames]) : COMPONENT_NAMES;
 	if (node.type === "CallExpression") {
-		const expr = node;
-		const args0 = expr.arguments[0];
-		const args1 = expr.arguments[1];
+		const args0 = node.arguments[0];
+		const args1 = node.arguments[1];
 		// We can't really analyze spread element
 		if (!args0 || args0.type === "SpreadElement") {
 			return [];

package/context-compat.d.ts

@@ -1,3 +0,0 @@
-import type { ParserServicesWithoutTypeInformation, ParserServicesWithTypeInformation } from "@typescript-eslint/utils";
-import { type RuleContext } from "@typescript-eslint/utils/ts-eslint";
-export declare const getParserServices: <TRuleContext extends RuleContext<string, unknown[]>>(context: TRuleContext) => Partial<ParserServicesWithoutTypeInformation> | Partial<ParserServicesWithTypeInformation> | undefined;

package/context-compat.js

@@ -1,7 +0,0 @@
-import "@typescript-eslint/utils/ts-eslint";
-export const getParserServices = (context) => {
-	if (context.parserServices) {
-		return context.parserServices;
-	}
-	return context.sourceCode.parserServices;
-};