@alextheman/eslint-plugin 2.8.2 → 3.0.0

package/dist/index.cjs

@@ -3411,7 +3411,7 @@ var require_package = __commonJS({
   "node_modules/@eslint/js/package.json"(exports2, module2) {
     module2.exports = {
       name: "@eslint/js",
-      version: "9.31.0",
+      version: "9.39.1",
       description: "ESLint JavaScript language implementation",
       funding: "https://eslint.org/donate",
       main: "./src/index.js",
@@ -3453,7 +3453,7 @@ var require_eslint_all = __commonJS({
   "node_modules/@eslint/js/src/configs/eslint-all.js"(exports2, module2) {
     "use strict";
     module2.exports = Object.freeze({
-      "rules": {
+      rules: Object.freeze({
         "accessor-pairs": "error",
         "array-callback-return": "error",
         "arrow-body-style": "error",
@@ -3637,6 +3637,7 @@ var require_eslint_all = __commonJS({
         "prefer-rest-params": "error",
         "prefer-spread": "error",
         "prefer-template": "error",
+        "preserve-caught-error": "error",
         "radix": "error",
         "require-atomic-updates": "error",
         "require-await": "error",
@@ -3652,7 +3653,7 @@ var require_eslint_all = __commonJS({
         "valid-typeof": "error",
         "vars-on-top": "error",
         "yoda": "error"
-      }
+      })
     });
   }
 });
@@ -3751,7 +3752,12 @@ var require_src = __commonJS({
 var index_exports = {};
 __export(index_exports, {
   default: () => index_default,
+  parseConsistentTestFunctionOptions: () => parseConsistentTestFunctionOptions,
+  parseNoNamespaceImportsOptions: () => parseNoNamespaceImportsOptions,
+  parseNoRelativeImportsOptions: () => parseNoRelativeImportsOptions,
+  parseStandardiseErrorMessagesOptions: () => parseStandardiseErrorMessagesOptions,
   parseTestFunction: () => parseTestFunction,
+  parseUseNormalizedImportsOptions: () => parseUseNormalizedImportsOptions,
   prettierRules: () => prettierRules_default,
   sortObjects: () => sortObjects_default
 });
@@ -3759,7 +3765,7 @@ module.exports = __toCommonJS(index_exports);
 
 // package.json
 var name = "@alextheman/eslint-plugin";
-var version = "2.8.2";
+var version = "3.0.0";
 
 // src/configs/index.ts
 var import_eslint_plugin_package_json = __toESM(require("eslint-plugin-package-json"), 1);
@@ -3860,14 +3866,14 @@ var import_js = __toESM(require_src(), 1);
 var import_eslint_config_prettier = __toESM(require("eslint-config-prettier"), 1);
 var import_eslint_plugin_import = __toESM(require("eslint-plugin-import"), 1);
 
-// src/configs/miscellaneous/javaScriptLanguageOptions.ts
+// src/configs/helpers/javaScriptLanguageOptions.ts
 var import_globals2 = __toESM(require_globals2(), 1);
 var javaScriptLanguageOptions = {
   globals: __spreadValues(__spreadValues(__spreadValues({}, import_globals2.default.node), import_globals2.default.browser), import_globals2.default.vitest)
 };
 var javaScriptLanguageOptions_default = javaScriptLanguageOptions;
 
-// src/configs/miscellaneous/unusedVarsIgnorePatterns.ts
+// src/configs/helpers/unusedVarsIgnorePatterns.ts
 var unusedVarsIgnorePatterns = {
   argsIgnorePattern: "^_",
   caughtErrorsIgnorePattern: "^_",
@@ -3926,7 +3932,7 @@ var javaScriptBase_default = javaScriptBase;
 var import_eslint_plugin_perfectionist = __toESM(require("eslint-plugin-perfectionist"), 1);
 var import_eslint_plugin_prettier = __toESM(require("eslint-plugin-prettier"), 1);
 
-// src/configs/miscellaneous/prettierRules.ts
+// src/configs/helpers/prettierRules.ts
 var prettierRules = {
   printWidth: 100
 };
@@ -4009,10 +4015,20 @@ var javaScriptBase_default3 = createCombinedJavaScriptBaseConfig;
 // src/configs/general/reactBase.ts
 var import_eslint_plugin_jsx_a11y = __toESM(require("eslint-plugin-jsx-a11y"), 1);
 var import_eslint_plugin_react = __toESM(require("eslint-plugin-react"), 1);
-var import_eslint_plugin_react_hooks = __toESM(require("eslint-plugin-react-hooks"), 1);
 var import_eslint_plugin_react_refresh = __toESM(require("eslint-plugin-react-refresh"), 1);
 
-// src/configs/miscellaneous/reactLanguageOptions.ts
+// src/configs/helpers/reactHooks.ts
+var import_utility = require("@alextheman/utility");
+var import_eslint_plugin_react_hooks = __toESM(require("eslint-plugin-react-hooks"), 1);
+var reactHooks = __spreadProps(__spreadValues({}, import_eslint_plugin_react_hooks.default), {
+  configs: __spreadProps(__spreadValues({}, (0, import_utility.omitProperties)(import_eslint_plugin_react_hooks.default.configs, "flat")), {
+    "flat/recommended": import_eslint_plugin_react_hooks.default.configs.flat.recommended,
+    "flat/recommended-latest": import_eslint_plugin_react_hooks.default.configs.flat["recommended-latest"]
+  })
+});
+var reactHooks_default = reactHooks;
+
+// src/configs/helpers/reactLanguageOptions.ts
 var import_globals3 = __toESM(require_globals2(), 1);
 var reactLanguageOptions = {
   ecmaVersion: 2020,
@@ -4035,10 +4051,10 @@ var reactBase = [
     name: "@alextheman/general/react",
     plugins: {
       react: import_eslint_plugin_react.default,
-      "react-hooks": import_eslint_plugin_react_hooks.default,
+      "react-hooks": reactHooks_default,
       "react-refresh": import_eslint_plugin_react_refresh.default
     },
-    rules: __spreadProps(__spreadValues({}, import_eslint_plugin_react_hooks.default.configs.recommended.rules), {
+    rules: __spreadProps(__spreadValues({}, reactHooks_default.configs["flat/recommended"].rules), {
       "react/destructuring-assignment": ["error", "always", { destructureInSignature: "always" }],
       "react/hook-use-state": "error",
       "react/jsx-curly-brace-presence": [
@@ -4060,7 +4076,6 @@ var reactBase_default = reactBase;
 
 // src/configs/personal/reactBase.ts
 var import_eslint_plugin_react2 = __toESM(require("eslint-plugin-react"), 1);
-var import_eslint_plugin_react_hooks2 = __toESM(require("eslint-plugin-react-hooks"), 1);
 var import_eslint_plugin_react_refresh2 = __toESM(require("eslint-plugin-react-refresh"), 1);
 var personalReactBaseConfig = [
   {
@@ -4068,7 +4083,7 @@ var personalReactBaseConfig = [
     name: "@alextheman/personal/react",
     plugins: {
       react: import_eslint_plugin_react2.default,
-      "react-hooks": import_eslint_plugin_react_hooks2.default,
+      "react-hooks": reactHooks_default,
       "react-refresh": import_eslint_plugin_react_refresh2.default
     },
     rules: {
@@ -4110,12 +4125,12 @@ function createCombinedJavaScriptReactBaseConfig(plugin) {
 var javaScriptReactBase_default = createCombinedJavaScriptReactBaseConfig;
 
 // src/configs/general/typeScriptBase.ts
-var import_typescript_eslint = __toESM(require("typescript-eslint"), 1);
+var import_typescript_eslint2 = __toESM(require("typescript-eslint"), 1);
 
-// src/configs/miscellaneous/typeScriptLanguageOptions.ts
-var import_parser = __toESM(require("@typescript-eslint/parser"), 1);
+// src/configs/helpers/typeScriptLanguageOptions.ts
+var import_typescript_eslint = __toESM(require("typescript-eslint"), 1);
 var typeScriptLanguageOptions = {
-  parser: import_parser.default,
+  parser: import_typescript_eslint.default.parser,
   parserOptions: {
     ecmaVersion: "latest",
     projectService: true,
@@ -4127,7 +4142,7 @@ var typeScriptLanguageOptions_default = typeScriptLanguageOptions;
 
 // src/configs/general/typeScriptBase.ts
 var typeScriptBase = [
-  ...import_typescript_eslint.default.configs.recommended,
+  ...import_typescript_eslint2.default.configs.recommended,
   ...javaScriptBase_default,
   {
     files: ["**/*.ts", "**/*.tsx"],
@@ -4156,7 +4171,7 @@ var typeScriptBase_default = typeScriptBase;
 // src/configs/personal/eslintPlugin.ts
 var import_eslint_plugin_perfectionist2 = __toESM(require("eslint-plugin-perfectionist"), 1);
 
-// src/configs/miscellaneous/sortObjects.ts
+// src/configs/helpers/sortObjects.ts
 var sortObjects = {
   customGroups: [],
   destructuredObjects: true,
@@ -4195,20 +4210,25 @@ function createPersonalEslintPluginConfig(plugin) {
         "no-restricted-imports": [
           "error",
           {
-            paths: ["src/alexPlugin", "src/index", "src"].map((name2) => {
-              return {
+            paths: [
+              ...["src/alexPlugin", "src/index", "src"].map((name2) => {
+                return {
+                  importNames: ["default"],
+                  message: "Do not import the plugin directly from the config files. Please create a function that takes in the plugin and returns the config instead.",
+                  name: name2
+                };
+              }),
+              {
                 importNames: ["default"],
-                message: "Do not import the plugin directly from the config files. Please create a function that takes in the plugin and returns the config instead.",
-                name: name2
-              };
-            })
+                message: 'Please import from "src/configs/helpers/reactHooks" instead.',
+                name: "eslint-plugin-react-hooks"
+              }
+            ]
           }
         ]
       }
     },
     {
-      // Since the object exported in the rules index serves the same function as the exports in other projects, it's best to sort them in alphabetical order
-      // as well to make it easier to compare against the file directory.
       files: ["src/rules/index.ts", "src/configs/**"],
       rules: {
         "perfectionist/sort-objects": ["error", sortObjects_default]
@@ -4314,7 +4334,7 @@ var neurosongsFrontEndConfig = [
 var neurosongsFrontEnd_default = neurosongsFrontEndConfig;
 
 // src/configs/personal/typeScriptBase.ts
-var import_typescript_eslint2 = __toESM(require("typescript-eslint"), 1);
+var import_typescript_eslint3 = __toESM(require("typescript-eslint"), 1);
 function createPersonalTypeScriptBaseConfig(plugin) {
   return [
     {
@@ -4323,7 +4343,7 @@ function createPersonalTypeScriptBaseConfig(plugin) {
       name: "@alextheman/personal/typescript",
       plugins: {
         "@alextheman": plugin,
-        "@typescript-eslint": import_typescript_eslint2.default.plugin
+        "@typescript-eslint": import_typescript_eslint3.default.plugin
       },
       rules: {
         "@alextheman/standardise-error-messages": "error",
@@ -4341,12 +4361,12 @@ function createPersonalTypeScriptBaseConfig(plugin) {
 var typeScriptBase_default2 = createPersonalTypeScriptBaseConfig;
 
 // src/configs/personal/utility.ts
-var import_typescript_eslint3 = __toESM(require("typescript-eslint"), 1);
+var import_typescript_eslint4 = __toESM(require("typescript-eslint"), 1);
 var utilityConfig = [
   {
     name: "@alextheman/personal/utility",
     plugins: {
-      "@typescript-eslint": import_typescript_eslint3.default.plugin
+      "@typescript-eslint": import_typescript_eslint4.default.plugin
     },
     rules: {
       "@typescript-eslint/explicit-module-boundary-types": "error"
@@ -4393,9 +4413,9 @@ var alexCLineConfig = [
 var alexCLine_default = alexCLineConfig;
 
 // src/utility/camelToKebab.ts
-var import_utility2 = require("@alextheman/utility");
+var import_utility3 = require("@alextheman/utility");
 function camelToKebab(string) {
-  return (0, import_utility2.camelToKebab)(
+  return (0, import_utility3.camelToKebab)(
     string.replace(/[Tt]ypeScript/, "typescript").replace(/[Jj]avaScript/, "javascript")
   );
 }
@@ -4464,7 +4484,7 @@ var configs_default = createAlexPluginConfigs;
 
 // src/rules/consistent-test-function.ts
 var import_utils2 = require("@typescript-eslint/utils");
-var import_zod = __toESM(require("zod"), 1);
+var import_zod2 = __toESM(require("zod"), 1);
 
 // src/createRule.ts
 var import_utils = require("@typescript-eslint/utils");
@@ -4473,6 +4493,14 @@ var createRule = import_utils.ESLintUtils.RuleCreator((ruleName) => {
 });
 var createRule_default = createRule;
 
+// src/utility/createRuleSchema.ts
+var import_utility4 = require("@alextheman/utility");
+var import_zod = __toESM(require("zod"), 1);
+function createRuleSchema(schema6) {
+  return [(0, import_utility4.omitProperties)(import_zod.default.toJSONSchema(schema6), "$schema")];
+}
+var createRuleSchema_default = createRuleSchema;
+
 // src/utility/getImportSpecifiersAfterRemoving.ts
 function getImportSpecifiersAfterRemoving(context, specifiers, importToRemove) {
   return specifiers.filter((specifier) => {
@@ -4484,10 +4512,17 @@ function getImportSpecifiersAfterRemoving(context, specifiers, importToRemove) {
 var getImportSpecifiersAfterRemoving_default = getImportSpecifiersAfterRemoving;
 
 // src/rules/consistent-test-function.ts
-var validTestFunctionsSchema = import_zod.default.enum(["test", "it"]);
+var validTestFunctionsSchema = import_zod2.default.enum(["test", "it"]);
 function parseTestFunction(data) {
   return validTestFunctionsSchema.parse(data);
 }
+var consistentTestFunctionOptionsSchema = import_zod2.default.object({
+  preference: validTestFunctionsSchema
+}).partial();
+function parseConsistentTestFunctionOptions(data) {
+  return consistentTestFunctionOptionsSchema.parse(data);
+}
+var schema = createRuleSchema_default(consistentTestFunctionOptionsSchema);
 var consistentTestFunction = createRule_default({
   name: "consistent-test-function",
   meta: {
@@ -4499,46 +4534,36 @@ var consistentTestFunction = createRule_default({
     },
     type: "suggestion",
     fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          preference: {
-            type: "string",
-            enum: ["it", "test"]
-          }
-        },
-        additionalProperties: false
-      }
-    ]
+    schema
   },
   defaultOptions: [{ preference: "test" }],
   create(context) {
     var _a;
-    const preference = (_a = context.options[0]) == null ? void 0 : _a.preference;
-    const validatedPreference = parseTestFunction(preference != null ? preference : "test");
+    const { preference } = parseConsistentTestFunctionOptions(
+      (_a = context.options[0]) != null ? _a : { preference: "test" }
+    );
     return {
       CallExpression(node) {
-        if (node.callee.type === import_utils2.AST_NODE_TYPES.Identifier && node.callee.name === "it" && validatedPreference === "test") {
+        if (node.callee.type === import_utils2.AST_NODE_TYPES.Identifier && node.callee.name === "it" && preference === "test") {
           return context.report({
             node,
             messageId: "message",
             data: {
               source: node.callee.name,
-              preference: validatedPreference
+              preference
             },
             fix(fixer) {
               return fixer.replaceText(node.callee, "test");
             }
           });
         }
-        if (node.callee.type === import_utils2.AST_NODE_TYPES.Identifier && node.callee.name === "test" && validatedPreference === "it") {
+        if (node.callee.type === import_utils2.AST_NODE_TYPES.Identifier && node.callee.name === "test" && preference === "it") {
           return context.report({
             node,
             messageId: "message",
             data: {
               source: node.callee.name,
-              preference: validatedPreference
+              preference
             },
             fix(fixer) {
               return fixer.replaceText(node.callee, "it");
@@ -4548,13 +4573,13 @@ var consistentTestFunction = createRule_default({
       },
       ImportDeclaration(node) {
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils2.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils2.AST_NODE_TYPES.Identifier && specifier.imported.name === "it" && validatedPreference === "test") {
+          if (specifier.type === import_utils2.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils2.AST_NODE_TYPES.Identifier && specifier.imported.name === "it" && preference === "test") {
             return context.report({
               node,
               messageId: "message",
               data: {
                 source: specifier.imported.name,
-                preference: validatedPreference
+                preference
               },
               fix(fixer) {
                 const importedNames = node.specifiers.map((specifier2) => {
@@ -4576,18 +4601,18 @@ var consistentTestFunction = createRule_default({
                 }
                 return fixer.replaceTextRange(
                   [specifier.imported.range[0], specifier.imported.range[1]],
-                  validatedPreference
+                  preference
                 );
               }
             });
           }
-          if (specifier.type === import_utils2.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils2.AST_NODE_TYPES.Identifier && specifier.imported.name === "test" && validatedPreference === "it") {
+          if (specifier.type === import_utils2.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils2.AST_NODE_TYPES.Identifier && specifier.imported.name === "test" && preference === "it") {
             return context.report({
               node,
               messageId: "message",
               data: {
                 source: specifier.imported.name,
-                preference: validatedPreference
+                preference
               },
               fix(fixer) {
                 const importedNames = node.specifiers.map((specifier2) => {
@@ -4609,7 +4634,7 @@ var consistentTestFunction = createRule_default({
                 }
                 return fixer.replaceTextRange(
                   [specifier.imported.range[0], specifier.imported.range[1]],
-                  validatedPreference
+                  preference
                 );
               }
             });
@@ -4661,6 +4686,14 @@ var noIsolatedTests = createRule_default({
 var no_isolated_tests_default = noIsolatedTests;
 
 // src/rules/no-namespace-imports.ts
+var import_zod3 = __toESM(require("zod"), 1);
+var noNamespaceImportsOptionsSchema = import_zod3.default.object({
+  allow: import_zod3.default.array(import_zod3.default.string())
+}).partial();
+function parseNoNamespaceImportsOptions(data) {
+  return noNamespaceImportsOptionsSchema.parse(data);
+}
+var schema2 = createRuleSchema_default(noNamespaceImportsOptionsSchema);
 var noNamespaceImports = createRule_default({
   name: "no-namespace-imports",
   meta: {
@@ -4671,31 +4704,17 @@ var noNamespaceImports = createRule_default({
       message: 'Import * from "{{source}}" is not allowed. Please use named imports instead.'
     },
     type: "suggestion",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          allow: {
-            type: "array",
-            items: {
-              type: "string"
-            },
-            uniqueItems: true
-          }
-        },
-        additionalProperties: false
-      }
-    ]
+    schema: schema2
   },
   defaultOptions: [{ allow: [""] }],
   create(context) {
     var _a;
-    const allowableNamedImports = (_a = context.options[0]) == null ? void 0 : _a.allow;
+    const { allow } = parseNoNamespaceImportsOptions((_a = context.options[0]) != null ? _a : { allow: [] });
     return {
       ImportDeclaration(node) {
         const allSpecifiers = node.specifiers;
         for (const specifier of allSpecifiers) {
-          if (specifier.type === "ImportNamespaceSpecifier" && !(allowableNamedImports == null ? void 0 : allowableNamedImports.includes(node.source.value))) {
+          if (specifier.type === "ImportNamespaceSpecifier" && !(allow == null ? void 0 : allow.includes(node.source.value))) {
             context.report({
               node,
               messageId: "message",
@@ -4748,6 +4767,14 @@ var noPluginConfigAccessFromSrcConfigs = createRule_default({
 var no_plugin_configs_access_from_src_configs_default = noPluginConfigAccessFromSrcConfigs;
 
 // src/rules/no-relative-imports.ts
+var import_zod4 = __toESM(require("zod"), 1);
+var noRelativeImportsOptionsSchema = import_zod4.default.object({
+  depth: import_zod4.default.int().nonnegative()
+}).partial();
+function parseNoRelativeImportsOptions(data) {
+  return noRelativeImportsOptionsSchema.parse(data);
+}
+var schema3 = createRuleSchema_default(noRelativeImportsOptionsSchema);
 var noRelativeImports = createRule_default({
   name: "no-relative-imports",
   meta: {
@@ -4759,34 +4786,16 @@ var noRelativeImports = createRule_default({
       stupidPath: "For the love of God, please do not mix relative path parts in your import statements like that! How can you possibly be ok with {{source}}?!"
     },
     type: "suggestion",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          depth: {
-            type: "number"
-          }
-        },
-        additionalProperties: false
-      }
-    ]
+    schema: schema3
   },
   defaultOptions: [{ depth: void 0 }],
   create(context) {
     var _a;
-    const allowedDepth = (_a = context.options[0]) == null ? void 0 : _a.depth;
-    if (allowedDepth !== void 0) {
-      if (allowedDepth % 1 !== 0) {
-        throw new Error("NON_INTEGER_DEPTH_NOT_ALLOWED");
-      }
-      if (allowedDepth < 0) {
-        throw new Error("NEGATIVE_DEPTH_NOT_ALLOWED");
-      }
-    }
+    const { depth } = parseNoRelativeImportsOptions((_a = context.options[0]) != null ? _a : { depth: void 0 });
     return {
       ImportDeclaration(node) {
         if (node.source.value.includes("./") || node.source.value.includes("../")) {
-          if (allowedDepth === void 0) {
+          if (depth === void 0) {
             return context.report({
               node,
               messageId: "strictNoRelative",
@@ -4814,18 +4823,18 @@ var noRelativeImports = createRule_default({
               }
             });
           }
-          if (allowedDepth === 0 && importPathParts[0] === ".") {
+          if (depth === 0 && importPathParts[0] === ".") {
             return;
           }
           let endOfRelativePathFound = false;
-          for (const part of importPathParts.slice(0, allowedDepth + 1)) {
+          for (const part of importPathParts.slice(0, depth + 1)) {
             if (part !== "..") {
               endOfRelativePathFound = true;
               break;
             }
           }
           if (!endOfRelativePathFound) {
-            if (allowedDepth === 0) {
+            if (depth === 0) {
               return context.report({
                 node,
                 messageId: "rootOnly",
@@ -4839,8 +4848,8 @@ var noRelativeImports = createRule_default({
               messageId: "exceededAllowedDepth",
               data: {
                 source: node.source.value,
-                depth: allowedDepth,
-                s: allowedDepth !== 1 ? "s" : ""
+                depth,
+                s: depth !== 1 ? "s" : ""
               }
             });
           }
@@ -4885,9 +4894,20 @@ var no_skipped_tests_default = noSkippedTests;
 
 // src/rules/standardise-error-messages.ts
 var import_utils4 = require("@typescript-eslint/utils");
+var import_zod5 = __toESM(require("zod"), 1);
+var standardiseErrorMessagesOptionsSchema = import_zod5.default.object({
+  regex: import_zod5.default.string()
+}).partial();
+function parseStandardiseErrorMessagesOptions(data) {
+  return standardiseErrorMessagesOptionsSchema.parse(data);
+}
+var schema4 = createRuleSchema_default(standardiseErrorMessagesOptionsSchema);
+var defaultErrorRegex = "^[A-Z]+(?:_[A-Z]+)*$";
 function checkCurrentNode(context, node) {
-  var _a, _b;
-  const errorRegex = (_b = (_a = context.options[0]) == null ? void 0 : _a.regex) != null ? _b : "^[A-Z]+(?:_[A-Z]+)*$";
+  var _a;
+  const { regex: errorRegex = defaultErrorRegex } = parseStandardiseErrorMessagesOptions(
+    (_a = context.options[0]) != null ? _a : { regex: defaultErrorRegex }
+  );
   if (node.callee.type === import_utils4.AST_NODE_TYPES.Identifier && node.callee.name === "Error") {
     const [errorArgument] = node.arguments;
     const errorMessage = errorArgument.type === import_utils4.AST_NODE_TYPES.Literal ? errorArgument.value : "";
@@ -4913,19 +4933,9 @@ var standardiseErrorMessages = createRule_default({
       message: "Expected error message {{error}} to match {{regex}}."
     },
     type: "suggestion",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: {
-            type: "string"
-          }
-        },
-        additionalProperties: false
-      }
-    ]
+    schema: schema4
   },
-  defaultOptions: [{ regex: "^[A-Z]+(?:_[A-Z]+)*$" }],
+  defaultOptions: [{ regex: defaultErrorRegex }],
   create(context) {
     return {
       CallExpression(node) {
@@ -4941,6 +4951,14 @@ var standardise_error_messages_default = standardiseErrorMessages;
 
 // src/rules/use-normalized-imports.ts
 var import_path = __toESM(require("path"), 1);
+var import_zod6 = __toESM(require("zod"), 1);
+var useNormalizedImportsOptionsSchema = import_zod6.default.object({
+  fixable: import_zod6.default.boolean()
+}).partial();
+function parseUseNormalizedImportsOptions(data) {
+  return useNormalizedImportsOptionsSchema.parse(data);
+}
+var schema5 = createRuleSchema_default(useNormalizedImportsOptionsSchema);
 var useNormalizedImports = createRule_default({
   name: "use-normalized-imports",
   meta: {
@@ -4951,23 +4969,15 @@ var useNormalizedImports = createRule_default({
       pathNotNormalized: "Import path {{nonNormalized}} is not normalised. Please use {{normalized}} instead."
     },
     type: "suggestion",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          fixable: {
-            type: "boolean"
-          }
-        },
-        additionalProperties: false
-      }
-    ],
+    schema: schema5,
     fixable: "code"
   },
   defaultOptions: [{ fixable: true }],
   create(context) {
-    var _a, _b;
-    const isFixable = (_b = (_a = context.options[0]) == null ? void 0 : _a.fixable) != null ? _b : true;
+    var _a;
+    const { fixable: isFixable } = parseUseNormalizedImportsOptions(
+      (_a = context.options[0]) != null ? _a : { fixable: true }
+    );
     return {
       ImportDeclaration(node) {
         const normalizedPath = import_path.default.posix.normalize(node.source.value);
@@ -5059,7 +5069,12 @@ var alexPlugin_default = alexPlugin;
 var index_default = alexPlugin_default;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  parseConsistentTestFunctionOptions,
+  parseNoNamespaceImportsOptions,
+  parseNoRelativeImportsOptions,
+  parseStandardiseErrorMessagesOptions,
   parseTestFunction,
+  parseUseNormalizedImportsOptions,
   prettierRules,
   sortObjects
 });