ai-deslop 0.4.8 → 0.5.0

package/README.md

@@ -72,6 +72,7 @@ All rules below are enabled by the recommended config unless listed as opt-in.
 | --- | --- |
 | [`no-duplicate-consts`](docs/no-duplicate-consts.md) | Reports all-caps constants with the same static value in different files. |
 | [`no-duplicate-types`](docs/no-duplicate-types.md) | Reports exact duplicate object contracts. No fixer. |
+| [`no-pass-through-schema`](docs/no-pass-through-schema.md) | Reports const aliases that only rename known schemas. Supports Zod, ArkType, and configured imports. No fixer. |
 | [`no-renamed-imports`](docs/no-renamed-imports.md) | Fixes unnecessary named-import aliases when the original name has no module-level conflict. |
 | [`no-reexports-outside-entrypoints`](docs/no-reexports-outside-entrypoints.md) | Keeps re-exports in configured entrypoint files. No fixer. |
 | [`canonical-class-names`](docs/tailwind.md) | Fixes non-canonical Tailwind CSS v4 class spellings. |
@@ -88,7 +89,7 @@ All rules below are enabled by the recommended config unless listed as opt-in.
 
 ## Credits
 
-- Generic rules vendored verbatim from [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) (MIT, © Dillon Mulroy), including `src/shared/*`.
+- Generic rules vendored verbatim from [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) (MIT, © Dillon Mulroy) in `src/vendor/anti-slop/`, including shared helpers.
 
 ## License
 

package/dist/index.d.ts

@@ -1,6 +1,9 @@
 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">;
+export declare const recommendedRules: Record<string, "error" | ["error", {
+    selector: string;
+    message: string;
+}]>;
 /** ESLint flat-config style configs. `recommended` enables every recommended `deslop/*` rule as `"error"` (excluding opt-in rules), plus standard `typescript/*` rules. The `typescript/*` rules require type-aware linting (`options.typeAware`), so `recommended` sets it. */
 export declare const configs: {
     recommended: {
@@ -8,7 +11,10 @@ export declare const configs: {
         options: {
             typeAware: boolean;
         };
-        rules: Record<string, "error">;
+        rules: Record<string, "error" | ["error", {
+            selector: string;
+            message: string;
+        }]>;
     };
 };
 /** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */

package/dist/index.js

@@ -1,25 +1,27 @@
 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 { noArrayFilterMapRule } from "./vendor/anti-slop/rules/no-array-filter-map.js";
+import { noReduceAccumulatorCopyRule } from "./vendor/anti-slop/rules/no-reduce-accumulator-copy.js";
+import { noChainedTypeAssertionsRule } from "./vendor/anti-slop/rules/no-chained-type-assertions.js";
+import { noConditionalEmptyObjectSpreadRule } from "./vendor/anti-slop/rules/no-conditional-empty-object-spread.js";
+import { noKnownValueWideningRule } from "./vendor/anti-slop/rules/no-known-value-widening.js";
+import { noModuleMockingRule } from "./vendor/anti-slop/rules/no-module-mocking.js";
+import { noObjectParametersRule } from "./vendor/anti-slop/rules/no-object-parameters.js";
+import { noReflectApplyRule } from "./vendor/anti-slop/rules/no-reflect-apply.js";
+import { noReflectGetRule } from "./vendor/anti-slop/rules/no-reflect-get.js";
+import { noRestrictedSyntaxRule } from "./rules/no-restricted-syntax.js";
+import { noRuntimeTypeofRule } from "./vendor/anti-slop/rules/no-runtime-typeof.js";
+import { noForbiddenTermInSymbolNamesRule } from "./vendor/anti-slop/rules/no-shape-in-symbol-names.js";
+import { noUnknownParametersRule } from "./vendor/anti-slop/rules/no-unknown-parameters.js";
+import { noUnknownReturnsRule } from "./vendor/anti-slop/rules/no-unknown-returns.js";
+import { noUnknownTypeAliasesRule } from "./vendor/anti-slop/rules/no-unknown-type-aliases.js";
+import { noUnsafeDictionaryTypeRule } from "./vendor/anti-slop/rules/no-unsafe-dictionary-type.js";
+import { noWidenThenAssertRule } from "./vendor/anti-slop/rules/no-widen-then-assert.js";
+import { requireSafetyCommentForTypeAssertionRule } from "./vendor/anti-slop/rules/require-safety-comment-for-type-assertion.js";
 import { noCallOnlyAssertionsRule } from "./rules/no-call-only-assertions.js";
 import { noPoorSubstringTestsRule } from "./rules/no-poor-substring-tests.js";
 import { noRepeatedExpectCallRule } from "./rules/no-repeated-expect-call.js";
 import { noPassThroughTypeAliasRule } from "./rules/no-pass-through-type-alias.js";
+import { noPassThroughSchemaRule } from "./rules/no-pass-through-schema.js";
 import { noDuplicateTypesRule } from "./rules/no-duplicate-types.js";
 import { noDuplicateConstsRule } from "./rules/no-duplicate-consts.js";
 import { noRenamedImportsRule } from "./rules/no-renamed-imports.js";
@@ -29,6 +31,7 @@ import { canonicalClassNames } from "./tailwind/rule.js";
 export const recommendedRules = {
     "deslop/no-array-filter-map": "error",
     "deslop/no-reduce-accumulator-copy": "error",
+    "oxc/no-accumulating-spread": "error",
     "deslop/no-chained-type-assertions": "error",
     "deslop/no-conditional-empty-object-spread": "error",
     "deslop/no-known-value-widening": "error",
@@ -53,6 +56,13 @@ export const recommendedRules = {
     "typescript/no-floating-promises": "error",
     "typescript/no-unnecessary-condition": "error",
     "no-unreachable": "error",
+    "deslop/no-restricted-syntax": [
+        "error",
+        {
+            selector: "NewExpression[callee.name='Map'][arguments.length=0]:not([typeArguments])",
+            message: "Bare new Map() infers Map<any, any>. Provide entries so types can be inferred.",
+        },
+    ],
 };
 /** ESLint flat-config style configs. `recommended` enables every recommended `deslop/*` rule as `"error"` (excluding opt-in rules), plus standard `typescript/*` rules. The `typescript/*` rules require type-aware linting (`options.typeAware`), so `recommended` sets it. */
 export const configs = {
@@ -75,6 +85,7 @@ const deslopPlugin = eslintCompatPlugin({
         "no-object-parameters": noObjectParametersRule,
         "no-reflect-apply": noReflectApplyRule,
         "no-reflect-get": noReflectGetRule,
+        "no-restricted-syntax": noRestrictedSyntaxRule,
         "no-runtime-typeof": noRuntimeTypeofRule,
         "no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
         "no-unknown-parameters": noUnknownParametersRule,
@@ -88,6 +99,7 @@ const deslopPlugin = eslintCompatPlugin({
         "no-repeated-expect-call": noRepeatedExpectCallRule,
         "no-constant-substring-tests": noPoorSubstringTestsRule,
         "no-pass-through-type-alias": noPassThroughTypeAliasRule,
+        "no-pass-through-schema": noPassThroughSchemaRule,
         "no-duplicate-types": noDuplicateTypesRule,
         "no-duplicate-consts": noDuplicateConstsRule,
         "no-renamed-imports": noRenamedImportsRule,

package/dist/rules/no-pass-through-schema.d.ts

@@ -0,0 +1,2 @@
+/** Disallow const aliases that only rename a known schema. */
+export declare const noPassThroughSchemaRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-pass-through-schema.js

@@ -0,0 +1,200 @@
+import { defineRule } from "@oxlint/plugins";
+// Only known schema-producing APIs belong here. Parsing and inspection APIs do not.
+const zodFactories = new Set([
+    "string", "number", "bigint", "boolean", "date", "symbol", "undefined", "null", "void",
+    "any", "unknown", "never", "literal", "enum", "nativeEnum", "object", "strictObject",
+    "looseObject", "array", "tuple", "record", "map", "set", "union", "discriminatedUnion",
+    "intersection", "optional", "nullable", "nullish", "lazy", "promise", "custom",
+    "preprocess", "instanceof", "templateLiteral", "file", "json",
+]);
+const zodMethods = new Set([
+    "optional", "nullable", "nullish", "array", "or", "and", "refine", "superRefine", "check",
+    "transform", "pipe", "default", "prefault", "catch", "brand", "readonly", "describe", "meta",
+    "extend", "safeExtend", "merge", "pick", "omit", "partial", "required", "keyof",
+    "strict", "strip", "passthrough", "catchall", "nonoptional", "unwrap",
+    "min", "max", "length", "nonempty", "email", "url", "uuid", "regex", "includes",
+    "startsWith", "endsWith", "trim", "toLowerCase", "toUpperCase", "int", "positive",
+    "negative", "nonnegative", "nonpositive", "finite", "multipleOf", "safe", "gt", "gte", "lt", "lte",
+]);
+const arkMethods = new Set([
+    "array", "or", "and", "pipe", "narrow", "brand", "describe", "configure", "optional",
+    "default", "pick", "omit", "partial", "required", "merge", "keyof", "extract", "exclude",
+    "atLeast", "atMost", "moreThan", "lessThan", "atLeastLength", "atMostLength", "exactlyLength",
+    "matching", "divisibleBy", "onUndeclaredKey", "onDeepUndeclaredKey",
+]);
+function memberName(node) {
+    if (!node.computed && node.property.type === "Identifier")
+        return node.property.name;
+    if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string")
+        return node.property.value;
+    return null;
+}
+function memberKind(owner, name) {
+    if (name === null)
+        return null;
+    if ((owner === "zod-module" || owner === "zod-namespace") && name === "z")
+        return "zod-namespace";
+    if ((owner === "zod-module" || owner === "zod-namespace") && zodFactories.has(name))
+        return "zod-factory";
+    if (owner === "ark-module" && name === "type")
+        return "ark-factory";
+    return null;
+}
+/** Disallow const aliases that only rename a known schema. */
+export const noPassThroughSchemaRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Disallow pass-through aliases of known schemas" },
+        messages: { passThroughSchema: "Use {{schemaName}} directly instead of creating a pass-through schema alias." },
+        schema: [{
+                type: "object",
+                properties: {
+                    libraries: { type: "array", items: { enum: ["zod", "arktype"] }, uniqueItems: true },
+                    allowExportedAliases: { type: "boolean" },
+                    schemaImports: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: { from: { type: "string" }, names: { type: "array", items: { type: "string" } } },
+                            required: ["from", "names"],
+                            additionalProperties: false,
+                        },
+                    },
+                },
+                additionalProperties: false,
+            }],
+    },
+    createOnce(context) {
+        let options;
+        const candidates = [];
+        const exported = new Set();
+        function variableFor(node) {
+            let scope = context.sourceCode.getScope(node);
+            while (true) {
+                const variable = scope.set.get(node.name);
+                if (variable !== undefined)
+                    return variable;
+                if (scope.upper === null)
+                    return null;
+                scope = scope.upper;
+            }
+        }
+        function kind(node, seen = new Set()) {
+            if (node.type === "Identifier") {
+                const variable = variableFor(node);
+                if (variable === null || seen.has(variable) || variable.defs.length !== 1)
+                    return null;
+                seen.add(variable);
+                const definition = variable.defs[0];
+                if (definition.type === "ImportBinding") {
+                    const specifier = definition.node;
+                    const declaration = specifier.parent;
+                    if (declaration?.type !== "ImportDeclaration" || declaration.importKind === "type")
+                        return null;
+                    if (specifier.type === "ImportSpecifier" && specifier.importKind === "type")
+                        return null;
+                    const source = declaration.source.value;
+                    const name = specifier.type === "ImportSpecifier"
+                        ? specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value
+                        : specifier.type === "ImportDefaultSpecifier" ? "default" : null;
+                    if (name !== null && options.schemaImports?.some((entry) => entry.from === source && entry.names.includes(name)))
+                        return "schema";
+                    const libraries = options.libraries ?? ["zod", "arktype"];
+                    if (libraries.includes("zod") && ["zod", "zod/v3", "zod/v4", "zod/v4/classic", "zod/v4/mini", "zod/mini"].includes(source)) {
+                        if (name === null)
+                            return "zod-module";
+                        if (name === "z" || name === "default")
+                            return "zod-namespace";
+                        if (zodFactories.has(name))
+                            return "zod-factory";
+                    }
+                    if (libraries.includes("arktype") && source === "arktype") {
+                        if (name === null)
+                            return "ark-module";
+                        if (name === "type")
+                            return "ark-factory";
+                    }
+                    return null;
+                }
+                if (definition.type !== "Variable" || definition.node.type !== "VariableDeclarator")
+                    return null;
+                const declaration = definition.node;
+                if (declaration.parent.type !== "VariableDeclaration" || declaration.parent.kind !== "const" || declaration.id.type !== "Identifier" || declaration.init === null)
+                    return null;
+                return kind(declaration.init, seen);
+            }
+            if (node.type === "MemberExpression") {
+                return memberKind(kind(node.object, seen), memberName(node));
+            }
+            if (node.type !== "CallExpression")
+                return null;
+            let factory;
+            if (node.callee.type === "MemberExpression") {
+                const owner = kind(node.callee.object, seen);
+                const name = memberName(node.callee);
+                if (owner === "zod-schema" && name === "meta" && node.arguments.length === 0)
+                    return null;
+                if (name !== null && owner === "zod-schema" && zodMethods.has(name))
+                    return owner;
+                if (name !== null && owner === "ark-schema" && arkMethods.has(name))
+                    return owner;
+                factory = memberKind(owner, name);
+            }
+            else {
+                factory = kind(node.callee, seen);
+            }
+            if (factory === "zod-factory")
+                return "zod-schema";
+            if (factory === "ark-factory")
+                return "ark-schema";
+            return null;
+        }
+        function markExport(node) {
+            const variable = variableFor(node);
+            if (variable !== null)
+                exported.add(variable);
+        }
+        return {
+            before() {
+                options = context.options[0] ?? {};
+                candidates.length = 0;
+                exported.clear();
+            },
+            VariableDeclarator(node) {
+                if (node.parent.type === "VariableDeclaration" && node.parent.kind === "const" && node.id.type === "Identifier" && node.init?.type === "Identifier")
+                    candidates.push(node);
+            },
+            ExportNamedDeclaration(node) {
+                if (node.exportKind === "type")
+                    return;
+                if (node.declaration?.type === "VariableDeclaration") {
+                    for (const declaration of node.declaration.declarations)
+                        if (declaration.id.type === "Identifier")
+                            markExport(declaration.id);
+                }
+                if (node.source !== null)
+                    return;
+                for (const specifier of node.specifiers)
+                    if (specifier.exportKind !== "type" && specifier.local.type === "Identifier")
+                        markExport(specifier.local);
+            },
+            ExportDefaultDeclaration(node) {
+                if (node.declaration.type === "Identifier")
+                    markExport(node.declaration);
+            },
+            "Program:exit"() {
+                for (const node of candidates) {
+                    if (node.id.type !== "Identifier" || node.init?.type !== "Identifier")
+                        continue;
+                    const target = kind(node.init);
+                    if (target !== "schema" && target !== "zod-schema" && target !== "ark-schema")
+                        continue;
+                    const variable = variableFor(node.id);
+                    if (options.allowExportedAliases && variable !== null && exported.has(variable))
+                        continue;
+                    context.report({ node, messageId: "passThroughSchema", data: { schemaName: node.init.name } });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-poor-substring-tests.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { defineRule } from "@oxlint/plugins";
-import { resolveVariable } from "../shared/scope.js";
+import { resolveVariable } from "../vendor/anti-slop/shared/scope.js";
 const SUBSTRING_MATCHERS = new Set([
     "toContain",
     "toInclude",

package/dist/rules/no-reexports-outside-entrypoints.js

@@ -1,6 +1,6 @@
 import { matchesGlob, relative } from "node:path";
 import { defineRule } from "@oxlint/plugins";
-import { resolveVariable } from "../shared/scope.js";
+import { resolveVariable } from "../vendor/anti-slop/shared/scope.js";
 /** Keep re-exports in explicitly allowed entrypoint files. */
 export const noReexportsOutsideEntrypointsRule = defineRule({
     meta: {

package/dist/rules/no-repeated-expect-call.js

@@ -1,5 +1,5 @@
 import { defineRule } from "@oxlint/plugins";
-import { resolveVariable } from "../shared/scope.js";
+import { resolveVariable } from "../vendor/anti-slop/shared/scope.js";
 const TEST_FILE = /(?:^|[/\\])(?:__tests__|tests?)(?:[/\\]|$)|(?:[._](?:test|spec))\.[cm]?[jt]sx?$/i;
 const TEST_MODULES = new Set(["bun:test", "@jest/globals", "vitest"]);
 const CLOSING_TOKENS = new Set([")", "]", "}"]);

package/dist/rules/no-restricted-syntax.d.ts

@@ -0,0 +1 @@
+export declare const noRestrictedSyntaxRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-restricted-syntax.js

@@ -0,0 +1,39 @@
+import { defineRule } from "@oxlint/plugins";
+export const noRestrictedSyntaxRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Disallow syntax matched by configured AST selectors." },
+        messages: { restrictedSyntax: "{{message}}" },
+        schema: {
+            type: "array",
+            items: {
+                anyOf: [
+                    { type: "string" },
+                    {
+                        type: "object",
+                        properties: {
+                            selector: { type: "string" },
+                            message: { type: "string" },
+                        },
+                        required: ["selector"],
+                        additionalProperties: false,
+                    },
+                ],
+            },
+        },
+    },
+    create(context) {
+        const visitors = Object.create(null);
+        for (const restriction of context.options) {
+            const selector = typeof restriction === "string" ? restriction : restriction.selector;
+            const message = (typeof restriction === "string" ? undefined : restriction.message)
+                ?? `Using '${selector}' is not allowed.`;
+            const previous = visitors[selector];
+            visitors[selector] = (node) => {
+                previous?.(node);
+                context.report({ node, messageId: "restrictedSyntax", data: { message } });
+            };
+        }
+        return visitors;
+    },
+});

package/dist/vendor/anti-slop/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/vendor/anti-slop/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/vendor/anti-slop/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/vendor/anti-slop/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/vendor/anti-slop/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/vendor/anti-slop/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/vendor/anti-slop/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;