ai-deslop 0.2.0 → 0.2.1

package/README.md

@@ -11,7 +11,7 @@ npm install --save-dev ai-deslop
 # @oxlint/plugins comes along as a runtime dependency — keep it in sync with your oxlint version
 ```
 
-Requires a runtime with native TypeScript plugin support: Bun, Deno, or Node.js >= 22.18 / 20.19.
+Ships compiled JavaScript — works with any oxlint JS-plugin runtime (Bun, Deno, or Node.js).
 
 ## Usage
 
@@ -19,10 +19,10 @@ Register the plugin in `oxlint.config.ts` and enable every rule as an error via
 
 ```ts
 import { defineConfig } from "oxlint";
-import deslopPlugin, { configs as deslopConfigs } from "ai-deslop";
+import { configs as deslopConfigs } from "ai-deslop";
 
 export default defineConfig({
-  jsPlugins: [deslopPlugin],
+  jsPlugins: ["ai-deslop"],
   options: {
     ...deslopConfigs.recommended.options,
   },
@@ -108,8 +108,11 @@ The rules use Oxlint's ESTree and lexical-scope APIs rather than a TypeScript ty
 Enforces canonical Tailwind CSS class spellings with `--fix` support (`mt-[16px]` → `mt-4`). Same source of truth as the Tailwind language server. Excluded from `recommended` because it requires a `cssPath` option — add it manually:
 
 ```ts
+import { defineConfig } from "oxlint";
+import { configs as deslopConfigs } from "ai-deslop";
+
 export default defineConfig({
-  jsPlugins: [deslopPlugin],
+  jsPlugins: ["ai-deslop"],
   options: {
     ...deslopConfigs.recommended.options,
   },

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+/** Every `deslop/*` rule, plus selected standard rules, each set to `"error"`. Spread into the `rules` field of an oxlint config. */
+export declare const recommendedRules: Record<string, "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 declare const configs: {
+    recommended: {
+        name: string;
+        options: {
+            typeAware: boolean;
+        };
+        rules: Record<string, "error">;
+    };
+};
+/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
+declare const deslopPlugin: ReturnType<typeof eslintCompatPlugin> & {
+    configs: typeof configs;
+};
+export default deslopPlugin;

package/dist/index.js

@@ -0,0 +1,82 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+import { noArrayFilterMapRule } from "./rules/no-array-filter-map.js";
+import { noReduceAccumulatorCopyRule } from "./rules/no-reduce-accumulator-copy.js";
+import { noChainedTypeAssertionsRule } from "./rules/no-chained-type-assertions.js";
+import { noConditionalEmptyObjectSpreadRule } from "./rules/no-conditional-empty-object-spread.js";
+import { noKnownValueWideningRule } from "./rules/no-known-value-widening.js";
+import { noModuleMockingRule } from "./rules/no-module-mocking.js";
+import { noObjectParametersRule } from "./rules/no-object-parameters.js";
+import { noReflectApplyRule } from "./rules/no-reflect-apply.js";
+import { noReflectGetRule } from "./rules/no-reflect-get.js";
+import { noRuntimeTypeofRule } from "./rules/no-runtime-typeof.js";
+import { noForbiddenTermInSymbolNamesRule } from "./rules/no-shape-in-symbol-names.js";
+import { noUnknownParametersRule } from "./rules/no-unknown-parameters.js";
+import { noUnknownReturnsRule } from "./rules/no-unknown-returns.js";
+import { noUnknownTypeAliasesRule } from "./rules/no-unknown-type-aliases.js";
+import { noUnsafeDictionaryTypeRule } from "./rules/no-unsafe-dictionary-type.js";
+import { noWidenThenAssertRule } from "./rules/no-widen-then-assert.js";
+import { requireSafetyCommentForTypeAssertionRule } from "./rules/require-safety-comment-for-type-assertion.js";
+import { noCallOnlyAssertionsRule } from "./rules/no-call-only-assertions.js";
+import { noPassThroughTypeAliasRule } from "./rules/no-pass-through-type-alias.js";
+import { canonicalClassNames } from "./tailwind/rule.js";
+/** Every `deslop/*` rule, plus selected standard rules, each set to `"error"`. Spread into the `rules` field of an oxlint config. */
+export const recommendedRules = {
+    "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,
+    },
+});
+deslopPlugin.configs = configs;
+export default deslopPlugin;

package/dist/rules/no-array-filter-map.d.ts

@@ -0,0 +1,2 @@
+/** Reject eager array filter/map pipelines; lazy iterator helpers remain allowed. */
+export declare const noArrayFilterMapRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-array-filter-map.js

@@ -0,0 +1,30 @@
+import { defineRule } from "@oxlint/plugins";
+import { arrayMethodTarget, isKnownArrayExpression, unwrapArrayExpression } from "../shared/array-method.js";
+/** 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/dist/rules/no-call-only-assertions.d.ts

@@ -0,0 +1,2 @@
+/** Tests must assert on behavior, not only that a mock was called. */
+export declare const noCallOnlyAssertionsRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-call-only-assertions.js

@@ -0,0 +1,87 @@
+import { defineRule } 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) {
+    let current = 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) {
+    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) {
+    if (node.callee.type !== "MemberExpression" || node.callee.computed)
+        return undefined;
+    if (node.callee.property.type !== "Identifier")
+        return undefined;
+    let object = 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;
+}
+/** 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 = [];
+        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 });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-chained-type-assertions.d.ts

@@ -0,0 +1,2 @@
+/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
+export declare const noChainedTypeAssertionsRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-chained-type-assertions.js

@@ -0,0 +1,60 @@
+import { defineRule } from "@oxlint/plugins";
+function isTypeAssertionExpression(node) {
+    return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
+}
+function unwrapParenthesizedExpression(expression) {
+    let current = expression;
+    while (current.type === "ParenthesizedExpression") {
+        current = current.expression;
+    }
+    return current;
+}
+function isConstAssertion(node) {
+    const { typeAnnotation } = node;
+    return (typeAnnotation.type === "TSTypeReference" &&
+        typeAnnotation.typeName.type === "Identifier" &&
+        typeAnnotation.typeName.name === "const");
+}
+function isOutermostAssertionInChain(node) {
+    let current = node;
+    let parent = node.parent;
+    while (parent.type === "ParenthesizedExpression" && parent.expression === current) {
+        current = parent;
+        parent = parent.parent;
+    }
+    return !isTypeAssertionExpression(parent) || parent.expression !== current;
+}
+function isForbiddenAssertionChain(node) {
+    let assertionCount = 0;
+    let hasNonConstAssertion = false;
+    let current = node;
+    while (isTypeAssertionExpression(current)) {
+        assertionCount += 1;
+        hasNonConstAssertion ||= !isConstAssertion(current);
+        current = unwrapParenthesizedExpression(current.expression);
+    }
+    return assertionCount > 1 && hasNonConstAssertion;
+}
+/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
+export const noChainedTypeAssertionsRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow chained TypeScript as and angle-bracket assertions, including parenthesized chains.",
+        },
+        messages: {
+            chained: "This assertion chain discards type evidence. Keep the original precise type, or parse untrusted input at its boundary before narrowing it.",
+        },
+    },
+    createOnce(context) {
+        const checkTypeAssertion = (node) => {
+            if (!isOutermostAssertionInChain(node) || !isForbiddenAssertionChain(node))
+                return;
+            context.report({ node, messageId: "chained" });
+        };
+        return {
+            TSAsExpression: checkTypeAssertion,
+            TSTypeAssertion: checkTypeAssertion,
+        };
+    },
+});

package/dist/rules/no-conditional-empty-object-spread.d.ts

@@ -0,0 +1,2 @@
+/** Ban conditional empty-object spreads without changing their omission semantics. */
+export declare const noConditionalEmptyObjectSpreadRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-conditional-empty-object-spread.js

@@ -0,0 +1,40 @@
+import { defineRule } from "@oxlint/plugins";
+function unwrapParentheses(node) {
+    let current = node;
+    while (current.type === "ParenthesizedExpression") {
+        current = current.expression;
+    }
+    return current;
+}
+function isEmptyObjectExpression(node) {
+    return node.type === "ObjectExpression" && node.properties.length === 0;
+}
+function isConditionalEmptyObjectSpread(node) {
+    const conditional = unwrapParentheses(node);
+    return (conditional.type === "ConditionalExpression" &&
+        (isEmptyObjectExpression(conditional.consequent) ||
+            isEmptyObjectExpression(conditional.alternate)));
+}
+/** Ban conditional empty-object spreads without changing their omission semantics. */
+export const noConditionalEmptyObjectSpreadRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Disallow object spreads that conditionally spread an empty object to omit fields.",
+        },
+        messages: {
+            avoid: "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present.",
+        },
+    },
+    createOnce(context) {
+        return {
+            SpreadElement(node) {
+                if (node.parent.type !== "ObjectExpression")
+                    return;
+                if (isConditionalEmptyObjectSpread(node.argument)) {
+                    context.report({ node, messageId: "avoid" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-known-value-widening.d.ts

@@ -0,0 +1,2 @@
+/** Detect sound syntactic cases where a known value is explicitly widened and loses evidence. */
+export declare const noKnownValueWideningRule: import("@oxlint/plugins").Rule;