@coryrylan/tools 0.1.0

package/dist/eslint/rules/no-single-consumer-abstraction.js

@@ -0,0 +1,364 @@
+import { IMPLICIT_EXCLUDED_DIRS, getPackageFiles, normalizePath, readFileSafe, tryParseJson, walk } from "./utils.js";
+import { existsSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+//#region src/eslint/rules/no-single-consumer-abstraction.ts
+/**
+* Flags an exported abstraction (an `abstract` class, or one whose name matches
+* a configured `Base…`/`…Base` pattern) with fewer than `minimumConsumers`
+* implementation consumers. Consumers are found by scanning sibling source
+* files on disk (cached per package root) and text-matching `extends` clauses,
+* resolving named/aliased/namespace/default imports and package barrel re-exports.
+*/
+var DEFAULT_MINIMUM_CONSUMERS = 2;
+var DEFAULT_INCLUDE = ["src/**"];
+var DEFAULT_NAME_PATTERNS = ["^Base", "Base$"];
+var DEFAULT_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js"
+];
+/**
+* Equivalent specifier suffixes a consumer might use to import a `.ts` source
+* file: extensionless (bundler-resolution projects), `.js` (the NodeNext
+* "import the compiled output extension" convention), or `.ts`
+* (`allowImportingTsExtensions`).
+*/
+var TS_SPECIFIER_SUFFIXES = [
+	"",
+	".js",
+	".ts"
+];
+/** {@link TS_SPECIFIER_SUFFIXES} plus the JSX-bearing equivalents `.tsx` sources may use. */
+var TSX_SPECIFIER_SUFFIXES = [
+	"",
+	".js",
+	".ts",
+	".jsx",
+	".tsx"
+];
+var rule = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow abstractions (base classes) that have fewer than two implementation consumers.",
+			recommended: true
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				minimumConsumers: {
+					type: "number",
+					minimum: 2
+				},
+				rootDir: { type: "string" },
+				include: {
+					type: "array",
+					items: { type: "string" }
+				},
+				exclude: {
+					type: "array",
+					items: { type: "string" }
+				},
+				detectAbstract: { type: "boolean" },
+				namePatterns: {
+					type: "array",
+					items: { type: "string" }
+				},
+				extensions: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: { "single-consumer": "Abstraction \"{{name}}\" has {{count}} implementation consumer(s). Inline it into the consumer until at least {{minimum}} consumers need the abstraction." }
+	},
+	create(context) {
+		const filename = normalizePath(context.physicalFilename);
+		const options = normalizeOptions(context.options[0]);
+		const root = options.rootDir ?? findPackageRoot(filename);
+		if (root === null || !shouldLint(filename, root, options)) return {};
+		return { ClassDeclaration(node) {
+			const className = getCandidateName(node, options);
+			if (className === null) return;
+			const defaultExported = isDefaultExported(node);
+			const count = countConsumers({
+				ast: context.sourceCode.ast,
+				className,
+				defaultExported,
+				filename,
+				root,
+				options
+			});
+			if (count >= options.minimumConsumers) return;
+			const data = {
+				name: className,
+				count: String(count),
+				minimum: String(options.minimumConsumers)
+			};
+			context.report({
+				node,
+				messageId: "single-consumer",
+				data
+			});
+		} };
+	}
+};
+function normalizeOptions(raw) {
+	const record = isRecord(raw) ? raw : {};
+	return {
+		minimumConsumers: readNumber(record["minimumConsumers"], DEFAULT_MINIMUM_CONSUMERS),
+		rootDir: readOptionalRoot(record["rootDir"]),
+		include: readStringArray(record["include"], DEFAULT_INCLUDE).map(globToRegExp),
+		exclude: readStringArray(record["exclude"], []).map(globToRegExp),
+		detectAbstract: readBoolean(record["detectAbstract"], true),
+		namePatterns: compilePatterns(readStringArray(record["namePatterns"], DEFAULT_NAME_PATTERNS)),
+		extensions: readStringArray(record["extensions"], DEFAULT_EXTENSIONS)
+	};
+}
+function readOptionalRoot(value) {
+	return isString(value) ? normalizePath(value) : null;
+}
+function compilePatterns(sources) {
+	const patterns = [];
+	for (const source of sources) {
+		const compiled = tryCompile(source);
+		if (compiled !== null) patterns.push(compiled);
+	}
+	return patterns;
+}
+function tryCompile(source) {
+	try {
+		return new RegExp(source);
+	} catch {
+		return null;
+	}
+}
+function getCandidateName(node, options) {
+	const name = getClassName(node);
+	if (name === null || !isExported(node)) return null;
+	if (options.detectAbstract && readProp(node, "abstract") === true) return name;
+	return options.namePatterns.some((pattern) => pattern.test(name)) ? name : null;
+}
+function getClassName(node) {
+	const name = readProp(readProp(node, "id"), "name");
+	return isString(name) ? name : null;
+}
+function isExported(node) {
+	const parentType = node.parent.type;
+	return parentType === "ExportNamedDeclaration" || parentType === "ExportDefaultDeclaration";
+}
+function isDefaultExported(node) {
+	return node.parent.type === "ExportDefaultDeclaration";
+}
+function shouldLint(filename, root, options) {
+	return isSourceFile(toRelativePath(root, filename), options);
+}
+function isSourceFile(relPath, options) {
+	if (relPath === null || isInExcludedDir(relPath) || relPath.endsWith(".d.ts")) return false;
+	if (!hasScannedExtension(relPath, options.extensions)) return false;
+	return matchesAny(relPath, options.include) && !matchesAny(relPath, options.exclude);
+}
+function isInExcludedDir(relPath) {
+	return relPath.split("/").some((segment) => IMPLICIT_EXCLUDED_DIRS.includes(segment));
+}
+function hasScannedExtension(relPath, extensions) {
+	return extensions.some((extension) => relPath.endsWith(extension));
+}
+function matchesAny(relPath, patterns) {
+	return patterns.some((pattern) => pattern.test(relPath));
+}
+function toRelativePath(root, file) {
+	const rel = normalizePath(relative(root, file));
+	if (rel === "" || rel === "." || rel === ".." || rel.startsWith("../")) return null;
+	return rel;
+}
+function countConsumers(args) {
+	let consumers = countLocalSubclasses(args.ast, args.className);
+	const barrels = getBarrelSpecifiers(args);
+	for (const file of getSourceFiles(args.root, args.options)) if (file !== args.filename) consumers += countConsumersInFile(file, args, barrels);
+	return consumers;
+}
+function countConsumersInFile(file, args, barrels) {
+	const text = readFileSafe(file);
+	if (text === null) return 0;
+	const specifiers = relativeImportSpecifiers(file, args.filename);
+	const names = new Set(importedNames(text, specifiers, {
+		className: args.className,
+		defaultExported: args.defaultExported
+	}));
+	for (const barrel of barrels) for (const name of importedNames(text, [barrel], {
+		className: args.className,
+		defaultExported: false
+	})) names.add(name);
+	return countSubclassMatches(text, [...names]);
+}
+function countLocalSubclasses(ast, className) {
+	let count = 0;
+	walk(ast, (node) => {
+		if (node.type === "ClassDeclaration" && node.superClass && extendsClass(node.superClass, className)) count += 1;
+	});
+	return count;
+}
+function extendsClass(superClass, className) {
+	const type = readProp(superClass, "type");
+	if (type === "Identifier") return readProp(superClass, "name") === className;
+	if (type === "TSInstantiationExpression") return extendsClass(readProp(superClass, "expression"), className);
+	return false;
+}
+function countSubclassMatches(text, localNames) {
+	if (localNames.length === 0) return 0;
+	const alternation = localNames.map(escapeRegExp).join("|");
+	const pattern = new RegExp(String.raw`\bclass\s+[A-Za-z_$][\w$]*(?:\s*<[^{}]*?>)?\s+extends\s+(?:${alternation})\b`, "g");
+	return [...text.matchAll(pattern)].length;
+}
+function importedNames(text, specifiers, query) {
+	const importMap = buildImportMap(text, specifiers);
+	const names = new Set(importMap.get(query.className) ?? []);
+	for (const namespace of importMap.get("*") ?? []) names.add(`${namespace}.${query.className}`);
+	if (query.defaultExported) for (const local of importMap.get("default") ?? []) names.add(local);
+	return [...names];
+}
+function buildImportMap(text, specifiers) {
+	const imports = /* @__PURE__ */ new Map();
+	const alternation = specifierAlternation(specifiers);
+	const importPattern = new RegExp(String.raw`import\s+(?:type\s+)?([^;]*?)\s+from\s+['"](?:${alternation})['"]`, "g");
+	for (const match of text.matchAll(importPattern)) {
+		const clause = (match[1] ?? "").trim();
+		addDefaultImport(imports, clause);
+		addNamespaceImport(imports, clause);
+		addNamedImports(imports, clause);
+	}
+	return imports;
+}
+function addDefaultImport(imports, clause) {
+	if (clause === "" || clause.startsWith("{") || clause.startsWith("*")) return;
+	const localName = (clause.split(/[,{]/)[0] ?? "").trim();
+	if (isIdentifier(localName)) addImport(imports, "default", localName);
+}
+function addNamespaceImport(imports, clause) {
+	const namespace = clause.match(/\*\s+as\s+([A-Za-z_$][\w$]*)/)?.[1];
+	if (namespace !== void 0) addImport(imports, "*", namespace);
+}
+function addNamedImports(imports, clause) {
+	const named = clause.match(/{(?<imports>[\s\S]*?)}/)?.groups?.["imports"];
+	if (named === void 0) return;
+	for (const entry of named.split(",")) addNamedEntry(imports, entry);
+}
+function addNamedEntry(imports, entry) {
+	const match = entry.trim().replace(/^type\s+/, "").match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+	const exported = match?.[1];
+	if (exported !== void 0) addImport(imports, exported, match?.[2] ?? exported);
+}
+function addImport(imports, exportedName, localName) {
+	const set = imports.get(exportedName) ?? /* @__PURE__ */ new Set();
+	set.add(localName);
+	imports.set(exportedName, set);
+}
+function getBarrelSpecifiers(args) {
+	const packageName = readPackageName(args.root);
+	if (packageName === null) return [];
+	return barrelReExports(args) ? [packageName] : [];
+}
+function barrelReExports(args) {
+	for (const barrel of barrelCandidates(args.root, args.options)) {
+		const text = readFileSafe(barrel);
+		if (text !== null && reExportsClass(text, args.className, relativeImportSpecifiers(barrel, args.filename))) return true;
+	}
+	return false;
+}
+function barrelCandidates(root, options) {
+	const candidates = [];
+	for (const extension of options.extensions) {
+		candidates.push(normalizePath(join(root, "src", `index${extension}`)));
+		candidates.push(normalizePath(join(root, `index${extension}`)));
+	}
+	return candidates;
+}
+function reExportsClass(text, className, specifiers) {
+	const alternation = specifierAlternation(specifiers);
+	const starPattern = new RegExp(String.raw`export\s+\*\s+from\s+['"](?:${alternation})['"]`, "m");
+	const namedPattern = new RegExp(String.raw`export\s+{[^}]*\b${escapeRegExp(className)}\b[^}]*}\s+from\s+['"](?:${alternation})['"]`, "m");
+	return starPattern.test(text) || namedPattern.test(text);
+}
+function getSourceFiles(root, options) {
+	return getPackageFiles(root).filter((file) => isSourceFile(toRelativePath(root, file), options));
+}
+function readPackageName(root) {
+	const text = readFileSafe(join(root, "package.json"));
+	if (text === null) return null;
+	const name = readProp(tryParseJson(text), "name");
+	return isString(name) ? name : null;
+}
+function findPackageRoot(filename) {
+	let current = dirname(filename);
+	while (current !== dirname(current)) {
+		if (existsSync(join(current, "package.json")) && existsSync(join(current, "src"))) return normalizePath(current);
+		current = dirname(current);
+	}
+	return null;
+}
+/**
+* Every specifier a consumer could plausibly use to import `toFile` from
+* `fromFile`: extensionless, `.js`, `.ts`, and - when `toFile` is a `.tsx`
+* source - the JSX-bearing equivalents too. Text-matching imports can't know
+* which module resolution convention a given consumer file follows, so every
+* candidate is checked instead of assuming one.
+*/
+function relativeImportSpecifiers(fromFile, toFile) {
+	const relativeBase = normalizePath(relative(fromFile.slice(0, fromFile.lastIndexOf("/")), toFile.replace(/\.tsx?$/, "")));
+	const specifierBase = relativeBase.startsWith(".") ? relativeBase : `./${relativeBase}`;
+	return (toFile.endsWith(".tsx") ? TSX_SPECIFIER_SUFFIXES : TS_SPECIFIER_SUFFIXES).map((suffix) => `${specifierBase}${suffix}`);
+}
+function specifierAlternation(specifiers) {
+	return specifiers.map(escapeRegExp).join("|");
+}
+function globToRegExp(glob) {
+	const normalized = glob.replaceAll(sep, "/");
+	const parts = [];
+	let index = 0;
+	while (index < normalized.length) index = appendGlobToken(normalized, index, parts);
+	return new RegExp(`^${parts.join("")}$`);
+}
+function appendGlobToken(glob, index, parts) {
+	const char = glob[index] ?? "";
+	if (char === "*" && glob[index + 1] === "*") return appendGlobstar(glob, index, parts);
+	if (char === "*") parts.push("[^/]*");
+	else if (char === "?") parts.push("[^/]");
+	else parts.push(escapeRegExp(char));
+	return index + 1;
+}
+function appendGlobstar(glob, index, parts) {
+	if (glob[index + 2] === "/") {
+		parts.push("(?:[^/]*/)*");
+		return index + 3;
+	}
+	parts.push(".*");
+	return index + 2;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function readProp(value, key) {
+	return isRecord(value) ? value[key] : void 0;
+}
+function readNumber(value, fallback) {
+	return typeof value === "number" ? value : fallback;
+}
+function readBoolean(value, fallback) {
+	return typeof value === "boolean" ? value : fallback;
+}
+function readStringArray(value, fallback) {
+	return Array.isArray(value) ? value.filter(isString) : fallback;
+}
+function isIdentifier(value) {
+	return /^[A-Za-z_$][\w$]*$/.test(value);
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+export { rule as default };

package/dist/eslint/rules/no-unjustified-disable.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ESLint rule that requires every `eslint-disable*` directive comment to
+ * carry a trailing `-- <reason>` justification (and, by default, an explicit
+ * rule list rather than a blanket disable). Agents reach for `eslint-disable`
+ * to get a green CI run; without a reason attached, a reviewer (human or
+ * agent) has no way to tell a legitimate suppression from one hiding a real
+ * bug, and a blanket disable silences rules nobody has looked at yet.
+ */
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/eslint/rules/no-unjustified-disable.js

@@ -0,0 +1,75 @@
+//#region src/eslint/rules/no-unjustified-disable.ts
+function readOptions(context) {
+	return { requireRuleIds: context.options[0]?.requireRuleIds ?? true };
+}
+/**
+* Matches a comment that opens with one of the three ESLint directive
+* keywords (`eslint-disable`, `eslint-disable-line`, `eslint-disable-next-line`),
+* anchored so the keyword must be the very first thing in the (trimmed)
+* comment text and be followed by whitespace or end-of-text. This
+* deliberately excludes `eslint-enable` (not a suppression, nothing to
+* justify) and prose that merely mentions "eslint-disable" mid-sentence.
+*/
+var DIRECTIVE_KEYWORD_PATTERN = /^(eslint-disable-next-line|eslint-disable-line|eslint-disable)(?=\s|$)/;
+/**
+* The `--` separator ESLint's own directive syntax uses to split the rule
+* list from the human-readable description, e.g.
+* `eslint-disable-next-line no-console -- reason`. Requires at least one
+* whitespace character before the dashes (so it can't misfire mid rule-id)
+* but is otherwise lenient about spacing around it.
+*/
+var JUSTIFICATION_SEPARATOR_PATTERN = /\s+--\s*/;
+/** Parses a comment's raw text as a directive, or returns `null` if it isn't one. */
+function parseDirective(commentText) {
+	const trimmedStart = commentText.replace(/^\s+/, "");
+	const keywordMatch = DIRECTIVE_KEYWORD_PATTERN.exec(trimmedStart);
+	if (!keywordMatch) return null;
+	const rest = trimmedStart.slice(keywordMatch[0].length);
+	const separatorMatch = JUSTIFICATION_SEPARATOR_PATTERN.exec(rest);
+	if (!separatorMatch) return {
+		rulePart: rest.trim(),
+		justification: ""
+	};
+	return {
+		rulePart: rest.slice(0, separatorMatch.index).trim(),
+		justification: rest.slice(separatorMatch.index + separatorMatch[0].length).trim()
+	};
+}
+function checkComment(context, comment, options) {
+	const parsed = parseDirective(comment.value);
+	if (!parsed) return;
+	if (parsed.justification === "") context.report({
+		node: comment,
+		messageId: "missingJustification"
+	});
+	if (options.requireRuleIds && parsed.rulePart === "") context.report({
+		node: comment,
+		messageId: "missingRuleIds"
+	});
+}
+var rule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require eslint-disable directives to explain why, and (by default) which rules they target.",
+			recommended: true
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { requireRuleIds: { type: "boolean" } }
+		}],
+		messages: {
+			missingJustification: "eslint-disable directives must explain why: append `-- <reason>`",
+			missingRuleIds: "Blanket eslint-disable hides unknown future violations; list the specific rules being disabled"
+		}
+	},
+	create(context) {
+		const options = readOptions(context);
+		return { Program() {
+			for (const comment of context.sourceCode.getAllComments()) checkComment(context, comment, options);
+		} };
+	}
+};
+//#endregion
+export { rule as default };

package/dist/eslint/rules/no-unpinned-dependency-ranges.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Enforces version-specifier conventions in `package.json` dependency blocks
+ * so that installs stay reproducible without breaking downstream
+ * deduplication:
+ *
+ * - Private packages: every dependency must be pinned to an exact version
+ *   (or a `workspace:*` link) - there is no consumer to deduplicate for, so
+ *   a range only adds nondeterminism.
+ * - Published packages: runtime dependencies (`dependencies`,
+ *   `peerDependencies`, `optionalDependencies`) must use a range (`^`/`~`,
+ *   or a concrete `workspace:` range) so consumers can dedupe; `devDependencies`
+ *   must stay pinned since they never affect consumers.
+ *
+ * Agents habitually run `pnpm add` (or edit `package.json` by hand) using
+ * whatever specifier the tool defaults to, which is easy to get backwards
+ * for a given package's publish status - this rule catches that in the diff
+ * instead of at release time.
+ *
+ * This is a JSON-language rule (built on `@eslint/json`'s momoa-backed AST),
+ * not an ESTree rule. `@eslint/json` exports a `JSONRuleDefinition` helper
+ * type, which is used below for `meta`/`create` typing; the shapes of the
+ * individual momoa nodes touched inside `create` (Document/Object/Member/
+ * String/Boolean) are never named explicitly - TypeScript infers them
+ * contextually from the `Document(node)` visitor signature and narrows them
+ * via the `.type` discriminant checks, so no local structural interfaces
+ * (or a direct dependency on `@humanwhocodes/momoa`, which this package
+ * does not declare) are needed.
+ */
+import type { JSONRuleDefinition } from '@eslint/json';
+interface NoUnpinnedDependencyRangesOptions {
+    /**
+     * Whether pnpm's `catalog:` protocol (e.g. `catalog:`, `catalog:publish`)
+     * is accepted unconditionally, bypassing the pinned/range checks below.
+     * Defaults to `true`. Set to `false` to make `catalog:` specifiers subject
+     * to the same rules as any other version string.
+     */
+    readonly allowCatalog?: boolean;
+}
+type NoUnpinnedDependencyRangesRuleOptions = [NoUnpinnedDependencyRangesOptions?];
+type NoUnpinnedDependencyRangesMessageIds = 'unpinned-range';
+export type NoUnpinnedDependencyRangesRuleDefinition = JSONRuleDefinition<{
+    RuleOptions: NoUnpinnedDependencyRangesRuleOptions;
+    MessageIds: NoUnpinnedDependencyRangesMessageIds;
+}>;
+declare const rule: NoUnpinnedDependencyRangesRuleDefinition;
+export default rule;

package/dist/eslint/rules/no-unpinned-dependency-ranges.js

@@ -0,0 +1,79 @@
+//#region src/eslint/rules/no-unpinned-dependency-ranges.ts
+var DEPENDENCY_GROUPS = /* @__PURE__ */ new Set([
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+]);
+var RUNTIME_DEPENDENCY_GROUPS = /* @__PURE__ */ new Set([
+	"dependencies",
+	"peerDependencies",
+	"optionalDependencies"
+]);
+/**
+* Any specifier that can resolve to more than one version: caret/tilde,
+* comparators (`>=9`, `<6.1.0`), unions (`^9 || ^10`), hyphen ranges
+* (`1.2 - 2`), and wildcard components (`*`, `1.x`, `1.2.x`). Protocol
+* specifiers such as `workspace:*` and `catalog:` deliberately do not match;
+* they are handled by their own branches.
+*/
+var VERSION_RANGE_PATTERN = /^[\^~]|^[<>]=?\s*\d|\|\||\s-\s|^(?:\d+(?:\.\d+)?\.)?[x*]$/;
+function isVersionRange(version) {
+	return VERSION_RANGE_PATTERN.test(version);
+}
+/** Returns a human-readable reason the version specifier is invalid, or `null` if it's fine. */
+function reasonForDependency({ isPrivate, isRuntime, version }) {
+	if (isPrivate) return isVersionRange(version) ? "Private packages must use pinned versions to ensure reproducible installs." : null;
+	if (isRuntime) return isVersionRange(version) || version.startsWith("workspace:") && version !== "workspace:*" ? null : "Published runtime dependencies must use a range specifier (^, ~, or a comparator such as >=) for downstream deduplication.";
+	return isVersionRange(version) ? "Published devDependencies must use pinned versions for reproducible installs." : null;
+}
+var rule = {
+	meta: {
+		type: "problem",
+		docs: { description: "Require package.json dependency version specifiers appropriate to the package's publish status (private vs. published) and dependency kind (runtime vs. dev)." },
+		schema: [{
+			type: "object",
+			properties: { allowCatalog: {
+				type: "boolean",
+				default: true
+			} },
+			additionalProperties: false
+		}],
+		messages: { "unpinned-range": "Dependency \"{{name}}\" has an invalid version specifier \"{{version}}\". {{reason}}" }
+	},
+	create(context) {
+		const allowCatalog = context.options[0]?.allowCatalog ?? true;
+		return { Document(node) {
+			const root = node.body;
+			if (root.type !== "Object") return;
+			const isPrivate = root.members.some((member) => member.name.type === "String" && member.name.value === "private" && member.value.type === "Boolean" && member.value.value);
+			root.members.forEach((member) => {
+				if (member.name.type !== "String" || !DEPENDENCY_GROUPS.has(member.name.value) || member.value.type !== "Object") return;
+				const isRuntime = RUNTIME_DEPENDENCY_GROUPS.has(member.name.value);
+				member.value.members.forEach((dep) => {
+					if (dep.name.type !== "String" || dep.value.type !== "String") return;
+					const name = dep.name.value;
+					const version = dep.value.value;
+					if (allowCatalog && version.startsWith("catalog:")) return;
+					const reason = reasonForDependency({
+						isPrivate,
+						isRuntime,
+						version
+					});
+					if (!reason) return;
+					context.report({
+						loc: dep.value.loc,
+						messageId: "unpinned-range",
+						data: {
+							name,
+							version,
+							reason
+						}
+					});
+				});
+			});
+		} };
+	}
+};
+//#endregion
+export { rule as default };

package/dist/eslint/rules/require-listener-cleanup.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ESLint rule that catches event listener leaks in class-based lifecycles
+ * (custom elements, and anything else that exposes a paired setup/teardown
+ * method, e.g. `onMount`/`onDestroy`).
+ */
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;