@alextheman/eslint-plugin 2.8.2 → 2.9.0

package/dist/index.cjs

@@ -3759,7 +3759,7 @@ module.exports = __toCommonJS(index_exports);
 
 // package.json
 var name = "@alextheman/eslint-plugin";
-var version = "2.8.2";
+var version = "2.9.0";
 
 // src/configs/index.ts
 var import_eslint_plugin_package_json = __toESM(require("eslint-plugin-package-json"), 1);
@@ -4464,7 +4464,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 +4473,14 @@ var createRule = import_utils.ESLintUtils.RuleCreator((ruleName) => {
 });
 var createRule_default = createRule;
 
+// src/utility/createRuleSchema.ts
+var import_utility3 = require("@alextheman/utility");
+var import_zod = __toESM(require("zod"), 1);
+function createRuleSchema(schema6) {
+  return [(0, import_utility3.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 +4492,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 +4514,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 +4553,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 +4581,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 +4614,7 @@ var consistentTestFunction = createRule_default({
                 }
                 return fixer.replaceTextRange(
                   [specifier.imported.range[0], specifier.imported.range[1]],
-                  validatedPreference
+                  preference
                 );
               }
             });
@@ -4661,6 +4666,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 +4684,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 +4747,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 +4766,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 +4803,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 +4828,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 +4874,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 +4913,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 +4931,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 parseUseNormalizedImportsOptionsSchema(data) {
+  return useNormalizedImportsOptionsSchema.parse(data);
+}
+var schema5 = createRuleSchema_default(useNormalizedImportsOptionsSchema);
 var useNormalizedImports = createRule_default({
   name: "use-normalized-imports",
   meta: {
@@ -4951,23 +4949,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 } = parseUseNormalizedImportsOptionsSchema(
+      (_a = context.options[0]) != null ? _a : { fixable: true }
+    );
     return {
       ImportDeclaration(node) {
         const normalizedPath = import_path.default.posix.normalize(node.source.value);

package/dist/index.d.cts

@@ -4,7 +4,7 @@ import { Config } from 'prettier';
 import z from 'zod';
 
 var name = "@alextheman/eslint-plugin";
-var version = "2.8.2";
+var version = "2.9.0";
 
 type CamelToKebab<S extends string> = S extends `${IgnoreCase<"J">}avaScript${infer Rest}` ? Rest extends "" ? "javascript" : `javascript${CamelToKebab<Rest>}` : S extends `${IgnoreCase<"T">}ypeScript${infer Rest}` ? Rest extends "" ? "typescript" : `typescript${CamelToKebab<Rest>}` : S extends `${infer Head}${infer Tail}` ? Head extends Lowercase<Head> ? `${Head}${CamelToKebab<Tail>}` : `-${Lowercase<Head>}${CamelToKebab<Tail>}` : S;
 
@@ -64,35 +64,32 @@ declare const validTestFunctionsSchema: z.ZodEnum<{
 }>;
 type TestFunction = z.infer<typeof validTestFunctionsSchema>;
 declare function parseTestFunction(data: unknown): TestFunction;
+declare const consistentTestFunctionOptionsSchema: z.ZodObject<{
+    preference: z.ZodOptional<z.ZodEnum<{
+        test: "test";
+        it: "it";
+    }>>;
+}, z.core.$strip>;
+type ConsistentTestFunctionOptions = z.infer<typeof consistentTestFunctionOptionsSchema>;
 
-/** Generated from src/utility/generateRuleOptionsTypes.ts.
- * You may execute the above file to re-generate this type using `npm run generate-rule-options-types` */
-interface ConsistentTestFunctionOptions {
-    preference?: "it" | "test";
-}
-
-/** Generated from src/utility/generateRuleOptionsTypes.ts.
- * You may execute the above file to re-generate this type using `npm run generate-rule-options-types` */
-interface NoNamespaceImportsOptions {
-    allow?: string[];
-}
+declare const noNamespaceImportsOptionsSchema: z.ZodObject<{
+    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type NoNamespaceImportsOptions = z.infer<typeof noNamespaceImportsOptionsSchema>;
 
-/** Generated from src/utility/generateRuleOptionsTypes.ts.
- * You may execute the above file to re-generate this type using `npm run generate-rule-options-types` */
-interface NoRelativeImportsOptions {
-    depth?: number;
-}
+declare const noRelativeImportsOptionsSchema: z.ZodObject<{
+    depth: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+type NoRelativeImportsOptions = z.infer<typeof noRelativeImportsOptionsSchema>;
 
-/** Generated from src/utility/generateRuleOptionsTypes.ts.
- * You may execute the above file to re-generate this type using `npm run generate-rule-options-types` */
-interface StandardiseErrorMessagesOptions {
-    regex?: string;
-}
+declare const standardiseErrorMessagesOptionsSchema: z.ZodObject<{
+    regex: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type StandardiseErrorMessagesOptions = z.infer<typeof standardiseErrorMessagesOptionsSchema>;
 
-/** Generated from src/utility/generateRuleOptionsTypes.ts.
- * You may execute the above file to re-generate this type using `npm run generate-rule-options-types` */
-interface UseNormalizedImportsOptions {
-    fixable?: boolean;
-}
+declare const useNormalizedImportsOptionsSchema: z.ZodObject<{
+    fixable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type UseNormalizedImportsOptions = z.infer<typeof useNormalizedImportsOptionsSchema>;
 
 export { type AlexPlugin, type AlexPluginConfigGroup, type CombinedConfig, type ConfigGroupName, type ConfigKey, type ConsistentTestFunctionOptions, type GeneralConfig, type NoNamespaceImportsOptions, type NoRelativeImportsOptions, type PersonalConfig, type PluginConfig, type StandardiseErrorMessagesOptions, type TestFunction, type UseNormalizedImportsOptions, alexPlugin as default, parseTestFunction, prettierRules, sortObjects };

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import { Config } from 'prettier';
 import z from 'zod';
 
 var name = "@alextheman/eslint-plugin";
-var version = "2.8.2";
+var version = "2.9.0";
 
 type CamelToKebab<S extends string> = S extends `${IgnoreCase<"J">}avaScript${infer Rest}` ? Rest extends "" ? "javascript" : `javascript${CamelToKebab<Rest>}` : S extends `${IgnoreCase<"T">}ypeScript${infer Rest}` ? Rest extends "" ? "typescript" : `typescript${CamelToKebab<Rest>}` : S extends `${infer Head}${infer Tail}` ? Head extends Lowercase<Head> ? `${Head}${CamelToKebab<Tail>}` : `-${Lowercase<Head>}${CamelToKebab<Tail>}` : S;
 
@@ -64,35 +64,32 @@ declare const validTestFunctionsSchema: z.ZodEnum<{
 }>;
 type TestFunction = z.infer<typeof validTestFunctionsSchema>;
 declare function parseTestFunction(data: unknown): TestFunction;
+declare const consistentTestFunctionOptionsSchema: z.ZodObject<{
+    preference: z.ZodOptional<z.ZodEnum<{
+        test: "test";
+        it: "it";
+    }>>;
+}, z.core.$strip>;
+type ConsistentTestFunctionOptions = z.infer<typeof consistentTestFunctionOptionsSchema>;
 
-/** Generated from src/utility/generateRuleOptionsTypes.ts.
- * You may execute the above file to re-generate this type using `npm run generate-rule-options-types` */
-interface ConsistentTestFunctionOptions {
-    preference?: "it" | "test";
-}
-
-/** Generated from src/utility/generateRuleOptionsTypes.ts.
- * You may execute the above file to re-generate this type using `npm run generate-rule-options-types` */
-interface NoNamespaceImportsOptions {
-    allow?: string[];
-}
+declare const noNamespaceImportsOptionsSchema: z.ZodObject<{
+    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type NoNamespaceImportsOptions = z.infer<typeof noNamespaceImportsOptionsSchema>;
 
-/** Generated from src/utility/generateRuleOptionsTypes.ts.
- * You may execute the above file to re-generate this type using `npm run generate-rule-options-types` */
-interface NoRelativeImportsOptions {
-    depth?: number;
-}
+declare const noRelativeImportsOptionsSchema: z.ZodObject<{
+    depth: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+type NoRelativeImportsOptions = z.infer<typeof noRelativeImportsOptionsSchema>;
 
-/** Generated from src/utility/generateRuleOptionsTypes.ts.
- * You may execute the above file to re-generate this type using `npm run generate-rule-options-types` */
-interface StandardiseErrorMessagesOptions {
-    regex?: string;
-}
+declare const standardiseErrorMessagesOptionsSchema: z.ZodObject<{
+    regex: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type StandardiseErrorMessagesOptions = z.infer<typeof standardiseErrorMessagesOptionsSchema>;
 
-/** Generated from src/utility/generateRuleOptionsTypes.ts.
- * You may execute the above file to re-generate this type using `npm run generate-rule-options-types` */
-interface UseNormalizedImportsOptions {
-    fixable?: boolean;
-}
+declare const useNormalizedImportsOptionsSchema: z.ZodObject<{
+    fixable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type UseNormalizedImportsOptions = z.infer<typeof useNormalizedImportsOptionsSchema>;
 
 export { type AlexPlugin, type AlexPluginConfigGroup, type CombinedConfig, type ConfigGroupName, type ConfigKey, type ConsistentTestFunctionOptions, type GeneralConfig, type NoNamespaceImportsOptions, type NoRelativeImportsOptions, type PersonalConfig, type PluginConfig, type StandardiseErrorMessagesOptions, type TestFunction, type UseNormalizedImportsOptions, alexPlugin as default, parseTestFunction, prettierRules, sortObjects };

package/dist/index.js

@@ -3743,7 +3743,7 @@ var require_src = __commonJS({
 
 // package.json
 var name = "@alextheman/eslint-plugin";
-var version = "2.8.2";
+var version = "2.9.0";
 
 // src/configs/index.ts
 import packageJson from "eslint-plugin-package-json";
@@ -4448,7 +4448,7 @@ var configs_default = createAlexPluginConfigs;
 
 // src/rules/consistent-test-function.ts
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-import z from "zod";
+import z2 from "zod";
 
 // src/createRule.ts
 import { ESLintUtils } from "@typescript-eslint/utils";
@@ -4457,6 +4457,14 @@ var createRule = ESLintUtils.RuleCreator((ruleName) => {
 });
 var createRule_default = createRule;
 
+// src/utility/createRuleSchema.ts
+import { omitProperties } from "@alextheman/utility";
+import z from "zod";
+function createRuleSchema(schema6) {
+  return [omitProperties(z.toJSONSchema(schema6), "$schema")];
+}
+var createRuleSchema_default = createRuleSchema;
+
 // src/utility/getImportSpecifiersAfterRemoving.ts
 function getImportSpecifiersAfterRemoving(context, specifiers, importToRemove) {
   return specifiers.filter((specifier) => {
@@ -4468,10 +4476,17 @@ function getImportSpecifiersAfterRemoving(context, specifiers, importToRemove) {
 var getImportSpecifiersAfterRemoving_default = getImportSpecifiersAfterRemoving;
 
 // src/rules/consistent-test-function.ts
-var validTestFunctionsSchema = z.enum(["test", "it"]);
+var validTestFunctionsSchema = z2.enum(["test", "it"]);
 function parseTestFunction(data) {
   return validTestFunctionsSchema.parse(data);
 }
+var consistentTestFunctionOptionsSchema = z2.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: {
@@ -4483,46 +4498,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 === AST_NODE_TYPES.Identifier && node.callee.name === "it" && validatedPreference === "test") {
+        if (node.callee.type === 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 === AST_NODE_TYPES.Identifier && node.callee.name === "test" && validatedPreference === "it") {
+        if (node.callee.type === 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");
@@ -4532,13 +4537,13 @@ var consistentTestFunction = createRule_default({
       },
       ImportDeclaration(node) {
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === "it" && validatedPreference === "test") {
+          if (specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === 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) => {
@@ -4560,18 +4565,18 @@ var consistentTestFunction = createRule_default({
                 }
                 return fixer.replaceTextRange(
                   [specifier.imported.range[0], specifier.imported.range[1]],
-                  validatedPreference
+                  preference
                 );
               }
             });
           }
-          if (specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === "test" && validatedPreference === "it") {
+          if (specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === 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) => {
@@ -4593,7 +4598,7 @@ var consistentTestFunction = createRule_default({
                 }
                 return fixer.replaceTextRange(
                   [specifier.imported.range[0], specifier.imported.range[1]],
-                  validatedPreference
+                  preference
                 );
               }
             });
@@ -4645,6 +4650,14 @@ var noIsolatedTests = createRule_default({
 var no_isolated_tests_default = noIsolatedTests;
 
 // src/rules/no-namespace-imports.ts
+import z3 from "zod";
+var noNamespaceImportsOptionsSchema = z3.object({
+  allow: z3.array(z3.string())
+}).partial();
+function parseNoNamespaceImportsOptions(data) {
+  return noNamespaceImportsOptionsSchema.parse(data);
+}
+var schema2 = createRuleSchema_default(noNamespaceImportsOptionsSchema);
 var noNamespaceImports = createRule_default({
   name: "no-namespace-imports",
   meta: {
@@ -4655,31 +4668,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",
@@ -4732,6 +4731,14 @@ var noPluginConfigAccessFromSrcConfigs = createRule_default({
 var no_plugin_configs_access_from_src_configs_default = noPluginConfigAccessFromSrcConfigs;
 
 // src/rules/no-relative-imports.ts
+import z4 from "zod";
+var noRelativeImportsOptionsSchema = z4.object({
+  depth: z4.int().nonnegative()
+}).partial();
+function parseNoRelativeImportsOptions(data) {
+  return noRelativeImportsOptionsSchema.parse(data);
+}
+var schema3 = createRuleSchema_default(noRelativeImportsOptionsSchema);
 var noRelativeImports = createRule_default({
   name: "no-relative-imports",
   meta: {
@@ -4743,34 +4750,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",
@@ -4798,18 +4787,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",
@@ -4823,8 +4812,8 @@ var noRelativeImports = createRule_default({
               messageId: "exceededAllowedDepth",
               data: {
                 source: node.source.value,
-                depth: allowedDepth,
-                s: allowedDepth !== 1 ? "s" : ""
+                depth,
+                s: depth !== 1 ? "s" : ""
               }
             });
           }
@@ -4869,9 +4858,20 @@ var no_skipped_tests_default = noSkippedTests;
 
 // src/rules/standardise-error-messages.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
+import z5 from "zod";
+var standardiseErrorMessagesOptionsSchema = z5.object({
+  regex: z5.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 === AST_NODE_TYPES3.Identifier && node.callee.name === "Error") {
     const [errorArgument] = node.arguments;
     const errorMessage = errorArgument.type === AST_NODE_TYPES3.Literal ? errorArgument.value : "";
@@ -4897,19 +4897,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) {
@@ -4925,6 +4915,14 @@ var standardise_error_messages_default = standardiseErrorMessages;
 
 // src/rules/use-normalized-imports.ts
 import path from "path";
+import z6 from "zod";
+var useNormalizedImportsOptionsSchema = z6.object({
+  fixable: z6.boolean()
+}).partial();
+function parseUseNormalizedImportsOptionsSchema(data) {
+  return useNormalizedImportsOptionsSchema.parse(data);
+}
+var schema5 = createRuleSchema_default(useNormalizedImportsOptionsSchema);
 var useNormalizedImports = createRule_default({
   name: "use-normalized-imports",
   meta: {
@@ -4935,23 +4933,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 } = parseUseNormalizedImportsOptionsSchema(
+      (_a = context.options[0]) != null ? _a : { fixable: true }
+    );
     return {
       ImportDeclaration(node) {
         const normalizedPath = path.posix.normalize(node.source.value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alextheman/eslint-plugin",
-  "version": "2.8.2",
+  "version": "2.9.0",
   "description": "A package to provide custom ESLint rules and configs",
   "repository": {
     "type": "git",
@@ -25,7 +25,6 @@
     "format-prettier": "npm run format-prettier-typescript && npm run format-prettier-javascript",
     "format-prettier-javascript": "prettier --write \"./**/*.js\"",
     "format-prettier-typescript": "prettier --write --parser typescript \"./**/*.ts\"",
-    "generate-rule-options-types": "tsx src/utility/generateRuleOptionsTypes.ts",
     "lint": "tsx src/utility/checkConfigChanges.ts || npm run build && npm run lint-tsc && npm run lint-eslint && npm run lint-prettier",
     "lint-eslint": "eslint \"src/**/*.ts\" \"tests/**/*.ts\" \"package.json\"",
     "lint-prettier": "npm run lint-prettier-typescript && npm run lint-prettier-javascript",
@@ -40,8 +39,6 @@
   "dependencies": {
     "@alextheman/utility": "^2.15.1",
     "common-tags": "^1.8.2",
-    "eslint-plugin-package-json": "^0.64.0",
-    "json-schema-to-typescript": "^15.0.4",
     "zod": "^4.1.12"
   },
   "devDependencies": {
@@ -70,6 +67,7 @@
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-jsx-a11y": "^6.10.2",
+    "eslint-plugin-package-json": "^0.74.0",
     "eslint-plugin-perfectionist": "^4.15.0",
     "eslint-plugin-prettier": "^5.5.3",
     "eslint-plugin-react": "^7.37.5",