ESLint Rewrite

ESLint Rewrite is a monorepo containing the core components and utilities for the rewritten version of ESLint. The repository is organized into several specialized packages that handle configuration, compatibility, core logic, and plugin interfaces.

Available packages:
- `@eslint/compat`: ESLint Compatibility Utilities
- `@eslint/config-array`: Config Array
- `@eslint/config-helpers`: @eslint/config-helpers
- `@eslint/core`: ESLint Core
- `@eslint/mcp`: ESLint MCP Server
- `@eslint/migrate-config`: ESLint Configuration Migrator
- `@eslint/object-schema`: ObjectSchema Package
- `@eslint/plugin-kit`: @eslint/plugin-kit

To optimize performance, ConfigArray employs two aggressive caching strategies:

1. File-based Caching: The result of getConfig() is cached against the specific filename provided. This ensures that calling getConfig() with the same filename always returns the exact same object.
2. Index-based Caching: The system caches the combination of configuration elements used to generate a config. If a new file matches the same set of configuration elements (e.g., elements 1, 5, and 7), the result is retrieved from the cache using the key 1,5,7 instead of being recalculated.

If a custom merge() function returns undefined, the corresponding key will be removed from the resulting object during a merge operation.

const schema = new ObjectSchema({
	date: {
		merge() {
			return undefined;
		},
		validate(value) {
			if (isNaN(Date.parse(value))) {
				throw new Error("Invalid date.");
			}
		},
	},
});

const object1 = { date: "5/5/2005" };
const object2 = { date: "6/6/2006" };

const result = schema.merge(object1, object2);
console.log("date" in result); // false

To validate and merge nested objects, use the schema property within a key definition. This allows you to define a full ObjectSchema structure for that specific key.

const schema = new ObjectSchema({
	name: {
		schema: {
			first: {
				merge: "replace",
				validate: "string",
			},
			last: {
				merge: "replace",
				validate: "string",
			},
		},
	},
});

schema.validate({
	name: {
		first: "n",
		last: "z",
	},
});

ESLint is transitioning its type management strategy to ensure accuracy and control. The core rewrite will move primary type definitions into @eslint/core rather than relying solely on external community-maintained packages.

Key aspects of this strategy include:

• Primary Source of Truth: Core types (such as Position, SourceLocation, RuleSeverity, and Language) are defined within @eslint/core to ensure they match the rewritten core API.
• Interim Convergence: The @types/eslint package is being updated to pull definitions from @eslint/core where applicable to improve consistency.
• API Evolution: Users should be aware that the core rewrite will likely introduce a significantly different API compared to current versions, and type definitions will reflect these changes.

You can enforce that the presence of one key requires the presence of others by using the requires property. This property accepts an array of strings representing the names of the required keys.

const schema = new ObjectSchema({
	date: {
		merge() {
			return undefined;
		},
		validate(value) {
			if (isNaN(Date.parse(value))) {
				throw new Error("Invalid date.");
			}
		},
	},
	time: {
		requires: ["date"],
		merge(first, second) {
			return second;
		},
		validate(value) {
			// ...
		},
	},
});

// Throws error: Key "time" requires keys "date".
schema.validate({ time: "13:45" });

The ESLint Rewrite project uses JavaScript combined with JSDoc comments and tsc (TypeScript Compiler) to enforce type checking. This approach provides type safety while allowing the project to continue 'dogfooding' its own JavaScript-based utilities (like Espree and eslint-scope) instead of relying on typescript-eslint.

Key implementation details:

• Type Enforcement: tsc is used to check types defined via JSDoc.
• Interfaces: TypeScript is used specifically for defining interfaces where it is more convenient than JSDoc, but not for implementing functionality.
• Type Distribution: Each package within the rewrite repository publishes its own types.