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

package/dist/shared/file-globs.js

@@ -0,0 +1,17 @@
+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") : [];
+};
+// 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));
+};

package/dist/shared/match-ast.d.ts

@@ -0,0 +1,5 @@
+import type { ESTree } from "@oxlint/plugins";
+export declare const isMatchCall: (node: ESTree.Node | null | undefined) => node is ESTree.CallExpression;
+export declare const isMatchChain: (node: ESTree.Node | null | undefined) => boolean;
+export declare const handlersOf: (match: ESTree.CallExpression) => ESTree.Expression[];
+export declare const nestedBranches: (handler: ESTree.Node) => ReadonlyArray<ESTree.Node>;

package/dist/shared/match-ast.js

@@ -0,0 +1,52 @@
+import { calleeOf, isFunctionNode, memberOf } from "./effect-ast.js";
+const modulesWithMatch = ["Option", "Result", "Exit", "Either"];
+export const isMatchCall = (node) => {
+    if (node?.type !== "CallExpression")
+        return false;
+    const { callee } = node;
+    if (modulesWithMatch.some((module) => memberOf(callee, module) === "match"))
+        return true;
+    if (memberOf(callee, "Match") === "valueTags")
+        return true;
+    return (callee.type === "MemberExpression" &&
+        !callee.computed &&
+        callee.property.type === "Identifier" &&
+        callee.property.name === "$match");
+};
+const isMatchStart = (node) => {
+    const start = calleeOf(node, "Match");
+    return start === "value" || start === "type";
+};
+// `Match.value(x).pipe(...)`, the data-last `Match.type().pipe(...)`, and both through the
+// function form `pipe(Match.value(x), ...)`. Their handlers are arguments of `Match.when`
+// and friends, not object properties, so `handlersOf` sees none.
+export const isMatchChain = (node) => {
+    if (node?.type !== "CallExpression")
+        return false;
+    const { callee } = node;
+    if (callee.type === "Identifier")
+        return callee.name === "pipe" && isMatchStart(node.arguments[0]);
+    return (callee.type === "MemberExpression" &&
+        !callee.computed &&
+        callee.property.type === "Identifier" &&
+        callee.property.name === "pipe" &&
+        isMatchStart(callee.object));
+};
+export const handlersOf = (match) => match.arguments.flatMap((argument) => argument.type === "ObjectExpression"
+    ? argument.properties.flatMap((property) => property.type === "Property" ? [property.value] : [])
+    : []);
+const returnedExpressions = (fn) => {
+    if (fn.body?.type !== "BlockStatement")
+        return fn.body ? [fn.body] : [];
+    return fn.body.body.flatMap((statement) => statement.type === "ReturnStatement" && statement.argument ? [statement.argument] : []);
+};
+// What `no-nested-match` reports in a handler: itself a match, or a returned match or ternary.
+export const nestedBranches = (handler) => {
+    if (isMatchCall(handler) || isMatchChain(handler))
+        return [handler];
+    if (!isFunctionNode(handler))
+        return [];
+    return returnedExpressions(handler).filter((expression) => isMatchCall(expression) ||
+        isMatchChain(expression) ||
+        expression.type === "ConditionalExpression");
+};

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

@@ -0,0 +1,17 @@
+import type { ESTree } from "@oxlint/plugins";
+export declare const isEqualityComparison: (node: ESTree.Node) => node is ESTree.BinaryExpression;
+export declare const isStringLiteral: (node: ESTree.Node | null | undefined) => node is ESTree.StringLiteral;
+export declare const isTagMember: (node: ESTree.Node | null | undefined) => node is ESTree.MemberExpression;
+export declare const isReasonTagMember: (node: ESTree.MemberExpression) => boolean;
+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 discriminantOf: (node: ESTree.Node | null | undefined, discriminants: ReadonlySet<string>) => string | undefined;

package/dist/shared/tagged-values.js

@@ -0,0 +1,67 @@
+import { calleeOf } from "./effect-ast.js";
+const equalityOperators = new Set(["==", "===", "!=", "!=="]);
+const broadEffectCatchMethods = new Set(["catch", "catchAll", "catchIf"]);
+export const isEqualityComparison = (node) => node.type === "BinaryExpression" && equalityOperators.has(node.operator);
+export const isStringLiteral = (node) => node?.type === "Literal" && typeof node.value === "string";
+const isPropertyNamed = (node, name) => node.computed
+    ? isStringLiteral(node.property) && node.property.value === name
+    : node.property.type === "Identifier" && node.property.name === name;
+export const isTagMember = (node) => node?.type === "MemberExpression" && isPropertyNamed(node, "_tag");
+export const isReasonTagMember = (node) => node.object.type === "MemberExpression" && isPropertyNamed(node.object, "reason");
+export const tagMemberFromComparison = (node) => {
+    if (!isEqualityComparison(node))
+        return undefined;
+    if (isTagMember(node.left) && isStringLiteral(node.right))
+        return node.left;
+    if (isTagMember(node.right) && isStringLiteral(node.left))
+        return node.right;
+    return undefined;
+};
+// Only the nearest function counts: a `_tag` check in a callback nested inside the handler
+// is not the handler discriminating its error.
+export const isInsideBroadEffectHandler = (node) => {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") {
+            const call = current.parent;
+            return (call?.type === "CallExpression" &&
+                broadEffectCatchMethods.has(calleeOf(call, "Effect") ?? "") &&
+                call.arguments.some((argument) => argument === current));
+        }
+    }
+    return false;
+};
+export const propertyName = (property) => {
+    if (!property.computed && property.key.type === "Identifier")
+        return property.key.name;
+    if (isStringLiteral(property.key))
+        return property.key.value;
+    return undefined;
+};
+// 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 discriminantOf = (node, discriminants) => {
+    if (node?.type !== "MemberExpression")
+        return undefined;
+    const name = node.computed
+        ? isStringLiteral(node.property)
+            ? node.property.value
+            : undefined
+        : node.property.type === "Identifier"
+            ? node.property.name
+            : undefined;
+    return name !== undefined && discriminants.has(name) ? name : undefined;
+};

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

@@ -0,0 +1,6 @@
+export declare const defaultTestFiles: string[];
+export declare const isTestFile: (context: {
+    readonly filename: string;
+    readonly cwd: string;
+    readonly options: ReadonlyArray<unknown>;
+}) => boolean;

package/dist/shared/test-files.js

@@ -0,0 +1,10 @@
+import { makeFileMatcher } from "./file-globs.js";
+// `src/testing/` helpers are not matched on purpose: they are support code, not tests.
+export const defaultTestFiles = [
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/__tests__/**",
+    "**/test/**",
+    "**/tests/**",
+];
+export const isTestFile = makeFileMatcher("testFiles", defaultTestFiles);

package/package.json

@@ -1,6 +1,57 @@
 {
-  "name": "@doubleloop-io/oxlint-plugin-effect",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+    "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"
+    },
+    "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"
+    },
+    "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"
+}