linter-bundle 2.21.0 → 2.22.0

package/CHANGELOG.md

@@ -6,7 +6,19 @@ 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.22.0...HEAD)
+
+## [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,7 +18,8 @@ module.exports = {
 			recommended: true
 		},
 		messages: {
-			text: 'Unnecessary `typeof`, because the only possible type of `{{ name }}` is `{{ type }}`.'
+			textWithType: 'Unnecessary `typeof`, because the only possible type of `{{ name }}` is `{{ type }}`.',
+			textWithoutType: 'Unnecessary `typeof`, because there is only one possible type of `{{ name }}`.'
 		}
 	},
 	create (context) {
@@ -33,21 +36,161 @@ 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)) {
-					context.report({
-						node,
-						messageId: 'text',
-						data: {
-							name: node.argument.name,
-							type: nodeType.intrinsicName
-						}
-					});
+				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
+							}
+						});
+					}
 				}
 			}
 		};
 	}
 };
+
+/**
+ * Check if the number of types equals one.
+ *
+ * @param {Type} type - TypeScript type node.
+ * @returns {boolean} Returns `true` if the `type` is only one specific type.
+ */
+function isSingleType (type) {
+	if (isAnyOrUnknown(type)) {
+		return false;
+	}
+
+	if (!type.types) {
+		return true;
+	}
+
+	const firstType = type.types[0];
+
+	if (isAnyOrUnknown(firstType)) {
+		return false;
+	}
+
+	for (let i = 1; i < type.types.length; i++) {
+		if (isDifferentType(type.types[i], firstType)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/**
+ * 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));
+}
+
+/**
+ * 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`.
+ *
+ * @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.objectFlags === ts.ObjectFlags.Anonymous);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "linter-bundle",
-	"version": "2.21.0",
+	"version": "2.22.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.3.2",
 		"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.0",
 		"stylelint-declaration-block-no-ignored-properties": "2.5.0",
 		"stylelint-order": "5.0.0",
 		"stylelint-scss": "4.3.0",