Use stricter eslint rules

Author: fvictorio

eslint.config.js

@@ -0,0 +1,35 @@
+import { fileURLToPath } from "node:url";
+import eslint from "@eslint/js";
+import tseslint, { ConfigArray } from "typescript-eslint";
+import { includeIgnoreFile } from "@eslint/compat";
+import eslintConfigPrettier from "eslint-config-prettier/flat";
+
+const gitignorePath = fileURLToPath(new URL(".gitignore", import.meta.url));
+
+const config: ConfigArray = tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  ...tseslint.configs.recommendedTypeChecked,
+  {
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+  includeIgnoreFile(gitignorePath, "Imported .gitignore patterns"),
+  eslintConfigPrettier,
+  {
+    rules: {
+      "@typescript-eslint/strict-boolean-expressions": "error",
+      "no-undef": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unsafe-return": "off",
+      "@typescript-eslint/no-unsafe-assignment": "off",
+      "@typescript-eslint/require-await": "off",
+    },
+  },
+);
+
+export default config;

eslint.config.ts

@@ -40,9 +40,14 @@ async function main() {
   }
 }
 
+interface Argv {
+  help: boolean;
+  init: boolean;
+}
+
 async function runCli(): Promise<number> {
   const unknownArgs: string[] = [];
-  const argv = minimist(process.argv.slice(2), {
+  const argv = minimist<Argv>(process.argv.slice(2), {
     boolean: ["help", "init"],
     alias: { h: "help" },
     unknown: (arg) => {
@@ -111,7 +116,16 @@ async function runCli(): Promise<number> {
         throw new SlippyError(result.message, result.code, result.hint);
       }
     }),
-  ).finally(() => pool.terminate());
+  ).then(
+    async (x) => {
+      await pool.terminate();
+      return x;
+    },
+    async (e) => {
+      await pool.terminate();
+      throw e;
+    },
+  );
 
   const sortedResults = results
     .flatMap((x) => x.lintResults)
@@ -150,7 +164,7 @@ async function getSlippyVersion(): Promise<string> {
 
   const packageJsonContents = await fs.readFile(packageJsonPath, "utf8");
 
-  const packageJson = JSON.parse(packageJsonContents);
+  const packageJson = JSON.parse(packageJsonContents) as { version?: string };
 
   return packageJson.version ?? "unknown";
 }
@@ -172,4 +186,4 @@ ${chalk.bold("Options")}:
   );
 }
 
-main();
+await main();

src/cli/cli.ts

@@ -19,7 +19,7 @@ export async function initConfig() {
   let isEsm = false;
   if (packageJsonPath !== undefined) {
     const packageJsonContents = await fs.readFile(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(packageJsonContents);
+    const packageJson = JSON.parse(packageJsonContents) as { type?: string };
     isEsm = packageJson.type === "module";
   }
 

src/cli/init.ts

@@ -85,14 +85,15 @@ function validateRuleConfig(config: unknown): string | undefined {
     return "Invalid option: expected an array with at most two elements";
   }
 
-  const severity = config[0];
-  if (typeof severity !== "string") {
-    if (typeof severity === "number" && 0 <= severity && severity <= 2) {
+  if (typeof config[0] !== "string") {
+    if (typeof config[0] === "number" && 0 <= config[0] && config[0] <= 2) {
       return levelAsSeverityMessage;
     }
     return "Invalid option: expected the first element to be a string";
   }
 
+  const severity = config[0];
+
   const parsedSeverity = SeveritySchema.safeParse(severity);
   if (!parsedSeverity.success) {
     return invalidSeverityMessage;
@@ -101,9 +102,14 @@ function validateRuleConfig(config: unknown): string | undefined {
 
 async function loadSlippyConfig(slippyConfigPath: string): Promise<unknown> {
   try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     return (await import(pathToFileURL(slippyConfigPath).href)).default;
-  } catch (error: any) {
-    throw new SlippyConfigLoadingError(slippyConfigPath, error.message);
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      throw new SlippyConfigLoadingError(slippyConfigPath, error.message);
+    }
+
+    throw error;
   }
 }
 

src/config.ts

@@ -85,7 +85,7 @@ export class Linter {
         }
         rule = Rule.create();
       }
-      const ruleResults: LintResult[] = await rule.run({
+      const ruleResults: LintResult[] = rule.run({
         unit,
         file,
       });

src/linter.ts

@@ -455,7 +455,7 @@ class NamingConventionRule implements RuleWithConfig<Config> {
           if (
             config.modifiers?.some(
               (modifier) => !hasModifier(definitionCursor.spawn(), modifier),
-            )
+            ) === true
           ) {
             // does not have the required modifiers
             continue;
@@ -539,7 +539,7 @@ class NamingConventionRule implements RuleWithConfig<Config> {
       position === "leading"
         ? config.leadingUnderscore
         : config.trailingUnderscore;
-    if (!option) {
+    if (option === null) {
       return name;
     }
 
@@ -673,7 +673,7 @@ class NamingConventionRule implements RuleWithConfig<Config> {
     originalName: string,
   ): LintResult | undefined {
     const formats = config.format;
-    if (!formats?.length) {
+    if (formats === null || formats.length === 0) {
       return;
     }
 
@@ -716,7 +716,7 @@ function normalizeOption(option: Selector): NormalizedSelector[] {
   });
 
   // give selectors with a filter the _highest_ priority
-  if (option.filter) {
+  if (option.filter !== undefined) {
     weight |= 1 << 30;
   }
 

src/rules/naming-convention.ts

@@ -27,7 +27,7 @@ export async function compilationUnitFromContent({
   const builder = CompilationBuilder.create({
     languageVersion,
     readFile,
-    resolveImport: async () => undefined,
+    resolveImport: () => Promise.resolve(undefined),
   });
 
   await builder.addFile(filePath);

src/slang/compilation-unit.ts

@@ -58,15 +58,21 @@ describe("config", function () {
     const parseAndReturnErrorMessage = (config: unknown) => {
       try {
         validateUserConfig(config, "/path/to/config.js");
-      } catch (error: any) {
-        return error;
+      } catch (error: unknown) {
+        if (error instanceof SlippyInvalidConfigError) {
+          return error;
+        }
+
+        throw error;
       }
     };
 
     it("undefined config", function () {
       const error = parseAndReturnErrorMessage(undefined);
 
-      expect(error).instanceOf(SlippyInvalidConfigError);
+      if (error === undefined) {
+        expect.fail();
+      }
       expect(error.message).toMatchInlineSnapshot(
         `"Invalid config at '/path/to/config.js': Configuration must be an object"`,
       );
@@ -78,7 +84,9 @@ describe("config", function () {
     it("unknown key", function () {
       const error = parseAndReturnErrorMessage({ invalidKey: {} });
 
-      expect(error).instanceOf(SlippyInvalidConfigError);
+      if (error === undefined) {
+        expect.fail();
+      }
       expect(error.message).toMatchInlineSnapshot(`
         "Invalid config at '/path/to/config.js': 
 
@@ -91,7 +99,9 @@ describe("config", function () {
         rules: { "some-rule": "erro" },
       });
 
-      expect(error).instanceOf(SlippyInvalidConfigError);
+      if (error === undefined) {
+        expect.fail();
+      }
       expect(error.message).toMatchInlineSnapshot(`
         "Invalid config at '/path/to/config.js': 
 
@@ -105,7 +115,9 @@ describe("config", function () {
         rules: { "some-rule": ["erro"] },
       });
 
-      expect(error).instanceOf(SlippyInvalidConfigError);
+      if (error === undefined) {
+        expect.fail();
+      }
       expect(error.message).toMatchInlineSnapshot(`
         "Invalid config at '/path/to/config.js': 
 
@@ -117,7 +129,9 @@ describe("config", function () {
     it("rule config is empty array", function () {
       const error = parseAndReturnErrorMessage({ rules: { "some-rule": [] } });
 
-      expect(error).instanceOf(SlippyInvalidConfigError);
+      if (error === undefined) {
+        expect.fail();
+      }
       expect(error.message).toMatchInlineSnapshot(`
         "Invalid config at '/path/to/config.js': 
 
@@ -131,7 +145,9 @@ describe("config", function () {
         rules: { "some-rule": ["error", {}, {}] },
       });
 
-      expect(error).instanceOf(SlippyInvalidConfigError);
+      if (error === undefined) {
+        expect.fail();
+      }
       expect(error.message).toMatchInlineSnapshot(`
         "Invalid config at '/path/to/config.js': 
 
@@ -143,7 +159,9 @@ describe("config", function () {
     it("severity as a level, shorthand", function () {
       const error = parseAndReturnErrorMessage({ rules: { "some-rule": 1 } });
 
-      expect(error).instanceOf(SlippyInvalidConfigError);
+      if (error === undefined) {
+        expect.fail();
+      }
       expect(error.message).toMatchInlineSnapshot(`
         "Invalid config at '/path/to/config.js': 
 
@@ -155,7 +173,9 @@ describe("config", function () {
     it("severity as a level", function () {
       const error = parseAndReturnErrorMessage({ rules: { "some-rule": [1] } });
 
-      expect(error).instanceOf(SlippyInvalidConfigError);
+      if (error === undefined) {
+        expect.fail();
+      }
       expect(error.message).toMatchInlineSnapshot(`
         "Invalid config at '/path/to/config.js': 
 

test/config.test.ts

@@ -11,7 +11,7 @@ interface Example {
   config: any;
 }
 
-describe("rules examples", async function () {
+describe("rules examples", function () {
   const rules = getAllRules();
 
   for (const rule of rules) {