Merge pull request #14 from alexrecuenco/feature/upgrade

Feature/upgrade

Author: alexrecuenco

.eslintignore

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

.eslintrc.js

@@ -1,83 +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: 2020, // Allows for the parsing of modern ECMAScript features
-    sourceType: 'module', // Allows for the use of imports
+    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,
-
-    // Temporal?
-    'no-console': warn,
-    'no-return-await': 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': off,
-    eqeqeq: [error, 'smart'],
+    '@typescript-eslint/no-unused-vars': error,
+    '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,
-    '@typescript-eslint/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-object-literal-type-assertion': 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
@@ -90,24 +131,26 @@ module.exports = {
         'tests/**/*.ts',
         '__tests__/**/*.js',
         '__tests__/**/*.ts',
-        'jest.setup.js',
+        'jest.*.js',
+        'jest.*.ts',
       ],
 
       // 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"]
+      extends: ['plugin:jest/recommended'],
       plugins: ['jest'],
       rules: {
         'no-restricted-imports': off,
-        'jest/no-disabled-tests': warn,
-        'jest/no-focused-tests': error,
-        'jest/no-identical-title': error,
-        'jest/prefer-to-have-length': warn,
-        'jest/valid-expect': error,
+        'jest/expect-expect': [
+          error,
+          {
+            assertFunctionNames: ['expect', 'fc.assert'],
+          },
+        ],
+        ...any_rules('off'),
       },
     },
   ],

.github/workflows/main.yml

@@ -9,14 +9,15 @@ jobs:
     strategy:
       matrix:
       # Current versions not in maintainance
-        node-version: [16.x, 18.x, 20.x]
+        node-version: [18.x, 20.x]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
+          cache: 'npm'
       - run: npm ci
       - run: npm test
       - run: npm run lint

.pre-commit-config.yaml

@@ -19,7 +19,3 @@ repos: #The order matters, we want prospector to run after all the sorting was d
       # File normalization
       - id: end-of-file-fixer
       - id: trailing-whitespace
-  - repo: https://github.com/prettier/prettier
-    rev: '6b22977cb56127cc10e04425b0eca7c5eb304e6e' # Use the sha or tag you want to point at
-    hooks:
-      - id: prettier

.prettierrc.js

@@ -1,7 +1,6 @@
 {
     "recommendations": [
         "dbaeumer.vscode-eslint",
-        "esbenp.prettier-vscode",
         "ghmcadams.lintlens",
         "visualstudioexptteam.vscodeintellicode",
         "wix.vscode-import-cost",

.vscode/extensions.json

@@ -1,8 +1,15 @@
 {
-    "eslint.validate": ["typescript", "typescriptreact"],
+    "eslint.validate": [
+        "typescript",
+        "typescriptreact"
+    ],
     "editor.formatOnSave": true,
-    "editor.defaultFormatter": "esbenp.prettier-vscode",
-    "[javascript]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    "editor.defaultFormatter": "dbaeumer.vscode-eslint",
+    "[javascript,typescript]": {
+        "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+    },
+    "jest.jestCommandLine": "npm test -- ",
+    "jest.runMode": {
+        "type": "on-demand"
     }
 }

.vscode/settings.json

@@ -5,3 +5,10 @@ Example of typescript, eslint, and jest with property based testing.
 Possibly, you might want to delete the `.pre-commit-config.yaml` file if you are not using python anywhere.
 
 This is only tested with certain versions of node and npm, it might work with others, disable the `engine-strict=true` in the `.npmrc` file at your discretion.
+
+
+## Check upgrades
+
+```bash
+npx npm-check -u
+```

README.md

@@ -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();