@automattic/eslint-plugin-wpvip 0.4.7 → 0.4.9

package/.eslintrc.js

@@ -6,6 +6,8 @@ module.exports = {
 	extends: [
 		'plugin:eslint-plugin/recommended', // linting for eslint plugins!
 		'plugin:@automattic/wpvip/base',
+		'plugin:@automattic/wpvip/testing',
+		'plugin:@automattic/wpvip/typescript',
 	],
 	parserOptions: {
 		project: './tsconfig.json',

package/configs/base.js

@@ -1,138 +1,7 @@
-const isPackageInstalled = require('@wordpress/eslint-plugin/utils/is-package-installed');
-
-const baseConfig = {
-	env: {
-		node: true,
-	},
+module.exports = {
 	extends: [
-		'eslint:recommended',
-		'plugin:@wordpress/eslint-plugin/recommended',
 		'plugin:json/recommended',
 		'plugin:security/recommended',
+		require.resolve( './javascript' ),
 	],
-	/**
-	 * We must explicitly add this plugin to use our custom rules.
-	 */
-	plugins: ['@automattic/wpvip'],
-	/**
-	 * Please include a short description of the rule. For rules that downgrade or
-	 * disable errors, include a brief justification or reasoning.
-	 */
-	rules: {
-		// Async/await must not be used in a `.forEach` method, because the result
-		// will not be awaited in the outer scope.
-		'@automattic/wpvip/no-async-foreach': 'error',
-
-		// Identifiers should be in camelCase. Object properties are excluded
-		// (including when destructuring) since they often come from external
-		// sources (like APIs).
-		camelcase: [
-			'warn',
-			{
-				properties: 'never',
-				ignoreDestructuring: true,
-			},
-		],
-
-		// Maximum cyclomatic complexity must not be above 20.
-		complexity: 'error',
-
-		// Files must end in a newline.
-		'eol-last': ['error', 'always'],
-
-		// Identifiers should be between 2 and 40 characters in length.
-		'id-length': [
-			'warn',
-			{
-				min: 2,
-				max: 40,
-			},
-		],
-
-		// Disable JSDoc rule to require param definitions. While other JSDoc rules
-		// are still present and active, they are effectively dormant unless
-		// triggered by invalid or insufficient JSDoc. In other words, if you don't
-		// attempt JSDoc, none will be required by the linter.
-		//
-		// Reenable this rule with the jsdoc preset.
-		'jsdoc/require-param': 'off',
-
-		// Lines containing code should be a maximum of 200 characters in length.
-		'max-len': [
-			'warn',
-			{
-				code: 200,
-			},
-		],
-
-		// Async/await must not be used in a loop, because it leads to sequential
-		// execution, when parallel execution is almost always preferred.
-		'no-await-in-loop': 'error',
-
-		// `console.log` should not be used directly in code. Ideally, delegate to a
-		// logging function that logs on your behalf (and ignore this rule there).
-		'no-console': 'warn',
-
-		// A single `import` statement should be used when importing multiple things
-		// from a module.
-		'no-duplicate-imports': 'warn',
-
-		// `process.exit` must not be used.
-		'no-process-exit': 'error',
-
-		// Negating the left operand of a statment frequently leads to logical
-		// errors. Example: `!key in obj` vs. `!(key in obj)`.
-		'no-unsafe-negation': 'error',
-
-		// Defined variables must not go unused.
-		'no-unused-vars': 'error',
-
-		// Arrow functions should be used for function arguments and callbacks.
-		'prefer-arrow-callback': 'warn',
-
-		// `parseInt` calls must always supply a radix argument.
-		radix: 'error',
-
-		// Comments should always include consistent spacing for readability.
-		'spaced-comment': 'warn',
-
-		// The result of `typeof` must always be compared to a literal string.
-		'valid-typeof': [
-			'error',
-			{
-				requireStringLiterals: true,
-			},
-		],
-	},
-	overrides: [],
 };
-
-// Make our default TypeScript rules more useful.
-if (isPackageInstalled('typescript')) {
-	baseConfig.overrides.push({
-		extends: [
-			'plugin:@typescript-eslint/recommended-requiring-type-checking',
-			'plugin:@typescript-eslint/strict',
-		],
-		files: ['**/*.ts', '**/*.tsx'],
-		rules: {
-			// TypeScript `any` type must not be used. This is a warning in the base
-			// config, and is elevated to an error here.
-			'@typescript-eslint/no-explicit-any': 'error',
-		},
-	});
-}
-
-// Make our default React rules more useful.
-if (isPackageInstalled('react')) {
-	// @TODO
-}
-
-// Add Jest-specific rules if it is installed.
-if (isPackageInstalled('jest')) {
-	baseConfig.env['jest/globals'] = true;
-	baseConfig.extends.push('plugin:jest/recommended');
-	baseConfig.plugins.push('jest');
-}
-
-module.exports = baseConfig;

package/configs/cli.js

@@ -5,9 +5,9 @@ module.exports = {
 	 */
 	rules: {
 		// Allow child_process and non-literal `exec` arguments.
-		'security/detect-child-process': 0,
+		'security/detect-child-process': 'off',
 
 		// Process.exit is used in CLI context to stop execution.
-		'no-process-exit': 0,
+		'no-process-exit': 'off',
 	},
 };

package/configs/{prettier-off.js → formatting.js}

@@ -4,6 +4,6 @@ module.exports = {
 	 * disable errors, include a brief justification or reasoning.
 	 */
 	rules: {
-		'prettier/prettier': 'off',
 	},
 };
+

package/configs/index.js

@@ -1,8 +1,13 @@
 module.exports = {
-	base: require('./base'),
-	cli: require('./cli'),
-	jsdoc: require('./jsdoc'),
-	'prettier-off': require('./prettier-off'),
-	weak: require('./weak'),
-	'weak-typescript': require('./weak-typescript'),
+	base: require( './base' ),
+	cli: require( './cli' ),
+	formatting: require( './formatting' ),
+	javascript: require( './javascript' ),
+	jsdoc: require( './jsdoc' ),
+	prettier: require( './prettier' ),
+	react: require( './react' ),
+	testing: require( './testing' ),
+	typescript: require( './typescript' ),
+	'weak-javascript': require( './weak-javascript' ),
+	'weak-typescript': require( './weak-typescript' ),
 };

package/configs/javascript.js

@@ -0,0 +1,222 @@
+/**
+ * Based on:
+ * - https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/configs/jshint.js
+ * - https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/configs/es5.js
+ * - https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/configs/esnext.js
+ * - https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/configs/recommended-with-formatting.js
+ */
+
+module.exports = {
+	env: {
+		es2022: true, // 100% covered by Node.js v16
+		node: true,
+	},
+
+	parser: '@babel/eslint-parser',
+
+	parserOptions: {
+		requireConfigFile: false,
+		sourceType: 'module',
+	},
+
+	/**
+	 * Note: We must explicitly add this plugin to use our custom rules.
+	 */
+	plugins: [ '@automattic/wpvip', 'import' ],
+
+	/**
+	 * Please include a short description of the rule. For rules that downgrade or
+	 * disable errors, include a brief justification or reasoning.
+	 */
+	rules: {
+		// These rules are from eslint:recommended, but are enumerated here for
+		// visibility:
+		// https://github.com/eslint/eslint/blob/main/packages/js/src/configs/eslint-recommended.js
+		'constructor-super': 'error',
+		'for-direction': 'error',
+		'getter-return': 'error',
+		'no-async-promise-executor': 'error',
+		'no-case-declarations': 'error',
+		'no-class-assign': 'error',
+		'no-compare-neg-zero': 'error',
+		// 'no-cond-assign': 'error', // overridden below
+		'no-const-assign': 'error',
+		'no-constant-condition': 'error',
+		'no-control-regex': 'error',
+		'no-debugger': 'error',
+		'no-delete-var': 'error',
+		'no-dupe-args': 'error',
+		'no-dupe-class-members': 'error',
+		'no-dupe-else-if': 'error',
+		'no-dupe-keys': 'error',
+		'no-duplicate-case': 'error',
+		'no-empty': 'error',
+		'no-empty-character-class': 'error',
+		'no-empty-pattern': 'error',
+		'no-ex-assign': 'error',
+		'no-extra-boolean-cast': 'error',
+		'no-extra-semi': 'error',
+		'no-fallthrough': 'error',
+		'no-func-assign': 'error',
+		'no-global-assign': 'error',
+		'no-import-assign': 'error',
+		'no-inner-declarations': 'error',
+		'no-invalid-regexp': 'error',
+		'no-irregular-whitespace': 'error',
+		'no-loss-of-precision': 'error',
+		'no-misleading-character-class': 'error',
+		'no-mixed-spaces-and-tabs': 'error',
+		'no-new-symbol': 'error',
+		'no-nonoctal-decimal-escape': 'error',
+		'no-obj-calls': 'error',
+		'no-octal': 'error',
+		'no-prototype-builtins': 'error',
+		'no-redeclare': 'error',
+		'no-regex-spaces': 'error',
+		'no-self-assign': 'error',
+		'no-setter-return': 'error',
+		'no-shadow-restricted-names': 'error',
+		'no-sparse-arrays': 'error',
+		'no-this-before-super': 'error',
+		'no-undef': 'error',
+		'no-unexpected-multiline': 'error',
+		'no-unreachable': 'error',
+		'no-unsafe-finally': 'error',
+		'no-unsafe-negation': 'error',
+		'no-unsafe-optional-chaining': 'error',
+		'no-unused-labels': 'error',
+		// 'no-unused-vars': 'error', // overridden below
+		'no-useless-backreference': 'error',
+		'no-useless-catch': 'error',
+		'no-useless-escape': 'error',
+		'no-with': 'error',
+		'require-yield': 'error',
+		'use-isnan': 'error',
+		// 'valid-typeof': 'error', // overridden below
+
+		// Async/await must not be used in a `.forEach` method, because the result
+		// will not be awaited in the outer scope.
+		'@automattic/wpvip/no-async-foreach': 'error',
+
+		// Variables that are potentially not needed before a return statement can
+		// be assigned after the return.
+		'@automattic/wpvip/no-unused-vars-before-return': 'error',
+
+		// Unguarded getRangeAt calls can throw errors in some browsers.
+		'@automattic/wpvip/no-unguarded-get-range-at': 'error',
+
+		'array-callback-return': 'error',
+
+		// Maximum cyclomatic complexity must not be above 20.
+		complexity: 'error',
+
+		'dot-notation': 'error',
+
+		eqeqeq: 'error',
+
+		'func-call-spacing': 'error',
+
+		// Identifiers should be between 2 and 40 characters in length in order to
+		// provide a concise semantic meaning.
+		'id-length': [
+			'warn',
+			{
+				min: 2,
+				max: 40,
+			},
+		],
+
+		'import/default': 'warn',
+
+		'import/named': 'warn',
+
+		'import/no-extraneous-dependencies': [
+			'error',
+			{
+				peerDependencies: true,
+			},
+		],
+
+		'import/no-unresolved': 'error',
+
+		// Enforce Unix linebreaks. Included here and not in "formatting" since it
+		// is not controversial and helps with interchange.
+		'linebreak-style': [ 'error', 'unix' ],
+
+		'no-alert': 'error',
+
+		// Async/await must not be used in a loop, because it leads to sequential
+		// execution, when parallel execution is almost always preferred.
+		'no-await-in-loop': 'error',
+
+		'no-bitwise': 'error',
+
+		'no-caller': 'error',
+
+		'no-cond-assign': [ 'error', 'except-parens' ],
+
+		// `console.log` should not be used directly in code. Ideally, delegate to a
+		// logging function that logs on your behalf (and ignore this rule there).
+		'no-console': 'warn',
+
+		// A single `import` statement should be used when importing multiple things
+		// from a module.
+		'no-duplicate-imports': 'error',
+
+		'no-else-return': 'error',
+
+		'no-eq-null': 'error',
+
+		'no-eval': 'error',
+
+		'no-lonely-if': 'error',
+
+		'no-mixed-operators': 'error',
+
+		'no-multi-spaces': 'error',
+
+		'no-multi-str': 'error',
+
+		'no-multiple-empty-lines': [ 'error', { max: 1 } ],
+
+		'no-nested-ternary': 'error',
+
+		'no-shadow': 'error',
+
+		'no-undef-init': 'error',
+
+		'no-unused-expressions': 'error',
+
+		'no-unused-vars': [ 'error', { ignoreRestSiblings: true } ],
+
+		'no-useless-computed-key': 'error',
+
+		'no-useless-constructor': 'error',
+
+		'no-useless-return': 'error',
+
+		'no-var': 'error',
+
+		// Non-controversial formatting rule.
+		'no-whitespace-before-property': 'error',
+
+		'one-var': [ 'error', 'never' ],
+
+		'prefer-const': [ 'error', { destructuring: 'all' } ],
+
+		radix: 'error',
+
+		// Non-controversial formatting rule.
+		semi: 'error',
+
+		// The result of `typeof` must always be compared to a literal string.
+		'valid-typeof': [
+			'error',
+			{
+				requireStringLiterals: true,
+			},
+		],
+
+		'wrap-iife': [ 'error', 'any' ],
+	},
+};

package/configs/jsdoc.js

@@ -1,12 +1,112 @@
+/**
+ * Based on:
+ * https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/configs/jsdoc.js
+ */
+
+const globals = require( 'globals' );
+
+/**
+ * Helpful utilities that are globally defined and known to the TypeScript compiler.
+ *
+ * @see http://www.typescriptlang.org/docs/handbook/utility-types.html
+ */
+const typescriptUtilityTypes = [
+	'ArrayLike',
+	'Exclude',
+	'Extract',
+	'InstanceType',
+	'Iterable',
+	'IterableIterator',
+	'NonNullable',
+	'Omit',
+	'Parameters',
+	'Partial',
+	'Pick',
+	'PromiseLike',
+	'Readonly',
+	'ReadonlyArray',
+	'ReadonlyMap',
+	'ReadonlySet',
+	'Record',
+	'Required',
+	'ReturnType',
+	'ThisType',
+	'unknown',
+	'never',
+	'NodeJS',
+	'AsyncIterableIterator',
+	'NodeRequire',
+	'true',
+	'false',
+];
+
 module.exports = {
-	/**
-	 * Please include a short description of the rule. For rules that downgrade or
-	 * disable errors, include a brief justification or reasoning.
-	 */
+	extends: [ 'plugin:jsdoc/recommended' ],
+	settings: {
+		jsdoc: {
+			preferredTypes: {
+				object: 'Object',
+			},
+			tagNamePreference: {
+				returns: 'return',
+				yields: 'yield',
+			},
+		},
+	},
 	rules: {
-		// Reenable the requirement to document function parameters, which in turn
-		// enables additional lint rules to ensure accuracy and proper formatting.
-		// This overrides the base preset.
+		'jsdoc/no-undefined-types': [
+			'error',
+			{
+				definedTypes: [
+					// Required to reference browser types because we don't have the `browser` environment enabled for the project.
+					// Here we filter out all browser globals that don't begin with an uppercase letter because those
+					// generally refer to window-level event listeners and are not a valid type to reference (e.g. `onclick`).
+					...Object.keys( globals.browser ).filter( ( key ) =>
+						/^[A-Z]/.test( key ),
+					),
+					...typescriptUtilityTypes,
+					'void',
+					'JSX',
+				],
+			},
+		],
+		'jsdoc/require-jsdoc': 'off',
+		'jsdoc/require-param-description': 'off',
+		'jsdoc/require-returns': 'off',
+		'jsdoc/require-yields': 'off',
+		'jsdoc/tag-lines': 'off',
+		'jsdoc/no-multi-asterisks': [
+			'error',
+			{ preventAtMiddleLines: false },
+		],
+		'jsdoc/check-access': 'error',
+		'jsdoc/check-alignment': 'error',
+		'jsdoc/check-line-alignment': [
+			'error',
+			'always',
+			{
+				tags: [ 'param', 'arg', 'argument', 'property', 'prop' ],
+				preserveMainDescriptionPostDelimiter: true,
+			},
+		],
+		'jsdoc/check-param-names': 'error',
+		'jsdoc/check-property-names': 'error',
+		'jsdoc/check-tag-names': 'error',
+		'jsdoc/check-types': 'error',
+		'jsdoc/check-values': 'off',
+		'jsdoc/empty-tags': 'error',
+		'jsdoc/implements-on-classes': 'error',
+		'jsdoc/newline-after-description': 'error',
 		'jsdoc/require-param': 'error',
+		'jsdoc/require-param-name': 'error',
+		'jsdoc/require-param-type': 'error',
+		'jsdoc/require-property': 'error',
+		'jsdoc/require-property-description': 'error',
+		'jsdoc/require-property-name': 'error',
+		'jsdoc/require-property-type': 'error',
+		'jsdoc/require-returns-check': 'error',
+		'jsdoc/require-returns-description': 'error',
+		'jsdoc/require-returns-type': 'error',
+		'jsdoc/valid-types': 'error',
 	},
 };

package/configs/jsx-ally.js

@@ -0,0 +1,21 @@
+/**
+ * Based on:
+ * https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/configs/jsx-a11y.js
+ */
+
+module.exports = {
+	extends: [ 'plugin:jsx-a11y/recommended' ],
+	plugins: [ 'jsx-a11y' ],
+	rules: {
+		'jsx-a11y/label-has-associated-control': [
+			'error',
+			{
+				assert: 'htmlFor',
+			},
+		],
+		'jsx-a11y/media-has-caption': 'off',
+		'jsx-a11y/no-noninteractive-tabindex': 'off',
+		'jsx-a11y/role-has-required-aria-props': 'off',
+		'jsx-quotes': 'error',
+	},
+};

package/configs/prettier.js

@@ -0,0 +1,12 @@
+/**
+ * Based on:
+ * https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/configs/recommended.js
+ */
+
+module.exports = {
+	extends: [ 'plugin:prettier/recommended' ],
+	plugins: [ 'prettier' ],
+	rules: {
+		'prettier/prettier': 'error',
+	},
+};

package/configs/react.js

@@ -0,0 +1,47 @@
+/**
+ * Based on:
+ * https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/configs/react.js
+ */
+
+module.exports = {
+	extends: [
+		'plugin:react/recommended',
+		'plugin:react-hooks/recommended',
+		require( './jsx-ally' ),
+	],
+	parserOptions: {
+		ecmaFeatures: {
+			jsx: true,
+		},
+	},
+	settings: {
+		react: {
+			version: 'detect',
+		},
+	},
+	plugins: [ '@automattic/wpvip', 'react', 'react-hooks' ],
+	rules: {
+		'@automattic/wpvip/no-unused-vars-before-return': [
+			'error',
+			{
+				excludePattern: '^use',
+			},
+		],
+		'react/display-name': 'off',
+		'react/jsx-curly-spacing': [
+			'error',
+			{
+				when: 'always',
+				children: true,
+			},
+		],
+		'react/jsx-equals-spacing': 'error',
+		'react/jsx-indent': [ 'error', 'tab' ],
+		'react/jsx-indent-props': [ 'error', 'tab' ],
+		'react/jsx-key': 'error',
+		'react/jsx-tag-spacing': 'error',
+		'react/no-children-prop': 'off',
+		'react/prop-types': 'off',
+		'react/react-in-jsx-scope': 'off',
+	},
+};

package/configs/testing.js

@@ -0,0 +1,15 @@
+/**
+ * Based on:
+ * - https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/configs/test-unit.js
+ * - https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/configs/test-e2e.js
+ */
+
+module.exports = {
+	extends: [ 'plugin:jest/recommended' ],
+
+	env: {
+		'jest/globals': true,
+	},
+
+	plugins: [ 'jest' ],
+};

package/configs/typescript.js

@@ -0,0 +1,51 @@
+/**
+ * Based on:
+ * https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/configs/recommended.js
+ */
+
+module.exports = {
+	ignorePatterns: [ '**/*.d.ts' ],
+
+	overrides: [
+		{
+			extends: [
+				'plugin:@typescript-eslint/eslint-recommended',
+				'plugin:@typescript-eslint/recommended-requiring-type-checking',
+				'plugin:@typescript-eslint/strict',
+			],
+
+			files: [ '**/*.ts', '**/*.tsx' ],
+
+			parser: '@typescript-eslint/parser',
+
+			rules: {
+				// TypeScript `any` type must not be used. This is a warning in the base
+				// config, and is elevated to an error here.
+				'@typescript-eslint/no-explicit-any': 'error',
+
+				// Don't require redundant JSDoc types in TypeScript files.
+				'jsdoc/require-param-type': 'off',
+				'jsdoc/require-returns-type': 'off',
+
+				// Use TypeScript-specific rules.
+				'no-duplicate-imports': 'off',
+				'no-shadow': 'off',
+				'@typescript-eslint/no-duplicate-imports': 'error',
+				'@typescript-eslint/no-shadow': 'error',
+
+				// Handled by TS itself.
+				'no-unused-vars': 'off',
+			},
+		},
+	],
+
+	plugins: [ '@typescript-eslint', 'jsdoc' ],
+
+	settings: {
+		'import/resolver': {
+			node: {
+				extensions: [ '.js', '.jsx', '.ts', '.tsx' ],
+			},
+		},
+	},
+};

package/configs/{weak.js → weak-javascript.js}

@@ -8,9 +8,8 @@
  */
 module.exports = {
 	/**
-	 * Downgrade rules from the base preset to "warning". Do not disable
-	 * rules (set to "off"). If a rule is already set to a warning, do not
-	 * disable it.
+	 * Downgrade rules from the base preset to "warn". Do not disable rules (set
+	 * to "off"). If a rule is already set to a warning, do not disable it.
 	 */
 	rules: {},
 };

package/configs/weak-typescript.js

@@ -6,13 +6,8 @@
  */
 module.exports = {
 	/**
-	 * Downgrade rules from the base preset to "warning". Do not disable
-	 * rules (set to "off"). If a rule is already set to a warning, do not
-	 * disable it.
-	 *
-	 * An example is the `@typescript-eslint/no-explicit-any` rule, which is set
-	 * to `warning` in the base preset (via `@typescript-eslint/recommended`) and
-	 * is intentionally not overridden here.
+	 * Downgrade rules from the base preset to "warn". Do not disable rules (set
+	 * to "off"). If a rule is already set to a warning, do not disable it.
 	 */
 	rules: {},
 };

package/index.js

@@ -1,4 +1,4 @@
 module.exports = {
-	configs: require('./configs'),
-	rules: require('./rules'),
+	configs: require( './configs' ),
+	rules: require( './rules' ),
 };

package/init.js

@@ -1 +1 @@
-require('@rushstack/eslint-patch/modern-module-resolution');
+require( '@rushstack/eslint-patch/modern-module-resolution' );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automattic/eslint-plugin-wpvip",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "ESLint plugin for internal WordPress VIP projects",
   "main": "index.js",
   "scripts": {
@@ -25,17 +25,26 @@
   },
   "homepage": "https://github.com/Automattic/eslint-config-wpvip#readme",
   "dependencies": {
+    "@babel/eslint-parser": "7.21.3",
     "@rushstack/eslint-patch": "1.2.0",
-    "@wordpress/eslint-plugin": "14.1.0",
+    "@typescript-eslint/eslint-plugin": "5.55.0",
+    "@typescript-eslint/parser": "5.55.0",
+    "eslint-plugin-import": "2.27.5",
     "eslint-plugin-jest": "27.2.1",
+    "eslint-plugin-jsdoc": "40.0.2",
     "eslint-plugin-json": "3.1.0",
-    "eslint-plugin-security": "1.7.1"
+    "eslint-plugin-jsx-a11y": "6.7.1",
+    "eslint-plugin-react": "7.32.2",
+    "eslint-plugin-react-hooks": "4.6.0",
+    "eslint-plugin-security": "1.7.1",
+    "globals": "13.20.0"
   },
   "peerDependencies": {
     "eslint": ">=8"
   },
   "devDependencies": {
     "eslint": "8.35.0",
+    "eslint-config-prettier": "8.7.0",
     "eslint-plugin-eslint-plugin": "5.0.8",
     "jest": "29.5.0",
     "prettier": "2.8.4",

package/rules/dependency-group.js

@@ -0,0 +1,263 @@
+/**
+ * From:
+ * https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/rules/dependency-group.js
+ */
+
+/** @typedef {import('estree').Comment} Comment */
+/** @typedef {import('estree').Node} Node */
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Enforce dependencies docblocks formatting',
+			url: 'https://github.com/WordPress/gutenberg/blob/HEAD/packages/eslint-plugin/docs/rules/dependency-group.md',
+		},
+		schema: [],
+		fixable: 'code',
+	},
+	create( context ) {
+		const comments = context.getSourceCode().getAllComments();
+
+		/**
+		 * Locality classification of an import, one of "External",
+		 * "WordPress", "Internal".
+		 *
+		 * @typedef {string} WPPackageLocality
+		 */
+
+		/**
+		 * Object describing a dependency block correction to be made.
+		 *
+		 * @typedef WPDependencyBlockCorrection
+		 *
+		 * @property {Comment} [comment] Comment node on which to replace value,
+		 *                               if one can be salvaged.
+		 * @property {string}  value     Expected comment node value.
+		 */
+
+		/**
+		 * Given a desired locality, generates the expected comment node value
+		 * property.
+		 *
+		 * @param {WPPackageLocality} locality Desired package locality.
+		 *
+		 * @return {string} Expected comment node value.
+		 */
+		function getCommentValue( locality ) {
+			return `*\n * ${ locality } dependencies\n `;
+		}
+
+		/**
+		 * Given an import source string, returns the locality classification
+		 * of the import sort.
+		 *
+		 * @param {string} source Import source string.
+		 *
+		 * @return {WPPackageLocality} Package locality.
+		 */
+		function getPackageLocality( source ) {
+			if ( source.startsWith( '.' ) ) {
+				return 'Internal';
+			} else if ( source.startsWith( '@wordpress/' ) ) {
+				return 'WordPress';
+			}
+
+			return 'External';
+		}
+
+		/**
+		 * Returns true if the given comment node satisfies a desired locality,
+		 * or false otherwise.
+		 *
+		 * @param {Comment}           node     Comment node to check.
+		 * @param {WPPackageLocality} locality Desired package locality.
+		 *
+		 * @return {boolean} Whether comment node satisfies locality.
+		 */
+		function isLocalityDependencyBlock( node, locality ) {
+			const { type, value } = node;
+			if ( type !== 'Block' ) {
+				return false;
+			}
+
+			// Tolerances:
+			// - Normalize `/**` and `/*`
+			// - Case insensitive "Dependencies" vs. "dependencies"
+			// - Ending period
+			// - "Node" dependencies as an alias for External.
+
+			if ( locality === 'External' ) {
+				locality = '(External|Node)';
+			}
+
+			// eslint-disable-next-line security/detect-non-literal-regexp
+			const pattern = new RegExp(
+				`^\\*?\\n \\* ${ locality } dependencies\\.?\\n $`,
+				'i',
+			);
+			return pattern.test( value );
+		}
+
+		/**
+		 * Returns true if the given node occurs prior in code to a reference,
+		 * or false otherwise.
+		 *
+		 * @param {Comment} node      Node to test being before reference.
+		 * @param {Node}    reference Node against which to compare.
+		 *
+		 * @return {boolean} Whether node occurs before reference.
+		 */
+		function isBefore( node, reference ) {
+			if ( ! node.range || ! reference.range ) {
+				return false;
+			}
+
+			return node.range[ 0 ] < reference.range[ 0 ];
+		}
+
+		/**
+		 * Tests source comments to determine whether a comment exists which
+		 * satisfies the desired locality. If a match is found and requires no
+		 * updates, the function returns undefined. Otherwise, it will return
+		 * a WPDependencyBlockCorrection object describing a correction.
+		 *
+		 * @param {Node}              node     Node to test.
+		 * @param {WPPackageLocality} locality Desired package locality.
+		 *
+		 * @return {WPDependencyBlockCorrection | undefined} Correction, if applicable.
+		 */
+		function getDependencyBlockCorrection( node, locality ) {
+			const value = getCommentValue( locality );
+
+			for ( const comment of comments ) {
+				if ( ! isBefore( comment, node ) ) {
+					// Exhausted options.
+					break;
+				}
+
+				if ( ! isLocalityDependencyBlock( comment, locality ) ) {
+					// Not usable (either not an block comment, or not one
+					// matching a tolerable pattern).
+					continue;
+				}
+
+				if ( comment.value === value ) {
+					// No change needed. (OK)
+					return;
+				}
+
+				// Found a comment needing correction.
+				return { comment, value };
+			}
+
+			return { value };
+		}
+
+		return {
+			/**
+			 * @param {import('estree').Program} node Program node.
+			 */
+			Program( node ) {
+				/**
+				 * The set of package localities which have been reported for
+				 * the current program. Each locality is reported at most one
+				 * time, since otherwise the fixer would insert a comment
+				 * block for each individual import statement.
+				 *
+				 * @type {Set<WPPackageLocality>}
+				 */
+				const verified = new Set();
+
+				/**
+				 * Nodes to check for violations associated with module import,
+				 * an array of tuples of the node and its import source string.
+				 *
+				 * @type {Array<[Node,string]>}
+				 */
+				const candidates = [];
+
+				// Since we only care to enforce imports which occur at the
+				// top-level scope, match on Program and test its children,
+				// rather than matching the import nodes directly.
+				node.body.forEach( ( child ) => {
+					/** @type {string} */
+					let source;
+					switch ( child.type ) {
+						case 'ImportDeclaration':
+							source = /** @type {string} */ (
+								child.source.value
+							);
+							candidates.push( [ child, source ] );
+							break;
+
+						case 'VariableDeclaration':
+							child.declarations.forEach( ( declaration ) => {
+								const { init } = declaration;
+								if (
+									! init ||
+									init.type !== 'CallExpression' ||
+									/** @type {import('estree').CallExpression} */ (
+										init
+									).callee.type !== 'Identifier' ||
+									/** @type {import('estree').Identifier} */ (
+										init.callee
+									).name !== 'require'
+								) {
+									return;
+								}
+
+								const { arguments: args } = init;
+								if (
+									args.length === 1 &&
+									args[ 0 ].type === 'Literal' &&
+									typeof args[ 0 ].value === 'string'
+								) {
+									source = args[ 0 ].value;
+									candidates.push( [ child, source ] );
+								}
+							} );
+					}
+				} );
+
+				for ( const [ child, source ] of candidates ) {
+					const locality = getPackageLocality( source );
+					if ( verified.has( locality ) ) {
+						continue;
+					}
+
+					// Avoid verifying any other imports for the locality,
+					// regardless whether a correction must be made.
+					verified.add( locality );
+
+					// Determine whether a correction must be made.
+					const correction = getDependencyBlockCorrection(
+						child,
+						locality,
+					);
+					if ( ! correction ) {
+						continue;
+					}
+
+					context.report( {
+						node: child,
+						message: `Expected preceding "${ locality } dependencies" comment block`,
+						fix( fixer ) {
+							const { comment, value } = correction;
+							const text = `/*${ value }*/`;
+							if ( comment && comment.range ) {
+								return fixer.replaceTextRange(
+									comment.range,
+									text,
+								);
+							}
+
+							return fixer.insertTextBefore( child, text + '\n' );
+						},
+					} );
+				}
+			},
+		};
+	},
+};

package/rules/index.js

@@ -1,4 +1,9 @@
+/**
+ * Custom ESLint rules
+ */
 module.exports = {
-	// Custom ESLint rules
-	'no-async-foreach': require('./no-async-foreach'),
+	'dependency-group': require( './dependency-group' ),
+	'no-async-foreach': require( './no-async-foreach' ),
+	'no-unguarded-get-range-at': require( './no-unguarded-get-range-at' ),
+	'no-unused-vars-before-return': require( './no-unused-vars-before-return' ),
 };

package/rules/no-async-foreach.js

@@ -8,26 +8,27 @@
  */
 
 module.exports = {
-	create(context) {
+	create( context ) {
 		return {
-			ExpressionStatement(node) {
+			ExpressionStatement( node ) {
 				const { callee } = node.expression;
-				if (!callee || !callee.property || !callee.property.name)
+				if ( ! callee || ! callee.property || ! callee.property.name ) {
 					return;
-				if (callee.property.name === 'forEach') {
+				}
+				if ( callee.property.name === 'forEach' ) {
 					const functionArguments = node.expression.arguments.find(
-						(exp) => {
+						( exp ) => {
 							return (
 								exp.type === 'ArrowFunctionExpression' ||
 								exp.type === 'FunctionExpression'
 							);
-						}
+						},
 					);
-					if (functionArguments) {
-						if (functionArguments.async) {
+					if ( functionArguments ) {
+						if ( functionArguments.async ) {
 							context.report(
 								node,
-								'Avoid passing an async function to Array.prototype.forEach'
+								'Avoid passing an async function to Array.prototype.forEach',
 							);
 						}
 					}

package/rules/no-unguarded-get-range-at.js

@@ -0,0 +1,23 @@
+/**
+ * From:
+ * https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/rules/no-unguarded-get-range-at.js
+ */
+
+module.exports = {
+	meta: {
+		type: 'problem',
+		schema: [],
+	},
+	create( context ) {
+		return {
+			'CallExpression[callee.object.callee.property.name="getSelection"][callee.property.name="getRangeAt"]'(
+				node,
+			) {
+				context.report( {
+					node,
+					message: 'Avoid unguarded getRangeAt',
+				} );
+			},
+		};
+	},
+};

package/rules/no-unused-vars-before-return.js

@@ -0,0 +1,162 @@
+/**
+ * From:
+ * https://github.com/WordPress/gutenberg/blob/%40wordpress/eslint-plugin%4014.1.0/packages/eslint-plugin/rules/no-unused-vars-before-return.js
+ */
+
+/** @typedef {import('eslint').Scope.Scope} ESLintScope */
+/** @typedef {import('eslint').Rule.RuleContext} ESLintRuleContext */
+/** @typedef {import('estree').Node} ESTreeNode */
+
+/**
+ * Mapping of function scope objects to a set of identified JSX identifiers
+ * within that scope.
+ *
+ * @type {WeakMap<ESLintScope,Set<ESTreeNode>>}
+ */
+const FUNCTION_SCOPE_JSX_IDENTIFIERS = new WeakMap();
+
+/**
+ * Returns the closest function scope for the current ESLint context object, or
+ * undefined if it cannot be determined.
+ *
+ * @param {ESLintRuleContext} context ESLint context object.
+ *
+ * @return {ESLintScope|undefined} Function scope, if known.
+ */
+function getClosestFunctionScope( context ) {
+	let functionScope = context.getScope();
+	while ( functionScope.type !== 'function' && functionScope.upper ) {
+		functionScope = functionScope.upper;
+	}
+
+	return functionScope;
+}
+
+module.exports = /** @type {import('eslint').Rule} */ ( {
+	meta: {
+		type: 'problem',
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					excludePattern: {
+						type: 'string',
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+	},
+	/**
+	 * @param {ESLintRuleContext} context Rule context.
+	 */
+	create( context ) {
+		const options = context.options[ 0 ] || {};
+		const { excludePattern } = options;
+
+		/**
+		 * Given an Espree VariableDeclarator node, returns true if the node
+		 * can be exempted from consideration as unused, or false otherwise. A
+		 * node can be exempt if it destructures to multiple variables, since
+		 * those other variables may be used prior to the return statement. A
+		 * future enhancement could validate that they are in-fact referenced.
+		 *
+		 * @param {Object} node Node to test.
+		 *
+		 * @return {boolean} Whether declarator is emempt from consideration.
+		 */
+		function isExemptObjectDestructureDeclarator( node ) {
+			return (
+				node.id.type === 'ObjectPattern' &&
+				node.id.properties.length > 1
+			);
+		}
+
+		return {
+			JSXIdentifier( node ) {
+				// Currently, a scope's variable references does not include JSX
+				// identifiers. Account for this by visiting JSX identifiers
+				// first, and tracking them in a map per function scope, which
+				// is later merged with the known variable references.
+				const functionScope = getClosestFunctionScope( context );
+				if ( ! functionScope ) {
+					return;
+				}
+
+				if ( ! FUNCTION_SCOPE_JSX_IDENTIFIERS.has( functionScope ) ) {
+					FUNCTION_SCOPE_JSX_IDENTIFIERS.set(
+						functionScope,
+						new Set(),
+					);
+				}
+
+				FUNCTION_SCOPE_JSX_IDENTIFIERS.get( functionScope ).add( node );
+			},
+			'ReturnStatement:exit'( node ) {
+				const functionScope = getClosestFunctionScope( context );
+				if ( ! functionScope ) {
+					return;
+				}
+
+				for ( const variable of functionScope.variables ) {
+					const declaratorCandidate = variable.defs.find( ( def ) => {
+						return (
+							def.node.type === 'VariableDeclarator' &&
+							// Allow declarations which are not initialized.
+							def.node.init &&
+							// Target function calls as "expensive".
+							def.node.init.type === 'CallExpression' &&
+							// Allow unused if part of an object destructuring.
+							! isExemptObjectDestructureDeclarator( def.node ) &&
+							// Only target assignments preceding `return`.
+							def.node.range[ 1 ] < node.range[ 1 ]
+						);
+					} );
+
+					if ( ! declaratorCandidate ) {
+						continue;
+					}
+
+					if (
+						excludePattern !== undefined &&
+						// eslint-disable-next-line security/detect-non-literal-regexp
+						new RegExp( excludePattern ).test(
+							declaratorCandidate.node.init.callee.name,
+						)
+					) {
+						continue;
+					}
+
+					// The first entry in `references` is the declaration
+					// itself, which can be ignored.
+					const identifiers = variable.references
+						.slice( 1 )
+						.map( ( reference ) => reference.identifier );
+
+					// Merge with any JSX identifiers in scope, if any.
+					if ( FUNCTION_SCOPE_JSX_IDENTIFIERS.has( functionScope ) ) {
+						const jsxIdentifiers =
+							FUNCTION_SCOPE_JSX_IDENTIFIERS.get( functionScope );
+
+						identifiers.push( ...jsxIdentifiers );
+					}
+
+					const isUsedBeforeReturn = identifiers.some(
+						( identifier ) =>
+							identifier.range[ 1 ] < node.range[ 1 ],
+					);
+
+					if ( isUsedBeforeReturn ) {
+						continue;
+					}
+
+					context.report(
+						declaratorCandidate.node,
+						'Variables should not be assigned until just prior its first reference. ' +
+							'An early return statement may leave this variable unused.',
+					);
+				}
+			},
+		};
+	},
+} );