@jameswyse/oxc-config 0.1.0

package/dist/rules/no-ambient-random.js

@@ -0,0 +1,71 @@
+import { defineRule } from "@oxlint/plugins";
+import { isGlobalValue, isInjectionSeam, propertyName, variableFor } from "../shared/index.js";
+const cryptoModules = ["node:crypto", "crypto"];
+const webRandom = new Set(["randomUUID"]);
+const nodeRandom = new Set(["randomUUID", "randomInt"]);
+function importedName(specifier) {
+    return specifier.imported.type === "Identifier" ? specifier.imported.name : null;
+}
+function cryptoImport(sourceCode, node) {
+    if (node.type !== "Identifier") {
+        return null;
+    }
+    const definition = variableFor(sourceCode, node)?.defs[0];
+    if (definition?.type !== "ImportBinding" ||
+        definition.parent?.type !== "ImportDeclaration" ||
+        !cryptoModules.includes(definition.parent.source.value)) {
+        return null;
+    }
+    const specifier = definition.node;
+    if (specifier.type === "ImportSpecifier") {
+        return importedName(specifier) === "webcrypto" ? webRandom : null;
+    }
+    return nodeRandom;
+}
+function randomMembers(sourceCode, node) {
+    return isGlobalValue(sourceCode, node, "crypto") ? webRandom : cryptoImport(sourceCode, node);
+}
+export const noAmbientRandom = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Generate random numbers and identifiers only in a random owner." },
+        schema: [],
+        messages: {
+            random: "Accept random values or an identifier factory from the caller. If this module owns randomness, add it to the `random` owners.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            MemberExpression(node) {
+                const name = propertyName(node);
+                if (((name === "random" && isGlobalValue(sourceCode, node.object, "Math")) ||
+                    (name !== null && randomMembers(sourceCode, node.object)?.has(name))) &&
+                    !isInjectionSeam(node)) {
+                    context.report({ node, messageId: "random" });
+                }
+            },
+            ImportDeclaration(node) {
+                if (!cryptoModules.includes(node.source.value) || node.importKind === "type") {
+                    return;
+                }
+                for (const specifier of node.specifiers) {
+                    if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") {
+                        continue;
+                    }
+                    const name = importedName(specifier);
+                    if (name === null || !nodeRandom.has(name)) {
+                        continue;
+                    }
+                    for (const variable of sourceCode.getDeclaredVariables(specifier)) {
+                        for (const { identifier } of variable.references) {
+                            if (!isInjectionSeam(identifier)) {
+                                context.report({ node: identifier, messageId: "random" });
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-comments.d.ts

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

package/dist/rules/no-comments.js

@@ -0,0 +1,64 @@
+import { defineRule } from "@oxlint/plugins";
+import { optionStrings } from "../shared/rule-options.js";
+const directivePatterns = [
+    /^(?:oxlint|eslint)-(?:disable|enable)(?:-next-line|-line)?(?:\s|$)/u,
+    /^@ts-(?:expect-error|ignore|nocheck|check)(?:\s|$)/u,
+    /^\/\s*<(?:reference|amd-module|amd-dependency)\s/u,
+    /^[#@]__(?:PURE|NO_SIDE_EFFECTS)__$/u,
+    /^(?:oxfmt|prettier|biome)-ignore(?:-start|-end|-all)?(?:\s|$)/u,
+    /^(?:c8|v8|istanbul)\s+ignore(?:\s|$)/u,
+    /^@vite-ignore$/u,
+    /^webpack[A-Z]\w*:/u,
+    /^@(?:vitest|jest)-environment\s/u,
+    /^@jsx(?:ImportSource|Runtime|Frag)?\s/u,
+];
+function commentText(comment) {
+    return comment.value
+        .split("\n")
+        .map((line) => line.replace(/^\s*\*?/u, "").trim())
+        .filter((line) => line.length > 0)
+        .join(" ");
+}
+const javaScriptFile = /\.(?:js|jsx|mjs|cjs)$/u;
+const typeTag = /@(?:(?:type|typedef|callback|template|satisfies|import|overload|this|enum|extends|augments|implements)\b|(?:param|arg|argument|returns?|property|prop)\s+\{)/u;
+function isTypeAnnotation(comment) {
+    return comment.type === "Block" && comment.value.startsWith("*") && typeTag.test(comment.value);
+}
+export const noComments = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Express intent in code instead of comments; allow tool directives and JavaScript type annotations.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { allow: { type: "array", items: { type: "string" } } },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            comment: "Remove this comment. Carry intent in a name, type, test or validating function, and put a reason the code cannot show in the commit message.",
+        },
+    },
+    create(context) {
+        const allowed = [
+            ...directivePatterns,
+            ...optionStrings(context.options, "allow").map((source) => new RegExp(source, "u")),
+        ];
+        const typedDocs = javaScriptFile.test(context.filename);
+        return {
+            Program() {
+                for (const comment of context.sourceCode.getAllComments()) {
+                    if (comment.type === "Shebang" || (typedDocs && isTypeAnnotation(comment))) {
+                        continue;
+                    }
+                    const text = commentText(comment);
+                    if (!allowed.some((pattern) => pattern.test(text))) {
+                        context.report({ loc: comment.loc, messageId: "comment" });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-deep-ternary.d.ts

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

package/dist/rules/no-deep-ternary.js

@@ -0,0 +1,32 @@
+import { defineRule } from "@oxlint/plugins";
+export const noDeepTernary = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Allow one level of nested ternaries without deeper conditional chains." },
+        schema: [],
+        messages: {
+            depth: "This ternary is nested more than one level. Use named branches, a lookup or a switch.",
+        },
+    },
+    create(context) {
+        return {
+            ConditionalExpression(node) {
+                let depth = 1;
+                for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+                    if (["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"].includes(ancestor.type)) {
+                        break;
+                    }
+                    if (ancestor.type === "ConditionalExpression") {
+                        depth += 1;
+                        if (depth > 3) {
+                            return;
+                        }
+                    }
+                }
+                if (depth === 3) {
+                    context.report({ node, messageId: "depth" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-edit-proof-assertions.d.ts

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

package/dist/rules/no-edit-proof-assertions.js

@@ -0,0 +1,120 @@
+import { defineRule } from "@oxlint/plugins";
+import { variableFor, propertyName, apiReference } from "../shared/index.js";
+import { isStringLiteral } from "../vendor/anti-slop/effect/shared/tagged-values.js";
+const expectModules = new Set([
+    "vitest",
+    "@effect/vitest",
+    "@jest/globals",
+    "@playwright/test",
+    "playwright/test",
+    "global",
+]);
+const presenceMatchers = new Map([
+    ["toBeDefined", false],
+    ["toBeTruthy", false],
+    ["toBeUndefined", true],
+    ["toBeFalsy", true],
+    ["toBeNull", true],
+]);
+const equalityMatchers = new Set(["toBe", "toEqual", "toStrictEqual"]);
+function expectation(sourceCode, node) {
+    if (node.callee.type !== "MemberExpression") {
+        return null;
+    }
+    const matcher = propertyName(node.callee);
+    let target = node.callee.object;
+    let negated = false;
+    if (target.type === "MemberExpression" && propertyName(target) === "not") {
+        negated = true;
+        target = target.object;
+    }
+    if (!matcher || target.type !== "CallExpression") {
+        return null;
+    }
+    const [actual] = target.arguments;
+    if (actual === undefined) {
+        return null;
+    }
+    const callee = target.callee.type === "MemberExpression" && propertyName(target.callee) === "soft"
+        ? target.callee.object
+        : target.callee;
+    const api = apiReference(sourceCode, callee);
+    if (api?.name !== "expect" || !expectModules.has(api.module)) {
+        return null;
+    }
+    return { matcher, negated, actual, expected: node.arguments };
+}
+function dynamicImport(node) {
+    return node?.type === "AwaitExpression" && node.argument.type === "ImportExpression";
+}
+function importKind(sourceCode, node) {
+    if (node.type !== "Identifier") {
+        return null;
+    }
+    const variable = variableFor(sourceCode, node);
+    const definition = variable?.defs.length === 1 ? variable.defs[0] : undefined;
+    if (definition === undefined) {
+        return null;
+    }
+    if (definition.type === "ImportBinding") {
+        return definition.node.type === "ImportNamespaceSpecifier" ? "namespace" : "binding";
+    }
+    if (definition.type === "Variable" &&
+        definition.parent?.type === "VariableDeclaration" &&
+        definition.parent.kind === "const" &&
+        definition.node.type === "VariableDeclarator" &&
+        dynamicImport(definition.node.init)) {
+        return definition.node.id.type === "Identifier" ? "namespace" : "binding";
+    }
+    return null;
+}
+function importedValue(sourceCode, node) {
+    if (node.type === "Identifier") {
+        return importKind(sourceCode, node) !== null;
+    }
+    return (node.type === "MemberExpression" &&
+        propertyName(node) !== null &&
+        importKind(sourceCode, node.object) === "namespace");
+}
+function editProof(sourceCode, { matcher, negated, actual, expected }) {
+    if (presenceMatchers.has(matcher)) {
+        return presenceMatchers.get(matcher) === negated && importedValue(sourceCode, actual);
+    }
+    const [first] = expected;
+    if (negated || !isStringLiteral(first)) {
+        return false;
+    }
+    const functionType = first.value === "function";
+    if (matcher === "toBeTypeOf") {
+        return functionType || importedValue(sourceCode, actual);
+    }
+    if (equalityMatchers.has(matcher)) {
+        return (actual.type === "UnaryExpression" &&
+            actual.operator === "typeof" &&
+            (functionType || importedValue(sourceCode, actual.argument)));
+    }
+    return matcher === "toHaveProperty" && importKind(sourceCode, actual) === "namespace";
+}
+export const noEditProofAssertions = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Assert behaviour instead of proving that an import exists or that a value is a function.",
+        },
+        schema: [],
+        messages: {
+            editProof: "This assertion only proves that an import exists or that a value is a function. Call it and assert the behaviour it provides.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                const assertion = expectation(sourceCode, node);
+                if (assertion && editProof(sourceCode, assertion)) {
+                    context.report({ node, messageId: "editProof" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-env-access.d.ts

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

package/dist/rules/no-env-access.js

@@ -0,0 +1,35 @@
+import { defineRule } from "@oxlint/plugins";
+import { isGlobal, propertyName } from "../shared/index.js";
+function isImportMeta(node) {
+    return (node?.type === "MetaProperty" && node.meta.name === "import" && node.property.name === "meta");
+}
+function isEnvironmentSource(sourceCode, node) {
+    return isGlobal(sourceCode, node, "process") || isImportMeta(node);
+}
+export const noEnvAccess = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Read environment variables only in the configuration owner." },
+        schema: [],
+        messages: {
+            env: "Read environment variables in the configuration owner and pass parsed values in. If this file parses configuration, add it to the `env` owners.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            MemberExpression(node) {
+                if (propertyName(node) === "env" && isEnvironmentSource(sourceCode, node.object)) {
+                    context.report({ node, messageId: "env" });
+                }
+            },
+            VariableDeclarator(node) {
+                if (node.id.type === "ObjectPattern" &&
+                    isEnvironmentSource(sourceCode, node.init) &&
+                    node.id.properties.some((property) => property.type === "Property" && propertyName(property) === "env")) {
+                    context.report({ node, messageId: "env" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-fixed-test-delay.d.ts

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

package/dist/rules/no-fixed-test-delay.js

@@ -0,0 +1,130 @@
+import { defineRule } from "@oxlint/plugins";
+import { variableFor, isGlobal, propertyName, isPlaywright, apiReference, testContext, } from "../shared/index.js";
+function numericLiteral(node) {
+    return ((node?.type === "Literal" && typeof node.value === "number") ||
+        (node?.type === "UnaryExpression" &&
+            ["+", "-"].includes(node.operator) &&
+            node.argument.type === "Literal" &&
+            typeof node.argument.value === "number"));
+}
+function globalTimer(sourceCode, callee) {
+    if (isGlobal(sourceCode, callee, "setTimeout")) {
+        return true;
+    }
+    return (callee.type === "MemberExpression" &&
+        propertyName(callee) === "setTimeout" &&
+        ["globalThis", "global", "window"].some((name) => isGlobal(sourceCode, callee.object, name)));
+}
+function singleExpression(body) {
+    if (body === null) {
+        return null;
+    }
+    if (body.type !== "BlockStatement") {
+        return body;
+    }
+    if (body.body.length !== 1) {
+        return null;
+    }
+    const statement = body.body[0];
+    if (statement?.type === "ExpressionStatement") {
+        return statement.expression;
+    }
+    return statement?.type === "ReturnStatement" ? statement.argument : null;
+}
+function resolvesWithoutValue(sourceCode, callback, resolve) {
+    if (callback?.type === "Identifier") {
+        return variableFor(sourceCode, callback) === variableFor(sourceCode, resolve);
+    }
+    if (!callback ||
+        (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression") ||
+        callback.params.length !== 0 ||
+        callback.generator) {
+        return false;
+    }
+    const call = singleExpression(callback.body);
+    return (call?.type === "CallExpression" &&
+        call.arguments.length === 0 &&
+        call.callee.type === "Identifier" &&
+        variableFor(sourceCode, call.callee) === variableFor(sourceCode, resolve));
+}
+function timerPromise(sourceCode, node) {
+    if (!isGlobal(sourceCode, node.callee, "Promise")) {
+        return false;
+    }
+    const executor = node.arguments[0];
+    if (!executor ||
+        (executor.type !== "ArrowFunctionExpression" && executor.type !== "FunctionExpression") ||
+        executor.generator) {
+        return false;
+    }
+    const resolve = executor.params[0];
+    if (resolve?.type !== "Identifier") {
+        return false;
+    }
+    const timer = singleExpression(executor.body);
+    if (timer?.type !== "CallExpression" ||
+        !globalTimer(sourceCode, timer.callee) ||
+        !numericLiteral(timer.arguments[1])) {
+        return false;
+    }
+    return resolvesWithoutValue(sourceCode, timer.arguments[0], resolve);
+}
+function playwrightPage(sourceCode, node, enclosing) {
+    if (!isPlaywright(enclosing.api.module) || node.type !== "Identifier") {
+        return false;
+    }
+    const fixtures = enclosing.callback.params[0];
+    if (fixtures?.type !== "ObjectPattern") {
+        return false;
+    }
+    return fixtures.properties.some((property) => {
+        if (property.type !== "Property" || propertyName(property) !== "page") {
+            return false;
+        }
+        const binding = property.value.type === "AssignmentPattern" ? property.value.left : property.value;
+        return (binding.type === "Identifier" &&
+            variableFor(sourceCode, binding) === variableFor(sourceCode, node));
+    });
+}
+export const noFixedTestDelay = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "Wait for observable test outcomes instead of a fixed timer." },
+        schema: [],
+        messages: {
+            delay: "Wait for an observable condition or control the clock instead of waiting for a fixed delay.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                if (node.parent.type !== "AwaitExpression") {
+                    return;
+                }
+                const enclosing = testContext(sourceCode, node);
+                if (!enclosing) {
+                    return;
+                }
+                const api = apiReference(sourceCode, node.callee);
+                const importedTimer = api?.name === "setTimeout" &&
+                    ["node:timers/promises", "timers/promises"].includes(api.module) &&
+                    numericLiteral(node.arguments[0]);
+                const browserTimer = node.callee.type === "MemberExpression" &&
+                    propertyName(node.callee) === "waitForTimeout" &&
+                    numericLiteral(node.arguments[0]) &&
+                    playwrightPage(sourceCode, node.callee.object, enclosing);
+                if (importedTimer || browserTimer) {
+                    context.report({ node, messageId: "delay" });
+                }
+            },
+            NewExpression(node) {
+                if (node.parent.type === "AwaitExpression" &&
+                    testContext(sourceCode, node) &&
+                    timerPromise(sourceCode, node)) {
+                    context.report({ node, messageId: "delay" });
+                }
+            },
+        };
+    },
+});

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

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

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

@@ -0,0 +1,158 @@
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, join, matchesGlob, resolve } from "node:path";
+import { defineRule } from "@oxlint/plugins";
+import { projectPath } from "../shared/index.js";
+const routeFiles = new Set([
+    "page",
+    "layout",
+    "template",
+    "route",
+    "loading",
+    "error",
+    "global-error",
+    "not-found",
+    "forbidden",
+    "unauthorized",
+    "default",
+    "opengraph-image",
+    "twitter-image",
+    "icon",
+    "apple-icon",
+    "sitemap",
+    "robots",
+    "manifest",
+]);
+const rootFiles = new Set(["middleware", "proxy", "instrumentation", "instrumentation-client"]);
+const manifests = new Map();
+const entrypoints = new Map();
+function manifestDirectory(directory) {
+    const cached = manifests.get(directory);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const parent = dirname(directory);
+    const manifest = existsSync(join(directory, "package.json"))
+        ? directory
+        : parent === directory
+            ? null
+            : manifestDirectory(parent);
+    manifests.set(directory, manifest);
+    return manifest;
+}
+function targets(value) {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap(targets);
+    }
+    if (typeof value === "object" && value !== null) {
+        return Object.values(value).flatMap(targets);
+    }
+    return [];
+}
+function manifestFields(directory) {
+    const manifest = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+    return new Map(typeof manifest === "object" && manifest !== null ? Object.entries(manifest) : []);
+}
+function packageEntrypoints(directory) {
+    const cached = entrypoints.get(directory);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const manifest = manifestFields(directory);
+    const fields = [
+        manifest.get("main") ?? "index.js",
+        manifest.get("module"),
+        manifest.get("source"),
+        manifest.get("browser"),
+        manifest.get("types"),
+        manifest.get("typings"),
+    ];
+    const resolved = [...targets(fields), ...targets(manifest.get("exports"))].map((target) => resolve(directory, target));
+    entrypoints.set(directory, resolved);
+    return resolved;
+}
+function withoutExtension(path) {
+    return path.replace(/(?:\.d)?\.[cm]?[jt]sx?$/, "");
+}
+function isPackageEntrypoint(directory, filename) {
+    const file = withoutExtension(filename);
+    return packageEntrypoints(directory).some((target) => target.includes("*")
+        ? matchesGlob(file, withoutExtension(target))
+        : withoutExtension(target) === file);
+}
+function isFrameworkFile(directory, filename) {
+    const path = projectPath(directory, filename).split("/").slice(0, -1);
+    const name = withoutExtension(basename(filename));
+    const directories = path[0] === "src" ? path.slice(1) : path;
+    return ((directories[0] === "app" && routeFiles.has(name)) ||
+        directories[0] === "pages" ||
+        (directories.length === 0 && rootFiles.has(name)));
+}
+function exportedLocalName(specifier) {
+    return specifier.local.type === "Literal" ? specifier.local.value : specifier.local.name;
+}
+function isForwarding(body) {
+    const imported = new Set();
+    const exported = new Set();
+    let forwards = false;
+    for (const statement of body) {
+        if (statement.type === "ExportAllDeclaration") {
+            forwards = true;
+            continue;
+        }
+        if (statement.type === "ExportNamedDeclaration" && statement.declaration === null) {
+            if (statement.source !== null) {
+                forwards ||= statement.specifiers.length > 0;
+            }
+            else {
+                for (const specifier of statement.specifiers) {
+                    exported.add(exportedLocalName(specifier));
+                }
+            }
+            continue;
+        }
+        if (statement.type === "ExportDefaultDeclaration" &&
+            statement.declaration.type === "Identifier") {
+            exported.add(statement.declaration.name);
+            continue;
+        }
+        if (statement.type === "ImportDeclaration" && statement.specifiers.length > 0) {
+            forwards = true;
+            for (const specifier of statement.specifiers) {
+                imported.add(specifier.local.name);
+            }
+            continue;
+        }
+        return false;
+    }
+    return (forwards && imported.size === exported.size && [...imported].every((name) => exported.has(name)));
+}
+export const noForwardingModule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Import from the authoritative module instead of a file that only re-exports.",
+        },
+        schema: [],
+        messages: {
+            forwarding: "This module only re-exports other modules. Import from the authoritative module directly, or make this file a package entrypoint if it defines a supported public interface.",
+        },
+    },
+    create(context) {
+        return {
+            Program(node) {
+                if (!isForwarding(node.body)) {
+                    return;
+                }
+                const directory = manifestDirectory(dirname(context.filename));
+                if (directory === null ||
+                    (!isFrameworkFile(directory, context.filename) &&
+                        !isPackageEntrypoint(directory, context.filename))) {
+                    context.report({ node, messageId: "forwarding" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-generic-file-suffix.d.ts

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