oxlint-plugin-effect 0.1.0 → 0.2.1

package/src/vendor/effect-oxlint/Token.ts

@@ -1,131 +0,0 @@
-/**
- * Token type predicates and helpers for Effect-first lint rules.
- *
- * Provides convenience checks over oxlint's `Token` type (a discriminated
- * union of `BooleanToken`, `IdentifierToken`, `KeywordToken`, etc.).
- *
- * @since 0.2.0
- */
-import type { Token } from '@oxlint/plugins';
-import { dual } from 'effect/Function';
-
-// ---------------------------------------------------------------------------
-// Type predicates
-// ---------------------------------------------------------------------------
-
-/**
- * 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
- */
-export const isKeyword: {
-	(keyword: string): (token: Token) => boolean;
-	(token: Token, keyword: string): boolean;
-} = dual(
-	2,
-	(token: Token, keyword: string): boolean =>
-		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
- */
-export const isPunctuator: {
-	(value: string): (token: Token) => boolean;
-	(token: Token, value: string): boolean;
-} = dual(
-	2,
-	(token: Token, value: string): boolean =>
-		token.type === 'Punctuator' && token.value === value
-);
-
-/**
- * Check whether a token is an identifier.
- *
- * @since 0.2.0
- */
-export const isIdentifier = (token: Token): boolean =>
-	token.type === 'Identifier';
-
-/**
- * Check whether a token is a string literal.
- *
- * @since 0.2.0
- */
-export const isString = (token: Token): boolean => token.type === 'String';
-
-/**
- * Check whether a token is a numeric literal.
- *
- * @since 0.2.0
- */
-export const isNumeric = (token: Token): boolean => token.type === 'Numeric';
-
-/**
- * Check whether a token is a boolean literal.
- *
- * @since 0.2.0
- */
-export const isBoolean = (token: Token): boolean => token.type === 'Boolean';
-
-/**
- * Check whether a token is a null literal.
- *
- * @since 0.2.0
- */
-export const isNull = (token: Token): boolean => token.type === 'Null';
-
-/**
- * Check whether a token is a template literal part.
- *
- * @since 0.2.0
- */
-export const isTemplate = (token: Token): boolean => token.type === 'Template';
-
-/**
- * Check whether a token is a regular expression literal.
- *
- * @since 0.2.0
- */
-export const isRegularExpression = (token: Token): boolean =>
-	token.type === 'RegularExpression';
-
-/**
- * Check whether a token is a private identifier (e.g. `#foo`).
- *
- * @since 0.2.0
- */
-export const isPrivateIdentifier = (token: Token): boolean =>
-	token.type === 'PrivateIdentifier';
-
-// ---------------------------------------------------------------------------
-// Accessors
-// ---------------------------------------------------------------------------
-
-/**
- * Get the string value of a token.
- *
- * @since 0.2.0
- */
-export const value = (token: Token): string => token.value;
-
-/**
- * Get the type discriminant of a token.
- *
- * @since 0.2.0
- */
-export const type = (token: Token): string => token.type;

package/src/vendor/effect-oxlint/Visitor.ts

@@ -1,287 +0,0 @@
-/**
- * Composable visitor construction for Effect-first oxlint rules.
- *
- * Visitors are maps from AST node type names to Effect-returning handlers.
- * This module provides combinators to build, merge, and enhance visitors.
- *
- * @since 0.1.0
- */
-import type { ESTree, Visitor as OxlintVisitor } from '@oxlint/plugins';
-import * as Arr from 'effect/Array';
-import * as Effect from 'effect/Effect';
-import { dual, pipe } from 'effect/Function';
-import * as Option from 'effect/Option';
-import * as R from 'effect/Record';
-import * as Ref from 'effect/Ref';
-
-import { RuleContext } from './RuleContext.ts';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/**
- * 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
- */
-export 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
- */
-export 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
- */
-export type VisitorNodeType<K extends string> = K extends keyof OxlintVisitor
-	? ExtractNode<Exclude<OxlintVisitor[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
- */
-export type TypedEffectVisitor = {
-	readonly [K in keyof OxlintVisitor]?: EffectHandler<
-		ExtractNode<Exclude<OxlintVisitor[K], undefined>>
-	>;
-};
-
-// ---------------------------------------------------------------------------
-// Constructors
-// ---------------------------------------------------------------------------
-
-/**
- * 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
- */
-export const on = <K extends string>(
-	nodeType: K,
-	handler: EffectHandler<VisitorNodeType<K>>
-): EffectVisitor => ({ [nodeType]: handler as EffectHandler });
-
-/**
- * Create a single-entry visitor for the exit phase of a node type.
- *
- * @since 0.1.0
- */
-export const onExit = <K extends string>(
-	nodeType: K,
-	handler: EffectHandler<VisitorNodeType<K>>
-): EffectVisitor => ({ [`${nodeType}:exit`]: handler as EffectHandler });
-
-// ---------------------------------------------------------------------------
-// Combinators
-// ---------------------------------------------------------------------------
-
-/** @internal Empty visitor seed for reduce operations. */
-const emptyVisitor: EffectVisitor = {};
-
-/** @internal Combine two handlers for the same node type into one sequential handler. */
-const sequenceHandlers =
-	(left: EffectHandler, right: EffectHandler): EffectHandler =>
-	(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
- */
-export const merge = (
-	...visitors: ReadonlyArray<EffectVisitor>
-): EffectVisitor =>
-	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
- */
-export const tracked = <K extends string>(
-	nodeType: K,
-	predicate: (node: VisitorNodeType<K>) => boolean,
-	ref: Ref.Ref<number>
-): EffectVisitor => ({
-	[nodeType]: (node: ESTree.Node) =>
-		predicate(node as VisitorNodeType<K>)
-			? Ref.update(ref, (n) => n + 1)
-			: Effect.void,
-	[`${nodeType}:exit`]: (node: ESTree.Node) =>
-		predicate(node as VisitorNodeType<K>)
-			? 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
- */
-export const filter: {
-	(
-		predicate: (filename: string) => boolean
-	): (
-		visitor: EffectVisitor
-	) => Effect.Effect<EffectVisitor, never, RuleContext>;
-	(
-		predicate: (filename: string) => boolean,
-		visitor: EffectVisitor
-	): Effect.Effect<EffectVisitor, never, RuleContext>;
-} = dual(
-	2,
-	(
-		predicate: (filename: string) => boolean,
-		visitor: EffectVisitor
-	): Effect.Effect<EffectVisitor, never, RuleContext> =>
-		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
- */
-export 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> =>
-	Effect.gen(function* () {
-		const ref = yield* Ref.make<ReadonlyArray<A>>([]);
-		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))
-			)
-		);
-	});
-
-// ---------------------------------------------------------------------------
-// Conversion (internal — used by Rule.define at the runtime boundary)
-// ---------------------------------------------------------------------------
-
-/**
- * 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
- */
-export const toOxlintVisitor = (
-	effectVisitor: EffectVisitor,
-	runHandler: (effect: Effect.Effect<void, never, RuleContext>) => void
-): OxlintVisitor =>
-	R.map(
-		effectVisitor,
-		(handler) => (node: ESTree.Node) => runHandler(handler(node))
-	);

package/src/vendor/effect-oxlint/index.ts

@@ -1,88 +0,0 @@
-/**
- * Effect-first library for writing oxlint custom lint rules.
- *
- * @since 0.1.0
- * @packageDocumentation
- */
-
-// ---------------------------------------------------------------------------
-// Core modules
-// ---------------------------------------------------------------------------
-
-/** AST pattern matching helpers returning `Option` for safe composition. */
-export * as AST from './AST.ts';
-
-/** Comment type predicates and helpers. */
-export * as Comment from './Comment.ts';
-
-/** Structured diagnostic construction. */
-export * as Diagnostic from './Diagnostic.ts';
-
-/** Plugin definition and composition. */
-export * as Plugin from './Plugin.ts';
-
-/** Core rule builder — `Rule.define` is the primary entry point. */
-export * as Rule from './Rule.ts';
-
-/** Effect service wrapping the oxlint rule context. */
-export { RuleContext } from './RuleContext.ts';
-export {
-	ast,
-	cwd,
-	filename,
-	id,
-	report,
-	sourceCode,
-	text
-} from './RuleContext.ts';
-
-/** Scope analysis helpers with Option. */
-export * as Scope from './Scope.ts';
-
-/** Effect-wrapped SourceCode queries with Option. */
-export * as SourceCode from './SourceCode.ts';
-
-/** Testing infrastructure — builders, runners, assertion helpers. */
-export * as Testing from './Testing.ts';
-
-/** Token type predicates and helpers. */
-export * as Token from './Token.ts';
-
-/** Composable visitor construction. */
-export * as Visitor from './Visitor.ts';
-
-// ---------------------------------------------------------------------------
-// Type re-exports from @oxlint/plugins
-// ---------------------------------------------------------------------------
-
-export type {
-	Comment as OxlintComment,
-	Context,
-	CreateOnceRule,
-	CreateRule,
-	Definition,
-	DefinitionType,
-	ESTree,
-	Fix,
-	Fixer,
-	FixFn,
-	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';

package/tests/ban-rules.test.ts

@@ -1,85 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { Testing } from "../src/vendor/effect-oxlint/index.js"
-import {
-  noEffectDo,
-  noEffectNever,
-  noEffectAs,
-  noEffectAsync,
-  noEffectBind,
-  noOptionAs,
-  noRuntimeRunFork,
-  noRunInEffect,
-} from "../src/rules/index.js"
-
-// --- API ban rules ---
-
-describe("noEffectDo", () => {
-  test("reports Effect.Do", () => {
-    const result = Testing.runRule(noEffectDo, "MemberExpression", Testing.memberExpr("Effect", "Do"))
-    Testing.expectDiagnostics(result, [{ message: "Avoid Effect.Do builder notation. Use flat pipe-based flow or Effect.gen." }])
-  })
-
-  test("ignores Effect.map", () => {
-    const result = Testing.runRule(noEffectDo, "MemberExpression", Testing.memberExpr("Effect", "map"))
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noEffectNever", () => {
-  test("reports Effect.never", () => {
-    const result = Testing.runRule(noEffectNever, "MemberExpression", Testing.memberExpr("Effect", "never"))
-    Testing.expectDiagnostics(result, [{ message: "Avoid Effect.never. Use Stream or explicit acquire/release lifecycles." }])
-  })
-})
-
-describe("noEffectAs", () => {
-  test("reports Effect.as", () => {
-    const result = Testing.runRule(noEffectAs, "MemberExpression", Testing.memberExpr("Effect", "as"))
-    Testing.expectDiagnostics(result, [{ message: "Avoid Effect.as. Use Effect.map for value mapping or Effect.asVoid." }])
-  })
-})
-
-describe("noEffectAsync", () => {
-  test("reports Effect.async", () => {
-    const result = Testing.runRule(noEffectAsync, "MemberExpression", Testing.memberExpr("Effect", "async"))
-    expect(result.length).toBe(1)
-  })
-})
-
-describe("noEffectBind", () => {
-  test("reports Effect.bind", () => {
-    const result = Testing.runRule(noEffectBind, "MemberExpression", Testing.memberExpr("Effect", "bind"))
-    expect(result.length).toBe(1)
-  })
-})
-
-describe("noOptionAs", () => {
-  test("reports Option.as", () => {
-    const result = Testing.runRule(noOptionAs, "MemberExpression", Testing.memberExpr("Option", "as"))
-    expect(result.length).toBe(1)
-  })
-})
-
-describe("noRuntimeRunFork", () => {
-  test("reports Runtime.runFork", () => {
-    const result = Testing.runRule(noRuntimeRunFork, "MemberExpression", Testing.memberExpr("Runtime", "runFork"))
-    expect(result.length).toBe(1)
-  })
-})
-
-describe("noRunInEffect", () => {
-  test("reports Effect.runSync", () => {
-    const result = Testing.runRule(noRunInEffect, "MemberExpression", Testing.memberExpr("Effect", "runSync"))
-    expect(result.length).toBe(1)
-  })
-
-  test("reports Effect.runPromise", () => {
-    const result = Testing.runRule(noRunInEffect, "MemberExpression", Testing.memberExpr("Effect", "runPromise"))
-    expect(result.length).toBe(1)
-  })
-
-  test("ignores Effect.gen", () => {
-    const result = Testing.runRule(noRunInEffect, "MemberExpression", Testing.memberExpr("Effect", "gen"))
-    Testing.expectNoDiagnostics(result)
-  })
-})