@baseplate-dev/tools 0.2.1 → 0.2.3

package/eslint-configs/react.js

@@ -42,6 +42,13 @@ export const reactEslintConfig = tsEslint.config(
         'error',
         { checksVoidReturn: { attributes: false } },
       ],
+      // Allow floating navigate from useNavigate to be handled by the router
+      '@typescript-eslint/no-floating-promises': [
+        'error',
+        {
+          allowForKnownSafeCalls: ['UseNavigateResult'],
+        },
+      ],
     },
   },
 
@@ -56,6 +63,21 @@ export const reactEslintConfig = tsEslint.config(
     rules: {
       // We use replace since it is not supported by ES2020
       'unicorn/prefer-string-replace-all': 'off',
+      // Support kebab case with - prefix to support ignored files in routes
+      'unicorn/filename-case': [
+        'error',
+        {
+          cases: {
+            kebabCase: true,
+          },
+          ignore: [String.raw`^-[a-z0-9\-\.]+$`],
+        },
+      ],
     },
   },
+
+  // Global ignores
+  {
+    ignores: ['**/route-tree.gen.ts'],
+  },
 );

package/eslint-configs/rules/no-unused-generator-dependencies.js

@@ -0,0 +1,138 @@
+// @ts-check
+
+/**
+ * ESLint rule to disallow unused dependencies in `createGeneratorTask`'s `dependencies` object.
+ *
+ * This rule checks if a dependency declared in the `dependencies` object of a `createGeneratorTask`
+ * is actually destructured and used in the `run` function's parameters.
+ * It assumes that `no-unused-vars` will catch any unused destructured variables within the `run` function body.
+ *
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow unused dependencies in createGeneratorTask dependencies object.',
+      category: 'Possible Errors',
+      recommended: false,
+    },
+    fixable: 'code', // Indicate that this rule is auto-fixable
+    schema: [], // No options for this rule
+    messages: {
+      unusedDependency:
+        'Dependency "{{dependencyName}}" declared but not destructured in run function.',
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        // Check if this is a call to `createGeneratorTask`
+        // The callee can be `createGeneratorTask` directly or `someObject.createGeneratorTask`
+        const callee = node.callee;
+        let isCreateGeneratorTaskCall = false;
+
+        if (
+          callee.type === 'Identifier' &&
+          callee.name === 'createGeneratorTask'
+        ) {
+          isCreateGeneratorTaskCall = true;
+        } else if (
+          callee.type === 'MemberExpression' &&
+          callee.property.type === 'Identifier' &&
+          callee.property.name === 'createGeneratorTask'
+        ) {
+          isCreateGeneratorTaskCall = true;
+        }
+
+        if (
+          isCreateGeneratorTaskCall &&
+          node.arguments.length > 0 &&
+          node.arguments[0].type === 'ObjectExpression'
+        ) {
+          const taskConfig = node.arguments[0];
+          let dependenciesNode = null;
+          let runFunctionNode = null;
+
+          // Find 'dependencies' and 'run' properties within the task configuration object
+          for (const prop of taskConfig.properties) {
+            if (prop.type === 'Property' && prop.key.type === 'Identifier') {
+              if (
+                prop.key.name === 'dependencies' &&
+                prop.value.type === 'ObjectExpression'
+              ) {
+                dependenciesNode = prop.value;
+              } else if (
+                prop.key.name === 'run' &&
+                (prop.value.type === 'FunctionExpression' ||
+                  prop.value.type === 'ArrowFunctionExpression')
+              ) {
+                runFunctionNode = prop.value;
+              }
+            }
+          }
+
+          if (dependenciesNode && runFunctionNode) {
+            const destructuredRunParams = new Set();
+            // Check if the run function has parameters and if the first one is an ObjectPattern (destructuring)
+            if (
+              runFunctionNode.params.length > 0 &&
+              runFunctionNode.params[0].type === 'ObjectPattern'
+            ) {
+              for (const paramProp of runFunctionNode.params[0].properties) {
+                // Ensure it's a simple property (e.g., { foo }) not a rest element or nested destructuring
+                if (
+                  paramProp.type === 'Property' &&
+                  paramProp.key.type === 'Identifier'
+                ) {
+                  destructuredRunParams.add(paramProp.key.name);
+                }
+              }
+            }
+
+            // Iterate over declared dependencies and check if they are destructured in the run function
+            for (const depProp of dependenciesNode.properties) {
+              if (
+                depProp.type === 'Property' &&
+                depProp.key.type === 'Identifier'
+              ) {
+                const dependencyName = depProp.key.name;
+
+                // If the dependency is declared but NOT found in the destructured parameters of the run function
+                if (!destructuredRunParams.has(dependencyName)) {
+                  context.report({
+                    node: depProp, // Report on the specific dependency property
+                    messageId: 'unusedDependency',
+                    data: { dependencyName },
+                    fix(fixer) {
+                      // Remove the entire property from the dependencies object
+                      // This handles commas and whitespace correctly for object properties.
+                      const sourceCode = context.sourceCode;
+                      const nextToken = sourceCode.getTokenAfter(depProp);
+
+                      // If there's a comma after this property, remove it too
+                      if (
+                        nextToken &&
+                        nextToken.type === 'Punctuator' &&
+                        nextToken.value === ',' &&
+                        depProp.range
+                      ) {
+                        return fixer.removeRange([
+                          depProp.range[0],
+                          nextToken.range[1],
+                        ]);
+                      }
+
+                      return fixer.remove(depProp);
+                    },
+                  });
+                }
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/eslint-configs/typescript.js

@@ -5,8 +5,11 @@ import vitest from '@vitest/eslint-plugin';
 import { importX } from 'eslint-plugin-import-x';
 import perfectionist from 'eslint-plugin-perfectionist';
 import eslintPluginUnicorn from 'eslint-plugin-unicorn';
+import unusedImports from 'eslint-plugin-unused-imports';
 import tsEslint from 'typescript-eslint';
 
+import noUnusedGeneratorDependencies from './rules/no-unused-generator-dependencies.js';
+
 /**
  * @typedef {Object} GenerateTypescriptEslintConfigOptions
  * @property {string[]} [extraTsFileGlobs] - Additional file globs to lint with Typescript
@@ -113,6 +116,34 @@ export function generateTypescriptEslintConfig(options = []) {
           'error',
           { ignoreTernaryTests: true },
         ],
+
+        // Allow redirect and notFound to be thrown from routes (placing in generic config to allow it to be used in *.ts files too)
+        '@typescript-eslint/only-throw-error': [
+          'error',
+          {
+            allow: ['NotFoundError', 'Redirect'],
+          },
+        ],
+      },
+    },
+
+    // Unused Imports Configs
+    {
+      plugins: {
+        'unused-imports': unusedImports,
+      },
+      rules: {
+        '@typescript-eslint/no-unused-vars': 'off',
+        'unused-imports/no-unused-imports': 'error',
+        'unused-imports/no-unused-vars': [
+          'error',
+          {
+            vars: 'all',
+            varsIgnorePattern: '^_',
+            args: 'after-used',
+            argsIgnorePattern: '^_',
+          },
+        ],
       },
     },
 
@@ -236,6 +267,21 @@ export function generateTypescriptEslintConfig(options = []) {
       },
     },
 
+    // Baseplate Generator Eslint Rule
+    {
+      files: ['**/*.generator.ts'],
+      plugins: {
+        baseplate: {
+          rules: {
+            'no-unused-generator-dependencies': noUnusedGeneratorDependencies,
+          },
+        },
+      },
+      rules: {
+        'baseplate/no-unused-generator-dependencies': ['error'],
+      },
+    },
+
     // Global Ignores
     { ignores: ['dist', 'node_modules'] },
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baseplate-dev/tools",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Shared dev configurations for linting, formatting, and testing Baseplate projects",
   "keywords": [
     "development-tools",
@@ -63,6 +63,7 @@
     "eslint-plugin-react-hooks": "5.2.0",
     "eslint-plugin-storybook": "0.12.0",
     "eslint-plugin-unicorn": "59.0.1",
+    "eslint-plugin-unused-imports": "4.1.4",
     "prettier-plugin-packagejson": "2.5.11",
     "prettier-plugin-tailwindcss": "0.6.11",
     "typescript-eslint": "8.32.0"

package/tsconfig.vite.lib.json

@@ -4,6 +4,9 @@
   "display": "Vite React Library",
   "compilerOptions": {
     "allowImportingTsExtensions": false,
+    /* Make sure we use NodeNext for mixed-Node/React libraries */
+    "module": "NodeNext",
+    "moduleResolution": "Node16",
 
     /* Output */
     "noEmit": false,