refactor: run lint on all files (#349)

* Fix lint command so it runs on files directly in src

* Run lint --fix

* Use vitest env in test files

* Remove useless test file

* Remove useless import

* Use ts-expect-error and remove unused ignores

* Format and lint

* Correctly type averageObjectProperties and calcAverage

* Correctly type diffScores

* Remove anys

* Add typeroots

* Disable import plugin

* Allow single any use

* import vi

* Fix typeroots

* Use vi.mocked for types in tests

* Improve ts-expect-error cases

* Commit dist

* Update dist

.eslintrc.json

@@ -7,9 +7,18 @@
         "sourceType": "module",
         "project": "./tsconfig.json"
     },
+    "overrides": [
+        {
+            "files": ["*.test.ts"],
+            "env": {
+                "jest": true
+            }
+        }
+    ],
     "rules": {
         "i18n-text/no-en": "off",
         "eslint-comments/no-use": "off",
+        "import/named": "off",
         "import/no-namespace": "off",
         "no-console": "off",
         "@typescript-eslint/no-unused-vars": "error",
@@ -23,10 +32,7 @@
         "@typescript-eslint/ban-ts-comment": "error",
         "camelcase": "off",
         "@typescript-eslint/consistent-type-assertions": "error",
-        "@typescript-eslint/explicit-function-return-type": [
-            "error",
-            {"allowExpressions": true}
-        ],
+        "@typescript-eslint/explicit-function-return-type": "off",
         "@typescript-eslint/func-call-spacing": ["error", "never"],
         "@typescript-eslint/no-array-constructor": "error",
         "@typescript-eslint/no-empty-interface": "error",

package.json

@@ -11,7 +11,7 @@
         "test": "vitest run",
         "format": "prettier --write .",
         "format-check": "prettier --check '**/*.ts'",
-        "lint": "eslint src/**/*.ts",
+        "lint": "eslint 'src/**/*.ts'",
         "all": "npm run build && npm run format && npm run lint && npm test",
         "run:local:report": "tsx ./src/cli/report.ts",
         "run:local:debugfile": "tsx ./src/cli/debug-file.ts",

playground/src/main.ts

@@ -1,6 +1,6 @@
 import {createApp} from 'vue';
 import {install as VueMonacoEditorPlugin} from '@guolao/vue-monaco-editor';
-// @ts-ignore
+// @ts-expect-error
 import revel from '@rebilly/revel';
 import './style.css';
 import App from './App.vue';

src/github.ts

@@ -33,7 +33,7 @@ const listComments = async (
     return existingComments.filter(({body}) => body?.startsWith(hiddenHeader));
 };
 
-const insertComment = (
+const insertComment = async (
     client: Octokit,
     context: Context,
     prNumber: number,
@@ -46,7 +46,7 @@ const insertComment = (
         body: appendHiddenHeaderToComment(body, hiddenHeader),
     });
 
-const updateComment = (
+const updateComment = async (
     client: Octokit,
     context: Context,
     body: string,
@@ -59,13 +59,13 @@ const updateComment = (
         body: appendHiddenHeaderToComment(body, hiddenHeader),
     });
 
-const deleteComments = (
+const deleteComments = async (
     client: Octokit,
     context: Context,
     comments: {id: number}[],
 ) =>
     Promise.all(
-        comments.map(({id}) =>
+        comments.map(async ({id}) =>
             client.rest.issues.deleteComment({
                 ...context.repo,
                 comment_id: id,

src/markdown.ts

@@ -1,9 +1,5 @@
 import path from 'path';
-import {
-    ReadabilityReport,
-    ReadabilityReportFileResult,
-    SingleReadabilityResultWithDiff,
-} from './report';
+import {ReadabilityReport, SingleReadabilityResultWithDiff} from './report';
 
 const arrayToCells = (rows: string[]) => `${rows.join(' | ')}\n`;
 

src/readability-files.ts

@@ -13,26 +13,27 @@ export type ReadabilityResults = {
 };
 
 // Calculates the average of a particular property value, given an array of objects
-function calcAverage(
-    arrayOfObjects: Record<string, number>[],
-    accessorFn: (value: Record<string, number>) => number,
-) {
+function calcAverage<T extends Record<string, number>>(
+    arrayOfObjects: T[],
+    accessorFn: (value: T) => number,
+): number {
     return (
-        arrayOfObjects.reduce(
-            (acc: number, value) => acc + accessorFn(value),
-            0,
-        ) / arrayOfObjects.length
+        arrayOfObjects.reduce((acc, value) => acc + accessorFn(value), 0) /
+        arrayOfObjects.length
     );
 }
 
 // Returns a score object containing the averages, given an array of scores
-export function averageObjectProperties(objects: Record<string, number>[]) {
-    return Object.keys(objects[0]).reduce(
-        (acc: Record<string, number>, key) => {
+export function averageObjectProperties<T extends Record<string, number>>(
+    objects: T[],
+): Record<keyof T, number> {
+    const keys = Object.keys(objects[0]) as (keyof T)[];
+    return keys.reduce(
+        (acc, key) => {
             acc[key] = calcAverage(objects, (object) => object[key]);
             return acc;
         },
-        {},
+        {} as Record<keyof T, number>,
     );
 }
 
@@ -61,7 +62,6 @@ export function calculateReadability(globPath: string): ReadabilityResults {
 
     return {
         fileResults,
-        // @ts-ignore
         averageResult,
     };
 }

src/readability.test.ts

@@ -1,4 +1,4 @@
-import {describe} from 'node:test';
+import {describe, it, expect, vi} from 'vitest';
 import {preprocessMarkdown, calculateReadabilityOfText} from './readability';
 import readability from 'text-readability';
 
@@ -394,11 +394,11 @@ describe('scoring', () => {
     });
 
     it('should cap min and max scores', () => {
-        readability.automatedReadabilityIndex.mockReturnValue(-1);
-        readability.colemanLiauIndex.mockReturnValue(-1);
-        readability.daleChallReadabilityScore.mockReturnValue(-1);
-        readability.fleschReadingEase.mockReturnValue(-1);
-        readability.gunningFog.mockReturnValue(-1);
+        vi.mocked(readability.automatedReadabilityIndex).mockReturnValue(-1);
+        vi.mocked(readability.colemanLiauIndex).mockReturnValue(-1);
+        vi.mocked(readability.daleChallReadabilityScore).mockReturnValue(-1);
+        vi.mocked(readability.fleschReadingEase).mockReturnValue(-1);
+        vi.mocked(readability.gunningFog).mockReturnValue(-1);
 
         expect(calculateReadabilityOfText('dummy text')).toMatchObject({
             automatedReadabilityIndex: 6,
@@ -408,11 +408,11 @@ describe('scoring', () => {
             gunningFog: 6,
         });
 
-        readability.automatedReadabilityIndex.mockReturnValue(1000);
-        readability.colemanLiauIndex.mockReturnValue(1000);
-        readability.daleChallReadabilityScore.mockReturnValue(1000);
-        readability.fleschReadingEase.mockReturnValue(1000);
-        readability.gunningFog.mockReturnValue(1000);
+        vi.mocked(readability.automatedReadabilityIndex).mockReturnValue(1000);
+        vi.mocked(readability.colemanLiauIndex).mockReturnValue(1000);
+        vi.mocked(readability.daleChallReadabilityScore).mockReturnValue(1000);
+        vi.mocked(readability.fleschReadingEase).mockReturnValue(1000);
+        vi.mocked(readability.gunningFog).mockReturnValue(1000);
 
         expect(calculateReadabilityOfText('dummy text')).toMatchObject({
             automatedReadabilityIndex: 22,