@jameswyse/oxc-config 0.1.0

package/dist/rules/statement-spacing.js

@@ -0,0 +1,29 @@
+import { defineRule } from "@oxlint/plugins";
+import createPaddingLineRule from "../vendor/eslint-stylistic/padding-line-between-statements.js";
+const multilineDeclaration = {
+    selector: ':matches(VariableDeclaration, ExportNamedDeclaration[declaration.type="VariableDeclaration"])',
+    lineMode: "multiline",
+};
+const typeAlias = {
+    selector: ':matches(TSTypeAliasDeclaration, ExportNamedDeclaration[declaration.type="TSTypeAliasDeclaration"])',
+};
+const paddingRule = createPaddingLineRule([
+    { blankLine: "always", prev: "multiline-block-like", next: "*" },
+    { blankLine: "always", prev: "*", next: "multiline-block-like" },
+    { blankLine: "always", prev: "*", next: "return" },
+    { blankLine: "always", prev: "import", next: "*" },
+    { blankLine: "any", prev: "import", next: "import" },
+    { blankLine: "always", prev: "*", next: multilineDeclaration },
+    { blankLine: "always", prev: multilineDeclaration, next: "*" },
+    { blankLine: "any", prev: multilineDeclaration, next: typeAlias },
+]);
+export const statementSpacing = defineRule({
+    ...paddingRule,
+    meta: {
+        ...paddingRule.meta,
+        docs: {
+            description: "Separate imports, multiline blocks, multiline declarations and returns from neighbouring statements.",
+        },
+        schema: [],
+    },
+});

package/dist/rules/type-guard-name.d.ts

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

package/dist/rules/type-guard-name.js

@@ -0,0 +1,59 @@
+import { defineRule } from "@oxlint/plugins";
+import { propertyName } from "../shared/index.js";
+function predicateName(node) {
+    const owner = node.parent.parent;
+    if (!owner) {
+        return null;
+    }
+    if (owner.type === "TSMethodSignature") {
+        return owner.computed ? null : { node: owner.key, name: propertyName(owner) };
+    }
+    const parent = owner.type === "TSFunctionType" && owner.parent.type === "TSTypeAnnotation"
+        ? owner.parent.parent
+        : owner.parent;
+    if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+        return { node: parent.id, name: parent.id.name };
+    }
+    if (parent?.type === "Identifier" &&
+        parent.parent.type === "VariableDeclarator" &&
+        parent.parent.id === parent) {
+        return { node: parent, name: parent.name };
+    }
+    if (parent?.type === "Property" ||
+        parent?.type === "MethodDefinition" ||
+        parent?.type === "PropertyDefinition" ||
+        parent?.type === "TSPropertySignature") {
+        return parent.computed ? null : { node: parent.key, name: propertyName(parent) };
+    }
+    if ("id" in owner && owner.id?.type === "Identifier") {
+        return { node: owner.id, name: owner.id.name };
+    }
+    return null;
+}
+export const typeGuardName = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Name type predicates with an is or has prefix." },
+        schema: [],
+        messages: {
+            name: "Name the type predicate '{{name}}' with an is or has prefix, such as isValue or hasValue.",
+        },
+    },
+    create(context) {
+        const reported = new WeakSet();
+        return {
+            TSTypePredicate(node) {
+                if (node.asserts) {
+                    return;
+                }
+                const named = predicateName(node);
+                if (named?.name &&
+                    !reported.has(named.node) &&
+                    !/^(?:is|has)(?:\p{Lu}|\p{N}|_)/u.test(named.name)) {
+                    reported.add(named.node);
+                    context.report({ node: named.node, messageId: "name", data: { name: named.name } });
+                }
+            },
+        };
+    },
+});

package/dist/shared/index.d.ts

@@ -0,0 +1,26 @@
+import type { ESTree, SourceCode, Variable } from "@oxlint/plugins";
+export type ApiReference = {
+    readonly module: string;
+    readonly name: string;
+};
+export type TestContext = {
+    readonly callback: FunctionNode;
+    readonly api: ApiReference;
+};
+type FunctionNode = ESTree.ArrowFunctionExpression | ESTree.Function;
+type VisitorKeys = SourceCode["visitorKeys"];
+export declare const testModules: Set<string>;
+export declare const testFunctions: Set<string>;
+export declare function isNode(value: unknown): value is ESTree.Node;
+export declare function childNodes(node: ESTree.Node, visitorKeys: VisitorKeys): ESTree.Node[];
+export declare function variableFor(sourceCode: SourceCode, node: ESTree.Node): Variable | null;
+export declare function isGlobal(sourceCode: SourceCode, identifier: ESTree.Node | null | undefined, name: string): boolean;
+export declare function propertyName(node: ESTree.Node): string | null;
+export declare function isPlaywright(module: string): boolean;
+export declare function apiReference(sourceCode: SourceCode, node: ESTree.Node, seen?: Set<Variable>): ApiReference | null;
+export declare function testContext(sourceCode: SourceCode, node: ESTree.Node): TestContext | null;
+export declare function projectPath(cwd: string, file: string): string;
+export declare function matchesAny(path: string, patterns?: readonly string[]): boolean;
+export declare function isGlobalValue(sourceCode: SourceCode, node: ESTree.Node | null | undefined, name: string): boolean;
+export declare function isInjectionSeam(source: ESTree.Node): boolean;
+export {};

package/dist/shared/index.js

@@ -0,0 +1,260 @@
+import { matchesGlob, relative, sep } from "node:path";
+export const testModules = new Set([
+    "vitest",
+    "@effect/vitest",
+    "@jest/globals",
+    "@playwright/test",
+    "playwright/test",
+    "node:test",
+]);
+const defaultImports = new Map([
+    ["@playwright/test", "test"],
+    ["playwright/test", "test"],
+    ["node:test", "test"],
+    ["node:timers/promises", "*"],
+    ["timers/promises", "*"],
+]);
+export const testFunctions = new Set([
+    "test",
+    "it",
+    "beforeEach",
+    "afterEach",
+    "beforeAll",
+    "afterAll",
+]);
+const testModifiers = new Set([
+    "only",
+    "skip",
+    "todo",
+    "concurrent",
+    "sequential",
+    "serial",
+    "fails",
+]);
+const testFactories = new Set(["each", "for", "runIf", "skipIf"]);
+const effectModifiers = new Set(["effect", "live", "scoped"]);
+export function isNode(value) {
+    return (typeof value === "object" && value !== null && "type" in value && typeof value.type === "string");
+}
+export function childNodes(node, visitorKeys) {
+    const children = [];
+    for (const key of visitorKeys[node.type] ?? []) {
+        const value = Object.getOwnPropertyDescriptor(node, key)?.value;
+        const items = Array.isArray(value) ? value : [value];
+        for (const item of items) {
+            if (isNode(item)) {
+                children.push(item);
+            }
+        }
+    }
+    return children;
+}
+export function variableFor(sourceCode, node) {
+    if (node.type !== "Identifier" &&
+        node.type !== "PrivateIdentifier" &&
+        node.type !== "JSXIdentifier") {
+        return null;
+    }
+    let scope = sourceCode.getScope(node);
+    while (scope !== null) {
+        const variable = scope.set.get(node.name);
+        if (variable !== undefined) {
+            return variable;
+        }
+        scope = scope.upper;
+    }
+    return null;
+}
+export function isGlobal(sourceCode, identifier, name) {
+    return (identifier?.type === "Identifier" &&
+        identifier.name === name &&
+        !variableFor(sourceCode, identifier)?.defs.length);
+}
+function memberKey(node) {
+    if ("property" in node) {
+        return node.property;
+    }
+    return "key" in node ? node.key : null;
+}
+export function propertyName(node) {
+    if ("computed" in node && node.computed) {
+        return null;
+    }
+    const key = memberKey(node);
+    if (key?.type === "Identifier" || key?.type === "PrivateIdentifier") {
+        return key.name;
+    }
+    return key?.type === "Literal" && typeof key.value === "string" ? key.value : null;
+}
+export function isPlaywright(module) {
+    return module === "@playwright/test" || module === "playwright/test";
+}
+export function apiReference(sourceCode, node, seen = new Set()) {
+    if (node.type === "Identifier") {
+        const variable = variableFor(sourceCode, node);
+        if (!variable?.defs.length) {
+            return testFunctions.has(node.name) || node.name === "expect"
+                ? { module: "global", name: node.name }
+                : null;
+        }
+        const [definition] = variable.defs;
+        if (seen.has(variable) || definition === undefined || variable.defs.length !== 1) {
+            return null;
+        }
+        seen.add(variable);
+        const specifier = definition.node;
+        const declaration = definition.parent;
+        if (definition.type === "ImportBinding" && declaration?.type === "ImportDeclaration") {
+            const module = declaration.source.value;
+            if (specifier.type === "ImportDefaultSpecifier" ||
+                (specifier.type === "ImportSpecifier" &&
+                    specifier.imported.type === "Identifier" &&
+                    specifier.imported.name === "default")) {
+                const name = defaultImports.get(module);
+                return name ? { module, name } : null;
+            }
+            if (specifier.type === "ImportNamespaceSpecifier") {
+                return { module, name: "*" };
+            }
+            if (specifier.type === "ImportSpecifier") {
+                return {
+                    module,
+                    name: specifier.imported.type === "Identifier"
+                        ? specifier.imported.name
+                        : specifier.imported.value,
+                };
+            }
+            return null;
+        }
+        if (definition.type === "Variable" &&
+            declaration?.type === "VariableDeclaration" &&
+            declaration.kind === "const" &&
+            specifier.type === "VariableDeclarator" &&
+            specifier.id.type === "Identifier" &&
+            specifier.init) {
+            return apiReference(sourceCode, specifier.init, seen);
+        }
+        return null;
+    }
+    if (node.type === "MemberExpression") {
+        const object = apiReference(sourceCode, node.object, seen);
+        const name = propertyName(node);
+        if (!object || !name) {
+            return null;
+        }
+        if (object.name === "*") {
+            return { module: object.module, name };
+        }
+        if (testFunctions.has(object.name) && (testModifiers.has(name) || testFactories.has(name))) {
+            return object;
+        }
+        if (object.module === "@effect/vitest" &&
+            ["test", "it"].includes(object.name) &&
+            effectModifiers.has(name)) {
+            return object;
+        }
+        if (object.name === "test" && testFunctions.has(name)) {
+            return { module: object.module, name };
+        }
+        return null;
+    }
+    if (node.type === "CallExpression" && node.callee.type === "MemberExpression") {
+        const name = propertyName(node.callee);
+        const object = apiReference(sourceCode, node.callee.object, seen);
+        if (object && name !== null && testFunctions.has(object.name) && testFactories.has(name)) {
+            return object;
+        }
+        if (object &&
+            ["test", "it"].includes(object.name) &&
+            (isPlaywright(object.module) || ["vitest", "@effect/vitest"].includes(object.module)) &&
+            name === "extend") {
+            return object;
+        }
+    }
+    if (node.type === "TaggedTemplateExpression" &&
+        node.tag.type === "MemberExpression" &&
+        propertyName(node.tag) === "each") {
+        return apiReference(sourceCode, node.tag.object, seen);
+    }
+    return null;
+}
+export function testContext(sourceCode, node) {
+    for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+        if (ancestor.type !== "ArrowFunctionExpression" && ancestor.type !== "FunctionExpression") {
+            continue;
+        }
+        const call = ancestor.parent;
+        if (call.type !== "CallExpression" || !call.arguments.includes(ancestor)) {
+            continue;
+        }
+        const api = apiReference(sourceCode, call.callee);
+        if (api &&
+            testFunctions.has(api.name) &&
+            (testModules.has(api.module) || api.module === "global")) {
+            return { callback: ancestor, api };
+        }
+    }
+    return null;
+}
+export function projectPath(cwd, file) {
+    return relative(cwd, file).split(sep).join("/");
+}
+export function matchesAny(path, patterns = []) {
+    return patterns.some((pattern) => matchesGlob(path, pattern));
+}
+const globalObjects = ["globalThis", "global", "window", "self"];
+function isFunctionNode(node) {
+    return (node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionExpression" ||
+        node.type === "FunctionDeclaration");
+}
+export function isGlobalValue(sourceCode, node, name) {
+    if (isGlobal(sourceCode, node, name)) {
+        return true;
+    }
+    return (node?.type === "MemberExpression" &&
+        propertyName(node) === name &&
+        globalObjects.some((object) => isGlobal(sourceCode, node.object, object)));
+}
+function returns(callback, value) {
+    const body = callback.body;
+    if (body === value) {
+        return true;
+    }
+    if (body?.type !== "BlockStatement") {
+        return false;
+    }
+    const [statement] = body.body;
+    return (body.body.length === 1 && statement?.type === "ReturnStatement" && statement.argument === value);
+}
+function isProvider(callback, value) {
+    const holder = callback.parent;
+    if (holder.type === "AssignmentPattern") {
+        return holder.right === callback;
+    }
+    if (!returns(callback, value)) {
+        return false;
+    }
+    return ((holder.type === "Property" && holder.value === callback) ||
+        (holder.type === "LogicalExpression" &&
+            holder.right === callback &&
+            ["??", "||"].includes(holder.operator)));
+}
+export function isInjectionSeam(source) {
+    const parent = source.parent;
+    if (source.type !== "NewExpression" && source.type !== "CallExpression") {
+        return parent?.type === "CallExpression" && parent.callee === source
+            ? isInjectionSeam(parent)
+            : true;
+    }
+    let child = source;
+    for (let ancestor = parent; ancestor; child = ancestor, ancestor = ancestor.parent) {
+        if (ancestor.type === "AssignmentPattern") {
+            return ancestor.right === child;
+        }
+        if (isFunctionNode(ancestor)) {
+            return isProvider(ancestor, source);
+        }
+    }
+    return false;
+}

package/dist/shared/rule-options.d.ts

@@ -0,0 +1,2 @@
+import type { Options } from "@oxlint/plugins";
+export declare function optionStrings(options: Readonly<Options>, key: string): string[];

package/dist/shared/rule-options.js

@@ -0,0 +1,8 @@
+export function optionStrings(options, key) {
+    const [option] = options;
+    if (typeof option !== "object" || option === null || Array.isArray(option)) {
+        return [];
+    }
+    const value = option[key];
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}

package/dist/vendor/anti-slop/effect/rules/no-manual-effect-error-tag.d.ts

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

package/dist/vendor/anti-slop/effect/rules/no-manual-effect-error-tag.js

@@ -0,0 +1,35 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+import { isInsideBroadEffectHandler, isReasonTagMember, isTagMember, tagMemberFromComparison, } from "../shared/tagged-values.js";
+export const noManualEffectErrorTag = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Use Effect tagged error handlers instead of manually branching on `_tag` in a catch handler.",
+        },
+        messages: {
+            tag: "Use Effect.catchTag or Effect.catchTags instead of manually discriminating a tagged error in a broad Effect catch handler.",
+            reason: "Use Effect.catchReason or Effect.catchReasons instead of manually discriminating a tagged `reason` in a broad Effect catch handler.",
+        },
+    },
+    createOnce(context) {
+        return {
+            BinaryExpression(node) {
+                const tagMember = tagMemberFromComparison(node);
+                if (tagMember === void 0 || !isInsideBroadEffectHandler(node)) {
+                    return;
+                }
+                context.report({ node, messageId: isReasonTagMember(tagMember) ? "reason" : "tag" });
+            },
+            SwitchStatement(node) {
+                if (!isTagMember(node.discriminant) || !isInsideBroadEffectHandler(node)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: isReasonTagMember(node.discriminant) ? "reason" : "tag",
+                });
+            },
+        };
+    },
+});

package/dist/vendor/anti-slop/effect/rules/no-service-constructor-imports.d.ts

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

package/dist/vendor/anti-slop/effect/rules/no-service-constructor-imports.js

@@ -0,0 +1,48 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+const SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
+const TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
+function isProjectLocalImport(source) {
+    return source.startsWith("./") || source.startsWith("../");
+}
+function getImportedName(specifier) {
+    if (specifier.imported.type === "Identifier") {
+        return specifier.imported.name;
+    }
+    return specifier.imported.value;
+}
+export const noServiceConstructorImports = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow project-local make<CapabilityName> imports outside test and spec files.",
+        },
+        messages: {
+            serviceConstructorImport: 'Do not import Effect service constructor "{{name}}" into runtime code. Import the owning Layer, yield the contextual service, and allow its requirements to propagate to the composition root.',
+        },
+    },
+    create(context) {
+        const isTestFile = TEST_FILE.test(context.filename.replaceAll("\\", "/"));
+        return {
+            ImportDeclaration(node) {
+                if (isTestFile || !isProjectLocalImport(node.source.value)) {
+                    return;
+                }
+                for (const specifier of node.specifiers) {
+                    if (specifier.type !== "ImportSpecifier") {
+                        continue;
+                    }
+                    const importedName = getImportedName(specifier);
+                    if (!SERVICE_CONSTRUCTOR_NAME.test(importedName)) {
+                        continue;
+                    }
+                    context.report({
+                        node: specifier,
+                        messageId: "serviceConstructorImport",
+                        data: { name: importedName },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/vendor/anti-slop/effect/shared/tagged-values.d.ts

@@ -0,0 +1,9 @@
+import type { ESTree } from "@oxlint/plugins";
+declare const isStringLiteral: (node: ESTree.Node | null | undefined) => node is ESTree.StringLiteral;
+declare const isTagMember: (node: ESTree.Node | null | undefined) => node is ESTree.MemberExpression;
+declare const tagMemberFromComparison: (node: ESTree.BinaryExpression) => ESTree.MemberExpression | undefined;
+declare const isInsideBroadEffectHandler: (node: ESTree.Node) => boolean;
+declare const isReasonTagMember: (node: ESTree.MemberExpression) => boolean;
+declare const propertyName: (property: ESTree.ObjectProperty) => string | undefined;
+declare const isMatchPatternObject: (node: ESTree.Node) => boolean;
+export { isInsideBroadEffectHandler, isMatchPatternObject, isReasonTagMember, isStringLiteral, isTagMember, propertyName, tagMemberFromComparison, };

package/dist/vendor/anti-slop/effect/shared/tagged-values.js

@@ -0,0 +1,65 @@
+const equalityOperators = new Set(["==", "===", "!=", "!=="]);
+const broadEffectCatchMethods = new Set(["catch", "catchAll", "catchIf"]);
+const isStringLiteral = (node) => node?.type === "Literal" && typeof node.value === "string";
+const isTagMember = (node) => node?.type === "MemberExpression" &&
+    ((!node.computed && node.property.type === "Identifier" && node.property.name === "_tag") ||
+        (node.computed && isStringLiteral(node.property) && node.property.value === "_tag"));
+const tagMemberFromComparison = (node) => {
+    if (!equalityOperators.has(node.operator)) {
+        return void 0;
+    }
+    if (isTagMember(node.left) && isStringLiteral(node.right)) {
+        return node.left;
+    }
+    if (isTagMember(node.right) && isStringLiteral(node.left)) {
+        return node.right;
+    }
+    return void 0;
+};
+const isBroadEffectCatchCall = (node) => node?.type === "CallExpression" &&
+    node.callee.type === "MemberExpression" &&
+    node.callee.object.type === "Identifier" &&
+    node.callee.object.name === "Effect" &&
+    !node.callee.computed &&
+    node.callee.property.type === "Identifier" &&
+    broadEffectCatchMethods.has(node.callee.property.name);
+const isInsideBroadEffectHandler = (node) => {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") {
+            return isBroadEffectCatchCall(current.parent) && current.parent.arguments.includes(current);
+        }
+        current = current.parent;
+    }
+    return false;
+};
+const isReasonTagMember = (node) => node.object.type === "MemberExpression" &&
+    ((!node.object.computed &&
+        node.object.property.type === "Identifier" &&
+        node.object.property.name === "reason") ||
+        (node.object.computed &&
+            isStringLiteral(node.object.property) &&
+            node.object.property.value === "reason"));
+const propertyName = (property) => {
+    if (!property.computed && property.key.type === "Identifier") {
+        return property.key.name;
+    }
+    if (property.key.type === "Literal" && typeof property.key.value === "string") {
+        return property.key.value;
+    }
+    return void 0;
+};
+const isMatchPatternObject = (node) => {
+    const call = node.parent;
+    if (call?.type !== "CallExpression" || !call.arguments.some((argument) => argument === node)) {
+        return false;
+    }
+    const callee = call.callee;
+    return (callee.type === "MemberExpression" &&
+        callee.object.type === "Identifier" &&
+        callee.object.name === "Match" &&
+        !callee.computed &&
+        callee.property.type === "Identifier" &&
+        (callee.property.name === "when" || callee.property.name === "not"));
+};
+export { isInsideBroadEffectHandler, isMatchPatternObject, isReasonTagMember, isStringLiteral, isTagMember, propertyName, tagMemberFromComparison, };

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

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

package/dist/vendor/anti-slop/rules/no-array-filter-map.js

@@ -0,0 +1,40 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+import { arrayMethodTarget, isKnownArrayExpression, unwrapArrayExpression, } from "../shared/array-method.js";
+export const noArrayFilterMap = 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 @@
+export declare const noChainedTypeAssertions: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-chained-type-assertions.js

@@ -0,0 +1,58 @@
+// Adapted from dmmulroy/anti-slop
+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;
+}
+export const noChainedTypeAssertions = 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 @@
+export declare const noConditionalEmptyObjectSpread: import("@oxlint/plugins").Rule;