oxlint-plugin-effect 0.2.0 → 0.2.2

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

@@ -0,0 +1,309 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { calleeName, matchImport, matchMember, narrow } from "./AST.js";
+import { make } from "./Diagnostic.js";
+import { RuleContext, fromOxlintContext } from "./RuleContext.js";
+import { merge, toOxlintVisitor } from "./Visitor.js";
+import * as Arr from "effect/Array";
+import { pipe } from "effect/Function";
+import * as Option from "effect/Option";
+import * as P from "effect/Predicate";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+//#region src/vendor/effect-oxlint/Rule.ts
+var Rule_exports = /* @__PURE__ */ __exportAll({
+	banCallOf: () => banCallOf,
+	banImport: () => banImport,
+	banMember: () => banMember,
+	banMultiple: () => banMultiple,
+	banNewExpr: () => banNewExpr,
+	banStatement: () => banStatement,
+	define: () => define,
+	meta: () => meta
+});
+/**
+* Extract the identifier name from a `NewExpression` callee.
+*
+* `AST.calleeName` only accepts `CallExpression`. This mirrors the
+* same logic for `NewExpression.callee`.
+*
+* @internal
+*/
+const newExprCalleeName = (callee) => callee.type === "Identifier" && "name" in callee && P.isString(callee.name) ? Option.some(callee.name) : Option.none();
+/**
+* Define an Effect-first oxlint lint rule.
+*
+* The `create` generator runs once per file via `Effect.runSync`.
+* Each visitor handler is also executed via `Effect.runSync` per node.
+* `Ref`-based state created in `create` persists across handler calls
+* via closure.
+*
+* `Effect.runSync` is used here at the runtime boundary — the bridge
+* between oxlint's synchronous plugin API and our Effect world.
+*
+* @since 0.1.0
+*/
+const define = (config) => ({
+	meta: config.meta,
+	create(oxlintContext) {
+		const ruleCtx = fromOxlintContext(oxlintContext);
+		const run = (effect) => Effect.runSync(Effect.provideService(effect, RuleContext, ruleCtx));
+		const decodeOptions = () => {
+			const schema = config.options;
+			if (schema === void 0) return void 0;
+			return Schema.decodeUnknownSync(schema)(oxlintContext.options[0]);
+		};
+		const options = run(Effect.sync(decodeOptions));
+		return toOxlintVisitor(run(Effect.gen(() => config.create(options))), run);
+	}
+});
+/**
+* Build `RuleMeta` with sensible defaults.
+*
+* @since 0.1.0
+*/
+const meta = (opts) => ({
+	type: opts.type,
+	...opts.fixable !== void 0 ? { fixable: opts.fixable } : {},
+	...opts.hasSuggestions !== void 0 ? { hasSuggestions: opts.hasSuggestions } : {},
+	...opts.messages !== void 0 ? { messages: opts.messages } : {},
+	docs: {
+		description: opts.description,
+		effectVersion: opts.effectVersion ?? "both",
+		...opts.docs
+	}
+});
+/**
+* Create a rule that bans `obj.prop` member expression access.
+*
+* Replaces the common `memberExprRule` utility pattern.
+*
+* @since 0.1.0
+*/
+const banMember = (obj, prop, opts) => define({
+	name: `ban-${obj}-${P.isString(prop) ? prop : Arr.join(prop, "-")}`,
+	meta: meta({
+		type: opts.meta?.type ?? "suggestion",
+		description: opts.message,
+		effectVersion: opts.meta?.effectVersion
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { MemberExpression: (node) => pipe(narrow(node, "MemberExpression"), Option.flatMap(matchMember(obj, prop)), Option.match({
+			onNone: () => Effect.void,
+			onSome: (matched) => ctx.report(make({
+				node: matched,
+				message: opts.message
+			}))
+		})) };
+	}
+});
+/**
+* Create a rule that bans imports matching a source string or predicate.
+*
+* Replaces the common `importRule` utility pattern.
+*
+* @since 0.1.0
+*/
+const banImport = (source, opts) => define({
+	name: "ban-import",
+	meta: meta({
+		type: opts.meta?.type ?? "suggestion",
+		description: opts.message,
+		effectVersion: opts.meta?.effectVersion
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { ImportDeclaration: (node) => pipe(narrow(node, "ImportDeclaration"), Option.flatMap(matchImport(source)), Option.match({
+			onNone: () => Effect.void,
+			onSome: (matched) => ctx.report(make({
+				node: matched,
+				message: opts.message
+			}))
+		})) };
+	}
+});
+/**
+* Create a rule that bans bare identifier call expressions.
+*
+* Matches `CallExpression` nodes whose callee is an identifier in
+* the given list (e.g. `fetch()`, `useState()`, `readFileSync()`).
+*
+* @example
+* ```ts
+* // Ban a single call
+* Rule.banCallOf('fetch', { message: 'Use Effect HTTP client' })
+*
+* // Ban multiple calls
+* Rule.banCallOf(['useState', 'useEffect'], { message: 'Use Effect' })
+* ```
+*
+* @since 0.2.0
+*/
+const banCallOf = (name, opts) => {
+	const names = P.isString(name) ? [name] : name;
+	return define({
+		name: `ban-call-${Arr.join(names, "-")}`,
+		meta: meta({
+			type: opts.meta?.type ?? "suggestion",
+			description: opts.message,
+			effectVersion: opts.meta?.effectVersion
+		}),
+		create: function* () {
+			const ctx = yield* RuleContext;
+			return { CallExpression: (node) => pipe(narrow(node, "CallExpression"), Option.flatMap(calleeName), Option.filter((n) => Arr.contains(names, n)), Option.match({
+				onNone: () => Effect.void,
+				onSome: () => ctx.report(make({
+					node,
+					message: opts.message
+				}))
+			})) };
+		}
+	});
+};
+/**
+* Create a rule that bans `new` expressions with the given callee name.
+*
+* Matches `NewExpression` nodes whose callee is an identifier in
+* the given list (e.g. `new Date()`, `new Error()`).
+*
+* @example
+* ```ts
+* // Ban a single constructor
+* Rule.banNewExpr('Date', { message: 'Use Clock service' })
+*
+* // Ban multiple constructors
+* Rule.banNewExpr(['Error', 'TypeError'], { message: 'Use tagged errors' })
+* ```
+*
+* @since 0.2.0
+*/
+const banNewExpr = (name, opts) => {
+	const names = P.isString(name) ? [name] : name;
+	return define({
+		name: `ban-new-${Arr.join(names, "-")}`,
+		meta: meta({
+			type: opts.meta?.type ?? "suggestion",
+			description: opts.message,
+			effectVersion: opts.meta?.effectVersion
+		}),
+		create: function* () {
+			const ctx = yield* RuleContext;
+			return { NewExpression: (node) => pipe(narrow(node, "NewExpression"), Option.flatMap((n) => newExprCalleeName(n.callee)), Option.filter((n) => Arr.contains(names, n)), Option.match({
+				onNone: () => Effect.void,
+				onSome: () => ctx.report(make({
+					node,
+					message: opts.message
+				}))
+			})) };
+		}
+	});
+};
+/**
+* Create a rule that bans a specific statement type.
+*
+* @since 0.1.0
+*/
+const banStatement = (nodeType, opts) => define({
+	name: `ban-${nodeType}`,
+	meta: meta({
+		type: opts.meta?.type ?? "suggestion",
+		description: opts.message,
+		effectVersion: opts.meta?.effectVersion
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { [nodeType]: (node) => ctx.report(make({
+			node,
+			message: opts.message
+		})) };
+	}
+});
+/**
+* Create a rule that bans multiple patterns, each with its own message.
+*
+* @example
+* ```ts
+* Rule.banMultiple({
+*   name: "no-global-date",
+*   meta: { type: "suggestion" },
+*   specs: [
+*     { type: "new", name: "Date", message: "Avoid new Date(). Use Clock service." },
+*     { type: "member", object: "Date", property: "now", message: "Avoid Date.now(). Use Clock service." },
+*   ],
+* })
+* ```
+*
+* @since 0.3.0
+*/
+const banMultiple = (config) => {
+	const description = config.specs.map((s) => s.message).join(" ");
+	return define({
+		name: config.name,
+		meta: meta({
+			type: config.meta?.type ?? "suggestion",
+			description,
+			effectVersion: config.meta?.effectVersion
+		}),
+		create: function* () {
+			const ctx = yield* RuleContext;
+			const visitors = [];
+			for (const spec of config.specs) switch (spec.type) {
+				case "member": {
+					const report = (node) => ctx.report(make({
+						node,
+						message: spec.message
+					}));
+					visitors.push({ MemberExpression: (node) => pipe(narrow(node, "MemberExpression"), Option.flatMap(matchMember(spec.object, spec.property)), Option.match({
+						onNone: () => Effect.void,
+						onSome: (matched) => report(matched)
+					})) });
+					break;
+				}
+				case "call": {
+					const names = P.isString(spec.name) ? [spec.name] : spec.name;
+					const report = (node) => ctx.report(make({
+						node,
+						message: spec.message
+					}));
+					visitors.push({ CallExpression: (node) => pipe(narrow(node, "CallExpression"), Option.flatMap(calleeName), Option.filter((n) => Arr.contains(names, n)), Option.match({
+						onNone: () => Effect.void,
+						onSome: () => report(node)
+					})) });
+					break;
+				}
+				case "new": {
+					const names = P.isString(spec.name) ? [spec.name] : spec.name;
+					const report = (node) => ctx.report(make({
+						node,
+						message: spec.message
+					}));
+					visitors.push({ NewExpression: (node) => pipe(narrow(node, "NewExpression"), Option.flatMap((n) => newExprCalleeName(n.callee)), Option.filter((n) => Arr.contains(names, n)), Option.match({
+						onNone: () => Effect.void,
+						onSome: () => report(node)
+					})) });
+					break;
+				}
+				case "import": {
+					const report = (node) => ctx.report(make({
+						node,
+						message: spec.message
+					}));
+					visitors.push({ ImportDeclaration: (node) => pipe(narrow(node, "ImportDeclaration"), Option.flatMap(matchImport(spec.source)), Option.match({
+						onNone: () => Effect.void,
+						onSome: (matched) => report(matched)
+					})) });
+					break;
+				}
+				case "statement":
+					visitors.push({ [spec.nodeType]: (node) => ctx.report(make({
+						node,
+						message: spec.message
+					})) });
+					break;
+			}
+			return merge(...visitors);
+		}
+	});
+};
+//#endregion
+export { Rule_exports, banCallOf, banImport, banMember, banMultiple, banNewExpr, banStatement, define, meta };

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

@@ -0,0 +1,77 @@
+import * as Effect from "effect/Effect";
+import * as Context$1 from "effect/Context";
+import { Context, Diagnostic, ESTree, LanguageOptions, Options, Settings, SourceCode } from "@oxlint/plugins";
+
+//#region src/vendor/effect-oxlint/RuleContext.d.ts
+declare const RuleContext_base: Context$1.ServiceClass<RuleContext, "effect-oxlint/RuleContext", {
+  /** Report a lint diagnostic for the current file. */readonly report: (diagnostic: Diagnostic) => Effect.Effect<void>; /** Rule ID in `plugin/rule` form. */
+  readonly id: string; /** Absolute path of the file being linted. */
+  readonly filename: string; /** Current working directory. */
+  readonly cwd: string; /** Raw rule options (JSON values). */
+  readonly options: Readonly<Options>; /** Source code access (tokens, comments, text, scope, etc.). */
+  readonly sourceCode: SourceCode; /** Language / parser options for this file. */
+  readonly languageOptions: Readonly<LanguageOptions>; /** Shared settings from the oxlint config. */
+  readonly settings: Readonly<Settings>;
+}>;
+/**
+ * The lint rule context, provided as an Effect service.
+ *
+ * Available inside `Rule.define`'s `create` generator and every
+ * visitor handler via `yield* RuleContext`.
+ *
+ * @since 0.1.0
+ */
+declare class RuleContext extends RuleContext_base {}
+/**
+ * Build a `RuleContext` value from the raw oxlint `Context`.
+ *
+ * @internal
+ */
+declare const fromOxlintContext: (ctx: Context) => RuleContext["Service"];
+/**
+ * Effectful access to the rule ID.
+ *
+ * @since 0.1.0
+ */
+declare const id: Effect.Effect<string, never, RuleContext>;
+/**
+ * Effectful access to the filename of the file being linted.
+ *
+ * @since 0.1.0
+ */
+declare const filename: Effect.Effect<string, never, RuleContext>;
+/**
+ * Effectful access to the working directory.
+ *
+ * @since 0.1.0
+ */
+declare const cwd: Effect.Effect<string, never, RuleContext>;
+/**
+ * Effectful access to the SourceCode object.
+ *
+ * @since 0.1.0
+ */
+declare const sourceCode: Effect.Effect<SourceCode, never, RuleContext>;
+/**
+ * Effectful access to the raw source text.
+ *
+ * @since 0.1.0
+ */
+declare const text: Effect.Effect<string, never, RuleContext>;
+/**
+ * Effectful access to the AST root node.
+ *
+ * @since 0.1.0
+ */
+declare const ast: Effect.Effect<ESTree.Program, never, RuleContext>;
+/**
+ * Report a lint diagnostic.
+ *
+ * Shorthand so handlers can `yield* RuleContext.report(diagnostic)`
+ * without first resolving the full service.
+ *
+ * @since 0.1.0
+ */
+declare const report: (diagnostic: Diagnostic) => Effect.Effect<void, never, RuleContext>;
+//#endregion
+export { RuleContext, ast, cwd, filename, fromOxlintContext, id, report, sourceCode, text };

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

@@ -0,0 +1,74 @@
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+//#region src/vendor/effect-oxlint/RuleContext.ts
+/**
+* The lint rule context, provided as an Effect service.
+*
+* Available inside `Rule.define`'s `create` generator and every
+* visitor handler via `yield* RuleContext`.
+*
+* @since 0.1.0
+*/
+var RuleContext = class extends Context.Service()("effect-oxlint/RuleContext") {};
+/**
+* Build a `RuleContext` value from the raw oxlint `Context`.
+*
+* @internal
+*/
+const fromOxlintContext = (ctx) => RuleContext.of({
+	report: (diagnostic) => Effect.sync(() => ctx.report(diagnostic)),
+	id: ctx.id,
+	filename: ctx.filename,
+	cwd: ctx.cwd,
+	options: ctx.options,
+	sourceCode: ctx.sourceCode,
+	languageOptions: ctx.languageOptions,
+	settings: ctx.settings
+});
+/**
+* Effectful access to the rule ID.
+*
+* @since 0.1.0
+*/
+const id = Effect.service(RuleContext).pipe(Effect.map((ctx) => ctx.id));
+/**
+* Effectful access to the filename of the file being linted.
+*
+* @since 0.1.0
+*/
+const filename = Effect.service(RuleContext).pipe(Effect.map((ctx) => ctx.filename));
+/**
+* Effectful access to the working directory.
+*
+* @since 0.1.0
+*/
+const cwd = Effect.service(RuleContext).pipe(Effect.map((ctx) => ctx.cwd));
+/**
+* Effectful access to the SourceCode object.
+*
+* @since 0.1.0
+*/
+const sourceCode = Effect.service(RuleContext).pipe(Effect.map((ctx) => ctx.sourceCode));
+/**
+* Effectful access to the raw source text.
+*
+* @since 0.1.0
+*/
+const text = Effect.service(RuleContext).pipe(Effect.map((ctx) => ctx.sourceCode.text));
+/**
+* Effectful access to the AST root node.
+*
+* @since 0.1.0
+*/
+const ast = Effect.service(RuleContext).pipe(Effect.map((ctx) => ctx.sourceCode.ast));
+/**
+* Report a lint diagnostic.
+*
+* Shorthand so handlers can `yield* RuleContext.report(diagnostic)`
+* without first resolving the full service.
+*
+* @since 0.1.0
+*/
+const report = (diagnostic) => Effect.service(RuleContext).pipe(Effect.flatMap((ctx) => ctx.report(diagnostic)));
+//#endregion
+export { RuleContext, ast, cwd, filename, fromOxlintContext, id, report, sourceCode, text };

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

@@ -0,0 +1,100 @@
+import * as Option from "effect/Option";
+import { Reference, Scope, Variable } from "@oxlint/plugins";
+
+//#region src/vendor/effect-oxlint/Scope.d.ts
+declare namespace Scope_d_exports {
+  export { childScopes, findVariable, findVariableUp, getReadReferences, getReferences, getWriteReferences, isReadOnly, isStrict, isUsed, isWritten, throughReferences, upper, variables };
+}
+/**
+ * Find a variable by name in a scope.
+ *
+ * Searches the scope's `set` (a `Map<string, Variable>`).
+ *
+ * @since 0.2.0
+ */
+declare const findVariable: {
+  (name: string): (scope: Scope) => Option.Option<Variable>;
+  (scope: Scope, name: string): Option.Option<Variable>;
+};
+/**
+ * Find a variable by name, walking up the scope chain.
+ *
+ * Starts at the given scope and checks each `upper` scope until found
+ * or the global scope is exhausted.
+ *
+ * @since 0.2.0
+ */
+declare const findVariableUp: {
+  (name: string): (scope: Scope) => Option.Option<Variable>;
+  (scope: Scope, name: string): Option.Option<Variable>;
+};
+/**
+ * Check whether a variable has any read references.
+ *
+ * A variable is considered "used" if at least one reference reads it.
+ *
+ * @since 0.2.0
+ */
+declare const isUsed: (variable: Variable) => boolean;
+/**
+ * Check whether a variable has any write references.
+ *
+ * @since 0.2.0
+ */
+declare const isWritten: (variable: Variable) => boolean;
+/**
+ * Check whether a variable is only read (no writes).
+ *
+ * @since 0.2.0
+ */
+declare const isReadOnly: (variable: Variable) => boolean;
+/**
+ * Get all references for a variable.
+ *
+ * @since 0.2.0
+ */
+declare const getReferences: (variable: Variable) => ReadonlyArray<Reference>;
+/**
+ * Get the read references for a variable.
+ *
+ * @since 0.2.0
+ */
+declare const getReadReferences: (variable: Variable) => ReadonlyArray<Reference>;
+/**
+ * Get the write references for a variable.
+ *
+ * @since 0.2.0
+ */
+declare const getWriteReferences: (variable: Variable) => ReadonlyArray<Reference>;
+/**
+ * Get the parent (upper) scope.
+ *
+ * @since 0.2.0
+ */
+declare const upper: (scope: Scope) => Option.Option<Scope>;
+/**
+ * Get the child scopes.
+ *
+ * @since 0.2.0
+ */
+declare const childScopes: (scope: Scope) => ReadonlyArray<Scope>;
+/**
+ * Get all variables in a scope.
+ *
+ * @since 0.2.0
+ */
+declare const variables: (scope: Scope) => ReadonlyArray<Variable>;
+/**
+ * Get "through" references (unresolved in this scope).
+ *
+ * @since 0.2.0
+ */
+declare const throughReferences: (scope: Scope) => ReadonlyArray<Reference>;
+/**
+ * Check whether a scope is strict mode.
+ *
+ * @since 0.2.0
+ */
+declare const isStrict: (scope: Scope) => boolean;
+//#endregion
+export { Scope_d_exports, childScopes, findVariable, findVariableUp, getReadReferences, getReferences, getWriteReferences, isReadOnly, isStrict, isUsed, isWritten, throughReferences, upper, variables };

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

@@ -0,0 +1,110 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import * as Arr from "effect/Array";
+import { dual, pipe } from "effect/Function";
+import * as Option from "effect/Option";
+//#region src/vendor/effect-oxlint/Scope.ts
+var Scope_exports = /* @__PURE__ */ __exportAll({
+	childScopes: () => childScopes,
+	findVariable: () => findVariable,
+	findVariableUp: () => findVariableUp,
+	getReadReferences: () => getReadReferences,
+	getReferences: () => getReferences,
+	getWriteReferences: () => getWriteReferences,
+	isReadOnly: () => isReadOnly,
+	isStrict: () => isStrict,
+	isUsed: () => isUsed,
+	isWritten: () => isWritten,
+	throughReferences: () => throughReferences,
+	upper: () => upper,
+	variables: () => variables
+});
+/**
+* Find a variable by name in a scope.
+*
+* Searches the scope's `set` (a `Map<string, Variable>`).
+*
+* @since 0.2.0
+*/
+const findVariable = dual(2, (scope, name) => Option.fromNullishOr(scope.set.get(name)));
+/**
+* Find a variable by name, walking up the scope chain.
+*
+* Starts at the given scope and checks each `upper` scope until found
+* or the global scope is exhausted.
+*
+* @since 0.2.0
+*/
+const findVariableUp = dual(2, (scope, name) => {
+	const walk = (current) => pipe(Option.fromNullishOr(current.set.get(name)), Option.orElse(() => pipe(Option.fromNullishOr(current.upper), Option.flatMap((parent) => walk(parent)))));
+	return walk(scope);
+});
+/**
+* Check whether a variable has any read references.
+*
+* A variable is considered "used" if at least one reference reads it.
+*
+* @since 0.2.0
+*/
+const isUsed = (variable) => Arr.some(variable.references, (ref) => ref.isRead());
+/**
+* Check whether a variable has any write references.
+*
+* @since 0.2.0
+*/
+const isWritten = (variable) => Arr.some(variable.references, (ref) => ref.isWrite());
+/**
+* Check whether a variable is only read (no writes).
+*
+* @since 0.2.0
+*/
+const isReadOnly = (variable) => Arr.some(variable.references, (ref) => ref.isReadOnly());
+/**
+* Get all references for a variable.
+*
+* @since 0.2.0
+*/
+const getReferences = (variable) => variable.references;
+/**
+* Get the read references for a variable.
+*
+* @since 0.2.0
+*/
+const getReadReferences = (variable) => pipe(variable.references, Arr.filter((ref) => ref.isRead()));
+/**
+* Get the write references for a variable.
+*
+* @since 0.2.0
+*/
+const getWriteReferences = (variable) => pipe(variable.references, Arr.filter((ref) => ref.isWrite()));
+/**
+* Get the parent (upper) scope.
+*
+* @since 0.2.0
+*/
+const upper = (scope) => Option.fromNullishOr(scope.upper);
+/**
+* Get the child scopes.
+*
+* @since 0.2.0
+*/
+const childScopes = (scope) => scope.childScopes;
+/**
+* Get all variables in a scope.
+*
+* @since 0.2.0
+*/
+const variables = (scope) => scope.variables;
+/**
+* Get "through" references (unresolved in this scope).
+*
+* @since 0.2.0
+*/
+const throughReferences = (scope) => scope.through;
+/**
+* Check whether a scope is strict mode.
+*
+* @since 0.2.0
+*/
+const isStrict = (scope) => scope.isStrict;
+//#endregion
+export { Scope_exports, childScopes, findVariable, findVariableUp, getReadReferences, getReferences, getWriteReferences, isReadOnly, isStrict, isUsed, isWritten, throughReferences, upper, variables };