oxlint-plugin-effect 0.0.0 → 0.1.0

package/tests/context-rules.test.ts

@@ -1,105 +1,100 @@
 import { describe, test, expect } from "bun:test"
 import { Testing } from "../src/vendor/effect-oxlint/index.js"
 import {
-  noPlatformGlobals,
-  noThrowInEffectGen,
-  noTryCatchInEffectGen,
-  noConsoleInEffect,
-  noFetchInEffect,
-  noDateInEffect,
-  noRandomInEffect,
-  noTimersInEffect,
-  noJsonInEffect,
-  noProcessEnvInEffect,
+  noGlobals,
+  noThrowStatement,
+  noTryCatch,
+  noNewPromise,
+  noNewError,
+  noReturnNullish,
 } from "../src/rules/index.js"
 
 // Helper: simulate entering and exiting Effect.gen context
 const effectGenNode = Testing.callOfMember("Effect", "gen", [])
 
-/**
- * For context-aware rules, we need to:
- * 1. Enter Effect.gen (CallExpression event)
- * 2. Fire the target event (ThrowStatement, MemberExpression, etc.)
- * 3. Exit Effect.gen (CallExpression:exit event)
- *
- * Using runRuleMulti to simulate the sequence.
- */
+// --- Global Effect-enforcing rules (fire everywhere) ---
 
-describe("noThrowInEffectGen", () => {
-  test("reports throw inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noThrowInEffectGen, [
-      ["CallExpression", effectGenNode],
-      ["ThrowStatement", Testing.throwStmt()],
-      ["CallExpression:exit", effectGenNode],
-    ])
+describe("noThrowStatement", () => {
+  test("reports throw", () => {
+    const result = Testing.runRule(noThrowStatement, "ThrowStatement", Testing.throwStmt())
     expect(result.length).toBe(1)
   })
+})
 
-  test("ignores throw outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noThrowInEffectGen, [
-      ["ThrowStatement", Testing.throwStmt()],
-    ])
-    Testing.expectNoDiagnostics(result)
+describe("noTryCatch", () => {
+  test("reports try/catch", () => {
+    const result = Testing.runRule(noTryCatch, "TryStatement", Testing.tryStmt())
+    expect(result.length).toBe(1)
   })
 })
 
-describe("noTryCatchInEffectGen", () => {
-  test("reports try/catch inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noTryCatchInEffectGen, [
-      ["CallExpression", effectGenNode],
-      ["TryStatement", Testing.tryStmt()],
-      ["CallExpression:exit", effectGenNode],
-    ])
+describe("noNewPromise", () => {
+  test("reports new Promise()", () => {
+    const result = Testing.runRule(noNewPromise, "NewExpression", Testing.newExpr("Promise"))
     expect(result.length).toBe(1)
   })
+})
 
-  test("ignores try/catch outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noTryCatchInEffectGen, [
-      ["TryStatement", Testing.tryStmt()],
-    ])
+describe("noNewError", () => {
+  test("reports new Error()", () => {
+    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("Error"))
+    expect(result.length).toBe(1)
+  })
+
+  test("reports new TypeError()", () => {
+    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("TypeError"))
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores new MyError()", () => {
+    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("MyError"))
     Testing.expectNoDiagnostics(result)
   })
 })
 
-describe("noConsoleInEffect", () => {
-  test("reports console.log inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noConsoleInEffect, [
-      ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("console", "log")],
-      ["CallExpression:exit", effectGenNode],
-    ])
+describe("noReturnNullish", () => {
+  test("reports return null", () => {
+    const node = {
+      type: "ReturnStatement",
+      argument: { type: "Literal", value: null },
+    } as never
+    const result = Testing.runRule(noReturnNullish, "ReturnStatement", node)
     expect(result.length).toBe(1)
   })
 
-  test("ignores console.log outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noConsoleInEffect, [
-      ["MemberExpression", Testing.memberExpr("console", "log")],
-    ])
-    Testing.expectNoDiagnostics(result)
+  test("reports return undefined", () => {
+    const node = {
+      type: "ReturnStatement",
+      argument: { type: "Identifier", name: "undefined" },
+    } as never
+    const result = Testing.runRule(noReturnNullish, "ReturnStatement", node)
+    expect(result.length).toBe(1)
   })
 })
 
-describe("noFetchInEffect", () => {
-  test("reports fetch() inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noFetchInEffect, [
+// --- Effect-context rules (inside Effect.gen/fn only) ---
+
+describe("noGlobals", () => {
+  test("reports console.log inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
-      ["CallExpression", Testing.callExpr("fetch")],
+      ["MemberExpression", Testing.memberExpr("console", "log")],
       ["CallExpression:exit", effectGenNode],
     ])
     expect(result.length).toBe(1)
   })
 
-  test("ignores fetch() outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noFetchInEffect, [
+  test("reports fetch() inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
+      ["CallExpression", effectGenNode],
       ["CallExpression", Testing.callExpr("fetch")],
+      ["CallExpression:exit", effectGenNode],
     ])
-    Testing.expectNoDiagnostics(result)
+    expect(result.length).toBe(1)
   })
-})
 
-describe("noDateInEffect", () => {
   test("reports Date.now inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noDateInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("Date", "now")],
       ["CallExpression:exit", effectGenNode],
@@ -108,7 +103,7 @@ describe("noDateInEffect", () => {
   })
 
   test("reports new Date() inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noDateInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["NewExpression", Testing.newExpr("Date")],
       ["CallExpression:exit", effectGenNode],
@@ -116,17 +111,8 @@ describe("noDateInEffect", () => {
     expect(result.length).toBe(1)
   })
 
-  test("ignores Date.now outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noDateInEffect, [
-      ["MemberExpression", Testing.memberExpr("Date", "now")],
-    ])
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noRandomInEffect", () => {
   test("reports Math.random inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noRandomInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("Math", "random")],
       ["CallExpression:exit", effectGenNode],
@@ -134,17 +120,8 @@ describe("noRandomInEffect", () => {
     expect(result.length).toBe(1)
   })
 
-  test("ignores Math.random outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noRandomInEffect, [
-      ["MemberExpression", Testing.memberExpr("Math", "random")],
-    ])
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noTimersInEffect", () => {
   test("reports setTimeout inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noTimersInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["CallExpression", Testing.callExpr("setTimeout")],
       ["CallExpression:exit", effectGenNode],
@@ -152,17 +129,8 @@ describe("noTimersInEffect", () => {
     expect(result.length).toBe(1)
   })
 
-  test("ignores setTimeout outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noTimersInEffect, [
-      ["CallExpression", Testing.callExpr("setTimeout")],
-    ])
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noJsonInEffect", () => {
   test("reports JSON.parse inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noJsonInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("JSON", "parse")],
       ["CallExpression:exit", effectGenNode],
@@ -170,17 +138,8 @@ describe("noJsonInEffect", () => {
     expect(result.length).toBe(1)
   })
 
-  test("ignores JSON.parse outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noJsonInEffect, [
-      ["MemberExpression", Testing.memberExpr("JSON", "parse")],
-    ])
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noProcessEnvInEffect", () => {
   test("reports process.env inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noProcessEnvInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("process", "env")],
       ["CallExpression:exit", effectGenNode],
@@ -188,39 +147,8 @@ describe("noProcessEnvInEffect", () => {
     expect(result.length).toBe(1)
   })
 
-  test("ignores process.env outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noProcessEnvInEffect, [
-      ["MemberExpression", Testing.memberExpr("process", "env")],
-    ])
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noPlatformGlobals", () => {
-  test("reports Bun.file with FileSystem hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
-      ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("Bun", "file")],
-      ["CallExpression:exit", effectGenNode],
-    ])
-    Testing.expectDiagnostics(result, [{
-      message: "Avoid Bun.file inside Effect context. Use FileSystem from 'effect'.",
-    }])
-  })
-
-  test("reports Bun.serve with HttpServer hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
-      ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("Bun", "serve")],
-      ["CallExpression:exit", effectGenNode],
-    ])
-    Testing.expectDiagnostics(result, [{
-      message: "Avoid Bun.serve inside Effect context. Use HttpServer from 'effect/unstable/http'.",
-    }])
-  })
-
-  test("reports process.exit with Effect.fail hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
+  test("reports process.exit with hint", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("process", "exit")],
       ["CallExpression:exit", effectGenNode],
@@ -230,19 +158,19 @@ describe("noPlatformGlobals", () => {
     }])
   })
 
-  test("reports process.cwd with Path hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
+  test("reports Bun.file with FileSystem hint", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("process", "cwd")],
+      ["MemberExpression", Testing.memberExpr("Bun", "file")],
       ["CallExpression:exit", effectGenNode],
     ])
     Testing.expectDiagnostics(result, [{
-      message: "Avoid process.cwd inside Effect context. Use Path from 'effect'.",
+      message: "Avoid Bun.file inside Effect context. Use FileSystem from 'effect'.",
     }])
   })
 
   test("reports Deno.readFile with FileSystem hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("Deno", "readFile")],
       ["CallExpression:exit", effectGenNode],
@@ -252,26 +180,15 @@ describe("noPlatformGlobals", () => {
     }])
   })
 
-  test("reports unknown property with generic hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
-      ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("Bun", "someNewApi")],
-      ["CallExpression:exit", effectGenNode],
-    ])
-    Testing.expectDiagnostics(result, [{
-      message: "Avoid Bun.someNewApi inside Effect context. Wrap in a service for testability.",
-    }])
-  })
-
-  test("ignores Bun.file outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
-      ["MemberExpression", Testing.memberExpr("Bun", "file")],
+  test("ignores console.log outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
+      ["MemberExpression", Testing.memberExpr("console", "log")],
     ])
     Testing.expectNoDiagnostics(result)
   })
 
-  test("ignores non-platform globals inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
+  test("ignores Effect.succeed inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("Effect", "succeed")],
       ["CallExpression:exit", effectGenNode],

package/tests/pattern-rules.test.ts

@@ -1,43 +1,20 @@
 import { describe, test, expect } from "bun:test"
 import { Testing } from "../src/vendor/effect-oxlint/index.js"
 import {
-  noReturnNull,
   noUnnecessaryPipe,
   noEffectSucceedVoid,
   noEffectMapVoid,
   noEffectFnGenerator,
   noExtendsNativeError,
-  noAsyncFunction,
   noIifeWrapper,
   noEffectSucceedString,
   noFromNullableCoalesce,
   noInstanceofSchema,
   noNestedPipe,
   noNestedEffectCall,
-  noFlatmapLadder,
-  noEffectOrElseLadder,
+  noPositionalLogError,
 } from "../src/rules/index.js"
 
-describe("noReturnNull", () => {
-  test("reports return null", () => {
-    const node = {
-      type: "ReturnStatement",
-      argument: { type: "Literal", value: null },
-    } as never
-    const result = Testing.runRule(noReturnNull, "ReturnStatement", node)
-    expect(result.length).toBe(1)
-  })
-
-  test("ignores return 42", () => {
-    const node = {
-      type: "ReturnStatement",
-      argument: { type: "Literal", value: 42 },
-    } as never
-    const result = Testing.runRule(noReturnNull, "ReturnStatement", node)
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
 describe("noUnnecessaryPipe", () => {
   test("reports pipe(x) with single arg", () => {
     const node = Testing.callExpr("pipe", [Testing.id("myEffect")])
@@ -126,32 +103,6 @@ describe("noExtendsNativeError", () => {
   })
 })
 
-describe("noAsyncFunction", () => {
-  test("reports async function", () => {
-    const node = {
-      type: "FunctionDeclaration",
-      async: true,
-      id: Testing.id("fetchData"),
-      params: [],
-      body: Testing.blockStmt([]),
-    } as never
-    const result = Testing.runRule(noAsyncFunction, "FunctionDeclaration", node)
-    expect(result.length).toBe(1)
-  })
-
-  test("ignores non-async function", () => {
-    const node = {
-      type: "FunctionDeclaration",
-      async: false,
-      id: Testing.id("fetchData"),
-      params: [],
-      body: Testing.blockStmt([]),
-    } as never
-    const result = Testing.runRule(noAsyncFunction, "FunctionDeclaration", node)
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
 describe("noIifeWrapper", () => {
   test("reports (() => expr)()", () => {
     const node = {
@@ -256,3 +207,41 @@ describe("noNestedEffectCall", () => {
     Testing.expectNoDiagnostics(result)
   })
 })
+
+describe("noPositionalLogError", () => {
+  test("reports Effect.logWarning with two args", () => {
+    const node = Testing.callOfMember("Effect", "logWarning", [
+      Testing.strLiteral("something failed"),
+      Testing.id("error"),
+    ])
+    const result = Testing.runRule(noPositionalLogError, "CallExpression", node)
+    expect(result.length).toBe(1)
+  })
+
+  test("reports Effect.logError with two args", () => {
+    const node = Testing.callOfMember("Effect", "logError", [
+      Testing.strLiteral("fatal"),
+      Testing.id("err"),
+    ])
+    const result = Testing.runRule(noPositionalLogError, "CallExpression", node)
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores Effect.log with single arg", () => {
+    const node = Testing.callOfMember("Effect", "log", [
+      Testing.strLiteral("hello"),
+    ])
+    const result = Testing.runRule(noPositionalLogError, "CallExpression", node)
+    Testing.expectNoDiagnostics(result)
+  })
+
+  test("allows Cause as second arg", () => {
+    const causeArg = Testing.callOfMember("Cause", "fail", [Testing.id("error")])
+    const node = Testing.callOfMember("Effect", "logWarning", [
+      Testing.strLiteral("something failed"),
+      causeArg,
+    ])
+    const result = Testing.runRule(noPositionalLogError, "CallExpression", node)
+    Testing.expectNoDiagnostics(result)
+  })
+})

package/src/rules/no-console-in-effect.ts

@@ -1,46 +0,0 @@
-/**
- * Ban `console.*` calls inside Effect.gen/fn context.
- *
- * Use Effect Logger service instead.
- *
- * Source: language-service/globalConsoleInEffect
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, Visitor } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as Ref from "effect/Ref"
-
-import { makeEffectContextTracker } from "./_effect-context.js"
-
-const consoleMethods = ["log", "warn", "error", "info", "debug", "trace"]
-
-export const noConsoleInEffect = Rule.define({
-  name: "no-console-in-effect",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid console.* inside Effect.gen/fn. Use Effect Logger service.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(tracker, {
-      MemberExpression: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) => {
-          if (d > 0 && Option.isSome(AST.matchMember(node as ESTree.MemberExpression, "console", consoleMethods))) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message:
-                  "Avoid console.* inside Effect context. Use Effect Logger service.",
-              }),
-            )
-          }
-          return Effect.void
-        }),
-    })
-  },
-})

package/src/rules/no-date-in-effect.ts

@@ -1,61 +0,0 @@
-/**
- * Ban `Date.now()` and `new Date()` inside Effect.gen/fn context.
- *
- * Use Clock service instead.
- *
- * Source: language-service/globalDateInEffect
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, Visitor } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as Ref from "effect/Ref"
-
-import { makeEffectContextTracker } from "./_effect-context.js"
-
-export const noDateInEffect = Rule.define({
-  name: "no-date-in-effect",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid Date.now() and new Date() inside Effect.gen/fn. Use Clock service.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(
-      tracker,
-      {
-        MemberExpression: (node) =>
-          Effect.flatMap(Ref.get(depth), (d) => {
-            if (d > 0 && Option.isSome(AST.matchMember(node as ESTree.MemberExpression, "Date", "now"))) {
-              return ctx.report(
-                Diagnostic.make({ node, message: "Avoid Date.now() inside Effect context. Use Clock service." }),
-              )
-            }
-            return Effect.void
-          }),
-        NewExpression: (node) =>
-          Effect.flatMap(Ref.get(depth), (d) => {
-            if (
-              d > 0 &&
-              "callee" in node &&
-              node.callee != null &&
-              typeof node.callee === "object" &&
-              "type" in node.callee &&
-              node.callee.type === "Identifier" &&
-              "name" in node.callee &&
-              node.callee.name === "Date"
-            ) {
-              return ctx.report(
-                Diagnostic.make({ node, message: "Avoid new Date() inside Effect context. Use Clock service." }),
-              )
-            }
-            return Effect.void
-          }),
-      },
-    )
-  },
-})

package/src/rules/no-dynamic-import.ts

@@ -1,13 +0,0 @@
-/**
- * Ban dynamic `import()` expressions.
- *
- * Use static module imports.
- *
- * Source: biome-effect-linting-rules/prevent-dynamic-imports
- */
-import { Rule } from "../vendor/effect-oxlint/index.js"
-
-export const noDynamicImport = Rule.banStatement("ImportExpression", {
-  message: "Avoid dynamic import(). Use static module imports.",
-  meta: { type: "problem" },
-})

package/src/rules/no-fetch-in-effect.ts

@@ -1,47 +0,0 @@
-/**
- * Ban `fetch()` inside Effect.gen/fn context.
- *
- * Use HttpClient from 'effect/unstable/http' instead.
- *
- * Source: language-service/globalFetchInEffect
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, Visitor } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as Ref from "effect/Ref"
-
-import { makeEffectContextTracker } from "./_effect-context.js"
-
-export const noFetchInEffect = Rule.define({
-  name: "no-fetch-in-effect",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid fetch() inside Effect.gen/fn. Use HttpClient from 'effect/unstable/http'.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(tracker, {
-      CallExpression: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) => {
-          if (d > 0) {
-            const name = Option.getOrUndefined(AST.calleeName(node as ESTree.CallExpression))
-            if (name === "fetch") {
-              return ctx.report(
-                Diagnostic.make({
-                  node,
-                  message:
-                    "Avoid fetch() inside Effect context. Use HttpClient from 'effect/unstable/http'.",
-                }),
-              )
-            }
-          }
-          return Effect.void
-        }),
-    })
-  },
-})

package/src/rules/no-global-console.ts

@@ -1,17 +0,0 @@
-/**
- * Ban `console.log/warn/error/info/debug/trace`.
- *
- * Use Effect Logger service instead.
- *
- * Source: language-service/globalConsole
- */
-import { Rule } from "../vendor/effect-oxlint/index.js"
-
-export const noGlobalConsole = Rule.banMember(
-  "console",
-  ["log", "warn", "error", "info", "debug", "trace"],
-  {
-    message: "Avoid console.*. Use Effect Logger service.",
-    meta: { type: "suggestion" },
-  },
-)

package/src/rules/no-global-date.ts

@@ -1,20 +0,0 @@
-/**
- * Ban `Date.now()` and `new Date()`.
- *
- * Use Effect Clock service instead.
- *
- * Source: language-service/globalDate
- */
-import { Rule } from "../vendor/effect-oxlint/index.js"
-
-export const noGlobalDate = Rule.banMultiple(
-  {
-    newExprs: "Date",
-    members: [["Date", "now"]],
-  },
-  {
-    name: "no-global-date",
-    message: "Avoid Date.now() and new Date(). Use Clock service.",
-    meta: { type: "suggestion" },
-  },
-)