linter-bundle 2.20.0 → 2.22.0

package/CHANGELOG.md

@@ -6,7 +6,36 @@ 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.20.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
+
+### Added
+
+- [eslint] New rule [`no-unnecessary-typeof`](./eslint/rules/no-unnecessary-typeof.md), which prevents `typeof` checks at runtime, if a `typeof` operant has only one type in TypeScript.
+
+### Changed
+
+- [eslint] Updated `@typescript-eslint` from `5.36.1` to `5.37.0`
+- [eslint] Updated `eslint` from `8.23.0` to `8.23.1`
+- [eslint] Updated `eslint-import-resolver-typescript` from `3.5.0` to `3.5.1`
+- [eslint] Updated `eslint-plugin-functional` from `4.2.2` to `4.3.1`
+- [eslint] Updated `eslint-plugin-jest` from `27.0.1` to `27.0.4`
+- [eslint] Updated `eslint-plugin-react` from `7.31.1` to `7.31.8`
+
+[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v2.20.0...v2.21.0)
 
 ## [2.20.0] - 2022-09-01
 
@@ -969,7 +998,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ### Added
 
-- [gatsby/overrides-gatsby] New rule `no-global-undefined-check`, which prevents `typeof window === 'undefined'` checks, which are often [the source of rehydration problems](https://www.joshwcomeau.com/react/the-perils-of-rehydration/) in Gatsby
+- [eslint/overrides-gatsby] New rule [`no-global-undefined-check`](./eslint/rules/no-global-undefined-check.md), which prevents `typeof window === 'undefined'` checks, which are often [the source of rehydration problems](https://www.joshwcomeau.com/react/the-perils-of-rehydration/) in Gatsby
 
 [Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v1.1.0...v1.2.0)
 

package/README.md

@@ -38,6 +38,7 @@ This setup is using the following additional plugins:
 Beside that, the following additional rules are part of this bundle:
 
 - [no-global-undefined-check](./eslint/rules/no-global-undefined-check.md)
+- [no-unnecessary-typeof](./eslint/rules/no-unnecessary-typeof.md)
 
 ### stylelint
 
@@ -424,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/index.js

@@ -91,6 +91,11 @@ module.exports = {
 	},
 	reportUnusedDisableDirectives: true,
 	rules: {
+		/**
+		 * ./rules
+		 */
+		'no-unnecessary-typeof': 'error',
+
 		/**
 		 * eslint
 		 *

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

@@ -0,0 +1,196 @@
+/**
+ * @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');
+
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+module.exports = {
+	meta: {
+		docs: {
+			description: 'If a `typeof` operant has only one type in TypeScript, it\'s unnecessary to check it\'s type at runtime.',
+			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 }}`.'
+		}
+	},
+	create (context) {
+		return {
+			UnaryExpression (node) {
+				if (node.operator !== 'typeof' || node.argument.type !== 'Identifier') {
+					return;
+				}
+
+				// @ts-expect-error -- Different type definitions for `Rule.RuleContext` in ESLint and @typescript-eslint
+				const parserServices = ESLintUtils.getParserServices(context);
+				const checker = parserServices.program.getTypeChecker();
+
+				// @ts-expect-error -- ESLint `Identifier` is not recognized as `Node` by @typescript-eslint
+				const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node.argument);
+
+				/** @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
+							}
+						});
+					}
+				}
+			}
+		};
+	}
+};
+
+/**
+ * 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/eslint/rules/no-unnecessary-typeof.md

@@ -0,0 +1,18 @@
+# Disallow unnecessary `typeof` checks (`no-unnecessary-typeof`)
+
+## Rule Details
+
+If a `typeof` operant has only one type in TypeScript, it's unnecessary to check it's type at runtime.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+declare var myString: string;
+
+if (typeof myString === 'string') {}
+if (typeof myString === 'boolean') {}
+
+declare var myBoolean: (boolean | string) & (boolean | number);
+
+if (typeof myBoolean === 'boolean') {}
+```

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "linter-bundle",
-	"version": "2.20.0",
+	"version": "2.22.0",
 	"description": "Ready-to use bundle of linting tools, containing configurations for ESLint, stylelint and markdownlint.",
 	"keywords": [
 		"eslint",
@@ -40,26 +40,27 @@
 		"check-outdated": "npx --yes -- check-outdated --ignore-pre-releases"
 	},
 	"dependencies": {
-		"@typescript-eslint/eslint-plugin": "5.36.1",
-		"@typescript-eslint/parser": "5.36.1",
-		"eslint": "8.23.0",
-		"eslint-import-resolver-typescript": "3.5.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.2.2",
+		"eslint-plugin-functional": "4.3.2",
 		"eslint-plugin-import": "2.26.0",
-		"eslint-plugin-jest": "27.0.1",
+		"eslint-plugin-jest": "27.0.4",
 		"eslint-plugin-jsdoc": "39.3.6",
 		"eslint-plugin-jsx-a11y": "6.6.1",
 		"eslint-plugin-node": "11.1.0",
 		"eslint-plugin-promise": "6.0.1",
-		"eslint-plugin-react": "7.31.1",
+		"eslint-plugin-react": "7.31.8",
 		"eslint-plugin-react-hooks": "4.6.0",
 		"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",
@@ -73,8 +74,8 @@
 	"devDependencies": {
 		"@types/eslint": "8.4.6",
 		"@types/micromatch": "4.0.2",
-		"@types/node": "18.7.14",
+		"@types/node": "18.7.18",
 		"stylelint-find-new-rules": "4.0.0",
-		"typescript": "4.8.2"
+		"typescript": "4.8.3"
 	}
 }