eslint-plugin-react-naming-convention 2.0.0-next.18 → 2.0.0-next.180

package/README.md

@@ -17,29 +17,32 @@ npm install --save-dev eslint-plugin-react-naming-convention
 // @ts-check
 import js from "@eslint/js";
 import reactNamingConvention from "eslint-plugin-react-naming-convention";
+import { defineConfig } from "eslint/config";
 import tseslint from "typescript-eslint";
 
-export default tseslint.config({
-  files: ["**/*.ts", "**/*.tsx"],
-  extends: [
-    js.configs.recommended,
-    tseslint.configs.recommended,
-  ],
-  plugins: {
-    "react-naming-convention": reactNamingConvention,
-  },
-  languageOptions: {
-    parser: tseslint.parser,
-    parserOptions: {
-      projectService: true,
-      tsconfigRootDir: import.meta.dirname,
+export default defineConfig([
+  {
+    files: ["**/*.ts", "**/*.tsx"],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+    ],
+    plugins: {
+      "react-naming-convention": reactNamingConvention,
+    },
+    languageOptions: {
+      parser: tseslint.parser,
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    rules: {
+      // Put rules you want to use here
+      "react-naming-convention/component-name": "warn",
     },
   },
-  rules: {
-    // Put rules you want to use here
-    "react-naming-convention/component-name": "warn",
-  },
-});
+]);
 ```
 
 ## Rules

package/dist/index.d.ts

@@ -1,71 +1,24 @@
-import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
-import { RulePreset } from '@eslint-react/kit';
-
-type MessageID$2 = "missingDestructuring" | "invalidSetterNaming";
-
-type MessageID$1 = "useJsxFileExtension" | "useNonJsxFileExtension";
-
-type MessageID = "filenameEmpty" | "filenameInvalid";
+import * as _eslint_react_kit0 from "@eslint-react/kit";
 
+//#region src/index.d.ts
 declare const _default: {
-    configs: {
-        recommended: {
-            plugins: {
-                "react-naming-convention": {
-                    readonly meta: {
-                        readonly name: string;
-                        readonly version: string;
-                    };
-                    readonly rules: {
-                        readonly "component-name": _typescript_eslint_utils_ts_eslint.RuleModule<"invalid", readonly [("CONSTANT_CASE" | "PascalCase") | {
-                            allowAllCaps?: boolean;
-                            excepts?: readonly string[];
-                            rule?: "CONSTANT_CASE" | "PascalCase";
-                        } | undefined], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "context-name": _typescript_eslint_utils_ts_eslint.RuleModule<"invalid", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly filename: _typescript_eslint_utils_ts_eslint.RuleModule<MessageID, readonly [("PascalCase" | "camelCase" | "kebab-case" | "snake_case") | {
-                            excepts?: readonly string[];
-                            rule?: "PascalCase" | "camelCase" | "kebab-case" | "snake_case";
-                        } | undefined], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "filename-extension": _typescript_eslint_utils_ts_eslint.RuleModule<MessageID$1, readonly [("always" | "as-needed") | {
-                            allow?: "always" | "as-needed";
-                            extensions?: readonly string[];
-                            ignoreFilesWithoutCode?: boolean;
-                        } | undefined], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "use-state": _typescript_eslint_utils_ts_eslint.RuleModule<MessageID$2, [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                    };
-                };
-            };
-            name: string;
-            rules: RulePreset;
-        };
-        "recommended-legacy": {
-            plugins: string[];
-            rules: RulePreset;
-        };
+  configs: {
+    recommended: {
+      plugins: {};
+      name?: string;
+      rules?: Record<string, _eslint_react_kit0.RuleConfig>;
+      settings?: _eslint_react_kit0.SettingsConfig;
     };
-    meta: {
-        readonly name: string;
-        readonly version: string;
-    };
-    rules: {
-        readonly "component-name": _typescript_eslint_utils_ts_eslint.RuleModule<"invalid", readonly [("CONSTANT_CASE" | "PascalCase") | {
-            allowAllCaps?: boolean;
-            excepts?: readonly string[];
-            rule?: "CONSTANT_CASE" | "PascalCase";
-        } | undefined], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "context-name": _typescript_eslint_utils_ts_eslint.RuleModule<"invalid", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly filename: _typescript_eslint_utils_ts_eslint.RuleModule<MessageID, readonly [("PascalCase" | "camelCase" | "kebab-case" | "snake_case") | {
-            excepts?: readonly string[];
-            rule?: "PascalCase" | "camelCase" | "kebab-case" | "snake_case";
-        } | undefined], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "filename-extension": _typescript_eslint_utils_ts_eslint.RuleModule<MessageID$1, readonly [("always" | "as-needed") | {
-            allow?: "always" | "as-needed";
-            extensions?: readonly string[];
-            ignoreFilesWithoutCode?: boolean;
-        } | undefined], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "use-state": _typescript_eslint_utils_ts_eslint.RuleModule<MessageID$2, [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    "recommended-legacy": {
+      plugins: string[];
+      rules: Record<string, _eslint_react_kit0.RuleConfig<unknown[]>> | undefined;
     };
+  };
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: Record<string, _eslint_react_kit0.CompatibleRule>;
 };
-
-export { _default as default };
+//#endregion
+export { _default as default };

package/dist/index.js

@@ -1,486 +1,466 @@
-import * as AST from '@eslint-react/ast';
-import * as ER2 from '@eslint-react/core';
-import { RegExp } from '@eslint-react/kit';
-import { getDocsUrl, getSettingsFromContext } from '@eslint-react/shared';
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { identity, isObject } from '@eslint-react/eff';
-import { AST_NODE_TYPES } from '@typescript-eslint/types';
-import { match, P } from 'ts-pattern';
-import path from 'node:path';
-import { snakeCase, pascalCase, camelCase, kebabCase } from 'string-ts';
+import { getConfigAdapters, getDocsUrl } from "@eslint-react/shared";
+import * as AST from "@eslint-react/ast";
+import * as ER from "@eslint-react/core";
+import { RE_CAMEL_CASE, RE_CONSTANT_CASE, RE_KEBAB_CASE, RE_PASCAL_CASE, RE_SNAKE_CASE, toRegExp } from "@eslint-react/kit";
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { identity, isObject } from "@eslint-react/eff";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { P, match } from "ts-pattern";
+import path from "node:path";
+import { camelCase, kebabCase, pascalCase, snakeCase } from "string-ts";
 
+//#region rolldown:runtime
 var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name3 in all)
-    __defProp(target, name3, { get: all[name3], enumerable: true });
+var __export = (all) => {
+	let target = {};
+	for (var name$2 in all) __defProp(target, name$2, {
+		get: all[name$2],
+		enumerable: true
+	});
+	return target;
 };
 
-// src/configs/recommended.ts
-var recommended_exports = {};
-__export(recommended_exports, {
-  name: () => name,
-  rules: () => rules
+//#endregion
+//#region src/configs/recommended.ts
+var recommended_exports = __export({
+	name: () => name$1,
+	rules: () => rules
 });
-var name = "react-naming-convention/recommended";
-var rules = {
-  "react-naming-convention/context-name": "warn"
-  // "react-naming-convention/use-state": "warn",
-};
+const name$1 = "react-naming-convention/recommended";
+const rules = { "react-naming-convention/context-name": "warn" };
+
+//#endregion
+//#region package.json
+var name = "eslint-plugin-react-naming-convention";
+var version = "2.0.0-next.180";
 
-// package.json
-var name2 = "eslint-plugin-react-naming-convention";
-var version = "2.0.0-next.18";
-var createRule = ESLintUtils.RuleCreator(getDocsUrl("naming-convention"));
+//#endregion
+//#region src/utils/create-rule.ts
+const createRule = ESLintUtils.RuleCreator(getDocsUrl("naming-convention"));
 
-// src/rules/component-name.ts
-var defaultOptions = [
-  {
-    allowAllCaps: false,
-    excepts: [],
-    rule: "PascalCase"
-  }
-];
-var schema = [
-  {
-    anyOf: [
-      {
-        type: "string",
-        enum: ["PascalCase", "CONSTANT_CASE"]
-      },
-      {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          allowAllCaps: { type: "boolean" },
-          excepts: {
-            type: "array",
-            items: { type: "string", format: "regex" }
-          },
-          rule: {
-            type: "string",
-            enum: ["PascalCase", "CONSTANT_CASE"]
-          }
-        }
-      }
-    ]
-  }
-];
-var RULE_NAME = "component-name";
+//#endregion
+//#region src/rules/component-name.ts
+const defaultOptions$2 = [{
+	allowAllCaps: false,
+	excepts: [],
+	rule: "PascalCase"
+}];
+const schema$2 = [{ anyOf: [{
+	type: "string",
+	enum: ["PascalCase", "CONSTANT_CASE"]
+}, {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		allowAllCaps: { type: "boolean" },
+		excepts: {
+			type: "array",
+			items: {
+				type: "string",
+				format: "regex"
+			}
+		},
+		rule: {
+			type: "string",
+			enum: ["PascalCase", "CONSTANT_CASE"]
+		}
+	}
+}] }];
+const RULE_NAME$4 = "component-name";
 var component_name_default = createRule({
-  meta: {
-    type: "problem",
-    defaultOptions: [...defaultOptions],
-    docs: {
-      description: "Enforces naming conventions for components."
-    },
-    messages: {
-      invalid: "A component name '{{name}}' does not match {{rule}}."
-    },
-    schema
-  },
-  name: RULE_NAME,
-  create,
-  defaultOptions
+	meta: {
+		type: "problem",
+		defaultOptions: [...defaultOptions$2],
+		docs: { description: "Enforces naming conventions for components." },
+		messages: { invalidComponentName: "A component name '{{name}}' does not match {{rule}}." },
+		schema: schema$2
+	},
+	name: RULE_NAME$4,
+	create: create$4,
+	defaultOptions: defaultOptions$2
 });
-function create(context) {
-  const options = normalizeOptions(context.options);
-  const { rule } = options;
-  const collector = ER2.useComponentCollector(context);
-  const collectorLegacy = ER2.useComponentCollectorLegacy();
-  return {
-    ...collector.listeners,
-    ...collectorLegacy.listeners,
-    "Program:exit"(program) {
-      const functionComponents = collector.ctx.getAllComponents(program);
-      const classComponents = collectorLegacy.ctx.getAllComponents(program);
-      for (const { node: component } of functionComponents.values()) {
-        const id = AST.getFunctionId(component);
-        if (id?.name == null) continue;
-        const name3 = id.name;
-        if (isValidName(name3, options)) return;
-        context.report({
-          messageId: "invalid",
-          node: id,
-          data: { name: name3, rule }
-        });
-      }
-      for (const { node: component } of classComponents.values()) {
-        const id = AST.getClassId(component);
-        if (id?.name == null) continue;
-        const name3 = id.name;
-        if (isValidName(name3, options)) continue;
-        context.report({
-          messageId: "invalid",
-          node: id,
-          data: { name: name3, rule }
-        });
-      }
-    }
-  };
+function create$4(context) {
+	const options = normalizeOptions(context.options);
+	const { rule } = options;
+	const collector = ER.useComponentCollector(context);
+	const collectorLegacy = ER.useComponentCollectorLegacy();
+	return {
+		...collector.listeners,
+		...collectorLegacy.listeners,
+		"Program:exit"(program) {
+			const functionComponents = collector.ctx.getAllComponents(program);
+			const classComponents = collectorLegacy.ctx.getAllComponents(program);
+			for (const { node: component } of functionComponents.values()) {
+				const id = AST.getFunctionId(component);
+				if (id?.name == null) continue;
+				const name$2 = id.name;
+				if (isValidName(name$2, options)) continue;
+				context.report({
+					messageId: "invalidComponentName",
+					node: id,
+					data: {
+						name: name$2,
+						rule
+					}
+				});
+			}
+			for (const { node: component } of classComponents.values()) {
+				const id = AST.getClassId(component);
+				if (id?.name == null) continue;
+				const name$2 = id.name;
+				if (isValidName(name$2, options)) continue;
+				context.report({
+					messageId: "invalidComponentName",
+					node: id,
+					data: {
+						name: name$2,
+						rule
+					}
+				});
+			}
+		}
+	};
 }
 function normalizeOptions(options) {
-  const opts = options[0];
-  const defaultOpts = defaultOptions[0];
-  if (opts == null) return defaultOpts;
-  return {
-    ...defaultOpts,
-    ...typeof opts === "string" ? { rule: opts } : {
-      ...opts,
-      excepts: opts.excepts?.map((s) => RegExp.toRegExp(s)) ?? []
-    }
-  };
+	const opts = options[0];
+	const defaultOpts = defaultOptions$2[0];
+	if (opts == null) return defaultOpts;
+	return {
+		...defaultOpts,
+		...typeof opts === "string" ? { rule: opts } : {
+			...opts,
+			excepts: opts.excepts?.map((s) => toRegExp(s)) ?? []
+		}
+	};
 }
-function isValidName(name3, options) {
-  if (name3 == null) return true;
-  if (options.excepts.some((regex) => regex.test(name3))) return true;
-  const normalized = name3.split(".").at(-1) ?? name3;
-  switch (options.rule) {
-    case "CONSTANT_CASE":
-      return RegExp.CONSTANT_CASE.test(normalized);
-    case "PascalCase":
-      if (normalized.length > 3 && /^[A-Z]+$/u.test(normalized)) {
-        return options.allowAllCaps;
-      }
-      return RegExp.PASCAL_CASE.test(normalized);
-  }
+function isValidName(name$2, options) {
+	if (name$2 == null) return true;
+	if (options.excepts.some((regex) => regex.test(name$2))) return true;
+	const normalized = name$2.split(".").at(-1) ?? name$2;
+	switch (options.rule) {
+		case "CONSTANT_CASE": return RE_CONSTANT_CASE.test(normalized);
+		case "PascalCase":
+			if (normalized.length > 3 && /^[A-Z]+$/u.test(normalized)) return options.allowAllCaps;
+			return RE_PASCAL_CASE.test(normalized);
+	}
 }
-var RULE_NAME2 = "context-name";
+
+//#endregion
+//#region src/rules/context-name.ts
+const RULE_NAME$3 = "context-name";
 var context_name_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Enforces context name to be a valid component name with the suffix `Context`."
-    },
-    messages: {
-      invalid: "A context name must be a valid component name with the suffix 'Context'."
-    },
-    schema: []
-  },
-  name: RULE_NAME2,
-  create: create2,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: { description: "Enforces context name to be a valid component name with the suffix `Context`." },
+		messages: { invalidContextName: "A context name must be a valid component name with the suffix 'Context'." },
+		schema: []
+	},
+	name: RULE_NAME$3,
+	create: create$3,
+	defaultOptions: []
 });
-function create2(context) {
-  if (!context.sourceCode.text.includes("createContext")) return {};
-  return {
-    CallExpression(node) {
-      if (!ER2.isCreateContextCall(context, node)) return;
-      const id = ER2.getInstanceId(node);
-      if (id == null) return;
-      const name3 = match(id).with({ type: AST_NODE_TYPES.Identifier, name: P.select() }, identity).with({ type: AST_NODE_TYPES.MemberExpression, property: { name: P.select(P.string) } }, identity).otherwise(() => null);
-      if (name3 != null && ER2.isComponentName(name3) && name3.endsWith("Context")) return;
-      context.report({
-        messageId: "invalid",
-        node: id
-      });
-    }
-  };
+function create$3(context) {
+	if (!context.sourceCode.text.includes("createContext")) return {};
+	return { CallExpression(node) {
+		if (!ER.isCreateContextCall(context, node)) return;
+		const id = ER.getInstanceId(node);
+		if (id == null) return;
+		const name$2 = match(id).with({
+			type: AST_NODE_TYPES.Identifier,
+			name: P.select()
+		}, identity).with({
+			type: AST_NODE_TYPES.MemberExpression,
+			property: { name: P.select(P.string) }
+		}, identity).otherwise(() => null);
+		if (name$2 != null && ER.isComponentName(name$2) && name$2.endsWith("Context")) return;
+		context.report({
+			messageId: "invalidContextName",
+			node: id
+		});
+	} };
 }
-var RULE_NAME3 = "filename";
-var defaultOptions2 = [
-  {
-    excepts: ["^index$"],
-    rule: "PascalCase"
-  }
-];
-var schema2 = [
-  {
-    anyOf: [
-      {
-        type: "string",
-        enum: ["PascalCase", "camelCase", "kebab-case", "snake_case"]
-      },
-      {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          excepts: {
-            type: "array",
-            items: { type: "string", format: "regex" }
-          },
-          extensions: {
-            type: "array",
-            items: { type: "string" },
-            uniqueItems: true
-          },
-          rule: {
-            type: "string",
-            enum: ["PascalCase", "camelCase", "kebab-case", "snake_case"]
-          }
-        }
-      }
-    ]
-  }
-];
+
+//#endregion
+//#region src/rules/filename.ts
+const RULE_NAME$2 = "filename";
+const defaultOptions$1 = [{
+	excepts: [
+		"index",
+		String.raw`/^_/`,
+		String.raw`/^\$/`,
+		String.raw`/^[0-9]+$/`,
+		String.raw`/^\[[^\]]+\]$/`
+	],
+	rule: "PascalCase"
+}];
+const schema$1 = [{ anyOf: [{
+	type: "string",
+	enum: [
+		"PascalCase",
+		"camelCase",
+		"kebab-case",
+		"snake_case"
+	]
+}, {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		excepts: {
+			type: "array",
+			items: {
+				type: "string",
+				format: "regex"
+			}
+		},
+		extensions: {
+			type: "array",
+			items: { type: "string" },
+			uniqueItems: true
+		},
+		rule: {
+			type: "string",
+			enum: [
+				"PascalCase",
+				"camelCase",
+				"kebab-case",
+				"snake_case"
+			]
+		}
+	}
+}] }];
 var filename_default = createRule({
-  meta: {
-    type: "problem",
-    defaultOptions: [...defaultOptions2],
-    docs: {
-      description: "Enforces consistent file naming conventions."
-    },
-    messages: {
-      filenameEmpty: "A file must have non-empty name.",
-      filenameInvalid: "A file with name '{{name}}' does not match {{rule}}. Rename it to '{{suggestion}}'."
-    },
-    schema: schema2
-  },
-  name: RULE_NAME3,
-  create: create3,
-  defaultOptions: defaultOptions2
+	meta: {
+		type: "problem",
+		defaultOptions: [...defaultOptions$1],
+		docs: { description: "Enforces consistent file naming conventions." },
+		messages: {
+			empty: "A file must have non-empty name.",
+			invalidCase: "A file with name '{{name}}' does not match {{rule}}. Rename it to '{{suggestion}}'."
+		},
+		schema: schema$1
+	},
+	name: RULE_NAME$2,
+	create: create$2,
+	defaultOptions: defaultOptions$1
 });
-function create3(context) {
-  const options = context.options[0] ?? defaultOptions2[0];
-  const rule = typeof options === "string" ? options : options.rule ?? "PascalCase";
-  const excepts = typeof options === "string" ? [] : (options.excepts ?? []).map((s) => RegExp.toRegExp(s));
-  function validate(name3, casing = rule, ignores = excepts) {
-    const shouldIgnore = ignores.some((pattern) => pattern.test(name3));
-    if (shouldIgnore) return true;
-    return match(casing).with("PascalCase", () => RegExp.PASCAL_CASE.test(name3)).with("camelCase", () => RegExp.CAMEL_CASE.test(name3)).with("kebab-case", () => RegExp.KEBAB_CASE.test(name3)).with("snake_case", () => RegExp.SNAKE_CASE.test(name3)).exhaustive();
-  }
-  function getSuggestion(name3, casing = rule) {
-    return match(casing).with("PascalCase", () => pascalCase(name3)).with("camelCase", () => camelCase(name3)).with("kebab-case", () => kebabCase(name3)).with("snake_case", () => snakeCase(name3)).exhaustive();
-  }
-  return {
-    Program(node) {
-      const [basename = "", ...rest] = path.basename(context.filename).split(".");
-      if (basename.length === 0) {
-        context.report({ messageId: "filenameEmpty", node });
-        return;
-      }
-      if (validate(basename)) {
-        return;
-      }
-      context.report({
-        messageId: "filenameInvalid",
-        node,
-        data: {
-          name: context.filename,
-          rule,
-          suggestion: [getSuggestion(basename), ...rest].join(".")
-        }
-      });
-    }
-  };
+function create$2(context) {
+	const options = context.options[0] ?? defaultOptions$1[0];
+	const rule = typeof options === "string" ? options : options.rule ?? "PascalCase";
+	const excepts = typeof options === "string" ? [] : (options.excepts ?? []).map((s) => toRegExp(s));
+	function validate(name$2, casing = rule, ignores = excepts) {
+		if (ignores.some((pattern) => pattern.test(name$2))) return true;
+		const filteredName = name$2.match(/[\w.-]/gu)?.join("") ?? "";
+		if (filteredName.length === 0) return true;
+		return match(casing).with("PascalCase", () => RE_PASCAL_CASE.test(filteredName)).with("camelCase", () => RE_CAMEL_CASE.test(filteredName)).with("kebab-case", () => RE_KEBAB_CASE.test(filteredName)).with("snake_case", () => RE_SNAKE_CASE.test(filteredName)).exhaustive();
+	}
+	function getSuggestion(name$2, casing = rule) {
+		return match(casing).with("PascalCase", () => pascalCase(name$2)).with("camelCase", () => camelCase(name$2)).with("kebab-case", () => kebabCase(name$2)).with("snake_case", () => snakeCase(name$2)).exhaustive();
+	}
+	return { Program(node) {
+		const [basename = "", ...rest] = path.basename(context.filename).split(".");
+		if (basename.length === 0) {
+			context.report({
+				messageId: "empty",
+				node
+			});
+			return;
+		}
+		if (validate(basename)) return;
+		context.report({
+			messageId: "invalidCase",
+			node,
+			data: {
+				name: context.filename,
+				rule,
+				suggestion: [getSuggestion(basename), ...rest].join(".")
+			}
+		});
+	} };
 }
-var RULE_NAME4 = "filename-extension";
-var defaultOptions3 = [{
-  allow: "as-needed",
-  extensions: [".jsx", ".tsx"],
-  ignoreFilesWithoutCode: false
+
+//#endregion
+//#region src/rules/filename-extension.ts
+const RULE_NAME$1 = "filename-extension";
+const defaultOptions = [{
+	allow: "as-needed",
+	extensions: [".jsx", ".tsx"],
+	ignoreFilesWithoutCode: false
 }];
-var schema3 = [
-  {
-    anyOf: [
-      {
-        type: "string",
-        enum: ["always", "as-needed"]
-      },
-      {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          allow: {
-            type: "string",
-            enum: ["always", "as-needed"]
-          },
-          extensions: {
-            type: "array",
-            items: {
-              type: "string"
-            },
-            uniqueItems: true
-          },
-          ignoreFilesWithoutCode: {
-            type: "boolean"
-          }
-        }
-      }
-    ]
-  }
-];
+const schema = [{ anyOf: [{
+	type: "string",
+	enum: ["always", "as-needed"]
+}, {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		allow: {
+			type: "string",
+			enum: ["always", "as-needed"]
+		},
+		extensions: {
+			type: "array",
+			items: { type: "string" },
+			uniqueItems: true
+		},
+		ignoreFilesWithoutCode: { type: "boolean" }
+	}
+}] }];
 var filename_extension_default = createRule({
-  meta: {
-    type: "problem",
-    defaultOptions: [...defaultOptions3],
-    docs: {
-      description: "Enforces consistent file naming conventions."
-    },
-    messages: {
-      useJsxFileExtension: "Use {{extensions}} file extension for JSX files.",
-      useNonJsxFileExtension: "Do not use {{extensions}} file extension for files without JSX."
-    },
-    schema: schema3
-  },
-  name: RULE_NAME4,
-  create: create4,
-  defaultOptions: defaultOptions3
+	meta: {
+		type: "problem",
+		defaultOptions: [...defaultOptions],
+		docs: { description: "Enforces consistent file naming conventions." },
+		messages: {
+			missingJSXExtension: "Use {{extensions}} file extension for JSX files.",
+			unnecessaryJSXExtension: "Do not use {{extensions}} file extension for files without JSX."
+		},
+		schema
+	},
+	name: RULE_NAME$1,
+	create: create$1,
+	defaultOptions
 });
-function create4(context) {
-  const options = context.options[0] ?? defaultOptions3[0];
-  const allow = isObject(options) ? options.allow : options;
-  const extensions = isObject(options) && "extensions" in options ? options.extensions : defaultOptions3[0].extensions;
-  const extensionsString = extensions.map((ext) => `'${ext}'`).join(", ");
-  const filename = context.filename;
-  let hasJSXNode = false;
-  return {
-    JSXElement() {
-      hasJSXNode = true;
-    },
-    JSXFragment() {
-      hasJSXNode = true;
-    },
-    "Program:exit"(program) {
-      const fileNameExt = filename.slice(filename.lastIndexOf("."));
-      const isJSXExt = extensions.includes(fileNameExt);
-      if (hasJSXNode && !isJSXExt) {
-        context.report({
-          messageId: "useJsxFileExtension",
-          node: program,
-          data: {
-            extensions: extensionsString
-          }
-        });
-        return;
-      }
-      const hasCode = program.body.length > 0;
-      const ignoreFilesWithoutCode = isObject(options) && options.ignoreFilesWithoutCode === true;
-      if (!hasCode && ignoreFilesWithoutCode) {
-        return;
-      }
-      if (!hasJSXNode && isJSXExt && allow === "as-needed") {
-        context.report({
-          messageId: "useNonJsxFileExtension",
-          node: program,
-          data: {
-            extensions: extensionsString
-          }
-        });
-      }
-    }
-  };
+function create$1(context) {
+	const options = context.options[0] ?? defaultOptions[0];
+	const allow = isObject(options) ? options.allow : options;
+	const extensions = isObject(options) && "extensions" in options ? options.extensions : defaultOptions[0].extensions;
+	const extensionsString = extensions.map((ext) => `'${ext}'`).join(", ");
+	const filename = context.filename;
+	let hasJSXNode = false;
+	return {
+		JSXElement() {
+			hasJSXNode = true;
+		},
+		JSXFragment() {
+			hasJSXNode = true;
+		},
+		"Program:exit"(program) {
+			const fileNameExt = filename.slice(filename.lastIndexOf("."));
+			const isJSXExt = extensions.includes(fileNameExt);
+			if (hasJSXNode && !isJSXExt) {
+				context.report({
+					messageId: "missingJSXExtension",
+					node: program,
+					data: { extensions: extensionsString }
+				});
+				return;
+			}
+			const hasCode = program.body.length > 0;
+			const ignoreFilesWithoutCode = isObject(options) && options.ignoreFilesWithoutCode === true;
+			if (!hasCode && ignoreFilesWithoutCode) return;
+			if (!hasJSXNode && isJSXExt && allow === "as-needed") context.report({
+				messageId: "unnecessaryJSXExtension",
+				node: program,
+				data: { extensions: extensionsString }
+			});
+		}
+	};
 }
-var RULE_NAME5 = "use-state";
-var RULE_FEATURES = [];
+
+//#endregion
+//#region src/rules/use-state.ts
+const RULE_NAME = "use-state";
+const RULE_FEATURES = [];
 var use_state_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Enforces destructuring and symmetric naming of `useState` hook value and setter.",
-      [Symbol.for("rule_features")]: RULE_FEATURES
-    },
-    messages: {
-      invalidSetterNaming: "The setter should be named 'set' followed by the capitalized state variable name, e.g., 'setState' for 'state'.",
-      missingDestructuring: "useState should be destructured into a value and setter pair, e.g., const [state, setState] = useState(...)."
-    },
-    schema: []
-  },
-  name: RULE_NAME5,
-  create: create5,
-  defaultOptions: []
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforces destructuring and symmetric naming of `useState` hook value and setter.",
+			[Symbol.for("rule_features")]: RULE_FEATURES
+		},
+		messages: {
+			invalidAssignment: "useState should be destructured into a value and setter pair, e.g., const [state, setState] = useState(...).",
+			invalidSetterName: "The setter should be named 'set' followed by the capitalized state variable name, e.g., 'setState' for 'state'."
+		},
+		schema: []
+	},
+	name: RULE_NAME,
+	create,
+	defaultOptions: []
 });
-function create5(context) {
-  const alias = getSettingsFromContext(context).additionalHooks.useState ?? [];
-  const isUseStateCall = ER2.isReactHookCallWithNameAlias(context, "useState", alias);
-  return {
-    CallExpression(node) {
-      if (!isUseStateCall(node)) {
-        return;
-      }
-      if (node.parent.type !== AST_NODE_TYPES.VariableDeclarator) {
-        context.report({
-          messageId: "missingDestructuring",
-          node
-        });
-        return;
-      }
-      const id = ER2.getInstanceId(node);
-      if (id?.type !== AST_NODE_TYPES.ArrayPattern) {
-        context.report({
-          messageId: "missingDestructuring",
-          node: id ?? node
-        });
-        return;
-      }
-      const [value, setter] = id.elements;
-      if (value == null || setter == null) {
-        context.report({
-          messageId: "missingDestructuring",
-          node: id
-        });
-        return;
-      }
-      const setterName = match(setter).with({ type: AST_NODE_TYPES.Identifier }, (id2) => id2.name).otherwise(() => null);
-      if (setterName == null || !setterName.startsWith("set")) {
-        context.report({
-          messageId: "invalidSetterNaming",
-          node: setter
-        });
-        return;
-      }
-      const valueName = match(value).with({ type: AST_NODE_TYPES.Identifier }, ({ name: name3 }) => snakeCase(name3)).with({ type: AST_NODE_TYPES.ObjectPattern }, ({ properties }) => {
-        const values = properties.reduce((acc, prop) => {
-          if (prop.type === AST_NODE_TYPES.Property && prop.key.type === AST_NODE_TYPES.Identifier) {
-            return [...acc, prop.key.name];
-          }
-          return acc;
-        }, []);
-        return values.join("_");
-      }).otherwise(() => null);
-      if (valueName == null) {
-        context.report({
-          messageId: "invalidSetterNaming",
-          node: value
-        });
-        return;
-      }
-      if (snakeCase(setterName) !== `set_${valueName}`) {
-        context.report({
-          messageId: "invalidSetterNaming",
-          node: setter
-        });
-        return;
-      }
-    }
-  };
+function create(context) {
+	return { CallExpression(node) {
+		if (!ER.isUseStateCall(node)) return;
+		if (node.parent.type !== AST_NODE_TYPES.VariableDeclarator) {
+			context.report({
+				messageId: "invalidAssignment",
+				node
+			});
+			return;
+		}
+		const id = ER.getInstanceId(node);
+		if (id?.type !== AST_NODE_TYPES.ArrayPattern) {
+			context.report({
+				messageId: "invalidAssignment",
+				node: id ?? node
+			});
+			return;
+		}
+		const [value, setter] = id.elements;
+		if (value == null || setter == null) {
+			context.report({
+				messageId: "invalidAssignment",
+				node: id
+			});
+			return;
+		}
+		const setterName = match(setter).with({ type: AST_NODE_TYPES.Identifier }, (id$1) => id$1.name).otherwise(() => null);
+		if (setterName == null || !setterName.startsWith("set")) {
+			context.report({
+				messageId: "invalidSetterName",
+				node: setter
+			});
+			return;
+		}
+		const valueName = match(value).with({ type: AST_NODE_TYPES.Identifier }, ({ name: name$2 }) => snakeCase(name$2)).with({ type: AST_NODE_TYPES.ObjectPattern }, ({ properties }) => {
+			return properties.reduce((acc, prop) => {
+				if (prop.type === AST_NODE_TYPES.Property && prop.key.type === AST_NODE_TYPES.Identifier) return [...acc, prop.key.name];
+				return acc;
+			}, []).join("_");
+		}).otherwise(() => null);
+		if (valueName == null) {
+			context.report({
+				messageId: "invalidSetterName",
+				node: value
+			});
+			return;
+		}
+		if (snakeCase(setterName) !== `set_${valueName}`) {
+			context.report({
+				messageId: "invalidSetterName",
+				node: setter
+			});
+			return;
+		}
+	} };
 }
 
-// src/plugin.ts
-var plugin = {
-  meta: {
-    name: name2,
-    version
-  },
-  rules: {
-    ["component-name"]: component_name_default,
-    ["context-name"]: context_name_default,
-    ["filename"]: filename_default,
-    ["filename-extension"]: filename_extension_default,
-    ["use-state"]: use_state_default
-  }
+//#endregion
+//#region src/plugin.ts
+const plugin = {
+	meta: {
+		name,
+		version
+	},
+	rules: {
+		["component-name"]: component_name_default,
+		["context-name"]: context_name_default,
+		["filename"]: filename_default,
+		["filename-extension"]: filename_extension_default,
+		["use-state"]: use_state_default
+	}
 };
 
-// src/index.ts
-function makeConfig(config) {
-  return {
-    ...config,
-    plugins: {
-      "react-naming-convention": plugin
-    }
-  };
-}
-function makeLegacyConfig({ rules: rules2 }) {
-  return {
-    plugins: ["react-naming-convention"],
-    rules: rules2
-  };
-}
-var index_default = {
-  ...plugin,
-  configs: {
-    ["recommended"]: makeConfig(recommended_exports),
-    ["recommended-legacy"]: makeLegacyConfig(recommended_exports)
-  }
+//#endregion
+//#region src/index.ts
+const { toFlatConfig, toLegacyConfig } = getConfigAdapters("react-naming-convention", plugin);
+var src_default = {
+	...plugin,
+	configs: {
+		["recommended"]: toFlatConfig(recommended_exports),
+		["recommended-legacy"]: toLegacyConfig(recommended_exports)
+	}
 };
 
-export { index_default as default };
+//#endregion
+export { src_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-naming-convention",
-  "version": "2.0.0-next.18",
+  "version": "2.0.0-next.180",
   "description": "ESLint React's ESLint plugin for naming convention related rules.",
   "keywords": [
     "react",
@@ -35,27 +35,27 @@
     "./package.json"
   ],
   "dependencies": {
-    "@typescript-eslint/scope-manager": "^8.32.0",
-    "@typescript-eslint/type-utils": "^8.32.0",
-    "@typescript-eslint/types": "^8.32.0",
-    "@typescript-eslint/utils": "^8.32.0",
+    "@typescript-eslint/scope-manager": "^8.43.0",
+    "@typescript-eslint/type-utils": "^8.43.0",
+    "@typescript-eslint/types": "^8.43.0",
+    "@typescript-eslint/utils": "^8.43.0",
     "string-ts": "^2.2.1",
-    "ts-pattern": "^5.7.0",
-    "@eslint-react/ast": "2.0.0-next.18",
-    "@eslint-react/core": "2.0.0-next.18",
-    "@eslint-react/kit": "2.0.0-next.18",
-    "@eslint-react/shared": "2.0.0-next.18",
-    "@eslint-react/eff": "2.0.0-next.18",
-    "@eslint-react/var": "2.0.0-next.18"
+    "ts-pattern": "^5.8.0",
+    "@eslint-react/ast": "2.0.0-next.180",
+    "@eslint-react/core": "2.0.0-next.180",
+    "@eslint-react/eff": "2.0.0-next.180",
+    "@eslint-react/shared": "2.0.0-next.180",
+    "@eslint-react/kit": "2.0.0-next.180",
+    "@eslint-react/var": "2.0.0-next.180"
   },
   "devDependencies": {
-    "@types/react": "^19.1.3",
-    "@types/react-dom": "^19.1.3",
-    "tsup": "^8.4.0",
+    "@types/react": "^19.1.12",
+    "@types/react-dom": "^19.1.9",
+    "tsdown": "^0.15.0",
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {
-    "eslint": "^9.26.0",
+    "eslint": "^9.35.0",
     "typescript": "^4.9.5 || ^5.4.5"
   },
   "peerDependenciesMeta": {
@@ -67,14 +67,13 @@
     }
   },
   "engines": {
-    "bun": ">=1.0.15",
     "node": ">=20.19.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsup --dts-resolve",
+    "build": "tsdown",
     "lint:publish": "publint",
     "lint:ts": "tsc --noEmit"
   }