@bastidood/eslint-config 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Basti Ortiz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,45 @@
-# Temporary Holding Version
+# `@bastidood/eslint-config`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+ESLint port of `@bastidood/oxlint-config` for projects that Oxlint cannot lint, such as Svelte and Astro.
+
+## Installation
+
+```sh
+pnpm add --save-dev @bastidood/eslint-config eslint typescript
+```
+
+## Configuration
+
+```ts
+// 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));
+```
+
+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 |
+
+## Limitations
+
+- Prefer `@bastidood/oxlint-config` wherever Oxlint can run.
+- Rules are not configurable. Supply only project-specific settings, such as `files` and globals.
+- No `files` are set. ESLint lints only JavaScript files unless you list others.
+- `typescript-eslint` supports TypeScript up to 6.0. On TypeScript 7, alias `typescript` to `@typescript/typescript6`.
+- Requires ESLint 10.
+- Run ESLint from the directory that contains `tsconfig.json` or a parent directory. Type-aware rules search for `tsconfig.json` only up to the working directory.

package/dist/compose/index.d.mts

@@ -0,0 +1,52 @@
+import { Linter } from "eslint";
+export interface RestrictedImportPath {
+  readonly name: string;
+  readonly importNames?: string[];
+  readonly message: string;
+}
+export interface RestrictedImportPattern {
+  readonly regex: string;
+  readonly message: string;
+}
+export interface RestrictedGlobal {
+  readonly name: string;
+  readonly message: string;
+}
+export interface RestrictedProperty {
+  readonly object: string;
+  readonly property: string;
+  readonly message: string;
+}
+export interface RestrictedSyntax {
+  readonly selector: string;
+  readonly message: string;
+}
+/** The same restriction lists as `@bastidood/oxlint-config/restrictions`. */
+export interface Restrictions {
+  readonly importPaths?: RestrictedImportPath[];
+  readonly importPatterns?: RestrictedImportPattern[];
+  readonly globals?: RestrictedGlobal[];
+  readonly properties?: RestrictedProperty[];
+  readonly syntax?: RestrictedSyntax[];
+}
+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.
+ */
+export interface Entry {
+  readonly configs?: (Linter.Config | Linter.Config[])[];
+  readonly extraFileExtensions?: string[];
+  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.
+ */
+export declare function compose(...entries: Entry[]): Linter.Config[];

package/dist/compose/index.mjs

@@ -0,0 +1,106 @@
+// ../oxlint/src/restrictions/index.ts
+/**
+* Restriction lists accumulated across entry points for the list-valued `no-restricted-*` rules, which Oxlint and
+* ESLint replace instead of merge. Each list is stored as the final rule entry with its severity in front, so
+* emitting a rule never copies the list.
+*/
+var RestrictionLists = class RestrictionLists {
+	#imports = {
+		paths: [],
+		patterns: []
+	};
+	#globals = ["error"];
+	#properties = ["error"];
+	#syntax = ["error"];
+	/** Append every list of an entry point's restrictions. */
+	append(restrictions) {
+		appendAll(this.#imports.paths, restrictions.importPaths);
+		appendAll(this.#imports.patterns, restrictions.importPatterns);
+		appendAll(this.#globals, restrictions.globals);
+		appendAll(this.#properties, restrictions.properties);
+		appendAll(this.#syntax, restrictions.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));
+		return copy;
+	}
+	importsRule() {
+		const { paths, patterns } = this.#imports;
+		return paths.length === 0 && patterns.length === 0 ? null : ["error", this.#imports];
+	}
+	globalsRule() {
+		return this.#globals.length === 1 ? null : this.#globals;
+	}
+	propertiesRule() {
+		return this.#properties.length === 1 ? null : this.#properties;
+	}
+	syntaxRule() {
+		return this.#syntax.length === 1 ? null : this.#syntax;
+	}
+};
+function appendAll(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.
+*/
+function compose(...entries) {
+	const configs = [];
+	const extraFileExtensions = [];
+	const restrictions = new RestrictionLists();
+	for (const { configs: entryConfigs, extraFileExtensions: entryExtensions, restrictions: entryRestrictions } of entries) {
+		appendConfigs(configs, entryConfigs);
+		if (typeof entryExtensions !== "undefined") for (const extension of entryExtensions) extraFileExtensions.push(extension);
+		if (typeof entryRestrictions !== "undefined") restrictions.append(entryRestrictions);
+	}
+	configs.push({
+		name: "@bastidood/eslint-config/restrictions",
+		rules: restrictionRules(restrictions)
+	});
+	for (const { scopedRestrictions } of entries) {
+		if (typeof scopedRestrictions === "undefined") continue;
+		for (const { files, restrictions: scoped } of scopedRestrictions) {
+			const lists = restrictions.copy();
+			lists.append(scoped);
+			configs.push({
+				name: "@bastidood/eslint-config/scoped-restrictions",
+				files,
+				rules: restrictionRules(lists)
+			});
+		}
+	}
+	if (extraFileExtensions.length > 0) configs.push({
+		name: "@bastidood/eslint-config/project-service",
+		languageOptions: { parserOptions: { extraFileExtensions } }
+	});
+	return configs;
+}
+/** Append an entry point's configurations, flattening nested configuration lists one level. */
+function appendConfigs(target, configs) {
+	if (typeof configs === "undefined") return;
+	for (const config of configs) if (Array.isArray(config)) for (const nested of config) target.push(nested);
+	else target.push(config);
+}
+function restrictionRules(lists) {
+	const rules = {};
+	const imports = lists.importsRule();
+	if (imports !== null) rules["no-restricted-imports"] = imports;
+	const globals = lists.globalsRule();
+	if (globals !== null) rules["no-restricted-globals"] = globals;
+	const properties = lists.propertiesRule();
+	if (properties !== null) rules["no-restricted-properties"] = properties;
+	const syntax = lists.syntaxRule();
+	if (syntax !== null) rules["no-restricted-syntax"] = syntax;
+	return rules;
+}
+export { compose };