@bastidood/eslint-config 0.4.0 → 0.6.1

package/README.md

@@ -14,26 +14,23 @@ pnpm add --save-dev @bastidood/eslint-config eslint typescript
 // eslint.config.ts
 import { compose } from '@bastidood/eslint-config';
 import { CORE } from '@bastidood/eslint-config/core';
-import { PROMISE } from '@bastidood/eslint-config/promise';
-import { UNICORN } from '@bastidood/eslint-config/unicorn';
 import { defineConfig } from 'eslint/config';
 
-export default defineConfig({ files: ['**/*.ts'] }, compose(CORE, UNICORN, PROMISE));
+export default defineConfig({ files: ['**/*.ts'] }, compose(CORE));
 ```
 
 List `CORE` first.
 
 ## Entry Points
 
-| Entry point                        | Contents                                                     |
-| ---------------------------------- | ------------------------------------------------------------ |
-| `@bastidood/eslint-config`         | `compose`                                                    |
-| `@bastidood/eslint-config/core`    | ESLint core, `import`, and `@typescript-eslint` rules        |
-| `@bastidood/eslint-config/unicorn` | `unicorn` rules                                              |
-| `@bastidood/eslint-config/promise` | `promise` rules                                              |
-| `@bastidood/eslint-config/node`    | Node.js rules                                                |
-| `@bastidood/eslint-config/vitest`  | Vitest rules                                                 |
-| `@bastidood/eslint-config/jsdoc`   | JSDoc rules for documentation that TypeScript does not cover |
+| Entry point                               | Contents                                                                                                                                                                                                                                        |
+| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@bastidood/eslint-config`                | `compose`                                                                                                                                                                                                                                       |
+| `@bastidood/eslint-config/core`           | ESLint core, `import`, `jsdoc`, `promise`, `@typescript-eslint`, and `unicorn` rules                                                                                                                                                            |
+| `@bastidood/eslint-config/node`           | Node.js rules                                                                                                                                                                                                                                   |
+| `@bastidood/eslint-config/vitest`         | Vitest rules                                                                                                                                                                                                                                    |
+| `@bastidood/eslint-config/tanstack/query` | Enables the slopstopper TanStack Query rules: `prefer-query-key-context`, `no-defaulted-query-key`, `no-standalone-mutate-async`, and `no-mutate-callback-cache-update`                                                                         |
+| `@bastidood/eslint-config/tanstack/table` | Enables the slopstopper TanStack Table rules: `prefer-table-atoms`, `require-table-state-pairs`, `no-render-scoped-table-schema`, and `require-exclusive-indeterminate`; bans `stockFeatures` and reading column templates outside `FlexRender` |
 
 ## Limitations
 

package/dist/compose/index.d.mts

@@ -1,3 +1,4 @@
+import { NewResolver } from "eslint-plugin-import-x";
 import { Linter } from "eslint";
 export interface RestrictedImportPath {
   readonly name: string;
@@ -29,24 +30,37 @@ export interface Restrictions {
   readonly properties?: RestrictedProperty[];
   readonly syntax?: RestrictedSyntax[];
 }
+/** An `import-x/resolver-next` resolver. `eslint-import-resolver-typescript` widens `interfaceVersion` to `number`. */
+export interface ImportResolver extends Omit<NewResolver, 'interfaceVersion'> {
+  readonly interfaceVersion: number;
+}
 export interface ScopedRestrictions {
   readonly files: string[];
   readonly restrictions: Restrictions;
 }
 /**
  * An entry point: ESLint configuration objects plus the lists that `compose` concatenates, namely the
- * restriction lists and the non-standard file extensions that the TypeScript project service must resolve.
- * `configs` may nest a configuration list one level deep, such as a plugin's `recommended` list.
+ * restriction lists, the non-standard file extensions that the TypeScript project service must resolve, and the
+ * `import-x` settings lists. `configs` may nest a configuration list one level deep, such as a plugin's
+ * `recommended` list.
  */
 export interface Entry {
   readonly configs?: (Linter.Config | Linter.Config[])[];
   readonly extraFileExtensions?: string[];
+  /** The file extensions that the `import` rules follow, as in `import-x/extensions`. */
+  readonly importExtensions?: string[];
+  /** The folders whose modules the `import` rules treat as external, as in `import-x/external-module-folders`. */
+  readonly importExternalModuleFolders?: string[];
+  /** Maps the module name of a parser to the file extensions that it parses, as in `import-x/parsers`. */
+  readonly importParsers?: Record<string, string[]>;
+  /** The resolvers that the `import` rules try in order, as in `import-x/resolver-next`. */
+  readonly importResolvers?: ImportResolver[];
   readonly restrictions?: Restrictions;
   readonly scopedRestrictions?: ScopedRestrictions[];
 }
 /**
- * Compose entry points into one ESLint flat configuration for `extends`. Restriction lists are concatenated
- * instead of replaced, and every scoped configuration repeats the top-level restrictions so that it cannot
- * drop them.
+ * Compose entry points into one ESLint flat configuration for `extends`. Restriction lists, file extension
+ * lists, and `import-x` settings lists are concatenated instead of replaced, and every scoped configuration repeats the top-level restrictions
+ * so that it cannot drop them.
  */
 export declare function compose(...entries: Entry[]): Linter.Config[];

package/dist/compose/index.mjs

@@ -12,22 +12,21 @@ var RestrictionLists = class RestrictionLists {
 	#globals = ["error"];
 	#properties = ["error"];
 	#syntax = ["error"];
-	/** Append every list of an entry point's restrictions. */
 	append({ importPaths, importPatterns, globals, properties, syntax }) {
-		appendAll(this.#imports.paths, importPaths);
-		appendAll(this.#imports.patterns, importPatterns);
-		appendAll(this.#globals, globals);
-		appendAll(this.#properties, properties);
-		appendAll(this.#syntax, syntax);
+		appendAll$1(this.#imports.paths, importPaths);
+		appendAll$1(this.#imports.patterns, importPatterns);
+		appendAll$1(this.#globals, globals);
+		appendAll$1(this.#properties, properties);
+		appendAll$1(this.#syntax, syntax);
 	}
 	/** Copy these lists so that a scoped override can extend them without changing the top-level rules. */
 	copy() {
 		const copy = new RestrictionLists();
-		appendAll(copy.#imports.paths, this.#imports.paths);
-		appendAll(copy.#imports.patterns, this.#imports.patterns);
-		appendAll(copy.#globals, this.#globals.values().drop(1));
-		appendAll(copy.#properties, this.#properties.values().drop(1));
-		appendAll(copy.#syntax, this.#syntax.values().drop(1));
+		appendAll$1(copy.#imports.paths, this.#imports.paths);
+		appendAll$1(copy.#imports.patterns, this.#imports.patterns);
+		appendAll$1(copy.#globals, this.#globals.values().drop(1));
+		appendAll$1(copy.#properties, this.#properties.values().drop(1));
+		appendAll$1(copy.#syntax, this.#syntax.values().drop(1));
 		return copy;
 	}
 	importsRule() {
@@ -44,23 +43,38 @@ var RestrictionLists = class RestrictionLists {
 		return this.#syntax.length === 1 ? null : this.#syntax;
 	}
 };
-function appendAll(target, items) {
+function appendAll$1(target, items) {
 	if (typeof items === "undefined") return;
 	for (const item of items) target.push(item);
 }
 // src/compose/index.ts
 /**
-* Compose entry points into one ESLint flat configuration for `extends`. Restriction lists are concatenated
-* instead of replaced, and every scoped configuration repeats the top-level restrictions so that it cannot
-* drop them.
+* Compose entry points into one ESLint flat configuration for `extends`. Restriction lists, file extension
+* lists, and `import-x` settings lists are concatenated instead of replaced, and every scoped configuration repeats the top-level restrictions
+* so that it cannot drop them.
 */
 function compose(...entries) {
 	const configs = [];
 	const extraFileExtensions = [];
+	const importExtensions = [];
+	const importExternalModuleFolders = [];
+	const importParsers = {};
+	const importResolvers = [];
+	let hasImportParsers = false;
 	const restrictions = new RestrictionLists();
-	for (const { configs: entryConfigs, extraFileExtensions: entryExtensions, restrictions: entryRestrictions } of entries) {
+	for (const { configs: entryConfigs, extraFileExtensions: entryExtensions, importExtensions: entryImportExtensions, importExternalModuleFolders: entryImportExternalModuleFolders, importParsers: entryImportParsers, importResolvers: entryImportResolvers, restrictions: entryRestrictions } of entries) {
 		appendConfigs(configs, entryConfigs);
-		if (typeof entryExtensions !== "undefined") for (const extension of entryExtensions) extraFileExtensions.push(extension);
+		appendAll(extraFileExtensions, entryExtensions);
+		appendAll(importExtensions, entryImportExtensions);
+		appendAll(importExternalModuleFolders, entryImportExternalModuleFolders);
+		appendAll(importResolvers, entryImportResolvers);
+		if (typeof entryImportParsers !== "undefined") for (const parser in entryImportParsers) {
+			if (!Object.hasOwn(entryImportParsers, parser)) continue;
+			const extensions = importParsers[parser] ?? [];
+			appendAll(extensions, entryImportParsers[parser]);
+			importParsers[parser] = extensions;
+			hasImportParsers = true;
+		}
 		if (typeof entryRestrictions !== "undefined") restrictions.append(entryRestrictions);
 	}
 	configs.push({
@@ -83,8 +97,31 @@ function compose(...entries) {
 		name: "@bastidood/eslint-config/project-service",
 		languageOptions: { parserOptions: { extraFileExtensions } }
 	});
+	const importSettings = {};
+	let hasImportSettings = hasImportParsers;
+	if (hasImportParsers) importSettings["import-x/parsers"] = importParsers;
+	if (importExtensions.length > 0) {
+		importSettings["import-x/extensions"] = importExtensions;
+		hasImportSettings = true;
+	}
+	if (importExternalModuleFolders.length > 0) {
+		importSettings["import-x/external-module-folders"] = importExternalModuleFolders;
+		hasImportSettings = true;
+	}
+	if (importResolvers.length > 0) {
+		importSettings["import-x/resolver-next"] = importResolvers;
+		hasImportSettings = true;
+	}
+	if (hasImportSettings) configs.push({
+		name: "@bastidood/eslint-config/import",
+		settings: importSettings
+	});
 	return configs;
 }
+function appendAll(target, items) {
+	if (typeof items === "undefined") return;
+	for (const item of items) target.push(item);
+}
 /** Append an entry point's configurations, flattening nested configuration lists one level. */
 function appendConfigs(target, configs) {
 	if (typeof configs === "undefined") return;