linter-bundle 2.21.0 → 2.23.0

package/CHANGELOG.md

@@ -6,7 +6,33 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
-[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v2.21.0...HEAD)
+[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v2.23.0...HEAD)
+
+## [2.23.0] - 2022-09-21
+
+### Added
+
+- [general] Add functionality to ensure that the installed dependencies match to the required dependency of the linter-bundle
+
+### Changed
+
+- [eslint] Updated `eslint-plugin-functional` from `4.3.2` to `4.4.0`
+- [stylelint] Updated `stylelint` from `14.12.0` to `14.12.1`
+- [eslint] Improved [`no-unnecessary-typeof`](./eslint/rules/no-unnecessary-typeof.md) to cover even more cases and fix false-positives
+
+[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v2.22.0...v2.23.0)
+
+## [2.22.0] - 2022-09-19
+
+### Changed
+
+- [eslint] Updated `@typescript-eslint` from `5.37.0` to `5.38.0`
+- [eslint] Updated `eslint-plugin-functional` from `4.3.1` to `4.3.2`
+- [stylelint] Updated `postcss-scss` from `4.0.4` to `4.0.5`
+- [stylelint] Updated `stylelint` from `14.11.0` to `14.12.0`
+- [eslint] Improved [`no-unnecessary-typeof`](./eslint/rules/no-unnecessary-typeof.md) to cover more cases
+
+[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v2.21.0...v2.22.0)
 
 ## [2.21.0] - 2022-09-14
 

package/README.md

@@ -425,3 +425,7 @@ If you get such an error message:
 the problem is most likely, that your `tsconfig.json` does not cover your JavaScript files and that you don't have a `jsconfig.json` file in your root directory. This is required by the `@typescript-eslint` to use TypeScript for linting of JavaScript files.
 
 To solve this problem, either `"include"` your JavaScript files in your `tsconfig.json` (don't forget to set the compiler option `"checkJs"` to `true`) or create a `jsconfig.json` file in your root directory (this can be a copy of your `tsconfig.json` with an `"include"` of your JavaScript files).
+
+### In VSCode, in every file, the first line shows the error `Definition for rule "no-unnecessary-typeof" was not found. eslint(no-unnecessary-typeof)`
+
+Please ensure that you've added the configuration options as described above ("VSCode setup" > "ESLint").

package/eslint/rules/no-unnecessary-typeof.js

@@ -1,9 +1,11 @@
 /**
- * @file ESLint rule which ensures that `typeof window === 'undefined'` is not used, since it's often the source of rehydration issues in Gatsby.
- *
- * @see https://www.joshwcomeau.com/react/the-perils-of-rehydration/
+ * @file ESLint rule which ensures that a `typeof` operant has more than one type in TypeScript, to prevent unnecessary checks of types at runtime.
  */
 
+/** @typedef {ts.Type & { intrinsicName?: string; types?: ts.Type[]; objectFlags?: ts.ObjectFlags; }} Type */
+
+const ts = require('typescript');
+
 const { ESLintUtils } = require('@typescript-eslint/utils');
 
 /**
@@ -16,13 +18,13 @@ module.exports = {
 			recommended: true
 		},
 		messages: {
-			text: 'Unnecessary `typeof`, because the only possible type of `{{ name }}` is `{{ type }}`.'
+			text: 'Unnecessary `typeof`, because the only possible type of {{ variableName }} is `{{ typeName }}`.'
 		}
 	},
 	create (context) {
 		return {
 			UnaryExpression (node) {
-				if (node.operator !== 'typeof' || node.argument.type !== 'Identifier') {
+				if (node.operator !== 'typeof') {
 					return;
 				}
 
@@ -33,17 +35,19 @@ module.exports = {
 				// @ts-expect-error -- ESLint `Identifier` is not recognized as `Node` by @typescript-eslint
 				const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node.argument);
 
-				/** @type {import('typescript').Type & { intrinsicName?: string; }} */
+				/** @type {Type} */
 				const nodeType = checker.getTypeAtLocation(originalNode);
 
-				// `intrinsicName` only exists if there is exactly one type
-				if (nodeType.intrinsicName && !['any', 'error', 'unknown'].includes(nodeType.intrinsicName)) {
+				const variableName = checker.getSymbolAtLocation(originalNode)?.getName();
+				const typeName = getSingleType(checker, nodeType);
+
+				if (typeName !== null) {
 					context.report({
 						node,
 						messageId: 'text',
 						data: {
-							name: node.argument.name,
-							type: nodeType.intrinsicName
+							variableName: (variableName ? `\`${variableName}\`` : `the ${node.argument.type.replace(/[A-Z]/gu, (substring) => ` ${substring.toLowerCase()}`).trim()}`),
+							typeName
 						}
 					});
 				}
@@ -51,3 +55,157 @@ module.exports = {
 		};
 	}
 };
+
+/**
+ * Check if the number of types equals one, and returns the type.
+ *
+ * @param {ts.TypeChecker} checker - TypeScript type checker.
+ * @param {Type} type - TypeScript type node.
+ * @returns {string | null} Type as string match the `typeof` string, or `null` if it's not a primitive type.
+ */
+function getSingleType (checker, type) {
+	if (isAnyOrUnknown(type)) {
+		return null;
+	}
+
+	if (!type.types) {
+		return getTypeString(checker, type);
+	}
+
+	const firstType = getTypeString(checker, type.types[0]);
+
+	if (firstType === null) {
+		return null;
+	}
+
+	for (let i = 1; i < type.types.length; i++) {
+		if (getTypeString(checker, type.types[i]) !== firstType) {
+			return null;
+		}
+	}
+
+	return firstType;
+}
+
+/**
+ * Converts a TypeScript type into a `typeof` compatible string, or `null` if it's not a primitive type.
+ *
+ * @param {ts.TypeChecker} checker - TypeScript type checker.
+ * @param {Type} type - TypeScript type node.
+ * @returns {string | null} Type as string match the `typeof` string, or `null` if it's not a primitive type.
+ */
+function getTypeString (checker, type) {
+	if (isAnyOrUnknown(type)) {
+		return null;
+	}
+
+	const typeString = checker.typeToString(type);
+
+	if (['undefined', 'boolean', 'number', 'bigint', 'string', 'symbol', 'function', 'object'].includes(typeString)) {
+		return typeString;
+	}
+
+	if (isUndefined(type)) { return 'undefined'; }
+	if (isBoolean(type)) { return 'boolean'; }
+	if (isNumber(type)) { return 'number'; }
+	if (isBigInt(type)) { return 'bigint'; }
+	if (isString(type)) { return 'string'; }
+	if (isSymbol(type)) { return 'symbol'; }
+	if (isFunction(type)) { return 'function'; }
+	if (isObject(type)) { return 'object'; }
+
+	return null;
+}
+
+/**
+ * Check if the type is either `any` or `unknown`, which represents multiple types.
+ *
+ * @param {ts.Type} type - TypeScript type node.
+ * @returns {boolean} Returns `true` if the type is either `any` or `unknown`, or an object which is based on `unknown`.
+ */
+function isAnyOrUnknown (type) {
+	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- `symbol` on Object is `undefined` for `Omit<unknown, 'undefined'>`
+	return (type.flags === ts.TypeFlags.Any || type.flags === ts.TypeFlags.Unknown || (type.flags === ts.TypeFlags.Object && type.symbol === undefined));
+}
+
+/**
+ * Checks if the given `type` is a `string`.
+ *
+ * @param {Type} type - TypeScript type node.
+ * @returns {boolean} Returns `true` if the type is a `string`.
+ */
+function isString (type) {
+	return [ts.TypeFlags.String, ts.TypeFlags.StringLiteral, ts.TypeFlags.StringMapping].includes(type.flags);
+}
+
+/**
+ * Checks if the given `type` is a `number`.
+ *
+ * @param {Type} type - TypeScript type node.
+ * @returns {boolean} Returns `true` if the type is a `number`.
+ */
+function isNumber (type) {
+	return [ts.TypeFlags.Number, ts.TypeFlags.NumberLiteral].includes(type.flags);
+}
+
+/**
+ * Checks if the given `type` is a `bigint`.
+ *
+ * @param {Type} type - TypeScript type node.
+ * @returns {boolean} Returns `true` if the type is a `bigint`.
+ */
+function isBigInt (type) {
+	return [ts.TypeFlags.BigInt, ts.TypeFlags.BigIntLiteral].includes(type.flags);
+}
+
+/**
+ * Checks if the given `type` is a `boolean`.
+ *
+ * @param {Type} type - TypeScript type node.
+ * @returns {boolean} Returns `true` if the type is a `boolean`.
+ */
+function isBoolean (type) {
+	return [ts.TypeFlags.Boolean, ts.TypeFlags.BooleanLiteral].includes(type.flags);
+}
+
+/**
+ * Checks if the given `type` is a `symbol`.
+ *
+ * @param {Type} type - TypeScript type node.
+ * @returns {boolean} Returns `true` if the type is a `symbol`.
+ */
+function isSymbol (type) {
+	return [ts.TypeFlags.ESSymbol, ts.TypeFlags.UniqueESSymbol].includes(type.flags);
+}
+
+/**
+ * Checks if the given `type` is a `function`.
+ *
+ * @param {Type} type - TypeScript type node.
+ * @returns {boolean} Returns `true` if the type is a `function`.
+ */
+function isFunction (type) {
+	return (type.flags === ts.TypeFlags.Object && type.objectFlags === ts.ObjectFlags.Anonymous);
+}
+
+/**
+ * Checks if the given `type` is a `undefined`.
+ *
+ * @param {Type} type - TypeScript type node.
+ * @returns {boolean} Returns `true` if the type is `undefined`.
+ */
+function isUndefined (type) {
+	return [ts.TypeFlags.Undefined].includes(type.flags);
+}
+
+/**
+ * Checks if the given `type` is a `object`.
+ *
+ * We don't check `ts.TypeFlags.Object`, because for TypeScript Object seems to be the fallback for everything - even unknown types.
+ *
+ * @param {Type} type - TypeScript type node.
+ * @returns {boolean} Returns `true` if the type is an `object`.
+ */
+function isObject (type) {
+	return [ts.TypeFlags.Null].includes(type.flags);
+}

package/helper/find-missing-overrides.js

@@ -0,0 +1,48 @@
+/**
+ * @file Ensures that the installed dependencies of the project matches to the versions used by the linter-bundle.
+ *
+ * @see https://docs.npmjs.com/cli/v8/configuring-npm/package-json#overrides
+ * @see https://classic.yarnpkg.com/en/docs/selective-version-resolutions/
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/** @typedef {{ name: string; configuredVersion: string; expectedVersion: string; }} Dependency */
+
+/**
+ * Detects if installed versions of dependencies don't match to the required dependencies.
+ *
+ * @returns {Dependency[]} An array of missing overrides (=wrong versions).
+ */
+function findMissingOverrides () {
+	const linterBundleDependencies = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8')).dependencies;
+
+	const result = [];
+
+	for (const [name, expectedVersion] of Object.entries(linterBundleDependencies)) {
+		let dependenyPackageJson;
+
+		try {
+			dependenyPackageJson = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'node_modules', name, 'package.json'), 'utf8'));
+		}
+		catch {
+			// If the file does not exist, we ignore it, because in this case it's most likely a linter-bundle-only dependency.
+			continue;
+		}
+
+		if (dependenyPackageJson.version !== expectedVersion) {
+			result.push({
+				name,
+				configuredVersion: dependenyPackageJson.version,
+				expectedVersion
+			});
+		}
+	}
+
+	return result;
+}
+
+module.exports = {
+	findMissingOverrides
+};

package/helper/is-npm-or-yarn.js

@@ -0,0 +1,48 @@
+/**
+ * @file Check if the project is using npm or yarn by checking the existance of a `package-lock.json` or a `yarn.lock`.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Returns if the project is using npm or yarn.
+ *
+ * @returns {'none' | 'npm' | 'yarn' | 'both'} Returns which package manager name.
+ */
+function isNpmOrYarn () {
+	let npm = false;
+	let yarn = false;
+
+	try {
+		fs.accessSync(path.join(process.cwd(), 'package-lock.json'), fs.constants.R_OK);
+
+		npm = true;
+	}
+	catch { /* `package-lock.json` cannot be accessed. */ }
+
+	try {
+		fs.accessSync(path.join(process.cwd(), 'yarn.lock'), fs.constants.R_OK);
+
+		yarn = true;
+	}
+	catch { /* `yarn.lock` cannot be accessed. */ }
+
+	if (npm && yarn) {
+		return 'both';
+	}
+
+	if (npm) {
+		return 'npm';
+	}
+
+	if (yarn) {
+		return 'yarn';
+	}
+
+	return 'none';
+}
+
+module.exports = {
+	isNpmOrYarn
+};

package/lint.js

@@ -4,12 +4,13 @@
  * @file Entry point of the linter-bundle.
  */
 
-const fs = require('fs');
 const path = require('path');
 const tty = require('tty');
 
 const micromatch = require('micromatch');
 
+const { findMissingOverrides } = require('./helper/find-missing-overrides.js');
+const { isNpmOrYarn } = require('./helper/is-npm-or-yarn.js');
 const { runProcess } = require('./helper/run-process.js');
 const { validatePackageOverrides } = require('./helper/validate-package-overrides.js');
 
@@ -21,21 +22,9 @@ const { validatePackageOverrides } = require('./helper/validate-package-override
 const isTerminal = tty.isatty(1);
 
 void (async () => {
-	const outdatedOverrides = validatePackageOverrides();
-
-	if (outdatedOverrides.overrides.length > 0 || outdatedOverrides.resolutions.length > 0) {
-		if (outdatedOverrides.overrides.length > 0) {
-			process.stderr.write(`Outdated "overrides" in package.json detected:\n- ${outdatedOverrides.overrides.map((dependency) => `${dependency.name}: ${dependency.configuredVersion} is configured, but ${dependency.expectedVersion} is expected`).join('\n- ')}\n\n`);
-		}
+	const npmOrYarn = isNpmOrYarn();
 
-		if (outdatedOverrides.resolutions.length > 0) {
-			process.stderr.write(`Outdated "resolutions" in package.json detected:\n- ${outdatedOverrides.resolutions.map((dependency) => `${dependency.name}: ${dependency.configuredVersion} is configured, but ${dependency.expectedVersion} is expected`).join('\n- ')}\n\n`);
-		}
-
-		process.exitCode = 1;
-
-		return;
-	}
+	validateEnvironment(npmOrYarn);
 
 	/** @type {{ diff: Promise<ProcessResult>; modified: Promise<ProcessResult>; deleted: Promise<ProcessResult>; } | undefined} */
 	let gitFilesProcessPromise;
@@ -151,7 +140,7 @@ void (async () => {
 				// eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- This is not a valid `audit` property, so  we need to remove it.
 				delete config['git'];
 
-				if (fs.existsSync('package-lock.json')) {
+				if (npmOrYarn === 'npm') {
 					return runTask({
 						taskName,
 						config,
@@ -167,7 +156,7 @@ void (async () => {
 						].filter((argument) => Boolean(argument)).join(' ')
 					});
 				}
-				else if (fs.existsSync('yarn.lock')) {
+				else if (npmOrYarn === 'yarn') {
 					return runTask({
 						taskName,
 						config,
@@ -246,6 +235,56 @@ void (async () => {
 	process.stdout.write('\n');
 })();
 
+/**
+ * Ensures that the environment in which the linter is running has the correct versions of the required dependencies.
+ *
+ * @param {ReturnType<isNpmOrYarn>} npmOrYarn - This should be the return value of `isNpmOrYarn()`.
+ * @returns {void}
+ */
+function validateEnvironment (npmOrYarn) {
+	const outdatedOverrides = validatePackageOverrides();
+
+	if (outdatedOverrides.overrides.length > 0 || outdatedOverrides.resolutions.length > 0) {
+		if (outdatedOverrides.overrides.length > 0) {
+			process.stderr.write(`Outdated "overrides" in package.json detected:\n- ${outdatedOverrides.overrides.map((dependency) => `${dependency.name}: ${dependency.configuredVersion} is configured, but ${dependency.expectedVersion} is expected`).join('\n- ')}\n\n`);
+		}
+
+		if (outdatedOverrides.resolutions.length > 0) {
+			process.stderr.write(`Outdated "resolutions" in package.json detected:\n- ${outdatedOverrides.resolutions.map((dependency) => `${dependency.name}: ${dependency.configuredVersion} is configured, but ${dependency.expectedVersion} is expected`).join('\n- ')}\n\n`);
+		}
+
+		process.exitCode = 1;
+
+		return;
+	}
+
+	const missingOverrides = findMissingOverrides().filter(({ name }) => !(npmOrYarn === 'npm' && outdatedOverrides.overrides.some((override) => name === override.name)) && !(npmOrYarn === 'yarn' && outdatedOverrides.resolutions.some((override) => name === override.name)));
+
+	if (missingOverrides.length > 0) {
+		let installCommand;
+		let propertyName;
+
+		if (npmOrYarn === 'yarn') {
+			installCommand = 'yarn install';
+			propertyName = 'resolutions';
+		}
+		else {
+			installCommand = 'npm install';
+			propertyName = 'overrides';
+		}
+
+		process.stderr.write(`The installed version of ${missingOverrides.length === 1 ? 'one dependency' : `${missingOverrides.length} dependencies`} does not match to the version required by the linter-bundle:\n`);
+		process.stderr.write(`- ${missingOverrides.map((dependency) => `${dependency.name}: ${dependency.configuredVersion} is installed, but ${dependency.expectedVersion} is expected`).join('\n- ')}\n\n`);
+		process.stderr.write(`This could be caused by forgetting to execute \`${installCommand}\` after changing a version number in the package.json, or by some other package shipping outdated versions of the ${missingOverrides.length === 1 ? 'dependency' : 'dependencies'}.\n`);
+		process.stderr.write('If another package is causing this problem, you can fix it by adding the following entry to your package.json:\n');
+		process.stderr.write(`{\n  "${propertyName}: {\n    ${missingOverrides.map((dependency) => `"${dependency.name}": "${dependency.expectedVersion}"`).join(',\n    ')}\n  }\n}\n\n`);
+
+		process.exitCode = 1;
+
+		return;
+	}
+}
+
 /**
  * Extracts the tasks which should be run from the command-line arguments passed in.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "linter-bundle",
-	"version": "2.21.0",
+	"version": "2.23.0",
 	"description": "Ready-to use bundle of linting tools, containing configurations for ESLint, stylelint and markdownlint.",
 	"keywords": [
 		"eslint",
@@ -40,14 +40,14 @@
 		"check-outdated": "npx --yes -- check-outdated --ignore-pre-releases"
 	},
 	"dependencies": {
-		"@typescript-eslint/eslint-plugin": "5.37.0",
-		"@typescript-eslint/parser": "5.37.0",
-		"@typescript-eslint/utils": "5.37.0",
+		"@typescript-eslint/eslint-plugin": "5.38.0",
+		"@typescript-eslint/parser": "5.38.0",
+		"@typescript-eslint/utils": "5.38.0",
 		"eslint": "8.23.1",
 		"eslint-import-resolver-typescript": "3.5.1",
 		"eslint-import-resolver-webpack": "0.13.2",
 		"eslint-plugin-eslint-comments": "3.2.0",
-		"eslint-plugin-functional": "4.3.1",
+		"eslint-plugin-functional": "4.4.0",
 		"eslint-plugin-import": "2.26.0",
 		"eslint-plugin-jest": "27.0.4",
 		"eslint-plugin-jsdoc": "39.3.6",
@@ -59,8 +59,8 @@
 		"eslint-plugin-unicorn": "43.0.2",
 		"markdownlint-cli": "0.32.2",
 		"micromatch": "4.0.5",
-		"postcss-scss": "4.0.4",
-		"stylelint": "14.11.0",
+		"postcss-scss": "4.0.5",
+		"stylelint": "14.12.1",
 		"stylelint-declaration-block-no-ignored-properties": "2.5.0",
 		"stylelint-order": "5.0.0",
 		"stylelint-scss": "4.3.0",