oxlint-plugin-effect 0.2.0 → 0.2.1

package/dist/vendor/effect-oxlint/Token.d.ts

@@ -0,0 +1,98 @@
+import { Token } from "@oxlint/plugins";
+
+//#region src/vendor/effect-oxlint/Token.d.ts
+declare namespace Token_d_exports {
+  export { isBoolean, isIdentifier, isKeyword, isNull, isNumeric, isPrivateIdentifier, isPunctuator, isRegularExpression, isString, isTemplate, type, value };
+}
+/**
+ * Check whether a token is a keyword with the given value.
+ *
+ * @example
+ * ```ts
+ * Token.isKeyword(token, 'const')  // true if keyword "const"
+ * Token.isKeyword(token, 'return') // true if keyword "return"
+ * ```
+ *
+ * @since 0.2.0
+ */
+declare const isKeyword: {
+  (keyword: string): (token: Token) => boolean;
+  (token: Token, keyword: string): boolean;
+};
+/**
+ * Check whether a token is a punctuator with the given value.
+ *
+ * @example
+ * ```ts
+ * Token.isPunctuator(token, '{')  // true if punctuator "{"
+ * Token.isPunctuator(token, ';')  // true if punctuator ";"
+ * ```
+ *
+ * @since 0.2.0
+ */
+declare const isPunctuator: {
+  (value: string): (token: Token) => boolean;
+  (token: Token, value: string): boolean;
+};
+/**
+ * Check whether a token is an identifier.
+ *
+ * @since 0.2.0
+ */
+declare const isIdentifier: (token: Token) => boolean;
+/**
+ * Check whether a token is a string literal.
+ *
+ * @since 0.2.0
+ */
+declare const isString: (token: Token) => boolean;
+/**
+ * Check whether a token is a numeric literal.
+ *
+ * @since 0.2.0
+ */
+declare const isNumeric: (token: Token) => boolean;
+/**
+ * Check whether a token is a boolean literal.
+ *
+ * @since 0.2.0
+ */
+declare const isBoolean: (token: Token) => boolean;
+/**
+ * Check whether a token is a null literal.
+ *
+ * @since 0.2.0
+ */
+declare const isNull: (token: Token) => boolean;
+/**
+ * Check whether a token is a template literal part.
+ *
+ * @since 0.2.0
+ */
+declare const isTemplate: (token: Token) => boolean;
+/**
+ * Check whether a token is a regular expression literal.
+ *
+ * @since 0.2.0
+ */
+declare const isRegularExpression: (token: Token) => boolean;
+/**
+ * Check whether a token is a private identifier (e.g. `#foo`).
+ *
+ * @since 0.2.0
+ */
+declare const isPrivateIdentifier: (token: Token) => boolean;
+/**
+ * Get the string value of a token.
+ *
+ * @since 0.2.0
+ */
+declare const value: (token: Token) => string;
+/**
+ * Get the type discriminant of a token.
+ *
+ * @since 0.2.0
+ */
+declare const type: (token: Token) => string;
+//#endregion
+export { Token_d_exports, isBoolean, isIdentifier, isKeyword, isNull, isNumeric, isPrivateIdentifier, isPunctuator, isRegularExpression, isString, isTemplate, type, value };

package/dist/vendor/effect-oxlint/Token.js

@@ -0,0 +1,103 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { dual } from "effect/Function";
+//#region src/vendor/effect-oxlint/Token.ts
+var Token_exports = /* @__PURE__ */ __exportAll({
+	isBoolean: () => isBoolean,
+	isIdentifier: () => isIdentifier,
+	isKeyword: () => isKeyword,
+	isNull: () => isNull,
+	isNumeric: () => isNumeric,
+	isPrivateIdentifier: () => isPrivateIdentifier,
+	isPunctuator: () => isPunctuator,
+	isRegularExpression: () => isRegularExpression,
+	isString: () => isString,
+	isTemplate: () => isTemplate,
+	type: () => type,
+	value: () => value
+});
+/**
+* Check whether a token is a keyword with the given value.
+*
+* @example
+* ```ts
+* Token.isKeyword(token, 'const')  // true if keyword "const"
+* Token.isKeyword(token, 'return') // true if keyword "return"
+* ```
+*
+* @since 0.2.0
+*/
+const isKeyword = dual(2, (token, keyword) => token.type === "Keyword" && token.value === keyword);
+/**
+* Check whether a token is a punctuator with the given value.
+*
+* @example
+* ```ts
+* Token.isPunctuator(token, '{')  // true if punctuator "{"
+* Token.isPunctuator(token, ';')  // true if punctuator ";"
+* ```
+*
+* @since 0.2.0
+*/
+const isPunctuator = dual(2, (token, value) => token.type === "Punctuator" && token.value === value);
+/**
+* Check whether a token is an identifier.
+*
+* @since 0.2.0
+*/
+const isIdentifier = (token) => token.type === "Identifier";
+/**
+* Check whether a token is a string literal.
+*
+* @since 0.2.0
+*/
+const isString = (token) => token.type === "String";
+/**
+* Check whether a token is a numeric literal.
+*
+* @since 0.2.0
+*/
+const isNumeric = (token) => token.type === "Numeric";
+/**
+* Check whether a token is a boolean literal.
+*
+* @since 0.2.0
+*/
+const isBoolean = (token) => token.type === "Boolean";
+/**
+* Check whether a token is a null literal.
+*
+* @since 0.2.0
+*/
+const isNull = (token) => token.type === "Null";
+/**
+* Check whether a token is a template literal part.
+*
+* @since 0.2.0
+*/
+const isTemplate = (token) => token.type === "Template";
+/**
+* Check whether a token is a regular expression literal.
+*
+* @since 0.2.0
+*/
+const isRegularExpression = (token) => token.type === "RegularExpression";
+/**
+* Check whether a token is a private identifier (e.g. `#foo`).
+*
+* @since 0.2.0
+*/
+const isPrivateIdentifier = (token) => token.type === "PrivateIdentifier";
+/**
+* Get the string value of a token.
+*
+* @since 0.2.0
+*/
+const value = (token) => token.value;
+/**
+* Get the type discriminant of a token.
+*
+* @since 0.2.0
+*/
+const type = (token) => token.type;
+//#endregion
+export { Token_exports, isBoolean, isIdentifier, isKeyword, isNull, isNumeric, isPrivateIdentifier, isPunctuator, isRegularExpression, isString, isTemplate, type, value };

package/dist/vendor/effect-oxlint/Visitor.d.ts

@@ -0,0 +1,166 @@
+import { RuleContext } from "./RuleContext.js";
+import * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import { ESTree, Visitor } from "@oxlint/plugins";
+
+//#region src/vendor/effect-oxlint/Visitor.d.ts
+declare namespace Visitor_d_exports {
+  export { EffectHandler, EffectVisitor, TypedEffectVisitor, VisitorNodeType, accumulate, filter, merge, on, onExit, toOxlintVisitor, tracked };
+}
+/**
+ * An effectful visitor handler.
+ *
+ * Receives an AST node and returns an `Effect<void>` that may read/write
+ * `Ref` state and report diagnostics via `RuleContext`.
+ *
+ * @since 0.1.0
+ */
+type EffectHandler<N = ESTree.Node> = {
+  bivarianceHack(node: N): Effect.Effect<void, never, RuleContext>;
+}['bivarianceHack'];
+/**
+ * A map from AST node type names (and `"NodeType:exit"` variants) to
+ * effectful handlers.
+ *
+ * This is the internal representation — handlers accept `ESTree.Node`.
+ *
+ * @since 0.1.0
+ */
+type EffectVisitor = {
+  readonly [key: string]: EffectHandler;
+};
+/** @internal Extract the node parameter type from an oxlint visitor handler. */
+type ExtractNode<H> = H extends ((node: infer N) => unknown) | {
+  bivarianceHack(node: infer N): void;
+} ? N : ESTree.Node;
+/**
+ * Resolve a visitor key to its narrowed node type.
+ *
+ * For known keys (e.g. `'CallExpression'`), returns the specific
+ * ESTree node type. For unknown keys, falls back to `ESTree.Node`.
+ *
+ * @since 0.2.0
+ */
+type VisitorNodeType<K extends string> = K extends keyof Visitor ? ExtractNode<Exclude<Visitor[K], undefined>> : ESTree.Node;
+/**
+ * Typed visitor map where known oxlint visitor keys provide the
+ * correctly narrowed node type to handlers (e.g. `MemberExpression`
+ * handlers receive `ESTree.MemberExpression`).
+ *
+ * Return this from `Rule.define`'s `create` generator. Callers get
+ * typed nodes in their handlers without manual narrowing.
+ *
+ * @since 0.2.0
+ */
+type TypedEffectVisitor = { readonly [K in keyof Visitor]?: EffectHandler<ExtractNode<Exclude<Visitor[K], undefined>>> };
+/**
+ * Create a single-entry visitor that handles one node type.
+ *
+ * The handler is a generator function that can `yield*` Effects.
+ *
+ * @example
+ * ```ts
+ * Visitor.on('ThrowStatement', function*(node) {
+ *   const depth = yield* Ref.get(myDepthRef)
+ *   if (depth > 0) {
+ *     yield* RuleContext.report({ node, message: '...' })
+ *   }
+ * })
+ * ```
+ *
+ * @since 0.1.0
+ */
+declare const on: <K extends string>(nodeType: K, handler: EffectHandler<VisitorNodeType<K>>) => EffectVisitor;
+/**
+ * Create a single-entry visitor for the exit phase of a node type.
+ *
+ * @since 0.1.0
+ */
+declare const onExit: <K extends string>(nodeType: K, handler: EffectHandler<VisitorNodeType<K>>) => EffectVisitor;
+/**
+ * Merge multiple visitors into one.
+ *
+ * When two visitors handle the same node type, both handlers run
+ * sequentially (left to right).
+ *
+ * @since 0.1.0
+ */
+declare const merge: (...visitors: ReadonlyArray<EffectVisitor>) => EffectVisitor;
+/**
+ * Create an enter/exit visitor pair that increments a `Ref<number>` on
+ * enter and decrements on exit, but only when the predicate matches.
+ *
+ * This replaces the common `let depth = 0` mutable counter pattern.
+ *
+ * The predicate receives the narrowed node type for the given key
+ * (e.g. `ESTree.CallExpression` for `'CallExpression'`).
+ *
+ * @example
+ * ```ts
+ * const effectGenDepth = yield* Ref.make(0)
+ *
+ * Visitor.tracked('CallExpression',
+ *   (node) => AST.isCallOf(node, 'Effect', 'gen'),
+ *   effectGenDepth
+ * )
+ * ```
+ *
+ * @since 0.1.0
+ */
+declare const tracked: <K extends string>(nodeType: K, predicate: (node: VisitorNodeType<K>) => boolean, ref: Ref.Ref<number>) => EffectVisitor;
+/**
+ * Conditionally apply a visitor based on a predicate evaluated once
+ * at create time.
+ *
+ * Useful for restricting a visitor to specific files (e.g. skip test files).
+ *
+ * @example
+ * ```ts
+ * Visitor.filter(
+ *   (filename) => !filename.endsWith('.test.ts'),
+ *   mainVisitor
+ * )
+ * ```
+ *
+ * @since 0.2.0
+ */
+declare const filter: {
+  (predicate: (filename: string) => boolean): (visitor: EffectVisitor) => Effect.Effect<EffectVisitor, never, RuleContext>;
+  (predicate: (filename: string) => boolean, visitor: EffectVisitor): Effect.Effect<EffectVisitor, never, RuleContext>;
+};
+/**
+ * Accumulate values during traversal and analyze them at `Program:exit`.
+ *
+ * The `extract` function is called for each node of `nodeType`. If it
+ * returns `Option.some(value)`, that value is accumulated. At
+ * `Program:exit`, the `analyze` generator receives all collected items.
+ *
+ * @example
+ * ```ts
+ * Visitor.accumulate(
+ *   'ExportNamedDeclaration',
+ *   (node) => AST.narrow(node, 'ExportNamedDeclaration').pipe(
+ *     Option.map(n => n.declaration)
+ *   ),
+ *   function*(accumulated) {
+ *     // Analyze all collected declarations at end of file
+ *   }
+ * )
+ * ```
+ *
+ * @since 0.2.0
+ */
+declare const accumulate: <A>(nodeType: string, extract: (node: ESTree.Node) => Option.Option<A>, analyze: (items: ReadonlyArray<A>) => Effect.Effect<void, never, RuleContext>) => Effect.Effect<EffectVisitor, never, RuleContext>;
+/**
+ * Convert an `EffectVisitor` to a plain oxlint `Visitor` by wrapping
+ * each handler with the provided runner function.
+ *
+ * This is the runtime boundary where Effects are executed. Called once
+ * per file inside `Rule.define`'s `create`.
+ *
+ * @internal
+ */
+declare const toOxlintVisitor: (effectVisitor: EffectVisitor, runHandler: (effect: Effect.Effect<void, never, RuleContext>) => void) => Visitor;
+//#endregion
+export { EffectHandler, EffectVisitor, TypedEffectVisitor, VisitorNodeType, Visitor_d_exports, accumulate, filter, merge, on, onExit, toOxlintVisitor, tracked };

package/dist/vendor/effect-oxlint/Visitor.js

@@ -0,0 +1,138 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { RuleContext } from "./RuleContext.js";
+import * as Arr from "effect/Array";
+import { dual, pipe } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+import * as R from "effect/Record";
+import * as Ref from "effect/Ref";
+//#region src/vendor/effect-oxlint/Visitor.ts
+var Visitor_exports = /* @__PURE__ */ __exportAll({
+	accumulate: () => accumulate,
+	filter: () => filter,
+	merge: () => merge,
+	on: () => on,
+	onExit: () => onExit,
+	toOxlintVisitor: () => toOxlintVisitor,
+	tracked: () => tracked
+});
+/**
+* Create a single-entry visitor that handles one node type.
+*
+* The handler is a generator function that can `yield*` Effects.
+*
+* @example
+* ```ts
+* Visitor.on('ThrowStatement', function*(node) {
+*   const depth = yield* Ref.get(myDepthRef)
+*   if (depth > 0) {
+*     yield* RuleContext.report({ node, message: '...' })
+*   }
+* })
+* ```
+*
+* @since 0.1.0
+*/
+const on = (nodeType, handler) => ({ [nodeType]: handler });
+/**
+* Create a single-entry visitor for the exit phase of a node type.
+*
+* @since 0.1.0
+*/
+const onExit = (nodeType, handler) => ({ [`${nodeType}:exit`]: handler });
+/** @internal Empty visitor seed for reduce operations. */
+const emptyVisitor = {};
+/** @internal Combine two handlers for the same node type into one sequential handler. */
+const sequenceHandlers = (left, right) => (node) => Effect.andThen(left(node), right(node));
+/**
+* Merge multiple visitors into one.
+*
+* When two visitors handle the same node type, both handlers run
+* sequentially (left to right).
+*
+* @since 0.1.0
+*/
+const merge = (...visitors) => Arr.reduce(visitors, emptyVisitor, (acc, visitor) => R.union(acc, visitor, (left, right) => sequenceHandlers(left, right)));
+/**
+* Create an enter/exit visitor pair that increments a `Ref<number>` on
+* enter and decrements on exit, but only when the predicate matches.
+*
+* This replaces the common `let depth = 0` mutable counter pattern.
+*
+* The predicate receives the narrowed node type for the given key
+* (e.g. `ESTree.CallExpression` for `'CallExpression'`).
+*
+* @example
+* ```ts
+* const effectGenDepth = yield* Ref.make(0)
+*
+* Visitor.tracked('CallExpression',
+*   (node) => AST.isCallOf(node, 'Effect', 'gen'),
+*   effectGenDepth
+* )
+* ```
+*
+* @since 0.1.0
+*/
+const tracked = (nodeType, predicate, ref) => ({
+	[nodeType]: (node) => predicate(node) ? Ref.update(ref, (n) => n + 1) : Effect.void,
+	[`${nodeType}:exit`]: (node) => predicate(node) ? Ref.update(ref, (n) => n - 1) : Effect.void
+});
+/**
+* Conditionally apply a visitor based on a predicate evaluated once
+* at create time.
+*
+* Useful for restricting a visitor to specific files (e.g. skip test files).
+*
+* @example
+* ```ts
+* Visitor.filter(
+*   (filename) => !filename.endsWith('.test.ts'),
+*   mainVisitor
+* )
+* ```
+*
+* @since 0.2.0
+*/
+const filter = dual(2, (predicate, visitor) => Effect.service(RuleContext).pipe(Effect.map((ctx) => predicate(ctx.filename) ? visitor : {})));
+/**
+* Accumulate values during traversal and analyze them at `Program:exit`.
+*
+* The `extract` function is called for each node of `nodeType`. If it
+* returns `Option.some(value)`, that value is accumulated. At
+* `Program:exit`, the `analyze` generator receives all collected items.
+*
+* @example
+* ```ts
+* Visitor.accumulate(
+*   'ExportNamedDeclaration',
+*   (node) => AST.narrow(node, 'ExportNamedDeclaration').pipe(
+*     Option.map(n => n.declaration)
+*   ),
+*   function*(accumulated) {
+*     // Analyze all collected declarations at end of file
+*   }
+* )
+* ```
+*
+* @since 0.2.0
+*/
+const accumulate = (nodeType, extract, analyze) => Effect.gen(function* () {
+	const ref = yield* Ref.make([]);
+	return merge(on(nodeType, (node) => pipe(extract(node), Option.match({
+		onNone: () => Effect.void,
+		onSome: (value) => Ref.update(ref, (items) => [...items, value])
+	}))), on("Program:exit", () => Effect.flatMap(Ref.get(ref), (items) => analyze(items))));
+});
+/**
+* Convert an `EffectVisitor` to a plain oxlint `Visitor` by wrapping
+* each handler with the provided runner function.
+*
+* This is the runtime boundary where Effects are executed. Called once
+* per file inside `Rule.define`'s `create`.
+*
+* @internal
+*/
+const toOxlintVisitor = (effectVisitor, runHandler) => R.map(effectVisitor, (handler) => (node) => runHandler(handler(node)));
+//#endregion
+export { Visitor_exports, accumulate, filter, merge, on, onExit, toOxlintVisitor, tracked };

package/dist/vendor/effect-oxlint/index.d.ts

@@ -0,0 +1,13 @@
+import { AST_d_exports } from "./AST.js";
+import { Comment_d_exports } from "./Comment.js";
+import { Diagnostic_d_exports } from "./Diagnostic.js";
+import { Plugin_d_exports } from "./Plugin.js";
+import { RuleContext, ast, cwd, filename, id, report, sourceCode, text } from "./RuleContext.js";
+import { Visitor_d_exports } from "./Visitor.js";
+import { Rule_d_exports } from "./Rule.js";
+import { Scope_d_exports } from "./Scope.js";
+import { SourceCode_d_exports } from "./SourceCode.js";
+import { Testing_d_exports } from "./Testing.js";
+import { Token_d_exports } from "./Token.js";
+import { Comment as OxlintComment, Context, CreateOnceRule, CreateRule, Definition, DefinitionType, ESTree, Fix, FixFn, Fixer, LineColumn, Location, Plugin as OxlintPlugin, Range, Ranged, Reference, Rule as OxlintRule, RuleDocs, RuleMeta, Scope as OxlintScope, ScopeManager, ScopeType, Settings, SourceCode as OxlintSourceCode, Span, Suggestion, Token as OxlintToken, Variable, Visitor as OxlintVisitor } from "@oxlint/plugins";
+export { AST_d_exports as AST, Comment_d_exports as Comment, type Context, type CreateOnceRule, type CreateRule, type Definition, type DefinitionType, Diagnostic_d_exports as Diagnostic, type ESTree, type Fix, type FixFn, type Fixer, type LineColumn, type Location, type OxlintComment, type OxlintPlugin, type OxlintRule, type OxlintScope, type OxlintSourceCode, type OxlintToken, type OxlintVisitor, Plugin_d_exports as Plugin, type Range, type Ranged, type Reference, Rule_d_exports as Rule, RuleContext, type RuleDocs, type RuleMeta, Scope_d_exports as Scope, type ScopeManager, type ScopeType, type Settings, SourceCode_d_exports as SourceCode, type Span, type Suggestion, Testing_d_exports as Testing, Token_d_exports as Token, type Variable, Visitor_d_exports as Visitor, ast, cwd, filename, id, report, sourceCode, text };

package/dist/vendor/effect-oxlint/index.js

@@ -0,0 +1,12 @@
+import { AST_exports } from "./AST.js";
+import { Comment_exports } from "./Comment.js";
+import { Diagnostic_exports } from "./Diagnostic.js";
+import { Plugin_exports } from "./Plugin.js";
+import { RuleContext, ast, cwd, filename, id, report, sourceCode, text } from "./RuleContext.js";
+import { Visitor_exports } from "./Visitor.js";
+import { Rule_exports } from "./Rule.js";
+import { Scope_exports } from "./Scope.js";
+import { SourceCode_exports } from "./SourceCode.js";
+import { Testing_exports } from "./Testing.js";
+import { Token_exports } from "./Token.js";
+export { AST_exports as AST, Comment_exports as Comment, Diagnostic_exports as Diagnostic, Plugin_exports as Plugin, Rule_exports as Rule, RuleContext, Scope_exports as Scope, SourceCode_exports as SourceCode, Testing_exports as Testing, Token_exports as Token, Visitor_exports as Visitor, ast, cwd, filename, id, report, sourceCode, text };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-effect",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "oxlint plugin with Effect-specific lint rules",
   "license": "MIT",
@@ -8,14 +8,32 @@
     "type": "git",
     "url": "https://github.com/cevr/effect-oxlint"
   },
+  "files": [
+    "dist"
+  ],
   "exports": {
-    ".": "./src/index.ts",
-    "./plugin": "./src/plugin.ts",
-    "./presets/*": "./src/presets/*.ts"
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./plugin": {
+      "import": {
+        "types": "./dist/plugin.d.ts",
+        "default": "./dist/plugin.js"
+      }
+    },
+    "./presets/*": {
+      "import": {
+        "types": "./dist/presets/*.d.ts",
+        "default": "./dist/presets/*.js"
+      }
+    }
   },
   "scripts": {
     "dev": "bun run src/index.ts",
-    "build": "bun run scripts/build.ts",
+    "build": "tsdown",
     "typecheck": "tsgo --noEmit",
     "lint": "concurrently -n ox,effect -c yellow,blue \"oxlint\" \"bun run lint:effect\"",
     "lint:ox": "oxlint",
@@ -44,6 +62,7 @@
     "lefthook": "latest",
     "oxfmt": "latest",
     "oxlint": "latest",
+    "tsdown": "^0.21.7",
     "typescript": "latest",
     "vitest": "latest"
   }

package/.effect-lsp.json

@@ -1,60 +0,0 @@
-{
-  "diagnostics": true,
-  "diagnosticsName": true,
-  "diagnosticSeverity": {
-    "anyUnknownInErrorContext": "error",
-    "deterministicKeys": "error",
-    "importFromBarrel": "error",
-    "instanceOfSchema": "error",
-    "missedPipeableOpportunity": "off",
-    "missingEffectServiceDependency": "error",
-    "schemaUnionOfLiterals": "error",
-    "strictBooleanExpressions": "off",
-    "strictEffectProvide": "error",
-    "catchAllToMapError": "error",
-    "catchUnfailableEffect": "error",
-    "effectFnOpportunity": "error",
-    "effectMapVoid": "error",
-    "effectSucceedWithVoid": "error",
-    "leakingRequirements": "error",
-    "preferSchemaOverJson": "error",
-    "redundantSchemaTagIdentifier": "error",
-    "returnEffectInGen": "error",
-    "runEffectInsideEffect": "error",
-    "schemaStructWithTag": "error",
-    "schemaSyncInEffect": "error",
-    "tryCatchInEffectGen": "error",
-    "unnecessaryEffectGen": "error",
-    "unnecessaryFailYieldableError": "error",
-    "unnecessaryPipe": "error",
-    "unnecessaryPipeChain": "error",
-    "extendsNativeError": "error",
-    "nodeBuiltinImport": "error",
-    "serviceNotAsClass": "error",
-    "outdatedApi": "error",
-    "globalFetch": "error",
-    "globalFetchInEffect": "error",
-    "globalDate": "error",
-    "globalDateInEffect": "error",
-    "globalConsole": "error",
-    "globalConsoleInEffect": "error",
-    "globalRandom": "error",
-    "globalRandomInEffect": "error",
-    "globalTimers": "error",
-    "globalTimersInEffect": "error",
-    "globalErrorInEffectCatch": "error",
-    "globalErrorInEffectFailure": "error"
-  },
-  "keyPatterns": [
-    {
-      "target": "service",
-      "pattern": "default",
-      "skipLeadingPath": ["src/"]
-    },
-    {
-      "target": "error",
-      "pattern": "default",
-      "skipLeadingPath": ["src/"]
-    }
-  ]
-}

package/.oxlintrc.json

@@ -1,33 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json",
-  "categories": {
-    "correctness": "error",
-    "suspicious": "error",
-    "perf": "error"
-  },
-  "plugins": ["typescript", "import"],
-  "rules": {
-    "typescript/no-explicit-any": "error",
-    "typescript/no-non-null-assertion": "error",
-    "typescript/no-extra-non-null-assertion": "error",
-    "typescript/no-non-null-asserted-optional-chain": "error",
-    "typescript/consistent-type-imports": [
-      "error",
-      { "prefer": "type-imports", "fixStyle": "separate-type-imports" }
-    ],
-    "typescript/no-unsafe-type-assertion": "error",
-    "import/no-duplicates": "error",
-    "no-unused-vars": ["error", { "argsIgnorePattern": "^_", "varsIgnorePattern": "^_" }]
-  },
-  "ignorePatterns": ["**/dist/**", "**/node_modules/**", "**/*.d.ts"],
-  "overrides": [
-    {
-      "files": ["**/*.test.ts", "**/tests/**"],
-      "rules": {
-        "typescript/no-non-null-assertion": "off",
-        "typescript/no-explicit-any": "off",
-        "typescript/no-unsafe-type-assertion": "off"
-      }
-    }
-  ]
-}