ai-deslop 0.2.0 → 0.2.2

package/dist/shared/type-alias-resolution.js

@@ -0,0 +1,162 @@
+import { lexicalTypeParameterNames } from "./lexical-type-parameters.js";
+const environmentsByProgram = new WeakMap();
+function isNode(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "type" in value &&
+        typeof value.type === "string");
+}
+function enclosingTypeScope(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === "Program" ||
+            current.type === "BlockStatement" ||
+            current.type === "TSModuleBlock" ||
+            current.type === "StaticBlock" ||
+            current.type === "SwitchStatement") {
+            return current;
+        }
+        current = current.parent;
+    }
+    return node;
+}
+function declaredTypeBinding(node) {
+    if (node.type === "TSTypeAliasDeclaration") {
+        return { alias: node, name: node.id.name };
+    }
+    if (node.type === "TSInterfaceDeclaration" ||
+        node.type === "TSEnumDeclaration" ||
+        node.type === "ClassDeclaration" ||
+        node.type === "ClassExpression") {
+        return node.id === null ? null : { alias: null, name: node.id.name };
+    }
+    if (node.type === "ImportSpecifier" ||
+        node.type === "ImportDefaultSpecifier" ||
+        node.type === "ImportNamespaceSpecifier") {
+        return { alias: null, name: node.local.name };
+    }
+    return null;
+}
+function collectTypeBindings(node, visitorKeys, bindingsByName, aliases) {
+    const declared = declaredTypeBinding(node);
+    if (declared !== null) {
+        const bindings = bindingsByName.get(declared.name) ?? [];
+        bindings.push({ ...declared, scope: enclosingTypeScope(node) });
+        bindingsByName.set(declared.name, bindings);
+        if (declared.alias !== null)
+            aliases.push(declared.alias);
+    }
+    // SAFETY: Oxlint's visitor keys identify only ESTree child-node properties.
+    const fields = node;
+    for (const key of visitorKeys[node.type] ?? []) {
+        const value = fields[key];
+        if (isNode(value)) {
+            collectTypeBindings(value, visitorKeys, bindingsByName, aliases);
+            continue;
+        }
+        if (!Array.isArray(value))
+            continue;
+        for (const child of value) {
+            if (isNode(child)) {
+                collectTypeBindings(child, visitorKeys, bindingsByName, aliases);
+            }
+        }
+    }
+}
+/** Collect every lexical type alias and competing type binding in a program. */
+export function createTypeAliasEnvironment(program, visitorKeys) {
+    const cached = environmentsByProgram.get(program);
+    if (cached !== undefined)
+        return cached;
+    const bindingsByName = new Map();
+    const aliases = [];
+    collectTypeBindings(program, visitorKeys, bindingsByName, aliases);
+    const environment = { aliases, bindingsByName, visitorKeys };
+    environmentsByProgram.set(program, environment);
+    return environment;
+}
+function ancestorDistance(ancestor, node) {
+    let current = node;
+    let distance = 0;
+    while (current !== null) {
+        if (current === ancestor)
+            return distance;
+        current = current.parent;
+        distance += 1;
+    }
+    return null;
+}
+function nearestTypeBindings(name, use, environment) {
+    const candidates = environment.bindingsByName.get(name) ?? [];
+    let nearestDistance = Number.POSITIVE_INFINITY;
+    let nearest = [];
+    for (const candidate of candidates) {
+        const distance = ancestorDistance(candidate.scope, use);
+        if (distance === null || distance > nearestDistance)
+            continue;
+        if (distance === nearestDistance) {
+            nearest.push(candidate);
+            continue;
+        }
+        nearestDistance = distance;
+        nearest = [candidate];
+    }
+    return nearest;
+}
+/** Resolve the nearest visible alias with this name, respecting lexical shadowing. */
+export function visibleTypeAlias(name, use, environment) {
+    if (lexicalTypeParameterNames(use, environment.visitorKeys).has(name))
+        return null;
+    const bindings = nearestTypeBindings(name, use, environment);
+    return bindings.length === 1 ? (bindings[0]?.alias ?? null) : null;
+}
+/** Return whether a local declaration shadows a built-in type at this use. */
+export function hasVisibleTypeBinding(name, use, environment) {
+    return (lexicalTypeParameterNames(use, environment.visitorKeys).has(name) ||
+        nearestTypeBindings(name, use, environment).length > 0);
+}
+function typeReferenceName(type) {
+    return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function aliasSubstitutions(alias, reference, base) {
+    const parameters = alias.typeParameters?.params ?? [];
+    const arguments_ = reference.typeArguments?.params ?? [];
+    const next = new Map(base);
+    for (const [index, parameter] of parameters.entries()) {
+        const explicitArgument = arguments_[index];
+        const argument = explicitArgument ?? parameter.default;
+        if (argument === null || argument === undefined)
+            return null;
+        const argumentSubstitutions = explicitArgument === undefined ? next : base;
+        next.set(parameter.name.name, {
+            type: argument,
+            substitutions: new Map(argumentSubstitutions),
+        });
+    }
+    return next;
+}
+/** Match a type after resolving visible aliases and substituting their type parameters. */
+export function resolvedTypeMatches(type, environment, matcher) {
+    const evaluate = (current, substitutions, resolvingAliases) => {
+        if (current.type === "TSTypeReference") {
+            const name = typeReferenceName(current);
+            if (name !== null) {
+                const substitution = substitutions.get(name);
+                if (substitution !== undefined && !current.typeArguments?.params.length) {
+                    return evaluate(substitution.type, substitution.substitutions, resolvingAliases);
+                }
+                const alias = visibleTypeAlias(name, current, environment);
+                if (alias !== null && !resolvingAliases.has(alias)) {
+                    const nextSubstitutions = aliasSubstitutions(alias, current, substitutions);
+                    if (nextSubstitutions !== null) {
+                        const nextResolving = new Set(resolvingAliases);
+                        nextResolving.add(alias);
+                        return evaluate(alias.typeAnnotation, nextSubstitutions, nextResolving);
+                    }
+                }
+            }
+        }
+        return matcher(current, (child) => evaluate(child, substitutions, resolvingAliases));
+    };
+    return evaluate(type, new Map(), new Set());
+}

package/dist/tailwind/candidates.d.ts

@@ -0,0 +1,14 @@
+export interface SpellingChange {
+    original: string;
+    canonical: string;
+}
+export declare function rewriteClassValue(value: string, canonicalOf: ReadonlyMap<string, string>): {
+    fixed: string;
+    changes: Array<SpellingChange>;
+};
+export declare function uniqueTokens(value: string): Array<string>;
+export declare function summarizeChanges(changes: ReadonlyArray<SpellingChange>): {
+    original: string;
+    canonical: string;
+    suffix: string;
+};

package/dist/tailwind/candidates.js

@@ -0,0 +1,24 @@
+export function rewriteClassValue(value, canonicalOf) {
+    const changes = [];
+    const fixed = value.replace(/\S+/g, (token) => {
+        const canonical = canonicalOf.get(token);
+        if (canonical !== undefined && canonical !== token) {
+            changes.push({ original: token, canonical });
+            return canonical;
+        }
+        return token;
+    });
+    return { fixed, changes };
+}
+export function uniqueTokens(value) {
+    const tokens = value.match(/\S+/g) ?? [];
+    return [...new Set(tokens)];
+}
+export function summarizeChanges(changes) {
+    const first = changes[0];
+    return {
+        original: first.original,
+        canonical: first.canonical,
+        suffix: changes.length > 1 ? ` (+${changes.length - 1} more in this string)` : "",
+    };
+}

package/dist/tailwind/design-system.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveCssPath(cssPath: string | undefined, cwd?: string): string;
+export declare function ensureDesignSystem(cssFile: string): string;
+export declare function canonicalizeTokens(key: string, tokens: Array<string>, rem: number): Map<string, string>;

package/dist/tailwind/design-system.js

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createSyncFn } from "synckit";
+// Resolved relative to the compiled output: `tsc` emits `worker.ts` as
+// `dist/tailwind/worker.js` next to this file, and consumers load the
+// package from `dist`, where Node cannot type-strip `.ts` under node_modules.
+const workerPath = fileURLToPath(new URL("./worker.js", import.meta.url));
+let syncCall = null;
+const loadedSystems = new Map();
+function getSyncCall() {
+    if (syncCall === null) {
+        syncCall = createSyncFn(workerPath);
+    }
+    return syncCall;
+}
+export function resolveCssPath(cssPath, cwd = process.cwd()) {
+    if (!cssPath)
+        throw new Error("cssPath is required");
+    return path.isAbsolute(cssPath) ? cssPath : path.resolve(cwd, cssPath);
+}
+export function ensureDesignSystem(cssFile) {
+    const stat = fs.statSync(cssFile);
+    if (loadedSystems.get(cssFile) === stat.mtimeMs)
+        return cssFile;
+    const cssContent = fs.readFileSync(cssFile, "utf8");
+    getSyncCall()({ type: "load", key: cssFile, cssContent, base: path.dirname(cssFile) });
+    loadedSystems.set(cssFile, stat.mtimeMs);
+    return cssFile;
+}
+export function canonicalizeTokens(key, tokens, rem) {
+    if (tokens.length === 0)
+        return new Map();
+    const canonical = getSyncCall()({ type: "canonicalize", key, candidates: tokens, rem });
+    if (!Array.isArray(canonical))
+        throw new Error("Tailwind canonicalization returned an invalid result");
+    const result = new Map();
+    for (let i = 0; i < tokens.length; i++)
+        result.set(tokens[i], canonical[i] ?? tokens[i]);
+    return result;
+}

package/dist/tailwind/rule.d.ts

@@ -0,0 +1,3 @@
+export declare const PLUGIN_NAME = "deslop";
+export declare const RULE_ID = "canonical-class-names";
+export declare const canonicalClassNames: import("@oxlint/plugins").Rule;

package/dist/tailwind/rule.js

@@ -0,0 +1,133 @@
+import { defineRule } from "@oxlint/plugins";
+import { rewriteClassValue, summarizeChanges, uniqueTokens } from "./candidates.js";
+import { canonicalizeTokens, ensureDesignSystem, resolveCssPath } from "./design-system.js";
+export const PLUGIN_NAME = "deslop";
+export const RULE_ID = "canonical-class-names";
+const DEFAULT_ATTRIBUTES = ["class", "className"];
+const DEFAULT_CALLEE_FUNCTIONS = ["cn", "clsx", "cva", "twMerge", "tw", "classNames", "cx"];
+const DEFAULT_ROOT_FONT_SIZE = 16;
+const OPTIONS_SCHEMA = {
+    type: "object",
+    properties: {
+        cssPath: { type: "string", description: "Path to the Tailwind v4 entry CSS." },
+        rootFontSize: { type: "number", description: "Root font size in px used for rem normalization." },
+        attributes: { type: "array", items: { type: "string" }, description: "JSX class-list attributes." },
+        calleeFunctions: { type: "array", items: { type: "string" }, description: "Class-list helper functions." },
+    },
+    required: ["cssPath"],
+    additionalProperties: false,
+};
+export const canonicalClassNames = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Enforce canonical Tailwind CSS class spellings." },
+        fixable: "code",
+        messages: {
+            nonCanonical: "Tailwind class '{{original}}' can be written as '{{canonical}}'.{{suffix}}",
+            cssNotFound: "Could not load Tailwind CSS entry file: {{path}}",
+        },
+        schema: [OPTIONS_SCHEMA],
+    },
+    createOnce(context) {
+        let attributes = new Set(DEFAULT_ATTRIBUTES);
+        let callees = new Set(DEFAULT_CALLEE_FUNCTIONS);
+        let rem = DEFAULT_ROOT_FONT_SIZE;
+        let cssFile = "";
+        let designKey = null;
+        function initFile() {
+            const options = (context.options?.[0] ?? {});
+            attributes = new Set(options.attributes ?? DEFAULT_ATTRIBUTES);
+            callees = new Set(options.calleeFunctions ?? DEFAULT_CALLEE_FUNCTIONS);
+            rem = options.rootFontSize ?? DEFAULT_ROOT_FONT_SIZE;
+            try {
+                cssFile = resolveCssPath(options.cssPath);
+            }
+            catch {
+                cssFile = options.cssPath ?? "";
+            }
+            designKey = null;
+        }
+        function getDesignKey() {
+            if (designKey === null) {
+                try {
+                    designKey = ensureDesignSystem(cssFile);
+                }
+                catch {
+                    designKey = false;
+                }
+            }
+            return designKey === false ? null : designKey;
+        }
+        function checkStringNode(node, value) {
+            const tokens = uniqueTokens(value);
+            if (tokens.length === 0)
+                return;
+            const key = getDesignKey();
+            if (key === null) {
+                context.report({ node, messageId: "cssNotFound", data: { path: cssFile } });
+                return;
+            }
+            let canonicalOf;
+            try {
+                canonicalOf = canonicalizeTokens(key, tokens, rem);
+            }
+            catch {
+                return;
+            }
+            const { fixed, changes } = rewriteClassValue(value, canonicalOf);
+            if (changes.length === 0)
+                return;
+            const summary = summarizeChanges(changes);
+            context.report({
+                node,
+                messageId: "nonCanonical",
+                data: summary,
+                fix(fixer) {
+                    const first = context.sourceCode.getText(node)[0];
+                    const quote = first === "'" || first === '"' || first === "`" ? first : '"';
+                    return fixer.replaceText(node, `${quote}${fixed}${quote}`);
+                },
+            });
+        }
+        function checkExpression(node) {
+            if (node.type === "Literal" && typeof node.value === "string")
+                checkStringNode(node, node.value);
+            else if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis.length === 1) {
+                checkStringNode(node, node.quasis[0].value.raw);
+            }
+        }
+        return {
+            before() {
+                initFile();
+                const text = context.sourceCode.text;
+                for (const name of attributes)
+                    if (name !== "" && text.includes(name))
+                        return;
+                for (const name of callees)
+                    if (name !== "" && text.includes(name))
+                        return;
+                return false;
+            },
+            JSXAttribute(node) {
+                if (node.name.type !== "JSXIdentifier" || !attributes.has(node.name.name) || !node.value)
+                    return;
+                if (node.value.type === "Literal" && typeof node.value.value === "string")
+                    checkStringNode(node.value, node.value.value);
+                else if (node.value.type === "JSXExpressionContainer")
+                    checkExpression(node.value.expression);
+            },
+            CallExpression(node) {
+                let name = null;
+                if (node.callee.type === "Identifier")
+                    name = node.callee.name;
+                else if (node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier")
+                    name = node.callee.property.name;
+                if (name === null || !callees.has(name))
+                    return;
+                for (const arg of node.arguments)
+                    if (arg.type === "Literal" || arg.type === "TemplateLiteral")
+                        checkExpression(arg);
+            },
+        };
+    },
+});

package/dist/tailwind/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tailwind/worker.js

@@ -0,0 +1,13 @@
+import { __unstable__loadDesignSystem } from "@tailwindcss/node";
+import { runAsWorker } from "synckit";
+const designSystems = new Map();
+runAsWorker(async (job) => {
+    if (job.type === "load") {
+        designSystems.set(job.key, await __unstable__loadDesignSystem(job.cssContent, { base: job.base }));
+        return { ok: true };
+    }
+    const designSystem = designSystems.get(job.key);
+    if (!designSystem)
+        throw new Error(`Tailwind design system not loaded for "${job.key}"`);
+    return designSystem.canonicalizeCandidates(job.candidates, { rem: job.rem });
+});

package/package.json

@@ -1,15 +1,25 @@
 {
   "name": "ai-deslop",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.",
   "type": "module",
-  "exports": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "files": [
-    "src"
+    "dist"
   ],
   "scripts": {
-    "check": "oxlint src && tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
+    "check": "npm run build && oxlint src && tsc --noEmit",
     "lint": "oxlint src",
+    "test": "vitest run",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
@@ -28,7 +38,8 @@
   "devDependencies": {
     "@types/node": "26.2.0",
     "oxlint": "1.82.0",
-    "typescript": "7.0.2"
+    "typescript": "7.0.2",
+    "vitest": "^5.0.1"
   },
   "license": "MIT",
   "repository": {

package/src/index.ts

@@ -1,87 +0,0 @@
-import { eslintCompatPlugin } from "@oxlint/plugins";
-
-import { noArrayFilterMapRule } from "./rules/no-array-filter-map.ts";
-import { noReduceAccumulatorCopyRule } from "./rules/no-reduce-accumulator-copy.ts";
-import { noChainedTypeAssertionsRule } from "./rules/no-chained-type-assertions.ts";
-import { noConditionalEmptyObjectSpreadRule } from "./rules/no-conditional-empty-object-spread.ts";
-import { noKnownValueWideningRule } from "./rules/no-known-value-widening.ts";
-import { noModuleMockingRule } from "./rules/no-module-mocking.ts";
-import { noObjectParametersRule } from "./rules/no-object-parameters.ts";
-import { noReflectApplyRule } from "./rules/no-reflect-apply.ts";
-import { noReflectGetRule } from "./rules/no-reflect-get.ts";
-import { noRuntimeTypeofRule } from "./rules/no-runtime-typeof.ts";
-import { noForbiddenTermInSymbolNamesRule } from "./rules/no-shape-in-symbol-names.ts";
-import { noUnknownParametersRule } from "./rules/no-unknown-parameters.ts";
-import { noUnknownReturnsRule } from "./rules/no-unknown-returns.ts";
-import { noUnknownTypeAliasesRule } from "./rules/no-unknown-type-aliases.ts";
-import { noUnsafeDictionaryTypeRule } from "./rules/no-unsafe-dictionary-type.ts";
-import { noWidenThenAssertRule } from "./rules/no-widen-then-assert.ts";
-import { requireSafetyCommentForTypeAssertionRule } from "./rules/require-safety-comment-for-type-assertion.ts";
-import { noCallOnlyAssertionsRule } from "./rules/no-call-only-assertions.ts";
-import { noPassThroughTypeAliasRule } from "./rules/no-pass-through-type-alias.ts";
-import { canonicalClassNames } from "./tailwind/rule.ts";
-
-/** Every `deslop/*` rule, plus selected standard rules, each set to `"error"`. Spread into the `rules` field of an oxlint config. */
-export const recommendedRules: Record<string, "error"> = {
-	"deslop/no-array-filter-map": "error",
-	"deslop/no-reduce-accumulator-copy": "error",
-	"deslop/no-chained-type-assertions": "error",
-	"deslop/no-conditional-empty-object-spread": "error",
-	"deslop/no-known-value-widening": "error",
-	"deslop/no-module-mocking": "error",
-	"deslop/no-object-parameters": "error",
-	"deslop/no-reflect-apply": "error",
-	"deslop/no-reflect-get": "error",
-	"deslop/no-runtime-typeof": "error",
-	"deslop/no-shape-in-symbol-names": "error",
-	"deslop/no-unknown-parameters": "error",
-	"deslop/no-unknown-returns": "error",
-	"deslop/no-unknown-type-aliases": "error",
-	"deslop/no-unsafe-dictionary-type": "error",
-	"deslop/no-widen-then-assert": "error",
-	"deslop/require-safety-comment-for-type-assertion": "error",
-	"deslop/no-call-only-assertions": "error",
-	"deslop/no-pass-through-type-alias": "error",
-	"typescript/no-deprecated": "error",
-	"typescript/no-floating-promises": "error",
-};
-
-/** ESLint flat-config style configs. `recommended` enables every `deslop/*` rule as `"error"` (except opt-in rules like `canonical-class-names`), plus standard `typescript/*` rules. The `typescript/*` rules require type-aware linting (`options.typeAware`), so `recommended` sets it. */
-export const configs = {
-	recommended: {
-		name: "deslop/recommended",
-		options: { typeAware: true },
-		rules: recommendedRules,
-	},
-};
-
-/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
-const deslopPlugin = eslintCompatPlugin({
-	meta: { name: "deslop" },
-	rules: {
-		"no-array-filter-map": noArrayFilterMapRule,
-		"no-reduce-accumulator-copy": noReduceAccumulatorCopyRule,
-		"no-chained-type-assertions": noChainedTypeAssertionsRule,
-		"no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
-		"no-known-value-widening": noKnownValueWideningRule,
-		"no-module-mocking": noModuleMockingRule,
-		"no-object-parameters": noObjectParametersRule,
-		"no-reflect-apply": noReflectApplyRule,
-		"no-reflect-get": noReflectGetRule,
-		"no-runtime-typeof": noRuntimeTypeofRule,
-		"no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
-		"no-unknown-parameters": noUnknownParametersRule,
-		"no-unknown-returns": noUnknownReturnsRule,
-		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
-		"no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
-		"no-widen-then-assert": noWidenThenAssertRule,
-		"require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
-		"no-call-only-assertions": noCallOnlyAssertionsRule,
-		"no-pass-through-type-alias": noPassThroughTypeAliasRule,
-		// Opt-in: NOT in `recommendedRules`. Requires a `cssPath` option, so users add it manually.
-		"canonical-class-names": canonicalClassNames,
-	},
-}) as ReturnType<typeof eslintCompatPlugin> & { configs: typeof configs };
-deslopPlugin.configs = configs;
-
-export default deslopPlugin;

package/src/rules/no-array-filter-map.ts

@@ -1,28 +0,0 @@
-import { defineRule } from "@oxlint/plugins";
-
-import { arrayMethodTarget, isKnownArrayExpression, unwrapArrayExpression } from "../shared/array-method.ts";
-
-/** Reject eager array filter/map pipelines; lazy iterator helpers remain allowed. */
-export const noArrayFilterMapRule = defineRule({
-  meta: {
-    type: "suggestion",
-    docs: { description: "Disallow adjacent array filter/map passes in favor of lazy iterator helpers or a single transformation." },
-    messages: {
-      arrayFilterMap: "Avoid consecutive array `{{first}}` and `{{second}}` passes. Prefer `.values().{{first}}(...).{{second}}(...).toArray()` where iterator helpers are supported, or a single `flatMap`/mutating reducer. Preserve callback ordering, indexes, and filtering semantics.",
-    },
-  },
-  createOnce(context) {
-    return {
-      CallExpression(node) {
-        const outer = arrayMethodTarget(node.callee);
-        if (outer === null || (outer.name !== "map" && outer.name !== "filter")) return;
-        const innerCall = unwrapArrayExpression(outer.object);
-        if (innerCall.type !== "CallExpression") return;
-        const inner = arrayMethodTarget(innerCall.callee);
-        if (inner === null || inner.name !== (outer.name === "map" ? "filter" : "map")) return;
-        if (!isKnownArrayExpression(context.sourceCode, inner.object)) return;
-        context.report({ node, messageId: "arrayFilterMap", data: { first: inner.name, second: outer.name } });
-      },
-    };
-  },
-});

package/src/rules/no-call-only-assertions.ts

@@ -1,94 +0,0 @@
-import { defineRule } from "@oxlint/plugins";
-import type { ESTree } from "@oxlint/plugins";
-
-// Tests whose every assertion is a "was it called" mock check verify orchestration, not behavior.
-// `toHaveBeenCalledWith` is allowed because it asserts on real data.
-
-const CALL_ONLY_MATCHERS = new Set(["toHaveBeenCalled", "toHaveBeenCalledTimes", "toHaveBeenCalledOnce"]);
-const TEST_NAMES = new Set(["it", "test"]);
-const MODIFIERS = new Set(["not", "resolves", "rejects"]);
-
-function rootIdentifierName(node: ESTree.Expression): string | undefined {
-	let current: ESTree.Expression = node;
-	while (true) {
-		if (current.type === "Identifier") return current.name;
-		if (current.type === "MemberExpression") {
-			current = current.object;
-		} else if (current.type === "CallExpression" || current.type === "TaggedTemplateExpression") {
-			current = current.type === "CallExpression" ? current.callee : current.tag;
-		} else {
-			return undefined;
-		}
-	}
-}
-
-function isTestCall(node: ESTree.CallExpression): boolean {
-	const name = rootIdentifierName(node.callee);
-	if (name === undefined || !TEST_NAMES.has(name)) return false;
-	const callback = node.arguments.at(-1);
-	return callback?.type === "FunctionExpression" || callback?.type === "ArrowFunctionExpression";
-}
-
-function matcherName(node: ESTree.CallExpression): string | undefined {
-	if (node.callee.type !== "MemberExpression" || node.callee.computed) return undefined;
-	if (node.callee.property.type !== "Identifier") return undefined;
-	let object: ESTree.Expression = node.callee.object;
-	while (
-		object.type === "MemberExpression" &&
-		!object.computed &&
-		object.property.type === "Identifier" &&
-		MODIFIERS.has(object.property.name)
-	) {
-		object = object.object;
-	}
-	const isExpectCall = object.type === "CallExpression" && rootIdentifierName(object.callee) === "expect";
-	return isExpectCall ? node.callee.property.name : undefined;
-}
-
-interface TestEntry {
-	node: ESTree.CallExpression;
-	total: number;
-	callOnly: number;
-}
-
-/** Tests must assert on behavior, not only that a mock was called. */
-export const noCallOnlyAssertionsRule = defineRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Tests must assert on behavior, not only that a mock was called" },
-		messages: {
-			callOnlyAssertions:
-				"Every assertion in this test only checks that a mock was called. First check whether this is a valuable test; remove it if not. Otherwise, assert on returned values, state, or call arguments instead.",
-		},
-		schema: [],
-	},
-	createOnce(context) {
-		let tests: Array<TestEntry> = [];
-
-		return {
-			before() {
-				tests = [];
-			},
-			CallExpression(node) {
-				if (isTestCall(node)) {
-					tests.push({ node, total: 0, callOnly: 0 });
-					return;
-				}
-				const test = tests.at(-1);
-				if (!test) return;
-				const matcher = matcherName(node);
-				if (!matcher) return;
-				test.total += 1;
-				if (CALL_ONLY_MATCHERS.has(matcher)) test.callOnly += 1;
-			},
-			"CallExpression:exit"(node) {
-				const test = tests.at(-1);
-				if (test?.node !== node) return;
-				tests.pop();
-				if (test.total > 0 && test.total === test.callOnly) {
-					context.report({ messageId: "callOnlyAssertions", node: node.callee });
-				}
-			},
-		};
-	},
-});