linter-bundle 2.22.0 → 2.23.0

package/CHANGELOG.md

@@ -6,7 +6,21 @@ 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.22.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
 

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

@@ -18,14 +18,13 @@ module.exports = {
 			recommended: true
 		},
 		messages: {
-			textWithType: 'Unnecessary `typeof`, because the only possible type of `{{ name }}` is `{{ type }}`.',
-			textWithoutType: 'Unnecessary `typeof`, because there is only one possible type of `{{ name }}`.'
+			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;
 				}
 
@@ -39,26 +38,18 @@ module.exports = {
 				/** @type {Type} */
 				const nodeType = checker.getTypeAtLocation(originalNode);
 
-				if (isSingleType(nodeType)) {
-					if (nodeType.intrinsicName) {
-						context.report({
-							node,
-							messageId: 'textWithType',
-							data: {
-								name: node.argument.name,
-								type: nodeType.intrinsicName
-							}
-						});
-					}
-					else {
-						context.report({
-							node,
-							messageId: 'textWithoutType',
-							data: {
-								name: node.argument.name
-							}
-						});
-					}
+				const variableName = checker.getSymbolAtLocation(originalNode)?.getName();
+				const typeName = getSingleType(checker, nodeType);
+
+				if (typeName !== null) {
+					context.report({
+						node,
+						messageId: 'text',
+						data: {
+							variableName: (variableName ? `\`${variableName}\`` : `the ${node.argument.type.replace(/[A-Z]/gu, (substring) => ` ${substring.toLowerCase()}`).trim()}`),
+							typeName
+						}
+					});
 				}
 			}
 		};
@@ -66,33 +57,64 @@ module.exports = {
 };
 
 /**
- * Check if the number of types equals one.
+ * 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 {boolean} Returns `true` if the `type` is only one specific type.
+ * @returns {string | null} Type as string match the `typeof` string, or `null` if it's not a primitive type.
  */
-function isSingleType (type) {
+function getSingleType (checker, type) {
 	if (isAnyOrUnknown(type)) {
-		return false;
+		return null;
 	}
 
 	if (!type.types) {
-		return true;
+		return getTypeString(checker, type);
 	}
 
-	const firstType = type.types[0];
+	const firstType = getTypeString(checker, type.types[0]);
 
-	if (isAnyOrUnknown(firstType)) {
-		return false;
+	if (firstType === null) {
+		return null;
 	}
 
 	for (let i = 1; i < type.types.length; i++) {
-		if (isDifferentType(type.types[i], firstType)) {
-			return false;
+		if (getTypeString(checker, type.types[i]) !== firstType) {
+			return null;
 		}
 	}
 
-	return true;
+	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;
 }
 
 /**
@@ -106,35 +128,6 @@ function isAnyOrUnknown (type) {
 	return (type.flags === ts.TypeFlags.Any || type.flags === ts.TypeFlags.Unknown || (type.flags === ts.TypeFlags.Object && type.symbol === undefined));
 }
 
-/**
- * Check if two types are identical.
- *
- * @param {Type} type1 - TypeScript type node.
- * @param {Type} type2 - TypeScript type node.
- * @returns {boolean} Returns `true` if both types are identical.
- */
-function isDifferentType (type1, type2) {
-	if (isString(type1) && isString(type2)) { return false; }
-	if (isNumber(type1) && isNumber(type2)) { return false; }
-	if (isBigInt(type1) && isBigInt(type2)) { return false; }
-	if (isBoolean(type1) && isBoolean(type2)) { return false; }
-	if (isSymbol(type1) && isSymbol(type2)) { return false; }
-
-	if (type1.flags !== type2.flags) {
-		return true;
-	}
-
-	if (type1.flags === ts.TypeFlags.Object) {
-		if (isFunction(type1)) {
-			return !isFunction(type2);
-		}
-
-		return isFunction(type2);
-	}
-
-	return false;
-}
-
 /**
  * Checks if the given `type` is a `string`.
  *
@@ -192,5 +185,27 @@ function isSymbol (type) {
  * @returns {boolean} Returns `true` if the type is a `function`.
  */
 function isFunction (type) {
-	return (type.objectFlags === ts.ObjectFlags.Anonymous);
+	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.22.0",
+	"version": "2.23.0",
 	"description": "Ready-to use bundle of linting tools, containing configurations for ESLint, stylelint and markdownlint.",
 	"keywords": [
 		"eslint",
@@ -47,7 +47,7 @@
 		"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.2",
+		"eslint-plugin-functional": "4.4.0",
 		"eslint-plugin-import": "2.26.0",
 		"eslint-plugin-jest": "27.0.4",
 		"eslint-plugin-jsdoc": "39.3.6",
@@ -60,7 +60,7 @@
 		"markdownlint-cli": "0.32.2",
 		"micromatch": "4.0.5",
 		"postcss-scss": "4.0.5",
-		"stylelint": "14.12.0",
+		"stylelint": "14.12.1",
 		"stylelint-declaration-block-no-ignored-properties": "2.5.0",
 		"stylelint-order": "5.0.0",
 		"stylelint-scss": "4.3.0",