@alextheman/eslint-plugin 2.8.2 → 3.0.0

package/dist/index.js

@@ -3405,7 +3405,7 @@ var require_package = __commonJS({
   "node_modules/@eslint/js/package.json"(exports, module) {
     module.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",
@@ -3447,7 +3447,7 @@ var require_eslint_all = __commonJS({
   "node_modules/@eslint/js/src/configs/eslint-all.js"(exports, module) {
     "use strict";
     module.exports = Object.freeze({
-      "rules": {
+      rules: Object.freeze({
         "accessor-pairs": "error",
         "array-callback-return": "error",
         "arrow-body-style": "error",
@@ -3631,6 +3631,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",
@@ -3646,7 +3647,7 @@ var require_eslint_all = __commonJS({
         "valid-typeof": "error",
         "vars-on-top": "error",
         "yoda": "error"
-      }
+      })
     });
   }
 });
@@ -3743,7 +3744,7 @@ var require_src = __commonJS({
 
 // package.json
 var name = "@alextheman/eslint-plugin";
-var version = "2.8.2";
+var version = "3.0.0";
 
 // src/configs/index.ts
 import packageJson from "eslint-plugin-package-json";
@@ -3844,14 +3845,14 @@ var import_js = __toESM(require_src(), 1);
 import prettierConfig from "eslint-config-prettier";
 import importPlugin from "eslint-plugin-import";
 
-// 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: "^_",
@@ -3910,7 +3911,7 @@ var javaScriptBase_default = javaScriptBase;
 import perfectionist from "eslint-plugin-perfectionist";
 import prettierPlugin from "eslint-plugin-prettier";
 
-// src/configs/miscellaneous/prettierRules.ts
+// src/configs/helpers/prettierRules.ts
 var prettierRules = {
   printWidth: 100
 };
@@ -3993,10 +3994,20 @@ var javaScriptBase_default3 = createCombinedJavaScriptBaseConfig;
 // src/configs/general/reactBase.ts
 import jsxA11y from "eslint-plugin-jsx-a11y";
 import reactPlugin from "eslint-plugin-react";
-import reactHooks from "eslint-plugin-react-hooks";
 import reactRefresh from "eslint-plugin-react-refresh";
 
-// src/configs/miscellaneous/reactLanguageOptions.ts
+// src/configs/helpers/reactHooks.ts
+import { omitProperties } from "@alextheman/utility";
+import reactHooksPlugin from "eslint-plugin-react-hooks";
+var reactHooks = __spreadProps(__spreadValues({}, reactHooksPlugin), {
+  configs: __spreadProps(__spreadValues({}, omitProperties(reactHooksPlugin.configs, "flat")), {
+    "flat/recommended": reactHooksPlugin.configs.flat.recommended,
+    "flat/recommended-latest": reactHooksPlugin.configs.flat["recommended-latest"]
+  })
+});
+var reactHooks_default = reactHooks;
+
+// src/configs/helpers/reactLanguageOptions.ts
 var import_globals3 = __toESM(require_globals2(), 1);
 var reactLanguageOptions = {
   ecmaVersion: 2020,
@@ -4019,10 +4030,10 @@ var reactBase = [
     name: "@alextheman/general/react",
     plugins: {
       react: reactPlugin,
-      "react-hooks": reactHooks,
+      "react-hooks": reactHooks_default,
       "react-refresh": reactRefresh
     },
-    rules: __spreadProps(__spreadValues({}, reactHooks.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": [
@@ -4044,7 +4055,6 @@ var reactBase_default = reactBase;
 
 // src/configs/personal/reactBase.ts
 import reactPlugin2 from "eslint-plugin-react";
-import reactHooks2 from "eslint-plugin-react-hooks";
 import reactRefresh2 from "eslint-plugin-react-refresh";
 var personalReactBaseConfig = [
   {
@@ -4052,7 +4062,7 @@ var personalReactBaseConfig = [
     name: "@alextheman/personal/react",
     plugins: {
       react: reactPlugin2,
-      "react-hooks": reactHooks2,
+      "react-hooks": reactHooks_default,
       "react-refresh": reactRefresh2
     },
     rules: {
@@ -4094,12 +4104,12 @@ function createCombinedJavaScriptReactBaseConfig(plugin) {
 var javaScriptReactBase_default = createCombinedJavaScriptReactBaseConfig;
 
 // src/configs/general/typeScriptBase.ts
-import tseslint from "typescript-eslint";
+import tseslint2 from "typescript-eslint";
 
-// src/configs/miscellaneous/typeScriptLanguageOptions.ts
-import tsparser from "@typescript-eslint/parser";
+// src/configs/helpers/typeScriptLanguageOptions.ts
+import tseslint from "typescript-eslint";
 var typeScriptLanguageOptions = {
-  parser: tsparser,
+  parser: tseslint.parser,
   parserOptions: {
     ecmaVersion: "latest",
     projectService: true,
@@ -4111,7 +4121,7 @@ var typeScriptLanguageOptions_default = typeScriptLanguageOptions;
 
 // src/configs/general/typeScriptBase.ts
 var typeScriptBase = [
-  ...tseslint.configs.recommended,
+  ...tseslint2.configs.recommended,
   ...javaScriptBase_default,
   {
     files: ["**/*.ts", "**/*.tsx"],
@@ -4140,7 +4150,7 @@ var typeScriptBase_default = typeScriptBase;
 // src/configs/personal/eslintPlugin.ts
 import perfectionist2 from "eslint-plugin-perfectionist";
 
-// src/configs/miscellaneous/sortObjects.ts
+// src/configs/helpers/sortObjects.ts
 var sortObjects = {
   customGroups: [],
   destructuredObjects: true,
@@ -4179,20 +4189,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]
@@ -4298,7 +4313,7 @@ var neurosongsFrontEndConfig = [
 var neurosongsFrontEnd_default = neurosongsFrontEndConfig;
 
 // src/configs/personal/typeScriptBase.ts
-import tseslint2 from "typescript-eslint";
+import tseslint3 from "typescript-eslint";
 function createPersonalTypeScriptBaseConfig(plugin) {
   return [
     {
@@ -4307,7 +4322,7 @@ function createPersonalTypeScriptBaseConfig(plugin) {
       name: "@alextheman/personal/typescript",
       plugins: {
         "@alextheman": plugin,
-        "@typescript-eslint": tseslint2.plugin
+        "@typescript-eslint": tseslint3.plugin
       },
       rules: {
         "@alextheman/standardise-error-messages": "error",
@@ -4325,12 +4340,12 @@ function createPersonalTypeScriptBaseConfig(plugin) {
 var typeScriptBase_default2 = createPersonalTypeScriptBaseConfig;
 
 // src/configs/personal/utility.ts
-import tseslint3 from "typescript-eslint";
+import tseslint4 from "typescript-eslint";
 var utilityConfig = [
   {
     name: "@alextheman/personal/utility",
     plugins: {
-      "@typescript-eslint": tseslint3.plugin
+      "@typescript-eslint": tseslint4.plugin
     },
     rules: {
       "@typescript-eslint/explicit-module-boundary-types": "error"
@@ -4448,7 +4463,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 +4472,14 @@ var createRule = ESLintUtils.RuleCreator((ruleName) => {
 });
 var createRule_default = createRule;
 
+// src/utility/createRuleSchema.ts
+import { omitProperties as omitProperties2 } from "@alextheman/utility";
+import z from "zod";
+function createRuleSchema(schema6) {
+  return [omitProperties2(z.toJSONSchema(schema6), "$schema")];
+}
+var createRuleSchema_default = createRuleSchema;
+
 // src/utility/getImportSpecifiersAfterRemoving.ts
 function getImportSpecifiersAfterRemoving(context, specifiers, importToRemove) {
   return specifiers.filter((specifier) => {
@@ -4468,10 +4491,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 +4513,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 +4552,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 +4580,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 +4613,7 @@ var consistentTestFunction = createRule_default({
                 }
                 return fixer.replaceTextRange(
                   [specifier.imported.range[0], specifier.imported.range[1]],
-                  validatedPreference
+                  preference
                 );
               }
             });
@@ -4645,6 +4665,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 +4683,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 +4746,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 +4765,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 +4802,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 +4827,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 +4873,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 +4912,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 +4930,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 parseUseNormalizedImportsOptions(data) {
+  return useNormalizedImportsOptionsSchema.parse(data);
+}
+var schema5 = createRuleSchema_default(useNormalizedImportsOptionsSchema);
 var useNormalizedImports = createRule_default({
   name: "use-normalized-imports",
   meta: {
@@ -4935,23 +4948,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 = path.posix.normalize(node.source.value);
@@ -5043,7 +5048,12 @@ var alexPlugin_default = alexPlugin;
 var index_default = alexPlugin_default;
 export {
   index_default as default,
+  parseConsistentTestFunctionOptions,
+  parseNoNamespaceImportsOptions,
+  parseNoRelativeImportsOptions,
+  parseStandardiseErrorMessagesOptions,
   parseTestFunction,
+  parseUseNormalizedImportsOptions,
   prettierRules_default as prettierRules,
   sortObjects_default as sortObjects
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alextheman/eslint-plugin",
-  "version": "2.8.2",
+  "version": "3.0.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,41 +39,38 @@
   "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": {
     "@types/common-tags": "^1.8.4",
     "@types/eslint": "^9.6.1",
     "@types/eslint-plugin-jsx-a11y": "^6.10.1",
-    "@types/node": "^24.10.0",
-    "@typescript-eslint/rule-tester": "^8.46.3",
-    "@typescript-eslint/utils": "^8.46.3",
+    "@types/node": "^24.10.1",
+    "@typescript-eslint/rule-tester": "^8.46.4",
+    "@typescript-eslint/utils": "^8.46.4",
     "eslint-plugin-eslint-plugin": "^7.2.0",
     "globals": "^16.5.0",
     "husky": "^9.1.7",
     "jiti": "^2.6.1",
     "prettier": "^3.6.2",
-    "tsup": "^8.5.0",
+    "tsup": "^8.5.1",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^4.0.8"
+    "vitest": "^4.0.9"
   },
   "peerDependencies": {
-    "@typescript-eslint/eslint-plugin": "^8.37.0",
-    "@typescript-eslint/parser": "^8.37.0",
-    "eslint": "^9.31.0",
+    "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-jsx-a11y": "^6.10.2",
-    "eslint-plugin-perfectionist": "^4.15.0",
-    "eslint-plugin-prettier": "^5.5.3",
+    "eslint-plugin-package-json": "^0.74.0",
+    "eslint-plugin-perfectionist": "^4.15.1",
+    "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^5.2.0",
-    "eslint-plugin-react-refresh": "^0.4.20",
-    "typescript-eslint": "^8.43.0"
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "typescript-eslint": "^8.46.4"
   }
 }