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

package/dist/rules/{error-handling-in-effect-fn-handler.js → split-success-path-from-error-handling.js}

@@ -1,6 +1,5 @@
 import { defineRule } from "@oxlint/plugins";
 import { isEffectGenerator, isInsideEffectGeneratorBody, memberOf, nearestFunction, } 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.
@@ -103,7 +102,7 @@ const isInsideIterationCallback = (node) => {
     }
     return false;
 };
-export const errorHandlingInEffectFnHandlerRule = defineRule({
+export const splitSuccessPathFromErrorHandlingRule = defineRule({
     meta: {
         type: "suggestion",
         docs: {
@@ -112,13 +111,7 @@ export const errorHandlingInEffectFnHandlerRule = defineRule({
         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,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         let inTestFile = false;

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

@@ -2,5 +2,5 @@ export declare const defaultEntryFiles: readonly ["**/main.ts", "**/cli.ts", "**
 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

@@ -2,5 +2,5 @@ export declare const defaultTestFiles: readonly ["**/*.test.*", "**/*.spec.*", "
 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,6 +1,6 @@
 {
   "name": "@doubleloop-io/oxlint-plugin-effect",
-  "version": "0.1.0-rc.1",
+  "version": "0.1.0-rc.2",
   "description": "Oxlint rules for Effect 4 code",
   "license": "MIT",
   "repository": {
@@ -50,14 +50,15 @@
     "format:check": "oxfmt --check",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint --deny-warnings",
-    "test": "node --test install-skill.test.ts link-consumer.test.ts rules-md.test.ts rules/*.test.ts",
+    "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",
-    "consumer:link": "./link-consumer.sh link",
-    "consumer:unlink": "./link-consumer.sh unlink"
+    "release": "node scripts/release.ts",
+    "consumer:link": "./scripts/link-consumer.sh link",
+    "consumer:unlink": "./scripts/link-consumer.sh unlink"
   }
 }

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/no-bare-error-in-effect.d.ts

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