Removed prettier

@Stylistic achieves a lot of better recommendations than prettier

Author: alexrecuenco

.eslintignore

@@ -7,4 +7,6 @@ node_modules/
 coverage/
 !.eslintrc.js
 !.prettierrc.js
+!*.js
+!*.ts
 !.vscode/*.json

.eslintrc.js

@@ -1,78 +1,124 @@
+// @ts-check
+const stylistic = require('@stylistic/eslint-plugin');
+
 const off = 'off';
 
 const warn = 'warn';
 
 const error = 'error';
 
 const TEST_ONLY_IMPORTS = ['fast-check', 'jest', 'eslint', 'prettier'];
+const customized = stylistic.configs.customize({
+  // the following options are the default values
+  semi: true,
+  blockSpacing: true,
+});
+
+/**
+ * set of typescript-eslint any rules
+ * @param {string} level
+ * @returns
+ */
+const any_rules = (level) => {
+  return {
+    '@typescript-eslint/no-unsafe-return': level,
+    '@typescript-eslint/no-var-requires': level,
+    '@typescript-eslint/no-unsafe-member-access': level,
+    '@typescript-eslint/no-unsafe-argument': level,
+    '@typescript-eslint/no-unsafe-call': level,
+    '@typescript-eslint/no-explicit-any': level,
+  };
+};
 
 module.exports = {
   extends: [
     'eslint:recommended',
     'plugin:@typescript-eslint/eslint-recommended',
     'plugin:@typescript-eslint/recommended',
     'plugin:@typescript-eslint/recommended-requiring-type-checking',
-    'plugin:prettier/recommended',
     'plugin:import/errors',
     'plugin:import/warnings',
     'plugin:import/typescript',
+    // 'plugin:prettier/recommended',
+    // 'prettier',
   ],
   env: {
     node: true,
   },
-  plugins: ['@typescript-eslint/eslint-plugin'],
+  plugins: [
+    '@typescript-eslint/eslint-plugin',
+    '@stylistic', // stylistic rules were migrated here
+  ],
   parser: '@typescript-eslint/parser',
   parserOptions: {
     ecmaVersion: 2022,
     sourceType: 'module',
     tsconfigRootDir: __dirname,
-    project: ['./tsconfig.eslint.json'],
+    project: [
+      './tsconfig.eslint.json',
+      './tsconfig.json',
+      '/tsconfig.prod.json',
+    ],
   },
   rules: {
-    'import/no-extraneous-dependencies': warn,
+    ...customized.rules,
+    'import/no-extraneous-dependencies': error,
     'no-console': error,
+    '@typescript-eslint/return-await': ['error', 'always'],
     'no-unused-vars': off,
     '@typescript-eslint/no-unused-vars': error,
-    eqeqeq: [error, 'smart'],
+    'eqeqeq': [error, 'smart'],
     'no-else-return': [
       error,
       {
         allowElseIf: true,
       },
     ],
+    '@typescript-eslint/require-await': error,
     '@typescript-eslint/unbound-method': [
       error,
       {
         ignoreStatic: true,
       },
     ],
+    // See https://github.com/orgs/react-hook-form/discussions/8622#discussioncomment-4060570
+    '@typescript-eslint/no-misused-promises': [
+      error,
+      {
+        checksVoidReturn: {
+          attributes: false,
+        },
+      },
+    ],
     'no-restricted-imports': [
       'error',
       {
         paths: TEST_ONLY_IMPORTS.map((name) => {
           return { name, message: `${name} is only available during testing` };
         }),
-        patterns: TEST_ONLY_IMPORTS.map((dep) => `${dep}/*`),
+        patterns: TEST_ONLY_IMPORTS.map(dep => `${dep}/*`),
       },
     ],
-    camelcase: off,
-    'require-await': off,
-    '@typescript-eslint/require-await': off,
-    '@typescript-eslint/indent': off,
     '@typescript-eslint/explicit-member-accessibility': warn,
-    '@typescript-eslint/no-explicit-any': off,
-    '@typescript-eslint/no-unsafe-argument': off,
-    '@typescript-eslint/no-unsafe-return': off,
-    '@typescript-eslint/no-unsafe-assignment': off,
+    '@typescript-eslint/no-explicit-any': warn,
     '@typescript-eslint/explicit-function-return-type': off,
-    '@typescript-eslint/no-var-requires': off,
+    // '@typescript-eslint/no-var-requires': off,
+
     '@typescript-eslint/no-empty-function': off,
+
     '@typescript-eslint/no-floating-promises': error,
   },
   overrides: [
     {
-      files: ['*.ts', '*.tsx'],
-      rules: {},
+      files: ['.*.js', '.*.cjs', '*.config.cjs', '*.config.js', '*.config.ts'],
+      env: {
+        node: true,
+      },
+      rules: {
+        'no-restricted-imports': off,
+        // Consider if this is too leanient for tests
+        ...any_rules('off'),
+      },
     },
     {
       // TESTING CONFIGURATION
@@ -87,16 +133,13 @@ module.exports = {
         '__tests__/**/*.ts',
         'jest.*.js',
         'jest.*.ts',
-        '.*.ts',
-        '.*.js',
       ],
 
       // https://eslint.org/docs/user-guide/configuring#specifying-environments
       env: {
         jest: true,
       },
 
-      // Can't extend in overrides: https://github.com/eslint/eslint/issues/8813
       extends: ['plugin:jest/recommended'],
       plugins: ['jest'],
       rules: {
@@ -107,6 +150,7 @@ module.exports = {
             assertFunctionNames: ['expect', 'fc.assert'],
           },
         ],
+        ...any_rules('off'),
       },
     },
   ],

.prettierrc.js

@@ -5,7 +5,7 @@
     ],
     "editor.formatOnSave": true,
     "editor.defaultFormatter": "dbaeumer.vscode-eslint",
-    "[javascript]": {
+    "[javascript,typescript]": {
         "editor.defaultFormatter": "dbaeumer.vscode-eslint"
     },
     "jest.jestCommandLine": "npm test -- ",

.vscode/settings.json

@@ -6,57 +6,84 @@ const EachSimpleType = [
   ['integers', fc.integer()],
 ] as const;
 
-describe.each(EachSimpleType)('Simple replacements works for %p', (_, arb: Arbitrary<any>) => {
-  test('Should replace simple types', () => {
-    fc.assert(
-      fc.property(arb, fc.func(arb), (s, f) => {
-        return replace(f, (t: string): t is any => true)(s) === f(s);
-      }),
-    );
-  });
-});
+describe.each(EachSimpleType)(
+  'Simple replacements works for %p',
+  (_, arb: Arbitrary<any>) => {
+    test('Should replace simple types', () => {
+      fc.assert(
+        fc.property(arb, fc.func(arb), (s, f) => {
+          return replace(f, (t: string): t is any => true)(s) === f(s);
+        }),
+      );
+    });
+  },
+);
 
-describe.each(EachSimpleType)('Simple replacements works for arrays of %p', (_, arb: Arbitrary<any>) => {
-  test('Should replace only elements', () => {
-    fc.assert(
-      fc.property(fc.array(arb), fc.func(arb), (arr, f) => {
-        const obtainedResult = replace(f, (t): t is any => !Array.isArray(t))(arr);
-        const realResult = arr.map((v) => f(v));
-        expect(obtainedResult).toStrictEqual(realResult);
-      }),
-    );
-  });
-});
+describe.each(EachSimpleType)(
+  'Simple replacements works for arrays of %p',
+  (_, arb: Arbitrary<any>) => {
+    test('Should replace only elements', () => {
+      fc.assert(
+        fc.property(fc.array(arb), fc.func(arb), (arr, f) => {
+          const obtainedResult = replace(
+            f,
+            (t): t is any => !Array.isArray(t),
+          )(arr);
+          const realResult = arr.map(v => f(v));
+          expect(obtainedResult).toStrictEqual(realResult);
+        }),
+      );
+    });
+  },
+);
 
-describe.each(EachSimpleType)('Simple replacements works for objects of %p', (_, arb: Arbitrary<any>) => {
-  test('Should replace only properties', () => {
-    fc.assert(
-      fc.property(fc.dictionary(fc.string(), arb), fc.func(arb), (obj, f) => {
-        const realResult = Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, f(v)]));
-        const obtainedResult = replace(f, (t): t is any => !Array.isArray(t) && typeof t !== 'object')(obj);
+describe.each(EachSimpleType)(
+  'Simple replacements works for objects of %p',
+  (_, arb: Arbitrary<any>) => {
+    test('Should replace only properties', () => {
+      fc.assert(
+        fc.property(fc.dictionary(fc.string(), arb), fc.func(arb), (obj, f) => {
+          const realResult = Object.fromEntries(
+            Object.entries(obj).map(([k, v]) => [k, f(v)]),
+          );
+          const obtainedResult = replace(
+            f,
+            (t): t is any => !Array.isArray(t) && typeof t !== 'object',
+          )(obj);
 
-        expect(obtainedResult).toStrictEqual(realResult);
-      }),
-    );
-  });
-});
+          expect(obtainedResult).toStrictEqual(realResult);
+        }),
+      );
+    });
+  },
+);
 
 describe('Ignoring values', () => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   const f = (v: any) => {
     throw new Error();
   };
   test('should leave json objects alone', () => {
     const throwOnReplace = replace(f, (t): t is any => false);
     fc.assert(
       fc.property(fc.json(), (json) => {
-        expect(() => expect(throwOnReplace(json)).toStrictEqual(json)).not.toThrow();
+        expect(() =>
+          expect(throwOnReplace(json)).toStrictEqual(json),
+        ).not.toThrow();
       }),
     );
   });
 
   test('Should leave numbers unchanged when searching for strings', () => {
-    const throwOnReplace = replace(f, (t): t is string => typeof t === 'string');
-    const objectArbitrary = fc.object({ maxDepth: 4, withTypedArray: true, values: [fc.integer()] });
+    const throwOnReplace = replace(
+      f,
+      (t): t is string => typeof t === 'string',
+    );
+    const objectArbitrary = fc.object({
+      maxDepth: 4,
+      withTypedArray: true,
+      values: [fc.integer()],
+    });
     fc.assert(
       fc.property(objectArbitrary, (obj) => {
         expect(() => throwOnReplace(obj)).not.toThrow();

__tests__/replace.test.ts

@@ -2,7 +2,11 @@ import type { JestConfigWithTsJest } from 'ts-jest';
 
 const config: JestConfigWithTsJest = {
   preset: 'ts-jest',
-  testRegex: ['/tests/.*tests?.[jt]sx?', '/__tests__/.*tests?.[jt]sx?', '.*.(spec|test).[jt]sx?'],
+  testRegex: [
+    '/tests/.*tests?.[jt]sx?',
+    '/__tests__/.*tests?.[jt]sx?',
+    '.*.(spec|test).[jt]sx?',
+  ],
   // I dono't think we need to run the spec multiple times.. the functional test on tests/ maybe.
   // We can change this if we consider it useful to run the spec tests when the code is transpiled to javascript
   testPathIgnorePatterns: ['node_modules', 'build/'],

jest.config.ts

@@ -9,8 +9,8 @@ import fc from 'fast-check';
 const JestTimeoutMs = 60000;
 const FcTimeoutMs = Math.floor(0.8 * JestTimeoutMs);
 
-const verbose =
-  process.env.DEBUG === undefined
+const verbose
+  = process.env.DEBUG === undefined
     ? fc.VerbosityLevel.None
     : process.env.DEBUG !== '*'
       ? fc.VerbosityLevel.Verbose