@doubleloop-io/oxlint-plugin-effect 0.1.0-rc.0 → 0.1.0-rc.2

package/dist/shared/effect-ast.js

@@ -28,8 +28,12 @@ export const isEffectGenerator = (fn) => {
         return call.arguments.some((arg) => arg === fn);
     return isEffectFnApplication(call) && call.arguments[0] === fn;
 };
-// Plain callbacks inside the generator still belong to its success path; the pipeable
-// arguments of an `Effect.fn` nested in it are the handler slot, so they do not.
+const isEffectCombinatorCallback = (fn) => fn.parent?.type === "CallExpression" &&
+    memberOf(fn.parent.callee, "Effect") !== undefined &&
+    fn.parent.arguments.some((arg) => arg === fn);
+// Callbacks handed to an `Effect.*` combinator inside the generator still belong to its success
+// path; the pipeable arguments of an `Effect.fn` nested in it are the handler slot, so they do
+// not, and neither does a function the generator only defines (an HTTP handler, a service method).
 export const isInsideEffectGeneratorBody = (node) => {
     let child = node;
     for (let current = node.parent; current; current = current.parent) {
@@ -37,8 +41,12 @@ export const isInsideEffectGeneratorBody = (node) => {
             current.arguments.findIndex((arg) => arg === child) > 0) {
             return false;
         }
-        if (isFunctionNode(current) && current.generator)
-            return isEffectGenerator(current);
+        if (isFunctionNode(current)) {
+            if (current.generator)
+                return isEffectGenerator(current);
+            if (!isEffectCombinatorCallback(current))
+                return false;
+        }
         child = current;
     }
     return false;
@@ -50,3 +58,6 @@ export const nearestFunction = (node) => {
     }
     return undefined;
 };
+// An async function that renders JSX is a React Server Component: it hands its outcome to React,
+// and how failures become UI is the application's call, not a rule's.
+export const isServerComponent = (fn, rendersJsx) => fn.async && rendersJsx;

package/dist/shared/effect-runners.d.ts

@@ -0,0 +1,2 @@
+import type { ESTree } from "@oxlint/plugins";
+export declare const runnerName: (node: ESTree.MemberExpression) => string | undefined;

package/dist/shared/effect-runners.js

@@ -0,0 +1,14 @@
+import { memberOf } from "./effect-ast.js";
+const runtimeEntries = [
+    ["NodeRuntime", "runMain"],
+    ["BunRuntime", "runMain"],
+    ["ManagedRuntime", "make"],
+];
+// The qualified name of the runner `node` refers to, when it runs an Effect program.
+export const runnerName = (node) => {
+    const effectMember = memberOf(node, "Effect");
+    if (effectMember?.startsWith("run"))
+        return `Effect.${effectMember}`;
+    const entry = runtimeEntries.find(([object, property]) => memberOf(node, object) === property);
+    return entry === undefined ? undefined : `${entry[0]}.${entry[1]}`;
+};

package/dist/shared/entry-files.d.ts

@@ -1,6 +1,6 @@
-export declare const defaultEntryFiles: string[];
+export declare const defaultEntryFiles: readonly ["**/main.ts", "**/cli.ts", "**/bin/**"];
 export declare const isEntryFile: (context: {
     readonly filename: string;
     readonly cwd: string;
-    readonly options: ReadonlyArray<unknown>;
+    readonly settings: Readonly<Record<string, unknown>>;
 }) => boolean;

package/dist/shared/file-globs.d.ts

@@ -1,14 +1,8 @@
-export declare const filePatternsSchema: {
-    type: string;
-    items: {
-        type: string;
-    };
-    uniqueItems: boolean;
-};
+import { type FileSettingKey } from "./settings.ts";
 type FileContext = {
     readonly filename: string;
     readonly cwd: string;
-    readonly options: ReadonlyArray<unknown>;
+    readonly settings: Readonly<Record<string, unknown>>;
 };
-export declare const makeFileMatcher: (key: string, defaults: ReadonlyArray<string>) => (context: FileContext) => boolean;
+export declare const makeFileMatcher: (key: FileSettingKey, defaults: ReadonlyArray<string>) => (context: FileContext) => boolean;
 export {};

package/dist/shared/file-globs.js

@@ -1,17 +1,8 @@
 import { matchesGlob, relative, sep } from "node:path";
-export const filePatternsSchema = { type: "array", items: { type: "string" }, uniqueItems: true };
-const configuredPatterns = (options, key, defaults) => {
-    const [first] = options;
-    if (typeof first !== "object" || first === null)
-        return defaults;
-    const entry = Object.entries(first).find(([name]) => name === key);
-    if (entry === undefined)
-        return defaults;
-    const patterns = entry[1];
-    return Array.isArray(patterns) ? patterns.filter((pattern) => typeof pattern === "string") : [];
-};
+import { projectSetting } from "./settings.js";
 // Globs match the path relative to the working directory, with `/` on every platform.
 export const makeFileMatcher = (key, defaults) => (context) => {
     const path = relative(context.cwd, context.filename).split(sep).join("/");
-    return configuredPatterns(context.options, key, defaults).some((pattern) => matchesGlob(path, pattern));
+    const patterns = projectSetting(context.settings, key) ?? defaults;
+    return patterns.some((pattern) => matchesGlob(path, pattern));
 };

package/dist/shared/settings.d.ts

@@ -0,0 +1,5 @@
+declare const settingKeys: readonly ["entryFiles", "testFiles", "discriminants"];
+type SettingKey = (typeof settingKeys)[number];
+export type FileSettingKey = Exclude<SettingKey, "discriminants">;
+export declare const projectSetting: (settings: Readonly<Record<string, unknown>>, key: SettingKey) => readonly string[] | undefined;
+export {};

package/dist/shared/settings.js

@@ -0,0 +1,26 @@
+const settingKeys = ["entryFiles", "testFiles", "discriminants"];
+const isSettingKey = (name) => settingKeys.some((key) => key === name);
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+const invalid = (problem) => new Error(`Invalid settings["dl-effect"]: ${problem}. Known keys: ${settingKeys.join(", ")}.`);
+// Every key is checked on every read, not only the requested one: a typo surfaces as soon as any
+// enabled rule reads a setting, even when no rule reads the misspelled key.
+export const projectSetting = (settings, key) => {
+    const pluginSettings = settings["dl-effect"];
+    if (pluginSettings === undefined)
+        return undefined;
+    if (typeof pluginSettings !== "object" ||
+        pluginSettings === null ||
+        Array.isArray(pluginSettings)) {
+        throw invalid("expected an object");
+    }
+    let configured;
+    for (const [name, value] of Object.entries(pluginSettings)) {
+        if (!isSettingKey(name))
+            throw invalid(`unknown key "${name}"`);
+        if (!isStringArray(value))
+            throw invalid(`"${name}" must be an array of strings`);
+        if (name === key)
+            configured = value;
+    }
+    return configured;
+};

package/dist/shared/tagged-values.d.ts

@@ -6,12 +6,6 @@ export declare const isReasonTagMember: (node: ESTree.MemberExpression) => boole
 export declare const tagMemberFromComparison: (node: ESTree.BinaryExpression) => ESTree.MemberExpression | undefined;
 export declare const isInsideBroadEffectHandler: (node: ESTree.Node) => boolean;
 export declare const propertyName: (property: ESTree.ObjectProperty) => string | undefined;
-export declare const discriminantsSchema: {
-    readonly type: "array";
-    readonly items: {
-        readonly type: "string";
-    };
-    readonly uniqueItems: true;
-};
-export declare const configuredDiscriminants: (options: ReadonlyArray<unknown>) => Set<string>;
+export declare const defaultDiscriminants: readonly ["_tag"];
+export declare const configuredDiscriminants: (settings: Readonly<Record<string, unknown>>) => Set<string>;
 export declare const discriminantOf: (node: ESTree.Node | null | undefined, discriminants: ReadonlySet<string>) => string | undefined;

package/dist/shared/tagged-values.js

@@ -1,4 +1,5 @@
 import { calleeOf } from "./effect-ast.js";
+import { projectSetting } from "./settings.js";
 const equalityOperators = new Set(["==", "===", "!=", "!=="]);
 const broadEffectCatchMethods = new Set(["catch", "catchAll", "catchIf"]);
 export const isEqualityComparison = (node) => node.type === "BinaryExpression" && equalityOperators.has(node.operator);
@@ -39,20 +40,8 @@ export const propertyName = (property) => {
 };
 // The fields that discriminate a closed union: `_tag` for Effect's tagged values, plus whatever
 // the codebase uses (`type`, `kind`). Shared by the rules on comparison and construction.
-const defaultDiscriminants = ["_tag"];
-export const discriminantsSchema = {
-    type: "array",
-    items: { type: "string" },
-    uniqueItems: true,
-};
-export const configuredDiscriminants = (options) => {
-    const [first] = options;
-    if (typeof first !== "object" || first === null || !("discriminants" in first)) {
-        return new Set(defaultDiscriminants);
-    }
-    const names = first.discriminants;
-    return new Set(Array.isArray(names) ? names.filter((name) => typeof name === "string") : []);
-};
+export const defaultDiscriminants = ["_tag"];
+export const configuredDiscriminants = (settings) => new Set(projectSetting(settings, "discriminants") ?? defaultDiscriminants);
 export const discriminantOf = (node, discriminants) => {
     if (node?.type !== "MemberExpression")
         return undefined;

package/dist/shared/test-files.d.ts

@@ -1,6 +1,6 @@
-export declare const defaultTestFiles: string[];
+export declare const defaultTestFiles: readonly ["**/*.test.*", "**/*.spec.*", "**/__tests__/**", "**/test/**", "**/tests/**"];
 export declare const isTestFile: (context: {
     readonly filename: string;
     readonly cwd: string;
-    readonly options: ReadonlyArray<unknown>;
+    readonly settings: Readonly<Record<string, unknown>>;
 }) => boolean;

package/package.json

@@ -1,57 +1,64 @@
 {
-    "name": "@doubleloop-io/oxlint-plugin-effect",
-    "version": "0.1.0-rc.0",
-    "description": "Oxlint rules for Effect 4 code",
-    "license": "MIT",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/doubleloop-io/oxlint-plugin-effect.git"
+  "name": "@doubleloop-io/oxlint-plugin-effect",
+  "version": "0.1.0-rc.2",
+  "description": "Oxlint rules for Effect 4 code",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/doubleloop-io/oxlint-plugin-effect.git"
+  },
+  "files": [
+    "dist/",
+    "RULES.md",
+    "README.md",
+    "LICENSE",
+    "LICENSE.anti-slop"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
-    "files": [
-        "dist/",
-        "RULES.md",
-        "README.md",
-        "LICENSE",
-        "LICENSE.anti-slop"
-    ],
-    "type": "module",
-    "exports": {
-        "./presets/all": {
-            "types": "./dist/presets/all.d.ts",
-            "default": "./dist/presets/all.js"
-        },
-        "./presets/all.json": "./dist/presets/all.json"
+    "./presets/all": {
+      "types": "./dist/presets/all.d.ts",
+      "default": "./dist/presets/all.js"
     },
-    "publishConfig": {
-        "access": "public"
-    },
-    "scripts": {
-        "format": "oxfmt",
-        "format:check": "oxfmt --check",
-        "typecheck": "tsc --noEmit",
-        "lint": "oxlint --deny-warnings",
-        "test": "node --test install-skill.test.ts rules-md.test.ts rules/*.test.ts",
-        "check": "pnpm format:check && pnpm typecheck && pnpm lint && pnpm test",
-        "build": "rm -rf dist && tsc -p tsconfig.build.json && node presets/all-json.ts",
-        "pack:check": "node --test presets/all-dist.test.ts && node scripts/pack-check.ts",
-        "build-and-pack": "pnpm check && pnpm build && pnpm pack:check && pnpm smoke-test",
-        "smoke-test": "node scripts/smoke-test.ts"
-    },
-    "dependencies": {
-        "@oxlint/plugins": "^1.82.0"
-    },
-    "devDependencies": {
-        "@types/node": "^24.13.6",
-        "oxfmt": "0.67.0",
-        "oxlint": "1.82.0",
-        "publint": "^0.3.25",
-        "typescript": "^7.0.2"
-    },
-    "peerDependencies": {
-        "oxlint": "^1.82.0"
-    },
-    "engines": {
-        "node": "^22.20.0 || >=24.8.0"
-    },
-    "packageManager": "pnpm@12.4.1"
-}
+    "./presets/all.json": "./dist/presets/all.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@oxlint/plugins": "^1.82.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.6",
+    "oxfmt": "0.67.0",
+    "oxlint": "1.82.0",
+    "publint": "^0.3.25",
+    "typescript": "^7.0.2"
+  },
+  "peerDependencies": {
+    "oxlint": "^1.82.0"
+  },
+  "engines": {
+    "node": "^22.20.0 || >=24.8.0"
+  },
+  "scripts": {
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint --deny-warnings",
+    "test": "node --test rules-md.test.ts rules/*.test.ts shared/*.test.ts scripts/*.test.ts",
+    "check": "pnpm format:check && pnpm typecheck && pnpm lint && pnpm test",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && node presets/all-json.ts",
+    "build:w": "node --watch-path=index.ts --watch-path=rules --watch-path=presets --watch-path=shared --watch-path=tsconfig.build.json scripts/build.ts",
+    "pack:check": "node --test presets/all-dist.test.ts && node scripts/pack-check.ts",
+    "build-and-pack": "pnpm check && pnpm build && pnpm pack:check && pnpm smoke-test",
+    "smoke-test": "node scripts/smoke-test.ts",
+    "release": "node scripts/release.ts",
+    "consumer:link": "./scripts/link-consumer.sh link",
+    "consumer:unlink": "./scripts/link-consumer.sh unlink"
+  }
+}

package/dist/rules/boundary-entrypoint-shape.d.ts

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

package/dist/rules/boundary-entrypoint-shape.js

@@ -1,52 +0,0 @@
-import { defineRule } from "@oxlint/plugins";
-import { calleeOf, nearestFunction } from "../shared/effect-ast.js";
-// The *Exit runners hand failures back as values, so an open error channel cannot leak there.
-const effectRunners = new Set(["runPromise", "runSync", "runFork", "runCallback"]);
-const runtimes = ["NodeRuntime", "BunRuntime"];
-const isRunnerCall = (node) => effectRunners.has(calleeOf(node, "Effect") ?? "") ||
-    runtimes.some((runtime) => calleeOf(node, runtime) === "runMain");
-const isEffectTypeName = (name) => (name.type === "Identifier" && name.name === "Effect") ||
-    (name.type === "TSQualifiedName" &&
-        name.left.type === "Identifier" &&
-        name.left.name === "Effect" &&
-        name.right.name === "Effect");
-const isClosedEffectType = (type) => type?.type === "TSTypeReference" &&
-    isEffectTypeName(type.typeName) &&
-    type.typeArguments?.params[1]?.type === "TSNeverKeyword";
-const parameterType = (identifier) => {
-    for (let fn = nearestFunction(identifier); fn; fn = nearestFunction(fn)) {
-        for (const param of fn.params) {
-            if (param.type === "Identifier" && param.name === identifier.name) {
-                return param.typeAnnotation?.typeAnnotation;
-            }
-        }
-    }
-    return undefined;
-};
-const hasClosedErrorChannel = (node) => {
-    if (node?.type === "TSSatisfiesExpression")
-        return isClosedEffectType(node.typeAnnotation);
-    if (node?.type === "Identifier")
-        return isClosedEffectType(parameterType(node));
-    return false;
-};
-export const boundaryEntrypointShapeRule = defineRule({
-    meta: {
-        type: "problem",
-        docs: {
-            description: "Close the error channel to `never` before running an Effect at the boundary.",
-        },
-        messages: {
-            openErrorChannel: "Close the error channel before running: `program satisfies Effect.Effect<A, never>`, or a runner parameter typed `Effect.Effect<A, never, never>`.",
-        },
-    },
-    createOnce(context) {
-        return {
-            CallExpression(node) {
-                if (isRunnerCall(node) && !hasClosedErrorChannel(node.arguments[0])) {
-                    context.report({ node, messageId: "openErrorChannel" });
-                }
-            },
-        };
-    },
-});

package/dist/rules/error-handling-in-effect-fn-handler.d.ts

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

package/dist/rules/error-handling-in-effect-fn-handler.js

@@ -1,66 +0,0 @@
-import { defineRule } from "@oxlint/plugins";
-import { isInsideEffectGeneratorBody, memberOf } from "../shared/effect-ast.js";
-import { filePatternsSchema } from "../shared/file-globs.js";
-import { isTestFile } from "../shared/test-files.js";
-// mapError, orElse and orElseSucceed stay allowed: they name a failure or give an alternative
-// without opening a handling branch inside the success path.
-const errorHandlers = new Set([
-    "catch",
-    "catchAll",
-    "catchCause",
-    "catchCauseFilter",
-    "catchCauseIf",
-    "catchDefect",
-    "catchEager",
-    "catchFilter",
-    "catchIf",
-    "catchReason",
-    "catchReasons",
-    "catchTag",
-    "catchTags",
-    "either",
-    "exit",
-    "match",
-    "matchCause",
-    "matchCauseEffect",
-    "matchEffect",
-    "result",
-    "sandbox",
-]);
-export const errorHandlingInEffectFnHandlerRule = defineRule({
-    meta: {
-        type: "suggestion",
-        docs: {
-            description: "Keep only the success path in Effect generators and handle errors in the second argument of `Effect.fn`. Test files are skipped.",
-        },
-        messages: {
-            handlerInGenerator: "Move `Effect.{{name}}` out of the generator: keep the success path in the body and handle errors in the pipeable arguments of `Effect.fn`.",
-        },
-        schema: [
-            {
-                type: "object",
-                properties: { testFiles: filePatternsSchema },
-                additionalProperties: false,
-            },
-        ],
-    },
-    createOnce(context) {
-        let inTestFile = false;
-        return {
-            // In a test the failure is the observed outcome, not a branch of the success path.
-            before() {
-                inTestFile = isTestFile(context);
-            },
-            MemberExpression(node) {
-                const name = memberOf(node, "Effect");
-                if (inTestFile ||
-                    name === undefined ||
-                    !errorHandlers.has(name) ||
-                    !isInsideEffectGeneratorBody(node)) {
-                    return;
-                }
-                context.report({ node, messageId: "handlerInGenerator", data: { name } });
-            },
-        };
-    },
-});

package/dist/rules/no-bare-error-in-effect.d.ts

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

package/dist/rules/run-only-at-entry.d.ts

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

package/dist/rules/run-only-at-entry.js

@@ -1,50 +0,0 @@
-import { defineRule } from "@oxlint/plugins";
-import { memberOf } from "../shared/effect-ast.js";
-import { isEntryFile } from "../shared/entry-files.js";
-import { filePatternsSchema } from "../shared/file-globs.js";
-const runtimeEntries = [
-    ["NodeRuntime", "runMain"],
-    ["BunRuntime", "runMain"],
-    ["ManagedRuntime", "make"],
-];
-const runnerName = (node) => {
-    const effectMember = memberOf(node, "Effect");
-    if (effectMember?.startsWith("run"))
-        return `Effect.${effectMember}`;
-    const entry = runtimeEntries.find(([object, property]) => memberOf(node, object) === property);
-    return entry === undefined ? undefined : `${entry[0]}.${entry[1]}`;
-};
-// Reports references too, not only calls: `const run = Effect.runPromise` escapes nothing.
-export const runOnlyAtEntryRule = defineRule({
-    meta: {
-        type: "problem",
-        docs: {
-            description: "Run Effect programs only at the entry point. Entry files are skipped.",
-        },
-        messages: {
-            runOutsideEntry: "`{{name}}` runs an Effect program: only the entry point may do that. Tests use `it.effect`, or a single test runner listed in `entryFiles`.",
-        },
-        schema: [
-            {
-                type: "object",
-                properties: { entryFiles: filePatternsSchema },
-                additionalProperties: false,
-            },
-        ],
-    },
-    createOnce(context) {
-        let inEntryFile = false;
-        return {
-            before() {
-                inEntryFile = isEntryFile(context);
-            },
-            MemberExpression(node) {
-                if (inEntryFile)
-                    return;
-                const name = runnerName(node);
-                if (name !== undefined)
-                    context.report({ node, messageId: "runOutsideEntry", data: { name } });
-            },
-        };
-    },
-});