eslint-config-reverentgeek 6.1.1 → 6.3.0

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(node:*)",
+      "Bash(npm test)",
+      "Bash(npm run lint)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/README.md

@@ -17,68 +17,44 @@ This package is [ReverentGeek's](https://reverentgeek.com/about/) preferred conf
 ```js
 "use strict";
 
-/* eslint-disable-next-line n/no-unpublished-require */
-const rgConfig = require( "eslint-config-reverentgeek" );
+const defineConfig = require( "eslint/config" ).defineConfig; // eslint-disable-line n/no-unpublished-require
+const rg = require( "eslint-config-reverentgeek" ); // eslint-disable-line n/no-extraneous-require
 
-module.exports = [
-	rgConfig.configs.common,
+module.exports = defineConfig( [
 	{
+		extends: [ rg.configs.node ],
 		rules: {
 		}
 	}
-];
+] );
 ```
 
+The _node_ config adds specific support for Node.js and CommonJS modules.
+
 ## Alternative Configs
 
 The _node-esm_ config adds specific support for Node.js and ES modules (`import`/`export`).
 
 ```js
-/* eslint-disable-next-line n/no-unpublished-import */
-import rg from "eslint-config-reverentgeek";
+import { defineConfig } from "eslint/config"; // eslint-disable-line n/no-unpublished-import
+import rg from "eslint-config-reverentgeek"; // eslint-disable-line n/no-extraneous-import
 
-export default [
-	rg.configs["node-esm"],
-	{
-		rules: {
-		}
+export default defineConfig( {
+	extends: [ rg.configs["node-esm"] ],
+	rules: {
 	}
-];
+} );
 ```
 
 The _blog_ config changes the code style to two-spaced indentions, which is better for copying code samples to blog posts.
 
 ```js
-"use strict";
-
-/* eslint-disable-next-line n/no-unpublished-require */
-const rgConfig = require( "eslint-config-reverentgeek" );
-
-module.exports = [
-	rgConfig.configs.browser,
-	rgConfig.configs.blog,
-	{
-		rules: {
-		}
-	}
-];
-```
-
-The _node_ config adds specific support for Node.js and CommonJS modules.
-
-```js
-"use strict";
-
-/* eslint-disable-next-line n/no-unpublished-require */
-const rgConfig = require( "eslint-config-reverentgeek" );
+import { defineConfig } from "eslint/config";
+import rg from "eslint-config-reverentgeek";
 
-module.exports = [
-	rgConfig.configs.node,
-	{
-		rules: {
-		}
-	}
-];
+export default defineConfig( {
+  extends: [ rg.configs.browser, rg.configs.blog ]
+} );
 ```
 
 The _react_ config adds specific support for React, browser, and ES modules (`import`/`export`).
@@ -88,39 +64,29 @@ npm install --save-dev eslint-plugin-react
 ```
 
 ```js
-/* eslint-disable-next-line n/no-unpublished-import */
+import { defineConfig } from "eslint/config";
 import rg from "eslint-config-reverentgeek";
-/* eslint-disable-next-line n/no-unpublished-import */
 import react from "eslint-plugin-react";
 
-export default [
-	rg.configs.browser,
-	rg.configs.react,
-	{
-		plugins: {
-			react,
-		},
-		rules: {
-		}
+export default defineConfig( {
+	extends: [ rg.configs.browser, rg.configs.react ],
+	plugins: {
+		react
+	},
+	rules: {
 	}
-];
+} );
 ```
 
 The _browser_ config sets the `browser` environment and adds ES module support.
 
 ```js
-"use strict";
-
-/* eslint-disable-next-line n/no-unpublished-require */
-const rgConfig = require( "eslint-config-reverentgeek" );
+import { defineConfig } from "eslint/config";
+import rg from "eslint-config-reverentgeek";
 
-module.exports = [
-	rgConfig.configs.browser,
-	{
-		rules: {
-		}
-	}
-];
+export default defineConfig( {
+	extends: [ rg.configs.browser ]
+} );
 ```
 
 ## Legacy .eslintrc.js support (eslint < v9.0)

package/eslint.config.js

@@ -1,5 +1,7 @@
 "use strict";
-const node = require( "./node" );
+const defineConfig = require( "eslint/config" ).defineConfig; // eslint-disable-line n/no-unpublished-require
+
+const node = require( "./src/node" );
 
 const config = {
 	rules: {
@@ -12,5 +14,12 @@ const config = {
 	}
 };
 
-module.exports = [ node, config ];
+const testConfig = {
+	files: [ "test/**/*.js" ],
+	rules: {
+		"n/no-unsupported-features/node-builtins": "off"
+	}
+};
+
+module.exports = defineConfig( [ node, config, testConfig ] );
 

package/package.json

@@ -1,14 +1,15 @@
 {
 	"name": "eslint-config-reverentgeek",
-	"version": "6.1.1",
+	"version": "6.3.0",
 	"description": "ESLint rules that ReverentGeek likes :)",
-	"main": "index.js",
+	"main": "src/index.js",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/reverentgeek/eslint-config-reverentgeek.git"
 	},
 	"scripts": {
-		"lint": "eslint ./ --fix"
+		"lint": "eslint ./ --fix",
+		"test": "node --test --experimental-test-coverage test/*.js"
 	},
 	"keywords": [
 		"lint",
@@ -18,11 +19,14 @@
 	"author": "David Neal <david@reverentgeek.com> (https://reverentgeek.com)",
 	"license": "MIT",
 	"dependencies": {
-		"@stylistic/eslint-plugin": "^5.2.1",
-		"eslint-plugin-n": "^17.7.0",
-		"globals": "^16.2.0"
+		"@stylistic/eslint-plugin": "^5.4.0",
+		"eslint-plugin-n": "^17.23.1",
+		"globals": "^16.4.0"
 	},
 	"devDependencies": {
-		"eslint": "^9.34.0"
+		"eslint": "^9.36.0"
+	},
+	"engines": {
+		"node": ">=18.0.0"
 	}
 }

package/src/blog.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const defineConfig = require( "eslint/config" ).defineConfig; // eslint-disable-line n/no-unpublished-require
+const styles = require( "@stylistic/eslint-plugin" );
+
+module.exports = defineConfig( {
+	name: "blog",
+	plugins: {
+		"@stylistic": styles
+	},
+	rules: {
+		"no-console": [ "off" ],
+		"@stylistic/indent": [ "error", 2 ]
+	}
+} );
+

package/{browser.js → src/browser.js}

@@ -1,17 +1,14 @@
 "use strict";
+const defineConfig = require( "eslint/config" ).defineConfig; // eslint-disable-line n/no-unpublished-require
 const globals = require( "globals" );
 const common = require( "./common" );
-const { merge } = require( "./utils" );
 
-const config = {
+module.exports = defineConfig( {
+	name: "browser",
+	extends: [ common ],
 	languageOptions: {
 		ecmaVersion: "latest",
 		sourceType: "module",
 		globals: globals.browser
-	},
-	rules: {
 	}
-};
-
-module.exports = merge( common, config );
-
+} );

package/src/common.js

@@ -0,0 +1,32 @@
+"use strict";
+
+const defineConfig = require( "eslint/config" ).defineConfig; // eslint-disable-line n/no-unpublished-require
+
+const eslint = require( "@eslint/js" );
+const styles = require( "@stylistic/eslint-plugin" );
+
+module.exports = defineConfig( {
+	name: "common",
+	extends: [ eslint.configs.recommended, styles.configs.recommended ],
+	rules: {
+		"no-console": [ "off" ],
+		"no-var": [ "error" ],
+		"@stylistic/array-bracket-spacing": [ "error", "always", { singleValue: true } ],
+		"@stylistic/brace-style": [ "error", "1tbs" ],
+		"@stylistic/comma-dangle": [ "error", "never" ],
+		"@stylistic/comma-spacing": [ "error", { before: false, after: true } ],
+		"@stylistic/eol-last": [ "error", "always" ],
+		"@stylistic/indent": [ "error", "tab" ],
+		"@stylistic/linebreak-style": [ "error", "unix" ],
+		"@stylistic/no-multiple-empty-lines": [ "error", { max: 1 } ],
+		"@stylistic/no-tabs": [ "error", { allowIndentationTabs: true } ],
+		"@stylistic/no-trailing-spaces": [ "error", { skipBlankLines: false, ignoreComments: false } ],
+		"@stylistic/object-curly-spacing": [ "error", "always" ],
+		"@stylistic/quote-props": [ "error", "as-needed" ],
+		"@stylistic/quotes": [ "error", "double" ],
+		"@stylistic/semi": [ "error", "always" ],
+		"@stylistic/space-in-parens": [ "error", "always" ],
+		"@stylistic/template-curly-spacing": [ "error", "always" ]
+	}
+} );
+

package/src/esm.js

@@ -0,0 +1,11 @@
+"use strict";
+const defineConfig = require( "eslint/config" ).defineConfig; // eslint-disable-line n/no-unpublished-require
+
+module.exports = defineConfig( {
+	name: "esm",
+	languageOptions: {
+		ecmaVersion: "latest",
+		sourceType: "module"
+	}
+} );
+

package/{index.js → src/index.js}

@@ -1,5 +1,5 @@
 "use strict";
-const pkg = require( "./package.json" );
+const pkg = require( "../package.json" );
 
 module.exports = {
 	meta: {

package/{node-esm.js → src/node-esm.js}

@@ -1,19 +1,17 @@
 "use strict";
+const defineConfig = require( "eslint/config" ).defineConfig; // eslint-disable-line n/no-unpublished-require
 const common = require( "./common" );
 const nodePlugin = require( "eslint-plugin-n" );
 const nodeRecommended = nodePlugin.configs["flat/recommended-module"];
-const { merge } = require( "./utils" );
 
-const config = {
-	name: "reverentgeek-node-esm",
+module.exports = defineConfig( {
+	name: "node-esm",
+	extends: [ common, nodeRecommended ],
 	languageOptions: {
 		sourceType: "module"
 	},
 	rules: {
 		"n/exports-style": [ "error" ]
 	}
-};
-const merged = merge( common, nodeRecommended, config );
-
-module.exports = merged;
+} );
 

package/{node.js → src/node.js}

@@ -1,12 +1,14 @@
 
 "use strict";
+
+const defineConfig = require( "eslint/config" ).defineConfig; // eslint-disable-line n/no-unpublished-require
 const common = require( "./common" );
 const nodePlugin = require( "eslint-plugin-n" );
 const nodeRecommended = nodePlugin.configs["flat/recommended-script"];
-const { merge } = require( "./utils" );
 
-const config = {
-	name: "reverentgeek-node-commonjs",
+module.exports = defineConfig( {
+	name: "node-commonjs",
+	extends: [ common, nodeRecommended ],
 	languageOptions: {
 		sourceType: "commonjs"
 	},
@@ -14,9 +16,4 @@ const config = {
 		strict: [ "error", "global" ],
 		"n/exports-style": [ "error" ]
 	}
-};
-
-const merged = merge( common, nodeRecommended, config );
-
-module.exports = merged;
-
+} );

package/src/react.js

@@ -0,0 +1,13 @@
+"use strict";
+const defineConfig = require( "eslint/config" ).defineConfig; // eslint-disable-line n/no-unpublished-require
+
+module.exports = defineConfig( {
+	name: "react",
+	languageOptions: {
+		parserOptions: {
+			ecmaFeatures: {
+				jsx: true
+			}
+		}
+	}
+} );

package/test/blog.test.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const { test, describe } = require( "node:test" );
+const assert = require( "node:assert" );
+const { testBasicConfigStructure, testHasPlugins, getConfig } = require( "./test-helpers.js" );
+
+describe( "blog config", () => {
+	const blogConfig = getConfig( "blog" );
+
+	testBasicConfigStructure( "blog", blogConfig );
+
+	test( "should use 2-space indentation", () => {
+		const indentRule = blogConfig.rules["@stylistic/indent"];
+		assert.ok( indentRule, "Should have indent rule" );
+		assert.strictEqual( indentRule[1], 2, "Should use 2-space indentation" );
+	} );
+
+	testHasPlugins( blogConfig, [ "@stylistic" ] );
+} );

package/test/browser.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const { test, describe } = require( "node:test" );
+const assert = require( "node:assert" );
+const { testBasicConfigStructure, testLanguageOptions, getConfig } = require( "./test-helpers.js" );
+
+describe( "browser config", () => {
+	const browserConfig = getConfig( "browser" );
+
+	testBasicConfigStructure( "browser", browserConfig );
+
+	testLanguageOptions( browserConfig, "module", true );
+
+	test( "should have browser globals", () => {
+		assert.ok( browserConfig.languageOptions.globals, "Should have globals" );
+		assert.ok( Object.prototype.hasOwnProperty.call( browserConfig.languageOptions.globals, "window" ), "Should have window global" );
+		assert.ok( Object.prototype.hasOwnProperty.call( browserConfig.languageOptions.globals, "document" ), "Should have document global" );
+		assert.ok( Object.prototype.hasOwnProperty.call( browserConfig.languageOptions.globals, "console" ), "Should have console global" );
+	} );
+} );

package/test/common.test.js

@@ -0,0 +1,14 @@
+"use strict";
+
+const { describe } = require( "node:test" );
+const { testBasicConfigStructure, testHasRules, testHasPlugins, getConfig } = require( "./test-helpers.js" );
+
+describe( "common config", () => {
+	const commonConfig = getConfig( "common" );
+
+	testBasicConfigStructure( "common", commonConfig );
+
+	testHasRules( commonConfig, [ "@stylistic/indent", "@stylistic/quotes", "@stylistic/semi", "@stylistic/brace-style" ] );
+
+	testHasPlugins( commonConfig, [ "@stylistic" ] );
+} );

package/test/esm.test.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const { test, describe } = require( "node:test" );
+const assert = require( "node:assert" );
+const { testBasicConfigStructure, testLanguageOptions, getConfig } = require( "./test-helpers.js" );
+
+describe( "esm config", () => {
+	const esmConfig = getConfig( "esm" );
+
+	testBasicConfigStructure( "esm", esmConfig );
+
+	testLanguageOptions( esmConfig, "module" );
+
+	test( "should have latest ecmaVersion", () => {
+		assert.ok( esmConfig.languageOptions, "Should have languageOptions" );
+		assert.strictEqual( esmConfig.languageOptions.ecmaVersion, "latest", "Should use latest ecmaVersion" );
+	} );
+} );

package/test/index.test.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const { test, describe } = require( "node:test" );
+const assert = require( "node:assert" );
+const pkg = require( "../package.json" );
+const configModule = require( "../src/index.js" );
+const { expectedNames, getConfig } = require( "./test-helpers.js" );
+
+describe( "eslint-config-reverentgeek", () => {
+	test( "should export meta information", () => {
+		assert.ok( configModule.meta, "Meta object should exist" );
+		assert.strictEqual( configModule.meta.name, pkg.name, "Meta name should match package name" );
+		assert.strictEqual( configModule.meta.version, pkg.version, "Meta version should match package version" );
+	} );
+
+	test( "should export configs object", () => {
+		assert.ok( configModule.configs, "Configs object should exist" );
+		assert.strictEqual( typeof configModule.configs, "object", "Configs should be an object" );
+	} );
+
+	describe( "configs", () => {
+		const expectedConfigs = [ "common", "blog", "browser", "node", "node-esm", "esm", "react" ];
+
+		test( "should have all expected configs", () => {
+			expectedConfigs.forEach( ( configName ) => {
+				assert.ok( configModule.configs[configName], `Config ${ configName } should exist` );
+			} );
+		} );
+	} );
+
+	describe( "config structure validation", () => {
+		test( "all configs should be valid objects", () => {
+			const configNames = Object.keys( configModule.configs );
+
+			for ( const configName of configNames ) {
+				const config = configModule.configs[configName];
+
+				assert.ok( config, `${ configName } config should exist` );
+				assert.strictEqual( typeof config, "object", `${ configName } config should be an object` );
+
+				if ( config.rules ) {
+					assert.strictEqual( typeof config.rules, "object", `${ configName } config rules should be an object` );
+				}
+
+				if ( config.plugins ) {
+					assert.strictEqual( typeof config.plugins, "object", `${ configName } config plugins should be an object` );
+				}
+
+				if ( config.languageOptions ) {
+					assert.strictEqual( typeof config.languageOptions, "object", `${ configName } config languageOptions should be an object` );
+				}
+			}
+		} );
+
+		test( "all configs should have correct names", () => {
+			for ( const [ configName, expectedName ] of Object.entries( expectedNames ) ) {
+				const config = getConfig( configName );
+				assert.ok( config.name, `${ configName } config should have a name property` );
+				assert.strictEqual( typeof config.name, "string", `${ configName } config name should be a string` );
+				assert.strictEqual( config.name, expectedName, `${ configName } config should have correct name` );
+			}
+		} );
+
+		test( "configs should not be empty objects", () => {
+			const configNames = Object.keys( configModule.configs );
+
+			for ( const configName of configNames ) {
+				const config = configModule.configs[configName];
+				const keys = Object.keys( config );
+				assert.ok( keys.length > 0, `${ configName } config should not be empty` );
+			}
+		} );
+	} );
+} );

package/test/merge.test.js

@@ -0,0 +1,393 @@
+"use strict";
+
+const { test, describe } = require( "node:test" );
+const assert = require( "node:assert" );
+const { merge } = require( "../src/utils.js" );
+
+describe( "merge function", () => {
+	describe( "basic functionality", () => {
+		test( "should merge two configs", () => {
+			const config1 = {
+				name: "config1",
+				plugins: { plugin1: "plugin1-content" },
+				languageOptions: {
+					sourceType: "script",
+					globals: { global1: true }
+				},
+				rules: { rule1: "error" }
+			};
+
+			const config2 = {
+				name: "config2",
+				plugins: { plugin2: "plugin2-content" },
+				languageOptions: {
+					sourceType: "module",
+					globals: { global2: false }
+				},
+				rules: { rule2: "warn" }
+			};
+
+			const result = merge( config1, config2 );
+
+			assert.strictEqual( result.name, "config2", "Should use the last config's name" );
+			assert.deepStrictEqual( result.plugins, {
+				plugin1: "plugin1-content",
+				plugin2: "plugin2-content"
+			}, "Should merge plugins from both configs" );
+			assert.strictEqual( result.languageOptions.sourceType, "module", "Should use the last config's sourceType" );
+			assert.deepStrictEqual( result.languageOptions.globals, {
+				global1: true,
+				global2: false
+			}, "Should merge globals from both configs" );
+			assert.deepStrictEqual( result.rules, {
+				rule1: "error",
+				rule2: "warn"
+			}, "Should merge rules from both configs" );
+		} );
+
+		test( "should merge three configs", () => {
+			const config1 = {
+				name: "config1",
+				plugins: { plugin1: "plugin1-content" },
+				languageOptions: {
+					sourceType: "script",
+					globals: { global1: true }
+				},
+				rules: { rule1: "error" }
+			};
+
+			const config2 = {
+				name: "config2",
+				plugins: { plugin2: "plugin2-content" },
+				languageOptions: {
+					sourceType: "module",
+					globals: { global2: false }
+				},
+				rules: { rule2: "warn" }
+			};
+
+			const config3 = {
+				name: "config3",
+				plugins: { plugin3: "plugin3-content" },
+				languageOptions: {
+					sourceType: "commonjs",
+					globals: { global3: "readonly" }
+				},
+				rules: { rule3: "off" }
+			};
+
+			const result = merge( config1, config2, config3 );
+
+			assert.strictEqual( result.name, "config3", "Should use the third config's name" );
+			assert.deepStrictEqual( result.plugins, {
+				plugin1: "plugin1-content",
+				plugin2: "plugin2-content",
+				plugin3: "plugin3-content"
+			}, "Should merge plugins from all three configs" );
+			assert.strictEqual( result.languageOptions.sourceType, "commonjs", "Should use the third config's sourceType" );
+			assert.deepStrictEqual( result.languageOptions.globals, {
+				global1: true,
+				global2: false,
+				global3: "readonly"
+			}, "Should merge globals from all three configs" );
+			assert.deepStrictEqual( result.rules, {
+				rule1: "error",
+				rule2: "warn",
+				rule3: "off"
+			}, "Should merge rules from all three configs" );
+		} );
+	} );
+
+	describe( "property override behavior", () => {
+		test( "should override properties in order - name", () => {
+			const config1 = { name: "first-name" };
+			const config2 = { name: "second-name" };
+			const config3 = { name: "third-name" };
+
+			const result = merge( config1, config2, config3 );
+			assert.strictEqual( result.name, "third-name", "Should use the last config's name" );
+		} );
+
+		test( "should override properties in order - plugins", () => {
+			const config1 = { plugins: { shared: "first-value", unique1: "value1" } };
+			const config2 = { plugins: { shared: "second-value", unique2: "value2" } };
+			const config3 = { plugins: { shared: "third-value", unique3: "value3" } };
+
+			const result = merge( config1, config2, config3 );
+			assert.deepStrictEqual( result.plugins, {
+				shared: "third-value",
+				unique1: "value1",
+				unique2: "value2",
+				unique3: "value3"
+			}, "Should override shared plugin with last value and include all unique plugins" );
+		} );
+
+		test( "should override properties in order - rules", () => {
+			const config1 = { rules: { "shared-rule": "error", rule1: "error" } };
+			const config2 = { rules: { "shared-rule": "warn", rule2: "warn" } };
+			const config3 = { rules: { "shared-rule": "off", rule3: "off" } };
+
+			const result = merge( config1, config2, config3 );
+			assert.deepStrictEqual( result.rules, {
+				"shared-rule": "off",
+				rule1: "error",
+				rule2: "warn",
+				rule3: "off"
+			}, "Should override shared rule with last value and include all unique rules" );
+		} );
+
+		test( "should override properties in order - globals", () => {
+			const config1 = {
+				languageOptions: {
+					globals: { shared: true, global1: true }
+				}
+			};
+			const config2 = {
+				languageOptions: {
+					globals: { shared: false, global2: false }
+				}
+			};
+			const config3 = {
+				languageOptions: {
+					globals: { shared: "readonly", global3: "readonly" }
+				}
+			};
+
+			const result = merge( config1, config2, config3 );
+			assert.deepStrictEqual( result.languageOptions.globals, {
+				shared: "readonly",
+				global1: true,
+				global2: false,
+				global3: "readonly"
+			}, "Should override shared global with last value and include all unique globals" );
+		} );
+
+		test( "should override sourceType with last non-null value", () => {
+			const config1 = { languageOptions: { sourceType: "script" } };
+			const config2 = { languageOptions: { sourceType: "module" } };
+			const config3 = { languageOptions: { sourceType: "commonjs" } };
+
+			const result = merge( config1, config2, config3 );
+			assert.strictEqual( result.languageOptions.sourceType, "commonjs", "Should use the last sourceType" );
+		} );
+	} );
+
+	describe( "edge cases and null handling", () => {
+		test( "should handle empty configs", () => {
+			const config1 = {};
+			const config2 = {};
+
+			const result = merge( config1, config2 );
+
+			assert.strictEqual( result.name, undefined, "Should handle missing names" );
+			assert.deepStrictEqual( result.plugins, {}, "Should return empty plugins object" );
+			assert.strictEqual( result.languageOptions.sourceType, undefined, "Should handle missing sourceType" );
+			assert.deepStrictEqual( result.languageOptions.globals, {}, "Should return empty globals object" );
+			assert.deepStrictEqual( result.rules, {}, "Should return empty rules object" );
+		} );
+
+		test( "should handle null/undefined configs", () => {
+			const config1 = { name: "valid-config", rules: { rule1: "error" } };
+			const config2 = null;
+			const config3 = undefined;
+			const config4 = { name: "another-valid", rules: { rule2: "warn" } };
+
+			const result = merge( config1, config2, config3, config4 );
+
+			assert.strictEqual( result.name, "another-valid", "Should skip null/undefined configs for name" );
+			assert.deepStrictEqual( result.rules, {
+				rule1: "error",
+				rule2: "warn"
+			}, "Should skip null/undefined configs for rules" );
+		} );
+
+		test( "should handle configs with missing properties", () => {
+			const config1 = { name: "config1" }; // No plugins, languageOptions, or rules
+			const config2 = { rules: { rule1: "error" } }; // No name, plugins, or languageOptions
+			const config3 = { plugins: { plugin1: "content" } }; // No name, languageOptions, or rules
+
+			const result = merge( config1, config2, config3 );
+
+			assert.strictEqual( result.name, "config1", "Should use available name" );
+			assert.deepStrictEqual( result.plugins, { plugin1: "content" }, "Should use available plugins" );
+			assert.deepStrictEqual( result.rules, { rule1: "error" }, "Should use available rules" );
+			assert.deepStrictEqual( result.languageOptions.globals, {}, "Should create empty globals" );
+		} );
+
+		test( "should handle configs with null languageOptions properties", () => {
+			const config1 = {
+				languageOptions: {
+					sourceType: null,
+					globals: null
+				}
+			};
+			const config2 = {
+				languageOptions: {
+					sourceType: "module",
+					globals: { window: true }
+				}
+			};
+
+			const result = merge( config1, config2 );
+
+			assert.strictEqual( result.languageOptions.sourceType, "module", "Should skip null sourceType" );
+			assert.deepStrictEqual( result.languageOptions.globals, { window: true }, "Should handle null globals" );
+		} );
+
+		test( "should handle single config", () => {
+			const config = {
+				name: "single-config",
+				plugins: { plugin1: "content" },
+				languageOptions: {
+					sourceType: "module",
+					globals: { window: true }
+				},
+				rules: { rule1: "error" }
+			};
+
+			const result = merge( config );
+
+			assert.deepStrictEqual( result, {
+				name: "single-config",
+				plugins: { plugin1: "content" },
+				languageOptions: {
+					sourceType: "module",
+					globals: { window: true }
+				},
+				rules: { rule1: "error" }
+			}, "Should return the single config as-is" );
+		} );
+
+		test( "should handle no configs", () => {
+			const result = merge();
+
+			assert.strictEqual( result.name, undefined, "Should handle no name" );
+			assert.deepStrictEqual( result.plugins, {}, "Should return empty plugins" );
+			assert.strictEqual( result.languageOptions.sourceType, undefined, "Should handle no sourceType" );
+			assert.deepStrictEqual( result.languageOptions.globals, {}, "Should return empty globals" );
+			assert.deepStrictEqual( result.rules, {}, "Should return empty rules" );
+		} );
+	} );
+
+	describe( "complex merging scenarios", () => {
+		test( "should handle nested rule configurations", () => {
+			const config1 = {
+				rules: {
+					indent: [ "error", 2 ],
+					quotes: [ "error", "single" ]
+				}
+			};
+			const config2 = {
+				rules: {
+					indent: [ "error", 4 ],
+					semi: [ "error", "always" ]
+				}
+			};
+
+			const result = merge( config1, config2 );
+
+			assert.deepStrictEqual( result.rules, {
+				indent: [ "error", 4 ], // Should override with config2's value
+				quotes: [ "error", "single" ],
+				semi: [ "error", "always" ]
+			}, "Should properly override nested rule arrays" );
+		} );
+
+		test( "should handle complex plugin objects", () => {
+			const plugin1 = { rules: { "custom-rule-1": {} }, configs: { recommended: {} } };
+			const plugin2 = { rules: { "custom-rule-2": {} }, configs: { strict: {} } };
+
+			const config1 = { plugins: { "@custom/plugin1": plugin1 } };
+			const config2 = { plugins: { "@custom/plugin2": plugin2 } };
+
+			const result = merge( config1, config2 );
+
+			assert.deepStrictEqual( result.plugins, {
+				"@custom/plugin1": plugin1,
+				"@custom/plugin2": plugin2
+			}, "Should merge complex plugin objects" );
+		} );
+
+		test( "should handle mixed global types", () => {
+			const config1 = {
+				languageOptions: {
+					globals: {
+						window: true,
+						document: false,
+						console: "readonly"
+					}
+				}
+			};
+			const config2 = {
+				languageOptions: {
+					globals: {
+						document: true, // Override from false to true
+						process: "writable",
+						Buffer: false
+					}
+				}
+			};
+
+			const result = merge( config1, config2 );
+
+			assert.deepStrictEqual( result.languageOptions.globals, {
+				window: true,
+				document: true, // Should be overridden
+				console: "readonly",
+				process: "writable",
+				Buffer: false
+			}, "Should properly merge and override different global types" );
+		} );
+	} );
+
+	describe( "order of operations", () => {
+		test( "should demonstrate merge order with four configs", () => {
+			const base = { name: "base", rules: { "base-rule": "error" } };
+			const common = { name: "common", rules: { "common-rule": "warn", "base-rule": "warn" } };
+			const specific = { name: "specific", rules: { "specific-rule": "off", "common-rule": "off" } };
+			const override = { name: "override", rules: { "override-rule": "error", "base-rule": "off" } };
+
+			const result = merge( base, common, specific, override );
+
+			assert.strictEqual( result.name, "override", "Should use the last config's name" );
+			assert.deepStrictEqual( result.rules, {
+				"base-rule": "off", // Overridden by 'override' config
+				"common-rule": "off", // Overridden by 'specific' config
+				"specific-rule": "off", // From 'specific' config
+				"override-rule": "error" // From 'override' config
+			}, "Should apply overrides in the correct order" );
+		} );
+
+		test( "should handle partial overrides correctly", () => {
+			const config1 = {
+				name: "config1",
+				plugins: { plugin1: "v1", shared: "v1" },
+				rules: { rule1: "error", shared: "error" }
+			};
+			const config2 = {
+				// No name - should keep config1's name
+				plugins: { plugin2: "v2", shared: "v2" }, // Override shared plugin
+				rules: { rule2: "warn" } // Don't override shared rule
+			};
+			const config3 = {
+				name: "config3", // Override name
+				// No plugins - keep merged plugins from config1 + config2
+				rules: { shared: "off" } // Override shared rule
+			};
+
+			const result = merge( config1, config2, config3 );
+
+			assert.strictEqual( result.name, "config3", "Should use config3's name" );
+			assert.deepStrictEqual( result.plugins, {
+				plugin1: "v1",
+				plugin2: "v2",
+				shared: "v2" // From config2
+			}, "Should keep merged plugins when config3 has none" );
+			assert.deepStrictEqual( result.rules, {
+				rule1: "error",
+				rule2: "warn",
+				shared: "off" // From config3
+			}, "Should override shared rule with config3's value" );
+		} );
+	} );
+} );

package/test/node-esm.test.js

@@ -0,0 +1,12 @@
+"use strict";
+
+const { describe } = require( "node:test" );
+const { testBasicConfigStructure, testLanguageOptions, getConfig } = require( "./test-helpers.js" );
+
+describe( "node-esm config", () => {
+	const nodeEsmConfig = getConfig( "node-esm" );
+
+	testBasicConfigStructure( "node-esm", nodeEsmConfig );
+
+	testLanguageOptions( nodeEsmConfig, "module" );
+} );

package/test/node.test.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const { describe } = require( "node:test" );
+const { testBasicConfigStructure, testHasRules, testHasPlugins, testLanguageOptions, getConfig } = require( "./test-helpers.js" );
+
+describe( "node config", () => {
+	const nodeConfig = getConfig( "node" );
+
+	testBasicConfigStructure( "node", nodeConfig );
+
+	testLanguageOptions( nodeConfig, "commonjs" );
+
+	testHasRules( nodeConfig, [ "strict", "n/exports-style" ] );
+
+	testHasPlugins( nodeConfig, [ "n" ] );
+} );

package/test/react.test.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const { test, describe } = require( "node:test" );
+const assert = require( "node:assert" );
+const { testBasicConfigStructure, getConfig } = require( "./test-helpers.js" );
+
+describe( "react config", () => {
+	const reactConfig = getConfig( "react" );
+
+	testBasicConfigStructure( "react", reactConfig );
+
+	test( "should have JSX support", () => {
+		assert.ok( reactConfig.languageOptions, "Should have languageOptions" );
+		assert.ok( reactConfig.languageOptions.parserOptions, "Should have parserOptions" );
+		assert.ok( reactConfig.languageOptions.parserOptions.ecmaFeatures, "Should have ecmaFeatures" );
+		assert.ok( reactConfig.languageOptions.parserOptions.ecmaFeatures.jsx, "Should support JSX" );
+	} );
+} );

package/test/test-helpers.js

@@ -0,0 +1,146 @@
+"use strict";
+
+const { test } = require( "node:test" );
+const assert = require( "node:assert" );
+const configModule = require( "../src/index.js" );
+
+// Expected names for all configs
+const expectedNames = {
+	common: "common",
+	blog: "blog",
+	browser: "browser",
+	node: "node-commonjs",
+	"node-esm": "node-esm",
+	esm: "esm",
+	react: "react"
+};
+
+/**
+ * Common test helper to validate basic ESLint config structure
+ */
+function testBasicConfigStructure( configName, config ) {
+	test( "should be a valid ESLint config object", () => {
+		assert.ok( config, `${ configName } config should exist` );
+		assert.strictEqual( typeof config, "object", `${ configName } config should be an object` );
+	} );
+
+	test( "should have correct name", () => {
+		const expectedName = expectedNames[configName];
+		if ( expectedName ) {
+			assert.strictEqual( config.name, expectedName, "Should have correct config name" );
+		}
+	} );
+}
+
+/**
+ * Test helper for validating rules exist
+ */
+function testHasRules( config, expectedRules = [] ) {
+	test( "should have rules", () => {
+		assert.ok( config.rules, "Should have rules object" );
+		assert.strictEqual( typeof config.rules, "object", "Rules should be an object" );
+	} );
+
+	if ( expectedRules.length > 0 ) {
+		test( "should have expected rules", () => {
+			const rules = config.rules;
+			expectedRules.forEach( ( ruleName ) => {
+				assert.ok( rules[ruleName], `Should have ${ ruleName } rule` );
+			} );
+		} );
+	}
+}
+
+/**
+ * Test helper for validating plugins exist
+ */
+function testHasPlugins( config, expectedPlugins = [] ) {
+	test( "should have plugins", () => {
+		assert.ok( config.plugins, "Should have plugins object" );
+		assert.strictEqual( typeof config.plugins, "object", "Plugins should be an object" );
+	} );
+
+	if ( expectedPlugins.length > 0 ) {
+		test( "should have expected plugins", () => {
+			const plugins = config.plugins;
+			expectedPlugins.forEach( ( pluginName ) => {
+				assert.ok( plugins[pluginName], `Should have ${ pluginName } plugin` );
+			} );
+		} );
+	}
+}
+
+/**
+ * Test helper for validating language options
+ */
+function testLanguageOptions( config, expectedSourceType, hasGlobals = false ) {
+	test( "should have correct language options", () => {
+		if ( expectedSourceType ) {
+			assert.ok( config.languageOptions, "Should have languageOptions" );
+			assert.strictEqual( config.languageOptions.sourceType, expectedSourceType, `Should use ${ expectedSourceType } sourceType` );
+		}
+
+		if ( hasGlobals ) {
+			assert.ok( config.languageOptions.globals, "Should have globals" );
+			assert.strictEqual( typeof config.languageOptions.globals, "object", "Globals should be an object" );
+		}
+	} );
+}
+
+/**
+ * Get a config from the main module
+ * Since configs are now arrays due to defineConfig, we need to handle them properly
+ */
+function getConfig( configName ) {
+	const configArray = configModule.configs[configName];
+
+	// If it's an array (which it should be with defineConfig), we need to get the effective config
+	if ( Array.isArray( configArray ) ) {
+		// For testing purposes, we'll merge all configs in the array to get the effective configuration
+		// This simulates what ESLint would do when processing the config
+		const merged = {
+			name: null,
+			plugins: {},
+			rules: {},
+			languageOptions: {}
+		};
+
+		configArray.forEach( ( config ) => {
+			if ( config.name ) {
+				merged.name = config.name;
+			}
+			if ( config.plugins ) {
+				Object.assign( merged.plugins, config.plugins );
+			}
+			if ( config.rules ) {
+				Object.assign( merged.rules, config.rules );
+			}
+			if ( config.languageOptions ) {
+				Object.assign( merged.languageOptions, config.languageOptions );
+			}
+		} );
+
+		// Clean up empty objects
+		if ( Object.keys( merged.plugins ).length === 0 ) {
+			delete merged.plugins;
+		}
+		if ( Object.keys( merged.languageOptions ).length === 0 ) {
+			delete merged.languageOptions;
+		}
+
+		return merged;
+	}
+
+	// Fallback for non-array configs (shouldn't happen with defineConfig)
+	return configArray;
+}
+
+module.exports = {
+	configModule,
+	expectedNames,
+	testBasicConfigStructure,
+	testHasRules,
+	testHasPlugins,
+	testLanguageOptions,
+	getConfig
+};

package/blog.js

@@ -1,18 +0,0 @@
-"use strict";
-
-async function createConfig() {
-	const styles = await import( "@stylistic/eslint-plugin" );
-
-	return {
-		plugins: {
-			"@stylistic": styles.default
-		},
-		rules: {
-			"no-console": [ "off" ],
-			"@stylistic/indent": [ "error", 2 ]
-		}
-	};
-}
-
-module.exports = createConfig();
-

package/common.js

@@ -1,36 +0,0 @@
-"use strict";
-
-const eslint = require( "@eslint/js" );
-const { merge } = require( "./utils" );
-
-async function createConfig() {
-	const styles = await import( "@stylistic/eslint-plugin" );
-
-	const config = {
-		name: "reverentgeek-common",
-		rules: {
-			"no-console": [ "off" ],
-			"no-var": [ "error" ],
-			"@stylistic/array-bracket-spacing": [ "error", "always", { singleValue: true } ],
-			"@stylistic/brace-style": [ "error", "1tbs" ],
-			"@stylistic/comma-dangle": [ "error", "never" ],
-			"@stylistic/comma-spacing": [ "error", { before: false, after: true } ],
-			"@stylistic/eol-last": [ "error", "always" ],
-			"@stylistic/indent": [ "error", "tab" ],
-			"@stylistic/linebreak-style": [ "error", "unix" ],
-			"@stylistic/no-multiple-empty-lines": [ "error", { max: 1 } ],
-			"@stylistic/no-tabs": [ "error", { allowIndentationTabs: true } ],
-			"@stylistic/no-trailing-spaces": [ "error", { skipBlankLines: false, ignoreComments: false } ],
-			"@stylistic/object-curly-spacing": [ "error", "always" ],
-			"@stylistic/quote-props": [ "error", "as-needed" ],
-			"@stylistic/quotes": [ "error", "double" ],
-			"@stylistic/semi": [ "error", "always" ],
-			"@stylistic/space-in-parens": [ "error", "always" ],
-			"@stylistic/template-curly-spacing": [ "error", "always" ]
-		}
-	};
-
-	return merge( eslint.configs.recommended, styles.default.configs.recommended, config );
-}
-
-module.exports = createConfig();

package/esm.js

@@ -1,9 +0,0 @@
-"use strict";
-
-module.exports = {
-	languageOptions: {
-		ecmaVersion: "latest",
-		sourceType: "module"
-	}
-};
-

package/react.js

@@ -1,12 +0,0 @@
-"use strict";
-
-module.exports = {
-	languageOptions: {
-		parserOptions: {
-			ecmaFeatures: {
-				jsx: true
-			}
-		}
-	}
-};
-