@wordpress/eslint-plugin 18.1.0 → 19.0.1

package/README.md

@@ -10,7 +10,7 @@ Install the module
 npm install @wordpress/eslint-plugin --save-dev
 ```
 
-**Note**: This package requires `node` 14.0.0 or later, and `npm` 6.14.4 or later. It is not compatible with older versions.
+**Note**: This package requires Node.js version with long-term support status (check [Active LTS or Maintenance LTS releases](https://nodejs.org/en/about/previous-releases)). It is not compatible with older versions.
 
 ## Usage
 
@@ -69,25 +69,26 @@ The granular rulesets will not define any environment globals. As such, if they
 
 ### Rules
 
-| Rule                                                                                                                                                                 | Description                                                                                    | Recommended |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | ----------- |
-| [data-no-store-string-literals](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/data-no-store-string-literals.md)                 | Discourage passing string literals to reference data stores                                    |             |
-| [dependency-group](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/dependency-group.md)                                           | Enforce dependencies docblocks formatting                                                      | ✓           |
-| [is-gutenberg-plugin](docs/rules/is-gutenberg-plugin.md)                                                                                                             | Governs the use of the `process.env.IS_GUTENBERG_PLUGIN` constant                              | ✓           |
-| [no-base-control-with-label-without-id](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/no-base-control-with-label-without-id.md) | Disallow the usage of BaseControl component with a label prop set but omitting the id property | ✓           |
-| [no-unguarded-get-range-at](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/no-unguarded-get-range-at.md)                         | Disallow the usage of unguarded `getRangeAt` calls                                             | ✓           |
-| [no-unsafe-wp-apis](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/no-unsafe-wp-apis.md)                                         | Disallow the usage of unsafe APIs from `@wordpress/*` packages                                 | ✓           |
-| [no-unused-vars-before-return](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/no-unused-vars-before-return.md)                   | Disallow assigning variable values if unused before a return                                   | ✓           |
-| [react-no-unsafe-timeout](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/react-no-unsafe-timeout.md)                             | Disallow unsafe `setTimeout` in component                                                      |             |
-| [valid-sprintf](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/valid-sprintf.md)                                                 | Enforce valid sprintf usage                                                                    | ✓           |
-| [i18n-ellipsis](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-ellipsis.md)                                                 | Disallow using three dots in translatable strings                                              | ✓           |
-| [i18n-no-collapsible-whitespace](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-no-collapsible-whitespace.md)               | Disallow collapsible whitespace in translatable strings                                        | ✓           |
-| [i18n-no-placeholders-only](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-no-placeholders-only.md)                         | Prevent using only placeholders in translatable strings                                        | ✓           |
-| [i18n-no-variables](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-no-variables.md)                                         | Enforce string literals as translation function arguments                                      | ✓           |
-| [i18n-text-domain](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-text-domain.md)                                           | Enforce passing valid text domains                                                             | ✓           |
-| [i18n-translator-comments](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-translator-comments.md)                           | Enforce adding translator comments                                                             | ✓           |
-| [i18n-no-flanking-whitespace](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-no-flanking-whitespace.md)                     | Disallow leading or trailing whitespace in translatable strings                                |             |
-| [i18n-hyphenated-range](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-hyphenated-range.md)                                 | Disallow hyphenated numerical ranges in translatable strings                                   |             |
+| Rule                                                                                                                                                                 | Description                                                                                     | Recommended |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | ----------- |
+| [data-no-store-string-literals](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/data-no-store-string-literals.md)                 | Discourage passing string literals to reference data stores.                                    |             |
+| [dependency-group](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/dependency-group.md)                                           | Enforce dependencies docblocks formatting.                                                      | ✓           |
+| [i18n-ellipsis](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-ellipsis.md)                                                 | Disallow using three dots in translatable strings.                                              | ✓           |
+| [i18n-hyphenated-range](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-hyphenated-range.md)                                 | Disallow hyphenated numerical ranges in translatable strings.                                   |             |
+| [i18n-no-collapsible-whitespace](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-no-collapsible-whitespace.md)               | Disallow collapsible whitespace in translatable strings.                                        | ✓           |
+| [i18n-no-flanking-whitespace](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-no-flanking-whitespace.md)                     | Disallow leading or trailing whitespace in translatable strings.                                |             |
+| [i18n-no-placeholders-only](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-no-placeholders-only.md)                         | Prevent using only placeholders in translatable strings.                                        | ✓           |
+| [i18n-no-variables](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-no-variables.md)                                         | Enforce string literals as translation function arguments.                                      | ✓           |
+| [i18n-text-domain](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-text-domain.md)                                           | Enforce passing valid text domains.                                                             | ✓           |
+| [i18n-translator-comments](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/i18n-translator-comments.md)                           | Enforce adding translator comments.                                                             | ✓           |
+| [no-base-control-with-label-without-id](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/no-base-control-with-label-without-id.md) | Disallow the usage of BaseControl component with a label prop set but omitting the id property. | ✓           |
+| [no-unguarded-get-range-at](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/no-unguarded-get-range-at.md)                         | Disallow the usage of unguarded `getRangeAt` calls.                                             | ✓           |
+| [no-unsafe-wp-apis](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/no-unsafe-wp-apis.md)                                         | Disallow the usage of unsafe APIs from `@wordpress/*` packagesl                                 | ✓           |
+| [no-unused-vars-before-return](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/no-unused-vars-before-return.md)                   | Disallow assigning variable values if unused before a return.                                   | ✓           |
+| [no-wp-process-env](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/no-wp-process-env.md)                                         | Disallow legacy usage of WordPress variables via `process.env` like `process.env.SCRIPT_DEBUG`. | ✓           |
+| [react-no-unsafe-timeout](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/react-no-unsafe-timeout.md)                             | Disallow unsafe `setTimeout` in component.                                                      |             |
+| [valid-sprintf](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/valid-sprintf.md)                                                 | Enforce valid sprintf usage.                                                                    | ✓           |
+| [wp-global-usage](https://github.com/WordPress/gutenberg/tree/HEAD/packages/eslint-plugin/docs/rules/wp-global-usage.md)                                             | Enforce correct usage of WordPress globals like `globalThis.SCRIPT_DEBUG`.                      |             |
 
 ### Legacy
 

package/configs/custom.js

@@ -7,6 +7,7 @@ module.exports = {
 		'@wordpress/no-global-active-element': 'error',
 		'@wordpress/no-global-get-selection': 'error',
 		'@wordpress/no-unsafe-wp-apis': 'error',
+		'@wordpress/no-wp-process-env': 'error',
 	},
 	overrides: [
 		{

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wordpress/eslint-plugin",
-	"version": "18.1.0",
+	"version": "19.0.1",
 	"description": "ESLint plugin for WordPress development.",
 	"author": "The WordPress Contributors",
 	"license": "GPL-2.0-or-later",
@@ -20,8 +20,8 @@
 		"url": "https://github.com/WordPress/gutenberg/issues"
 	},
 	"engines": {
-		"node": ">=14",
-		"npm": ">=6.14.4"
+		"node": ">=18.12.0",
+		"npm": ">=8.19.2"
 	},
 	"files": [
 		"configs",
@@ -34,8 +34,8 @@
 		"@babel/eslint-parser": "^7.16.0",
 		"@typescript-eslint/eslint-plugin": "^6.4.1",
 		"@typescript-eslint/parser": "^6.4.1",
-		"@wordpress/babel-preset-default": "^7.42.0",
-		"@wordpress/prettier-config": "^3.15.0",
+		"@wordpress/babel-preset-default": "^8.0.1",
+		"@wordpress/prettier-config": "^4.0.1",
 		"cosmiconfig": "^7.0.0",
 		"eslint-config-prettier": "^8.3.0",
 		"eslint-plugin-import": "^2.25.2",
@@ -66,5 +66,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "42f38f287506a6b3ed8ccba839b18ad066821044"
+	"gitHead": "0e973525f7787401b5a544e0727774d52a78639f"
 }

package/rules/__tests__/no-wp-process-env.js

@@ -0,0 +1,62 @@
+/**
+ * External dependencies
+ */
+import { RuleTester } from 'eslint';
+
+/**
+ * Internal dependencies
+ */
+import rule from '../no-wp-process-env';
+
+const ruleTester = new RuleTester( {
+	parserOptions: {
+		ecmaVersion: 6,
+	},
+} );
+
+ruleTester.run( 'no-wp-process-env', rule, {
+	valid: [
+		{ code: 'process.env.NODE_ENV' },
+		{ code: 'process.env.WHATEVER' },
+		{ code: 'process.env[foo]' },
+		{ code: 'process.env["foo"]' },
+		{ code: `process['env']["foo"]` },
+		{ code: "process['env'][`foo`]" },
+		{ code: "process.env[`${ '' }IS_GUTENBERG_PLUGIN`]" },
+		{ code: `a.b.c` },
+		{ code: `x['y']['z']` },
+		{ code: `d[e][f]` },
+		{ code: `process[ (()=>'env')() ][ {_:'SCRIPT_DEBUG'}['_'] ]` },
+	],
+	invalid: [
+		{
+			code: 'process.env.IS_GUTENBERG_PLUGIN',
+			errors: [ { messageId: 'useGlobalThis' } ],
+			output: 'globalThis.IS_GUTENBERG_PLUGIN',
+		},
+		{
+			code: 'process.env.SCRIPT_DEBUG',
+			errors: [ { messageId: 'useGlobalThis' } ],
+			output: 'globalThis.SCRIPT_DEBUG',
+		},
+		{
+			code: 'process.env.IS_WORDPRESS_CORE',
+			errors: [ { messageId: 'useGlobalThis' } ],
+			output: 'globalThis.IS_WORDPRESS_CORE',
+		},
+		{
+			code: `process['env']["IS_GUTENBERG_PLUGIN"]`,
+			errors: [ { messageId: 'useGlobalThis' } ],
+			output: 'globalThis.IS_GUTENBERG_PLUGIN',
+		},
+		{
+			code: 'process[`env`][`IS_GUTENBERG_PLUGIN`]',
+			errors: [ { messageId: 'useGlobalThis' } ],
+			output: 'globalThis.IS_GUTENBERG_PLUGIN',
+		},
+		{
+			code: 'process.env.GUTENBERG_PHASE',
+			errors: [ { messageId: 'noGutenbergPhase' } ],
+		},
+	],
+} );

package/rules/__tests__/wp-global-usage.js

@@ -0,0 +1,129 @@
+/**
+ * External dependencies
+ */
+import { RuleTester } from 'eslint';
+
+/**
+ * Internal dependencies
+ */
+import rule from '../wp-global-usage';
+
+const ruleTester = new RuleTester( {
+	parserOptions: {
+		ecmaVersion: 6,
+	},
+} );
+
+ruleTester.run( 'wp-global-usage', rule, {
+	valid: [
+		{ code: "const text = 'SCRIPT_DEBUG'" },
+		{ code: 'const config = { SCRIPT_DEBUG: true }' },
+		{ code: 'if ( globalThis.IS_GUTENBERG_PLUGIN ) {}' },
+		{ code: 'if ( globalThis.IS_WORDPRESS_CORE ) {}' },
+		{ code: 'if ( globalThis.SCRIPT_DEBUG ) {}' },
+		{ code: 'if ( process.env.SCRIPT_DEBUG ) {}' },
+		{ code: 'if ( ! globalThis.IS_GUTENBERG_PLUGIN ) {}' },
+		{
+			// Ensure whitespace is ok.
+			code: `if (
+				globalThis.
+				IS_GUTENBERG_PLUGIN
+			) {}`,
+		},
+		{ code: 'const test = globalThis.IS_GUTENBERG_PLUGIN ? foo : bar' },
+		{ code: 'const test = ! globalThis.IS_GUTENBERG_PLUGIN ? bar : foo' },
+		{
+			// Ensure whitespace is ok.
+			code: `const test = ! globalThis.
+				IS_GUTENBERG_PLUGIN ? bar : foo`,
+		},
+	],
+	invalid: [
+		{
+			code: 'if ( IS_GUTENBERG_PLUGIN ) {}',
+			errors: [
+				{
+					messageId: 'usedWithoutGlobalThis',
+					data: { name: 'IS_GUTENBERG_PLUGIN' },
+				},
+			],
+			output: 'if ( globalThis.IS_GUTENBERG_PLUGIN ) {}',
+		},
+		{
+			code: 'if ( window.IS_GUTENBERG_PLUGIN ) {}',
+			errors: [
+				{
+					messageId: 'usedWithoutGlobalThis',
+					data: { name: 'IS_GUTENBERG_PLUGIN' },
+				},
+			],
+			output: 'if ( globalThis.IS_GUTENBERG_PLUGIN ) {}',
+		},
+		{
+			code: 'if ( SCRIPT_DEBUG ) {}',
+			errors: [
+				{
+					messageId: 'usedWithoutGlobalThis',
+					data: { name: 'SCRIPT_DEBUG' },
+				},
+			],
+			output: 'if ( globalThis.SCRIPT_DEBUG ) {}',
+		},
+		{
+			code: 'if ( IS_WORDPRESS_CORE ) {}',
+			errors: [
+				{
+					messageId: 'usedWithoutGlobalThis',
+					data: { name: 'IS_WORDPRESS_CORE' },
+				},
+			],
+			output: 'if ( globalThis.IS_WORDPRESS_CORE ) {}',
+		},
+		{
+			code: "if ( window[ 'IS_GUTENBERG_PLUGIN' ] ) {}",
+			errors: [
+				{
+					messageId: 'usedWithoutGlobalThis',
+					data: { name: 'IS_GUTENBERG_PLUGIN' },
+				},
+			],
+			output: 'if ( globalThis.IS_GUTENBERG_PLUGIN ) {}',
+		},
+		{
+			code: 'if ( true ) { globalThis.IS_GUTENBERG_PLUGIN === 2 }',
+			errors: [
+				{
+					messageId: 'usedOutsideConditional',
+					data: { name: 'IS_GUTENBERG_PLUGIN' },
+				},
+			],
+		},
+		{
+			code: 'if ( globalThis.IS_GUTENBERG_PLUGIN === 2 ) {}',
+			errors: [
+				{
+					messageId: 'usedOutsideConditional',
+					data: { name: 'IS_GUTENBERG_PLUGIN' },
+				},
+			],
+		},
+		{
+			code: 'if ( true || globalThis.IS_GUTENBERG_PLUGIN === 2 ) {}',
+			errors: [
+				{
+					messageId: 'usedOutsideConditional',
+					data: { name: 'IS_GUTENBERG_PLUGIN' },
+				},
+			],
+		},
+		{
+			code: 'const isFeatureActive = globalThis.IS_GUTENBERG_PLUGIN;',
+			errors: [
+				{
+					messageId: 'usedOutsideConditional',
+					data: { name: 'IS_GUTENBERG_PLUGIN' },
+				},
+			],
+		},
+	],
+} );

package/rules/no-wp-process-env.js

@@ -0,0 +1,93 @@
+const NAMES = new Set(
+	/** @type {const} */ ( [
+		'GUTENBERG_PHASE',
+		'IS_GUTENBERG_PLUGIN',
+		'IS_WORDPRESS_CORE',
+		'SCRIPT_DEBUG',
+	] )
+);
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: 'problem',
+		schema: [],
+		fixable: true,
+		messages: {
+			useGlobalThis:
+				'`{{ name }}` should not be accessed from process.env. Use `globalThis.{{name}}`.',
+			noGutenbergPhase:
+				'The GUTENBERG_PHASE environement variable is no longer available. Use IS_GUTENBERG_PLUGIN (boolean).',
+		},
+	},
+	create( context ) {
+		return {
+			MemberExpression( node ) {
+				const propertyNameOrValue = memberProperty( node );
+				if ( ! propertyNameOrValue ) {
+					return;
+				}
+				if ( ! NAMES.has( propertyNameOrValue ) ) {
+					return;
+				}
+
+				if ( node.object.type !== 'MemberExpression' ) {
+					return;
+				}
+
+				const obj = node.object;
+				const envCandidateProperty = memberProperty( obj );
+				if ( envCandidateProperty !== 'env' ) {
+					return;
+				}
+
+				if (
+					obj.object.type !== 'Identifier' ||
+					obj.object.name !== 'process'
+				) {
+					return;
+				}
+
+				if ( propertyNameOrValue === 'GUTENBERG_PHASE' ) {
+					context.report( {
+						node,
+						messageId: 'noGutenbergPhase',
+					} );
+					return;
+				}
+
+				context.report( {
+					node,
+					messageId: 'useGlobalThis',
+					data: { name: propertyNameOrValue },
+					fix( fixer ) {
+						return fixer.replaceText(
+							node,
+							`globalThis.${ propertyNameOrValue }`
+						);
+					},
+				} );
+			},
+		};
+	},
+};
+
+/**
+ * @param {import('estree').MemberExpression} node
+ */
+function memberProperty( node ) {
+	switch ( node.property.type ) {
+		case 'Identifier':
+			return node.property.name;
+		case 'Literal':
+			return node.property.value;
+		case 'TemplateLiteral':
+			if (
+				! node.property.expressions.length &&
+				node.property.quasis.length === 1
+			) {
+				return node.property.quasis[ 0 ].value.raw;
+			}
+	}
+	return null;
+}

package/rules/wp-global-usage.js

@@ -0,0 +1,170 @@
+const NAMES = new Set(
+	/** @type {const} */ ( [
+		'IS_GUTENBERG_PLUGIN',
+		'IS_WORDPRESS_CORE',
+		'SCRIPT_DEBUG',
+	] )
+);
+
+/**
+ * Tests whether the IS_GUTENBERG_PLUGIN variable is used as the condition for an
+ * if statement or ternary, triggering a violation if not.
+ *
+ * @example
+ * ```js
+ * // good
+ * if ( process.env.IS_GUTENBERG_PLUGIN ) {
+ *
+ * // bad
+ * const isFeatureActive = process.env.IS_GUTENBERG_PLUGIN;
+ * ```
+ *
+ * @param {import('estree').Node} node The IS_GUTENBERG_PLUGIN identifier node.
+ */
+function isUsedInConditional( node ) {
+	/** @type {import('estree').Node|undefined} */
+	let current = node;
+
+	// Simple negation is the only expresion allowed in the conditional:
+	// if ( ! globalThis.SCRIPT_DEBUG ) {}
+	// const D = ! globalThis.SCRIPT_DEBUG ? 'yes' : 'no';
+	if (
+		current.parent.type === 'UnaryExpression' &&
+		current.parent.operator === '!'
+	) {
+		current = current.parent;
+	}
+
+	// Check if the current node is the test of a conditional
+
+	/** @type {import('estree').Node|undefined} */
+	const parent = current.parent;
+
+	if ( parent.type === 'IfStatement' && parent.test === current ) {
+		return true;
+	}
+	if ( parent.type === 'ConditionalExpression' && parent.test === current ) {
+		return true;
+	}
+	return false;
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: 'problem',
+		schema: [],
+		fixable: true,
+		messages: {
+			usedOutsideConditional:
+				'`globalThis.{{ name }}` should only be used as the condition in an if statement or ternary expression.',
+			usedWithoutGlobalThis:
+				'`{{ name }}` should not be used directly. Use `globalThis.{{ name }}`.',
+		},
+	},
+	create( context ) {
+		return {
+			Identifier( node ) {
+				// Bypass any identifiers with a node name different to `IS_GUTENBERG_PLUGIN`.
+				if ( ! NAMES.has( node.name ) ) {
+					return;
+				}
+
+				if ( node.parent.type === 'Property' ) {
+					return;
+				}
+
+				if ( node.parent.type !== 'MemberExpression' ) {
+					context.report( {
+						node,
+						messageId: 'usedWithoutGlobalThis',
+						data: { name: node.name },
+						fix( fixer ) {
+							return fixer.replaceText(
+								node,
+								`globalThis.${ node.name }`
+							);
+						},
+					} );
+
+					if ( ! isUsedInConditional( node ) ) {
+						context.report( {
+							node,
+							messageId: 'usedOutsideConditional',
+							data: {
+								name: node.name,
+							},
+						} );
+					}
+					return;
+				}
+
+				if (
+					node.parent.object.type === 'Identifier' &&
+					node.parent.object.name !== 'globalThis'
+				) {
+					context.report( {
+						node,
+						messageId: 'usedWithoutGlobalThis',
+						data: { name: node.name },
+						fix( fixer ) {
+							if ( node.parent.object.name === 'window' ) {
+								return fixer.replaceText(
+									node.parent,
+									`globalThis.${ node.name }`
+								);
+							}
+						},
+					} );
+				} else if ( ! isUsedInConditional( node.parent ) ) {
+					context.report( {
+						node,
+						messageId: 'usedOutsideConditional',
+						data: {
+							name: node.name,
+						},
+					} );
+				}
+			},
+
+			// Check for literals, e.g. when 'IS_GUTENBERG_PLUGIN' is used as a string via something like 'window[ 'IS_GUTENBERG_PLUGIN' ]'.
+			Literal( node ) {
+				// Bypass any identifiers with a node value different to `IS_GUTENBERG_PLUGIN`.
+				if ( ! NAMES.has( node.value ) ) {
+					return;
+				}
+
+				if ( node.parent.type !== 'MemberExpression' ) {
+					return;
+				}
+
+				if (
+					node.parent.object.type === 'Identifier' &&
+					node.parent.object.name !== 'globalThis'
+				) {
+					context.report( {
+						node,
+						messageId: 'usedWithoutGlobalThis',
+						data: { name: node.value },
+						fix( fixer ) {
+							if ( node.parent.object.name === 'window' ) {
+								return fixer.replaceText(
+									node.parent,
+									`globalThis.${ node.value }`
+								);
+							}
+						},
+					} );
+				} else if ( ! isUsedInConditional( node.parent ) ) {
+					context.report( {
+						node,
+						messageId: 'usedOutsideConditional',
+						data: {
+							name: node.value,
+						},
+					} );
+				}
+			},
+		};
+	},
+};

package/rules/__tests__/is-gutenberg-plugin.js

@@ -1,65 +0,0 @@
-/**
- * External dependencies
- */
-import { RuleTester } from 'eslint';
-
-/**
- * Internal dependencies
- */
-import rule from '../is-gutenberg-plugin';
-
-const ruleTester = new RuleTester( {
-	parserOptions: {
-		ecmaVersion: 6,
-	},
-} );
-
-const ERROR_MESSAGE =
-	'The `process.env.IS_GUTENBERG_PLUGIN` constant should only be used as the condition in an if statement or ternary expression.';
-
-ruleTester.run( 'is-gutenberg-plugin', rule, {
-	valid: [
-		{ code: `if ( process.env.IS_GUTENBERG_PLUGIN ) {}` },
-		{ code: `if ( ! process.env.IS_GUTENBERG_PLUGIN ) {}` },
-		{
-			// Ensure whitespace is ok.
-			code: `if (
-				process.env.
-				IS_GUTENBERG_PLUGIN
-			) {}`,
-		},
-		{ code: `const test = process.env.IS_GUTENBERG_PLUGIN ? foo : bar` },
-		{ code: `const test = ! process.env.IS_GUTENBERG_PLUGIN ? bar : foo` },
-		{
-			// Ensure whitespace is ok.
-			code: `const test = ! process.env.
-				IS_GUTENBERG_PLUGIN ? bar : foo`,
-		},
-	],
-	invalid: [
-		{
-			code: `if ( IS_GUTENBERG_PLUGIN ) {}`,
-			errors: [ { message: ERROR_MESSAGE } ],
-		},
-		{
-			code: `if ( window[ 'IS_GUTENBERG_PLUGIN' ] ) {}`,
-			errors: [ { message: ERROR_MESSAGE } ],
-		},
-		{
-			code: `if ( true ) { process.env.IS_GUTENBERG_PLUGIN === 2 }`,
-			errors: [ { message: ERROR_MESSAGE } ],
-		},
-		{
-			code: `if ( process.env.IS_GUTENBERG_PLUGIN === 2 ) {}`,
-			errors: [ { message: ERROR_MESSAGE } ],
-		},
-		{
-			code: `if ( true || process.env.IS_GUTENBERG_PLUGIN === 2 ) {}`,
-			errors: [ { message: ERROR_MESSAGE } ],
-		},
-		{
-			code: `const isFeatureActive = process.env.IS_GUTENBERG_PLUGIN;`,
-			errors: [ { message: ERROR_MESSAGE } ],
-		},
-	],
-} );

package/rules/gutenberg-phase.js

@@ -1,174 +0,0 @@
-/**
- * Traverse up through the chain of parent AST nodes returning the first parent
- * the predicate returns a truthy value for.
- *
- * @param {Object}   sourceNode The AST node to search from.
- * @param {Function} predicate  A predicate invoked for each parent.
- *
- * @return {Object | undefined} The first encountered parent node where the predicate
- *                    returns a truthy value.
- */
-function findParent( sourceNode, predicate ) {
-	if ( ! sourceNode.parent ) {
-		return;
-	}
-
-	if ( predicate( sourceNode.parent ) ) {
-		return sourceNode.parent;
-	}
-
-	return findParent( sourceNode.parent, predicate );
-}
-
-/**
- * Tests whether the GUTENBERG_PHASE variable is accessed via
- * `process.env.GUTENBERG_PHASE`.
- *
- * @example
- * ```js
- * // good
- * if ( process.env.GUTENBERG_PHASE === 2 ) {
- *
- * // bad
- * if ( GUTENBERG_PHASE === 2 ) {
- * ```
- *
- * @param {Object} node    The GUTENBERG_PHASE identifier node.
- * @param {Object} context The eslint context object.
- */
-function testIsAccessedViaProcessEnv( node, context ) {
-	const parent = node.parent;
-
-	if (
-		parent &&
-		parent.type === 'MemberExpression' &&
-		context.getSource( parent ) === 'process.env.GUTENBERG_PHASE'
-	) {
-		return;
-	}
-
-	context.report(
-		node,
-		'The `GUTENBERG_PHASE` constant should be accessed using `process.env.GUTENBERG_PHASE`.'
-	);
-}
-
-/**
- * Tests whether the GUTENBERG_PHASE variable is used in a strict binary
- * equality expression in a comparison with a number, triggering a
- * violation if not.
- *
- * @example
- * ```js
- * // good
- * if ( process.env.GUTENBERG_PHASE === 2 ) {
- *
- * // bad
- * if ( process.env.GUTENBERG_PHASE >= '2' ) {
- * ```
- *
- * @param {Object} node    The GUTENBERG_PHASE identifier node.
- * @param {Object} context The eslint context object.
- */
-function testIsUsedInStrictBinaryExpression( node, context ) {
-	const parent = findParent(
-		node,
-		( candidate ) => candidate.type === 'BinaryExpression'
-	);
-
-	if ( parent ) {
-		const comparisonNode =
-			node.parent.type === 'MemberExpression' ? node.parent : node;
-
-		// Test for process.env.GUTENBERG_PHASE === <number> or <number> === process.env.GUTENBERG_PHASE.
-		const hasCorrectOperator = [ '===', '!==' ].includes( parent.operator );
-		const hasCorrectOperands =
-			( parent.left === comparisonNode &&
-				typeof parent.right.value === 'number' ) ||
-			( parent.right === comparisonNode &&
-				typeof parent.left.value === 'number' );
-
-		if ( hasCorrectOperator && hasCorrectOperands ) {
-			return;
-		}
-	}
-
-	context.report(
-		node,
-		'The `GUTENBERG_PHASE` constant should only be used in a strict equality comparison with a primitive number.'
-	);
-}
-
-/**
- * Tests whether the GUTENBERG_PHASE variable is used as the condition for an
- * if statement, triggering a violation if not.
- *
- * @example
- * ```js
- * // good
- * if ( process.env.GUTENBERG_PHASE === 2 ) {
- *
- * // bad
- * const isFeatureActive = process.env.GUTENBERG_PHASE === 2;
- * ```
- *
- * @param {Object} node    The GUTENBERG_PHASE identifier node.
- * @param {Object} context The eslint context object.
- */
-function testIsUsedInIfOrTernary( node, context ) {
-	const conditionalParent = findParent( node, ( candidate ) =>
-		[ 'IfStatement', 'ConditionalExpression' ].includes( candidate.type )
-	);
-	const binaryParent = findParent(
-		node,
-		( candidate ) => candidate.type === 'BinaryExpression'
-	);
-
-	if (
-		conditionalParent &&
-		binaryParent &&
-		conditionalParent.test &&
-		conditionalParent.test.range[ 0 ] === binaryParent.range[ 0 ] &&
-		conditionalParent.test.range[ 1 ] === binaryParent.range[ 1 ]
-	) {
-		return;
-	}
-
-	context.report(
-		node,
-		'The `GUTENBERG_PHASE` constant should only be used as part of the condition in an if statement or ternary expression.'
-	);
-}
-
-module.exports = {
-	meta: {
-		type: 'problem',
-		schema: [],
-		deprecated: true,
-		replacedBy: '@wordpress/is-gutenberg-plugin',
-	},
-	create( context ) {
-		return {
-			Identifier( node ) {
-				// Bypass any identifiers with a node name different to `GUTENBERG_PHASE`.
-				if ( node.name !== 'GUTENBERG_PHASE' ) {
-					return;
-				}
-
-				testIsAccessedViaProcessEnv( node, context );
-				testIsUsedInStrictBinaryExpression( node, context );
-				testIsUsedInIfOrTernary( node, context );
-			},
-			Literal( node ) {
-				// Bypass any identifiers with a node value different to `GUTENBERG_PHASE`.
-				if ( node.value !== 'GUTENBERG_PHASE' ) {
-					return;
-				}
-
-				if ( node.parent && node.parent.type === 'MemberExpression' ) {
-					testIsAccessedViaProcessEnv( node, context );
-				}
-			},
-		};
-	},
-};

package/rules/is-gutenberg-plugin.js

@@ -1,94 +0,0 @@
-/**
- * Traverse up through the chain of parent AST nodes returning the first parent
- * the predicate returns a truthy value for.
- *
- * @param {Object}   sourceNode The AST node to search from.
- * @param {Function} predicate  A predicate invoked for each parent.
- *
- * @return {Object | undefined} The first encountered parent node where the predicate
- *                    returns a truthy value.
- */
-function findParent( sourceNode, predicate ) {
-	if ( ! sourceNode.parent ) {
-		return;
-	}
-
-	if ( predicate( sourceNode.parent ) ) {
-		return sourceNode.parent;
-	}
-
-	return findParent( sourceNode.parent, predicate );
-}
-
-/**
- * Tests whether the IS_GUTENBERG_PLUGIN variable is used as the condition for an
- * if statement or ternary, triggering a violation if not.
- *
- * @example
- * ```js
- * // good
- * if ( process.env.IS_GUTENBERG_PLUGIN ) {
- *
- * // bad
- * const isFeatureActive = process.env.IS_GUTENBERG_PLUGIN;
- * ```
- *
- * @param {Object} node    The IS_GUTENBERG_PLUGIN identifier node.
- * @param {Object} context The eslint context object.
- */
-function isUsedInConditional( node, context ) {
-	const conditionalParent = findParent( node, ( candidate ) =>
-		[ 'IfStatement', 'ConditionalExpression' ].includes( candidate.type )
-	);
-
-	if ( ! conditionalParent ) {
-		return false;
-	}
-
-	// Allow for whitespace as prettier sometimes breaks this on separate lines.
-	const textRegex = /^\s*!?\s*process\s*\.\s*env\s*\.\s*IS_GUTENBERG_PLUGIN$/;
-	const testSource = context.getSource( conditionalParent.test );
-
-	if ( ! textRegex.test( testSource ) ) {
-		return false;
-	}
-
-	return true;
-}
-
-const ERROR_MESSAGE =
-	'The `process.env.IS_GUTENBERG_PLUGIN` constant should only be used as the condition in an if statement or ternary expression.';
-
-module.exports = {
-	meta: {
-		type: 'problem',
-		schema: [],
-	},
-	create( context ) {
-		return {
-			Identifier( node ) {
-				// Bypass any identifiers with a node name different to `IS_GUTENBERG_PLUGIN`.
-				if ( node.name !== 'IS_GUTENBERG_PLUGIN' ) {
-					return;
-				}
-
-				if ( ! isUsedInConditional( node, context ) ) {
-					context.report( node, ERROR_MESSAGE );
-				}
-			},
-			// Check for literals, e.g. when 'IS_GUTENBERG_PLUGIN' is used as a string via something like 'window[ 'IS_GUTENBERG_PLUGIN' ]'.
-			Literal( node ) {
-				// Bypass any identifiers with a node value different to `IS_GUTENBERG_PLUGIN`.
-				if ( node.value !== 'IS_GUTENBERG_PLUGIN' ) {
-					return;
-				}
-
-				if ( node.parent && node.parent.type === 'MemberExpression' ) {
-					if ( ! isUsedInConditional( node, context ) ) {
-						context.report( node, ERROR_MESSAGE );
-					}
-				}
-			},
-		};
-	},
-};