chore: next version (#1079)

* chore: change CI target for next

* chore: add next branch to CI targets

* feat: target ESLint v9

* Tighten type checking config (#1071)

* Use more restrictive type signatures
* Don't rely on broken expect.error()

* chore: report node 18+ support (#1081)

* chore: update documentation for eslint ignore

---------

Co-authored-by: Gil Pedersen <[email protected]>

Author: Marsup

.eslintignore

@@ -4,11 +4,10 @@ on:
   push:
     branches:
       - master
+      - next
   pull_request:
   workflow_dispatch:
 
 jobs:
   test:
-    uses: hapijs/.github/.github/workflows/ci-module.yml@master
-    with:
-      min-node-version: 14
+    uses: hapijs/.github/.github/workflows/ci-module.yml@min-node-18-hapi-21

.github/workflows/ci-module.yml

@@ -632,10 +632,17 @@ Your project's eslint configuration will now extend the default **lab** configur
 
 ### Ignoring files in linting
 
-Since [eslint](http://eslint.org/) is used to lint, you can create an `.eslintignore` containing paths to be ignored:
-```
-node_modules/*
-**/vendor/*.js
+Since [eslint](http://eslint.org/) is used to lint, if you don't already have an `eslint.config.{js|cjs|mjs|ts|mts|cts}` you can create one,
+and add an `ignores` rule containing paths to be ignored. Here is an example preserving default hapi rules:
+```javascript
+import HapiPlugin from '@hapi/eslint-plugin';
+
+export default [
+    {
+        ignores: ['node_modules/*', '**/vendor/*.js'],
+    },
+    ...HapiPlugin.configs.module,
+];
 ```
 
 ### Only run linting

API.md

@@ -0,0 +1,20 @@
+'use strict';
+
+const HapiPlugin = require('@hapi/eslint-plugin');
+
+module.exports = [
+    {
+        ignores: [
+            'node_modules/',
+            'test_runner/',
+            'test/coverage/',
+            'test/cli/',
+            'test/cli_*/',
+            'test/lint/',
+            'test/override/',
+            'test/plan/',
+            'test/transform/'
+        ]
+    },
+    ...HapiPlugin.configs.module
+];

eslint.config.js

@@ -1,5 +1,5 @@
 'use strict';
 
-module.exports = {
-    extends: 'plugin:@hapi/module'
-};
+const HapiPlugin = require('@hapi/eslint-plugin');
+
+module.exports = [...HapiPlugin.configs.module];

lib/linter/.eslintrc.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const Fs = require('fs');
-const Path = require('path');
 
 const Eslint = require('eslint');
 const Hoek = require('@hapi/hoek');
@@ -18,31 +17,50 @@ exports.lint = async function () {
 
     const options = process.argv[2] ? JSON.parse(process.argv[2]) : undefined;
 
-    if (!Fs.existsSync('.eslintrc.js') &&
-        !Fs.existsSync('.eslintrc.cjs') && // Needed for projects with "type": "module"
-        !Fs.existsSync('.eslintrc.yaml') &&
-        !Fs.existsSync('.eslintrc.yml') &&
-        !Fs.existsSync('.eslintrc.json') &&
-        !Fs.existsSync('.eslintrc')) {
-        configuration.overrideConfigFile = Path.join(__dirname, '.eslintrc.js');
+    let usingDefault = false;
+
+    if (!Fs.existsSync('eslint.config.js') &&
+        !Fs.existsSync('eslint.config.cjs') &&
+        !Fs.existsSync('eslint.config.mjs') &&
+        !Fs.existsSync('eslint.config.ts') &&
+        !Fs.existsSync('eslint.config.mts') &&
+        !Fs.existsSync('eslint.config.cts')) {
+        // No configuration file found, using the default one
+        usingDefault = true;
+        configuration.baseConfig = require('./.eslintrc.js');
+        configuration.overrideConfigFile = true;
     }
 
     if (options) {
         Hoek.merge(configuration, options, true, false);
     }
 
-    if (!configuration.extensions) {
-        configuration.extensions = ['.js', '.cjs', '.mjs'];
+    // Only the default configuration should be altered, otherwise the user's configuration should be used as is
+    if (usingDefault) {
+        if (!configuration.extensions) {
+            const extensions = ['js', 'cjs', 'mjs'];
 
-        if (configuration.typescript) {
-            configuration.extensions.push('.ts');
+            if (configuration.typescript) {
+                extensions.push('ts');
+            }
+
+            configuration.baseConfig.unshift({
+                files: extensions.map((ext) => `**/*.${ext}`)
+            });
         }
-    }
 
-    if (configuration.typescript) {
-        delete configuration.typescript;
+        if (configuration.ignores) {
+            configuration.baseConfig.unshift({
+                ignores: configuration.ignores
+            });
+        }
     }
 
+    delete configuration.extensions;
+    delete configuration.typescript;
+    delete configuration.ignores;
+
+
     let results;
     try {
         const eslint = new Eslint.ESLint(configuration);
@@ -66,6 +84,13 @@ exports.lint = async function () {
 
         transformed.errors = result.messages.map((err) => {
 
+            if (err.messageTemplate === 'all-matched-files-ignored') {
+                return {
+                    severity: 'ERROR',
+                    message: err.message
+                };
+            }
+
             return {
                 line: err.line,
                 severity: err.severity === 1 ? 'WARNING' : 'ERROR',

lib/linter/index.js

@@ -16,8 +16,7 @@ const SourceMap = require('../source-map');
 const Transform = require('./transform');
 
 const internals = {
-    _state: Symbol.for('@hapi/lab/coverage/_state'),
-    eslint: new ESLint.ESLint({ baseConfig: Eslintrc })
+    _state: Symbol.for('@hapi/lab/coverage/_state')
 };
 
 
@@ -111,7 +110,7 @@ internals.prime = function (extension, ctx) {
     require.extensions[extension] = function (localModule, filename) {
 
         // We never want to instrument eslint configs in order to avoid infinite recursion
-        if (Path.basename(filename, extension) !== '.eslintrc') {
+        if (!['.eslintrc', 'eslint.config'].includes(Path.basename(filename, extension))) {
             for (let i = 0; i < internals.state.patterns.length; ++i) {
                 if (internals.state.patterns[i].test(filename.replace(/\\/g, '/'))) {
                     return localModule._compile(internals.instrument(filename, ctx), filename);
@@ -761,11 +760,40 @@ internals.file = async function (filename, data, options) {
 
 internals.context = async (options) => {
 
+    const filePath = Path.join(options.coveragePath || '', 'x.js');
+    let calculated;
+
     // The parserOptions are shared by all files for coverage purposes, based on
     // the effective eslint config for a hypothetical file {coveragePath}/x.js
-    const { parserOptions } = await internals.eslint.calculateConfigForFile(
-        Path.join(options.coveragePath || '', 'x.js')
-    );
+    try {
+        // Let's try first with eslint's native configuration detection
+        const eslint = new ESLint.ESLint({
+            ignore: false
+        });
+
+        calculated = await eslint.calculateConfigForFile(filePath);
+    }
+    catch (err) {
+        /* $lab:coverage:off$ */
+        if (err.messageTemplate !== 'config-file-missing') {
+            throw err;
+        }
+
+        // If the eslint config file is missing, we'll use the one provided by lab
+        const eslint = new ESLint.ESLint({
+            overrideConfig: Eslintrc,
+            overrideConfigFile: true,
+            ignore: false
+        });
+
+        calculated = await eslint.calculateConfigForFile(filePath);
+        /* $lab:coverage:on$ */
+    }
+
+    const parserOptions = {
+        ...calculated.languageOptions,
+        ...calculated.languageOptions?.parserOptions
+    };
 
     return { parserOptions };
 };

lib/modules/coverage.js

@@ -20,7 +20,7 @@ exports.lint = function (settings) {
         try {
             linterOptions = JSON.parse(settings['lint-options'] || '{}');
         }
-        catch (err) {
+        catch {
             return reject(new Error('lint-options could not be parsed'));
         }
 

lib/modules/lint.js

@@ -73,7 +73,7 @@ exports.retrieveFile = function (path) {
     try {
         contents = Fs.readFileSync(path, 'utf8');
     }
-    catch (e) {
+    catch {
         contents = null;
     }
 

lib/modules/transform.js

@@ -15,6 +15,8 @@ const Utils = require('../utils');
 const internals = {
     compiler: {
         strict: true,
+        noUncheckedIndexedAccess: true,
+        exactOptionalPropertyTypes: true,
         jsx: Ts.JsxEmit.React,
         lib: ['lib.es2020.d.ts'],
         module: Ts.ModuleKind.CommonJS,

lib/modules/types.js

@@ -14,7 +14,7 @@ internals.transform = function (content, fileName) {
         try {
             var { config, error } = Typescript.readConfigFile(configFile, Typescript.sys.readFile);
         }
-        catch (err) {
+        catch {
             throw new Error(`Cannot find a tsconfig file for ${fileName}`);
         }
 

lib/modules/typescript.js

@@ -13,10 +13,12 @@ const internals = {};
 
 // Prevent libraries like Sinon from clobbering global time functions
 
+/* eslint-disable no-redeclare */
 const Date = global.Date;
 const setTimeout = global.setTimeout;
 const clearTimeout = global.clearTimeout;
 const setImmediate = global.setImmediate;
+/* eslint-enable no-redeclare */
 
 
 Error.stackTraceLimit = Infinity;                   // Set Error stack size

lib/runner.js

@@ -5,6 +5,9 @@
     "repository": "git://github.com/hapijs/lab",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
+    "engines": {
+        "node": ">=18"
+    },
     "keywords": [
         "test",
         "runner"
@@ -13,19 +16,14 @@
         "bin/lab",
         "lib"
     ],
-    "eslintConfig": {
-        "extends": [
-            "plugin:@hapi/module"
-        ]
-    },
     "dependencies": {
         "@babel/core": "^7.16.0",
-        "@babel/eslint-parser": "^7.16.0",
+        "@babel/eslint-parser": "^7.25.1",
         "@hapi/bossy": "^6.0.0",
-        "@hapi/eslint-plugin": "^6.0.0",
+        "@hapi/eslint-plugin": "^7.0.0",
         "@hapi/hoek": "^11.0.2",
         "diff": "^5.0.0",
-        "eslint": "8.x.x",
+        "eslint": "9.x.x",
         "find-rc": "4.x.x",
         "globby": "^11.1.0",
         "handlebars": "4.x.x",
@@ -37,8 +35,8 @@
         "will-call": "1.x.x"
     },
     "peerDependencies": {
-        "@hapi/eslint-plugin": "^6.0.0",
-        "typescript": ">=3.6.5"
+        "@hapi/eslint-plugin": "^7.0.0",
+        "typescript": ">=4.4.0"
     },
     "peerDependenciesMeta": {
         "typescript": {
@@ -48,13 +46,14 @@
     "devDependencies": {
         "@hapi/code": "^9.0.0",
         "@hapi/somever": "^4.0.0",
+        "@types/eslint": "^9.6.0",
         "@types/node": "^18.11.17",
-        "@typescript-eslint/parser": "^5.62.0",
         "cpr": "3.x.x",
         "lab-event-reporter": "1.x.x",
         "semver": "7.x.x",
         "tsconfig-paths": "^4.0.0",
-        "typescript": "^4.5.4"
+        "typescript": "^4.5.4",
+        "typescript-eslint": "^8.1.0"
     },
     "bin": {
         "lab": "./bin/lab"

package.json

@@ -3,6 +3,7 @@
 // Load modules
 
 const ChildProcess = require('child_process');
+// eslint-disable-next-line no-redeclare
 const Crypto = require('crypto');
 const Fs = require('fs');
 const Http = require('http');
@@ -702,7 +703,7 @@ describe('CLI', () => {
         try {
             await unlink(outputPath);
         }
-        catch (err) {
+        catch {
 
             // Error is ok here
         }

test/cli.js

@@ -566,19 +566,19 @@ describe('Coverage', () => {
         it('sorts file paths in report', async () => {
 
             const files = global.__$$labCov.files;
-            const paths = ['/a/b', '/a/b/c', '/a/c/b', '/a/c', '/a/b/c', '/a/b/a'];
+            const paths = ['./a/b', './a/b/c', './a/c/b', './a/c', './a/b/c', './a/b/a'];
             paths.forEach((path) => {
 
                 files[path] = { source: [] };
             });
 
-            const cov = await Lab.coverage.analyze({ coveragePath: '/a' });
+            const cov = await Lab.coverage.analyze({ coveragePath: './a' });
             const sorted = cov.files.map((file) => {
 
                 return file.filename;
             });
 
-            expect(sorted).to.equal(['/a/b', '/a/c', '/a/b/a', '/a/b/c', '/a/c/b']);
+            expect(sorted).to.equal(['./a/b', './a/c', './a/b/a', './a/b/c', './a/c/b']);
         });
     });
 

test/coverage.js

@@ -1,9 +1,11 @@
+'use strict';
+
+const HapiPlugin = require('@hapi/eslint-plugin');
+
 // this is a deliberately unused function that will reduce coverage percentage
 // if it ends up getting instrumented, giving us something to assert against
 const unusedMethod = () => {
 	console.log('hello world')
 }
 
-module.exports = {
-	extends: 'plugin:@hapi/module'
-}
+module.exports = [...HapiPlugin.configs.module]

test/coverage/test-folder/.eslintrc.js test/coverage/test-folder/eslint.config.js

@@ -1,7 +1,7 @@
 'use strict';
 
 // Load modules
-
+const EslintConfig = require('./eslint.config');
 
 // Declare internals
 
@@ -10,5 +10,5 @@ const internals = {};
 
 exports.method = function () {
 
-    return;
+    return EslintConfig;
 };

test/coverage/test-folder/test-name.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const HapiPlugin = require('@hapi/eslint-plugin');
+
+module.exports = [
+    ...HapiPlugin.configs.module,
+    {
+        languageOptions: {
+            parserOptions: {
+                sourceType: 'module'
+            }
+        }
+    },
+    {
+        files: ['*.cjs'],
+        languageOptions: {
+            parserOptions: {
+                sourceType: 'script'
+            }
+        }
+    }
+];

test/lint/eslint/esm/.eslintrc.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+const HapiPlugin = require('@hapi/eslint-plugin');
+const TsESLint = require('typescript-eslint');
+
+module.exports = TsESLint.config(
+    {
+        files: ['**/*.ts']
+    },
+    ...HapiPlugin.configs.module,
+    TsESLint.configs.base
+);

test/lint/eslint/esm/eslint.config.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+module.exports = [
+    {
+        ignores: ['*.ignore.*']
+    },
+    {
+        'rules': {
+            'eol-last': 2,
+            'no-unused-vars': 0,
+            'no-undef': 0
+        }
+    }
+];
+

test/lint/eslint/typescript/.eslintrc.cjs

@@ -88,7 +88,7 @@ describe('Linters - eslint', () => {
             { line: 12, severity: 'WARNING', message: 'eol-last - Newline required at end of file but not found.' }
         ]);
 
-        const checkedCjsFile = eslintResults.find(({ filename }) => filename === Path.join(path, '.eslintrc.cjs'));
+        const checkedCjsFile = eslintResults.find(({ filename }) => filename === Path.join(path, 'eslint.config.cjs'));
         expect(checkedCjsFile.errors).to.be.empty();
     });
 
@@ -131,7 +131,6 @@ describe('Linters - eslint', () => {
         const checkedFile = eslintResults.find(({ filename }) => filename.endsWith('.ts'));
         expect(checkedFile).to.include({ filename: Path.join(path, 'fail.ts') });
         expect(checkedFile.errors).to.include([
-            { line: 1, severity: 'ERROR', message: `strict - Use the global form of 'use strict'.` },
             { line: 6, severity: 'ERROR', message: 'indent - Expected indentation of 4 spaces but found 1 tab.' },
             { line: 6, severity: 'ERROR', message: 'semi - Missing semicolon.' }
         ]);
@@ -195,15 +194,15 @@ describe('Linters - eslint', () => {
 
     it('should pass options and not find any files', async () => {
 
-        const lintOptions = JSON.stringify({ extensions: ['.jsx'] });
+        const lintOptions = JSON.stringify({ extensions: ['.jsx'], ignores: ['**/*.js'] });
         const path = Path.join(__dirname, 'lint', 'eslint', 'basic');
         const result = await Linters.lint({ lintingPath: path, linter: 'eslint', 'lint-options': lintOptions });
 
         expect(result).to.include('lint');
 
         const eslintResults = result.lint;
         expect(eslintResults).to.have.length(1);
-        expect(eslintResults[0].errors[0].message).to.contain('No files');
+        expect(eslintResults[0].errors[0].message).to.contain('All files matched by \'.\' are ignored.');
     });
 
     it('should fix lint rules when --lint-fix used', async (flags) => {

test/lint/eslint/typescript/eslint.config.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+// eslint-disable-next-line no-redeclare
 const Crypto = require('crypto');
 const Fs = require('fs/promises');
 const Os = require('os');

test/lint/eslint/with_config/.eslintignore

@@ -25,9 +25,11 @@ const expect = Code.expect;
 
 // save references to timer globals
 
+/* eslint-disable no-redeclare */
 const setTimeout = global.setTimeout;
 const clearTimeout = global.clearTimeout;
 const setImmediate = global.setImmediate;
+/* eslint-enable no-redeclare */
 
 describe('Runner', () => {
 

test/lint/eslint/with_config/.eslintrc.js

@@ -98,6 +98,18 @@ describe('Types', () => {
                 line: 3,
                 column: 4
             },
+            {
+                filename: 'test/restrict.ts',
+                message: `Type 'undefined' is not assignable to type 'string' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the type of the target.`,
+                line: 10,
+                column: 0
+            },
+            {
+                filename: 'test/restrict.ts',
+                message: `'unchecked.b' is possibly 'undefined'.`,
+                line: 15,
+                column: 0
+            },
             {
                 filename: 'test/syntax.ts',
                 message: `')' expected.`,

test/lint/eslint/with_config/eslint.config.js

@@ -8,3 +8,14 @@ export default add;
 export const sample: { readonly x: string };
 
 export function hasProperty(property: { name: string }): boolean;
+
+export interface UsesExactOptionalPropertyTypes {
+	a?: boolean | undefined;
+	b?: string;
+}
+
+export interface UncheckedIndexedAccess {
+	a: UsesExactOptionalPropertyTypes;
+
+	[prop: string]: UsesExactOptionalPropertyTypes;
+}

test/linters.js

@@ -0,0 +1,15 @@
+import * as Lab from '../../../..';
+import type { UncheckedIndexedAccess, UsesExactOptionalPropertyTypes } from '../lib/index';
+
+const { expect } = Lab.types;
+
+const exact: UsesExactOptionalPropertyTypes = { a: true };
+
+exact.a = undefined;
+exact.b = 'ok';
+exact.b = undefined;      // Fails
+
+const unchecked: UncheckedIndexedAccess = { a: exact, b: {} };
+
+unchecked.a.a;
+unchecked.b.a;      // Fails