ai-deslop 0.2.0 → 0.2.2

package/dist/rules/no-known-value-widening.js

@@ -0,0 +1,300 @@
+import { defineRule } from "@oxlint/plugins";
+import { classifyUnsafeDictionaryValue, classifyWideningTarget, createTypeEnvironment, isKnownEvidenceExpression, } from "../shared/dictionary-types.js";
+import { containsUnknownType, functionParameterBindingName, functionParameterTypeAnnotation, } from "../shared/function-parameters.js";
+import { resolveVariable } from "../shared/scope.js";
+function unwrapExpression(expression) {
+    let current = expression;
+    while (current.type === "ParenthesizedExpression" ||
+        current.type === "TSAsExpression" ||
+        current.type === "TSSatisfiesExpression" ||
+        current.type === "TSTypeAssertion" ||
+        current.type === "TSNonNullExpression") {
+        current = current.expression;
+    }
+    return current;
+}
+function variableDeclarator(variable) {
+    if (variable.defs.length !== 1)
+        return null;
+    const [definition] = variable.defs;
+    return definition?.type === "Variable" && definition.node.type === "VariableDeclarator"
+        ? definition.node
+        : null;
+}
+function isStableConstVariable(variable, declarator) {
+    return (declarator.parent.type === "VariableDeclaration" &&
+        declarator.parent.kind === "const" &&
+        variable.references.every((reference) => reference.init || !reference.isWrite()));
+}
+function hasKnownEvidence(sourceCode, expression, visitedVariables = new Set()) {
+    if (isKnownEvidenceExpression(expression))
+        return true;
+    const unwrapped = unwrapExpression(expression);
+    if (unwrapped.type !== "Identifier")
+        return false;
+    const variable = resolveVariable(sourceCode, unwrapped);
+    if (variable === null || visitedVariables.has(variable))
+        return false;
+    const declarator = variableDeclarator(variable);
+    if (declarator === null ||
+        declarator.init === null ||
+        !isStableConstVariable(variable, declarator)) {
+        return false;
+    }
+    visitedVariables.add(variable);
+    return hasKnownEvidence(sourceCode, declarator.init, visitedVariables);
+}
+function isFunctionExpression(node) {
+    return (node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionDeclaration" ||
+        node.type === "FunctionExpression" ||
+        node.type === "TSDeclareFunction" ||
+        node.type === "TSEmptyBodyFunctionExpression");
+}
+function localFunctionForCall(sourceCode, callee) {
+    const unwrapped = unwrapExpression(callee);
+    if (isFunctionExpression(unwrapped))
+        return unwrapped;
+    if (unwrapped.type !== "Identifier")
+        return null;
+    const variable = resolveVariable(sourceCode, unwrapped);
+    if (variable === null || variable.defs.length !== 1)
+        return null;
+    const [definition] = variable.defs;
+    if (definition === undefined)
+        return null;
+    if (definition.type === "FunctionName" && isFunctionExpression(definition.node)) {
+        return definition.node;
+    }
+    if (definition.type !== "Variable" || definition.node.type !== "VariableDeclarator") {
+        return null;
+    }
+    const initializer = definition.node.init;
+    if (initializer === null)
+        return null;
+    const unwrappedInitializer = unwrapExpression(initializer);
+    return isFunctionExpression(unwrappedInitializer) ? unwrappedInitializer : null;
+}
+function variableTypeAnnotation(sourceCode, variable) {
+    if (variable.defs.length !== 1)
+        return null;
+    const [definition] = variable.defs;
+    if (definition === undefined)
+        return null;
+    if (definition.type === "Variable" &&
+        definition.node.type === "VariableDeclarator" &&
+        definition.node.id.type === "Identifier") {
+        return definition.node.id.typeAnnotation ?? null;
+    }
+    if (definition.type !== "Parameter" || !isFunctionExpression(definition.node)) {
+        return null;
+    }
+    const parameter = definition.node.params.find((candidate) => functionParameterBindingName(candidate, sourceCode) === variable.name);
+    return parameter === undefined ? null : (functionParameterTypeAnnotation(parameter) ?? null);
+}
+function hasInformativeType(type, environment) {
+    return classifyUnsafeDictionaryValue(type, environment) === null;
+}
+function hasKnownCallArgumentEvidence(sourceCode, expression, environment, visitedVariables = new Set()) {
+    if (expression.type === "ParenthesizedExpression" || expression.type === "TSNonNullExpression") {
+        return hasKnownCallArgumentEvidence(sourceCode, expression.expression, environment, visitedVariables);
+    }
+    if (expression.type === "TSAsExpression" || expression.type === "TSTypeAssertion") {
+        return hasInformativeType(expression.typeAnnotation, environment);
+    }
+    if (expression.type === "TSSatisfiesExpression") {
+        return hasKnownCallArgumentEvidence(sourceCode, expression.expression, environment, visitedVariables);
+    }
+    if (expression.type === "CallExpression") {
+        const owner = localFunctionForCall(sourceCode, expression.callee);
+        const returnType = owner?.returnType?.typeAnnotation;
+        return returnType !== undefined && hasInformativeType(returnType, environment);
+    }
+    if (expression.type !== "Identifier")
+        return isKnownEvidenceExpression(expression);
+    const variable = resolveVariable(sourceCode, expression);
+    if (variable === null || visitedVariables.has(variable))
+        return false;
+    const annotation = variableTypeAnnotation(sourceCode, variable);
+    if (annotation !== null) {
+        return hasInformativeType(annotation.typeAnnotation, environment);
+    }
+    const declarator = variableDeclarator(variable);
+    if (declarator === null ||
+        declarator.init === null ||
+        !isStableConstVariable(variable, declarator)) {
+        return false;
+    }
+    visitedVariables.add(variable);
+    return hasKnownCallArgumentEvidence(sourceCode, declarator.init, environment, visitedVariables);
+}
+function typePredicateSubjectIndex(sourceCode, owner) {
+    const predicate = owner.returnType?.typeAnnotation;
+    if (predicate?.type !== "TSTypePredicate" || predicate.parameterName.type !== "Identifier") {
+        return null;
+    }
+    const predicateParameterName = predicate.parameterName.name;
+    const index = owner.params.findIndex((parameter) => functionParameterBindingName(parameter, sourceCode) === predicateParameterName);
+    return index === -1 ? null : index;
+}
+function annotationTarget(annotation, environment) {
+    return annotation === null || annotation === undefined
+        ? null
+        : classifyWideningTarget(annotation.typeAnnotation, environment);
+}
+function enclosingFunction(node) {
+    let current = node.parent;
+    while (current !== null && current.type !== "Program") {
+        if (current.type === "ArrowFunctionExpression" ||
+            current.type === "FunctionDeclaration" ||
+            current.type === "FunctionExpression") {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function sourceKeyName(sourceCode, key) {
+    if (key.type === "Identifier" || key.type === "PrivateIdentifier")
+        return key.name;
+    if (key.type === "Literal")
+        return String(key.value);
+    return sourceCode.getText(key);
+}
+function functionName(sourceCode, owner) {
+    if (owner === null)
+        return "anonymous function";
+    if (owner.id !== null)
+        return owner.id.name;
+    const parent = owner.parent;
+    if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier")
+        return parent.id.name;
+    if (parent.type === "MethodDefinition")
+        return sourceKeyName(sourceCode, parent.key);
+    return "anonymous function";
+}
+function isEmptyObjectExpression(expression) {
+    const unwrapped = unwrapExpression(expression);
+    return unwrapped.type === "ObjectExpression" && unwrapped.properties.length === 0;
+}
+function isDictionaryAccumulatorTarget(destination) {
+    return destination.kind === "open dictionary" || destination.kind === "generic container";
+}
+function hasParentAssertion(node) {
+    return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
+}
+/** Detect sound syntactic cases where a known value is explicitly widened and loses evidence. */
+export const noKnownValueWideningRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow syntactically established values from flowing into explicitly broad or anonymous target types that discard useful evidence.",
+        },
+        messages: {
+            widening: "The explicit {{target}} type on {{subject}} discards known type evidence. Keep inference, validate with `satisfies`, or use a named owner contract.",
+        },
+    },
+    createOnce(context) {
+        let environment = null;
+        const reportFlow = (expression, destination, subject) => {
+            if (destination === null)
+                return;
+            if (isDictionaryAccumulatorTarget(destination) &&
+                isEmptyObjectExpression(expression)) {
+                return;
+            }
+            if (!hasKnownEvidence(context.sourceCode, expression))
+                return;
+            context.report({
+                node: expression,
+                messageId: "widening",
+                data: { subject, target: destination.kind },
+            });
+        };
+        const targetFromAnnotation = (annotation) => environment === null ? null : annotationTarget(annotation, environment);
+        return {
+            Program(node) {
+                environment = createTypeEnvironment(node, context.sourceCode.visitorKeys);
+            },
+            VariableDeclarator(node) {
+                if (node.init === null || node.id.type !== "Identifier")
+                    return;
+                reportFlow(node.init, targetFromAnnotation(node.id.typeAnnotation), `binding \`${node.id.name}\``);
+            },
+            PropertyDefinition(node) {
+                if (node.value === null)
+                    return;
+                reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+            },
+            AccessorProperty(node) {
+                if (node.value === null)
+                    return;
+                reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+            },
+            AssignmentExpression(node) {
+                if (node.operator !== "=" || node.left.type !== "Identifier")
+                    return;
+                const variable = resolveVariable(context.sourceCode, node.left);
+                if (variable === null)
+                    return;
+                const declarator = variableDeclarator(variable);
+                if (declarator === null || declarator.id.type !== "Identifier")
+                    return;
+                reportFlow(node.right, targetFromAnnotation(declarator.id.typeAnnotation), `binding \`${declarator.id.name}\``);
+            },
+            CallExpression(node) {
+                if (environment === null)
+                    return;
+                const owner = localFunctionForCall(context.sourceCode, node.callee);
+                if (owner === null)
+                    return;
+                const parameterIndex = typePredicateSubjectIndex(context.sourceCode, owner);
+                if (parameterIndex === null)
+                    return;
+                const parameter = owner.params[parameterIndex];
+                const argument = node.arguments[parameterIndex];
+                if (parameter === undefined || argument === undefined || argument.type === "SpreadElement") {
+                    return;
+                }
+                const parameterAnnotation = functionParameterTypeAnnotation(parameter);
+                if (parameterAnnotation === null ||
+                    parameterAnnotation === undefined ||
+                    !containsUnknownType(parameterAnnotation.typeAnnotation)) {
+                    return;
+                }
+                if (!hasKnownCallArgumentEvidence(context.sourceCode, argument, environment)) {
+                    return;
+                }
+                context.report({
+                    node: argument,
+                    messageId: "widening",
+                    data: {
+                        subject: `argument for parameter \`${functionParameterBindingName(parameter, context.sourceCode)}\` of \`${functionName(context.sourceCode, owner)}\``,
+                        target: "unknown",
+                    },
+                });
+            },
+            ReturnStatement(node) {
+                if (node.argument === null)
+                    return;
+                const owner = enclosingFunction(node);
+                reportFlow(node.argument, targetFromAnnotation(owner?.returnType), `return value of \`${functionName(context.sourceCode, owner)}\``);
+            },
+            ArrowFunctionExpression(node) {
+                if (node.body.type === "BlockStatement")
+                    return;
+                reportFlow(node.body, targetFromAnnotation(node.returnType), `return value of \`${functionName(context.sourceCode, node)}\``);
+            },
+            TSAsExpression(node) {
+                if (environment === null || hasParentAssertion(node))
+                    return;
+                reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
+            },
+            TSTypeAssertion(node) {
+                if (environment === null || hasParentAssertion(node))
+                    return;
+                reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
+            },
+        };
+    },
+});

package/dist/rules/no-module-mocking.d.ts

@@ -0,0 +1,2 @@
+/** Ban test framework module mocking in favor of real dependency seams. */
+export declare const noModuleMockingRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-module-mocking.js

@@ -0,0 +1,69 @@
+import { defineRule } from "@oxlint/plugins";
+import { resolveVariable } from "../shared/scope.js";
+const moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
+function importedName(node) {
+    if (node.type !== "ImportSpecifier")
+        return null;
+    return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
+}
+function isTestFrameworkObject(sourceCode, expression) {
+    if (expression.type !== "Identifier")
+        return false;
+    if ((expression.name === "vi" || expression.name === "jest") &&
+        sourceCode.isGlobalReference(expression)) {
+        return true;
+    }
+    const variable = resolveVariable(sourceCode, expression);
+    if (variable === null || variable.defs.length === 0) {
+        return expression.name === "vi" || expression.name === "jest";
+    }
+    return variable.defs.some((definition) => {
+        if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") {
+            return false;
+        }
+        const source = definition.parent.source.value;
+        const name = importedName(definition.node);
+        return (source === "vitest" && name === "vi") || (source === "@jest/globals" && name === "jest");
+    });
+}
+function moduleMockCall(sourceCode, callee) {
+    if (!("property" in callee) || !("object" in callee) || !("computed" in callee))
+        return false;
+    if (!isTestFrameworkObject(sourceCode, callee.object))
+        return false;
+    const property = callee.property;
+    const method = callee.computed
+        ? property.type === "Literal" &&
+            (property.value === "doMock" ||
+                property.value === "mock" ||
+                property.value === "unstable_mockModule")
+            ? property.value
+            : null
+        : property.type === "Identifier"
+            ? property.name
+            : null;
+    return method !== null && moduleMockMethods.has(method);
+}
+/** Ban test framework module mocking in favor of real dependency seams. */
+export const noModuleMockingRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow Vitest and Jest module mocking; tests must replace dependencies through real interfaces.",
+        },
+        messages: {
+            moduleMock: "Replace module mocking with dependency injection through a real interface, service layer, or faithful test implementation.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression")
+                    return;
+                if (moduleMockCall(context.sourceCode, node.callee)) {
+                    context.report({ node, messageId: "moduleMock" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-object-parameters.d.ts

@@ -0,0 +1,2 @@
+/** Ban the broad object type on function inputs, including local aliases to object. */
+export declare const noObjectParametersRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-object-parameters.js

@@ -0,0 +1,56 @@
+import { defineRule } from "@oxlint/plugins";
+import { functionParameterBindingName, functionParameterTypeAnnotation, } from "../shared/function-parameters.js";
+import { createTypeAliasEnvironment, resolvedTypeMatches, } from "../shared/type-alias-resolution.js";
+/** Ban the broad object type on function inputs, including local aliases to object. */
+export const noObjectParametersRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow object function parameters; inputs must use an owner-provided type and be parsed at their boundary.",
+        },
+        messages: {
+            objectParameter: "Parameter `{{parameter}}` uses the broad `object` type. Accept a named owner type; parse external input at its boundary before calling this function.",
+        },
+    },
+    createOnce(context) {
+        let environment = null;
+        const resolvesToObject = (type) => environment !== null &&
+            resolvedTypeMatches(type, environment, (resolved, matches) => {
+                if (resolved.type === "TSObjectKeyword")
+                    return true;
+                if (resolved.type === "TSParenthesizedType") {
+                    return matches(resolved.typeAnnotation);
+                }
+                return (resolved.type === "TSUnionType" && resolved.types.some(matches));
+            });
+        const checkParameters = (node) => {
+            for (const parameter of node.params) {
+                const annotation = functionParameterTypeAnnotation(parameter);
+                if (annotation === null || annotation === undefined)
+                    continue;
+                if (!resolvesToObject(annotation.typeAnnotation))
+                    continue;
+                context.report({
+                    node: annotation.typeAnnotation,
+                    messageId: "objectParameter",
+                    data: { parameter: functionParameterBindingName(parameter, context.sourceCode) },
+                });
+            }
+        };
+        return {
+            Program(node) {
+                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+            },
+            ArrowFunctionExpression: checkParameters,
+            FunctionDeclaration: checkParameters,
+            FunctionExpression: checkParameters,
+            TSCallSignatureDeclaration: checkParameters,
+            TSConstructSignatureDeclaration: checkParameters,
+            TSConstructorType: checkParameters,
+            TSDeclareFunction: checkParameters,
+            TSEmptyBodyFunctionExpression: checkParameters,
+            TSFunctionType: checkParameters,
+            TSMethodSignature: checkParameters,
+        };
+    },
+});

package/dist/rules/no-pass-through-type-alias.d.ts

@@ -0,0 +1,2 @@
+/** Disallow type aliases that only rename another type. */
+export declare const noPassThroughTypeAliasRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-pass-through-type-alias.js

@@ -0,0 +1,41 @@
+import { defineRule } from "@oxlint/plugins";
+function isForwardedTypeParameter(typeArgument, typeParameter) {
+    return (typeArgument.type === "TSTypeReference" &&
+        typeArgument.typeName.type === "Identifier" &&
+        typeArgument.typeName.name === typeParameter.name.name &&
+        !typeArgument.typeArguments);
+}
+function passThroughTargetName(node) {
+    const annotation = node.typeAnnotation;
+    if (annotation.type !== "TSTypeReference" || annotation.typeName.type !== "Identifier") {
+        return null;
+    }
+    const typeParameters = node.typeParameters?.params ?? [];
+    const typeArguments = annotation.typeArguments?.params ?? [];
+    const isPassThrough = typeParameters.length === typeArguments.length &&
+        typeParameters.every((typeParameter, index) => isForwardedTypeParameter(typeArguments[index], typeParameter));
+    return isPassThrough ? annotation.typeName.name : null;
+}
+/** Disallow type aliases that only rename another type. */
+export const noPassThroughTypeAliasRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Disallow type aliases that only rename another type" },
+        messages: { passThroughAlias: "Use {{typeName}} directly instead of creating a pass-through type alias." },
+        schema: [],
+    },
+    createOnce(context) {
+        return {
+            TSTypeAliasDeclaration(node) {
+                const typeName = passThroughTargetName(node);
+                if (typeName !== null) {
+                    context.report({
+                        data: { typeName },
+                        messageId: "passThroughAlias",
+                        node,
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-reduce-accumulator-copy.d.ts

@@ -0,0 +1,2 @@
+/** Reject non-spread copies of reducer accumulators; pair with oxc/no-accumulating-spread. */
+export declare const noReduceAccumulatorCopyRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-reduce-accumulator-copy.js

@@ -0,0 +1,99 @@
+import { defineRule } from "@oxlint/plugins";
+import { arrayMethodTarget, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression, } from "../shared/array-method.js";
+function enclosingReducer(node) {
+    let parent = node.parent;
+    while (parent !== null) {
+        if (parent.type === "FunctionDeclaration")
+            return null;
+        if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") {
+            const callback = parent;
+            let owner = callback.parent;
+            while (owner !== null && unwrapArrayExpression(owner) === callback)
+                owner = owner.parent;
+            if (owner?.type !== "CallExpression")
+                return null;
+            const method = arrayMethodTarget(owner.callee);
+            const firstArgument = owner.arguments[0];
+            if (method === null || (method.name !== "reduce" && method.name !== "reduceRight") ||
+                owner.arguments.length > 2 || firstArgument === undefined ||
+                unwrapArrayExpression(firstArgument) !== callback)
+                return null;
+            const firstParameter = callback.params[0];
+            const accumulator = firstParameter?.type === "AssignmentPattern" ? firstParameter.left : firstParameter;
+            if (accumulator?.type !== "Identifier")
+                return null;
+            return { callback, accumulator, initialValue: owner.arguments[1] };
+        }
+        parent = parent.parent;
+    }
+    return null;
+}
+function referencesAccumulator(sourceCode, node, accumulator, visited = new Set()) {
+    const variable = resolveArrayBinding(sourceCode, node);
+    if (variable === null || visited.has(variable))
+        return false;
+    if (variable === accumulator)
+        return true;
+    visited.add(variable);
+    if (variable.references.some(reference => reference.isWrite() && !reference.init))
+        return false;
+    for (const definition of variable.defs) {
+        if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" &&
+            definition.node.id.type === "Identifier" && definition.node.init !== null &&
+            definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") {
+            return referencesAccumulator(sourceCode, definition.node.init, accumulator, visited);
+        }
+    }
+    return false;
+}
+function isGlobalCopyOwner(sourceCode, node, name) {
+    node = unwrapArrayExpression(node);
+    if (node.type !== "Identifier" || node.name !== name)
+        return false;
+    const variable = resolveArrayBinding(sourceCode, node);
+    return variable === null || variable.defs.length === 0;
+}
+/** Reject non-spread copies of reducer accumulators; pair with oxc/no-accumulating-spread. */
+export const noReduceAccumulatorCopyRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "Disallow copying growing reducer accumulators with Object.assign, Array.from, or array copy methods." },
+        messages: {
+            accumulatorCopy: "Do not copy the reducer accumulator on every iteration; growing copies can cause quadratic work. Mutate a fresh, locally owned accumulator and return it, or use an iterator pipeline/flatMap.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                const method = arrayMethodTarget(node.callee);
+                if (method === null)
+                    return;
+                const reducer = enclosingReducer(node);
+                if (reducer === null)
+                    return;
+                const accumulator = context.sourceCode.getDeclaredVariables(reducer.callback).find(variable => variable.identifiers.some(identifier => identifier.start === reducer.accumulator.start));
+                if (accumulator === undefined)
+                    return;
+                const isAccumulator = (expression) => referencesAccumulator(context.sourceCode, expression, accumulator);
+                let copiesAccumulator = false;
+                if (method.name === "assign" && isGlobalCopyOwner(context.sourceCode, method.object, "Object")) {
+                    const target = node.arguments[0];
+                    copiesAccumulator = (target !== undefined && unwrapArrayExpression(target).type === "ObjectExpression" &&
+                        node.arguments.slice(1).some(isAccumulator));
+                }
+                else if (method.name === "from" && isGlobalCopyOwner(context.sourceCode, method.object, "Array")) {
+                    const source = node.arguments[0];
+                    copiesAccumulator = source !== undefined && isAccumulator(source);
+                }
+                else if (["concat", "slice", "toSpliced", "toSorted", "toReversed", "with"].includes(method.name)) {
+                    const initialValue = reducer.initialValue;
+                    const arrayAccumulator = initialValue !== undefined &&
+                        isKnownArrayExpression(context.sourceCode, initialValue);
+                    copiesAccumulator = arrayAccumulator && isAccumulator(method.object);
+                }
+                if (copiesAccumulator)
+                    context.report({ node, messageId: "accumulatorCopy" });
+            },
+        };
+    },
+});

package/dist/rules/no-reflect-apply.d.ts

@@ -0,0 +1,2 @@
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+export declare const noReflectApplyRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-reflect-apply.js

@@ -0,0 +1,25 @@
+import { defineRule } from "@oxlint/plugins";
+import { isGlobalReflectMethodCall } from "../shared/reflect-method.js";
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+export const noReflectApplyRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow Reflect.apply; call typed functions directly or model dynamic dispatch behind an interface.",
+        },
+        messages: {
+            reflectApply: "Replace `Reflect.apply` with a typed function call. Model dynamic dispatch behind a named interface.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression")
+                    return;
+                if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "apply")) {
+                    context.report({ node, messageId: "reflectApply" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-reflect-get.d.ts

@@ -0,0 +1,2 @@
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+export declare const noReflectGetRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-reflect-get.js

@@ -0,0 +1,25 @@
+import { defineRule } from "@oxlint/plugins";
+import { isGlobalReflectMethodCall } from "../shared/reflect-method.js";
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+export const noReflectGetRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow Reflect.get; use typed property access or parse dynamic input into a domain type.",
+        },
+        messages: {
+            reflectGet: "Replace `Reflect.get` with typed property access. Parse dynamic input into a named domain type before reading it.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression")
+                    return;
+                if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "get")) {
+                    context.report({ node, messageId: "reflectGet" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-runtime-typeof.d.ts

@@ -0,0 +1,2 @@
+/** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
+export declare const noRuntimeTypeofRule: import("@oxlint/plugins").Rule;