oxlint-plugin-effect 0.2.0 → 0.2.1

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

@@ -0,0 +1,115 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import * as Arr from "effect/Array";
+import { dual } from "effect/Function";
+import * as Option from "effect/Option";
+import * as P from "effect/Predicate";
+import * as Result from "effect/Result";
+//#region src/vendor/effect-oxlint/Diagnostic.ts
+var Diagnostic_exports = /* @__PURE__ */ __exportAll({
+	composeFixes: () => composeFixes,
+	fromId: () => fromId,
+	insertAfter: () => insertAfter,
+	insertBefore: () => insertBefore,
+	make: () => make,
+	removeFix: () => removeFix,
+	replaceText: () => replaceText,
+	withFix: () => withFix,
+	withSuggestions: () => withSuggestions
+});
+/**
+* Create a diagnostic with a message and node location.
+*
+* @since 0.1.0
+*/
+const make = (opts) => ({
+	node: opts.node,
+	message: opts.message,
+	data: opts.data
+});
+/**
+* Create a diagnostic using a `messageId` from `meta.messages`.
+*
+* @since 0.1.0
+*/
+const fromId = (opts) => ({
+	node: opts.node,
+	messageId: opts.messageId,
+	data: opts.data
+});
+/**
+* Attach an autofix function to a diagnostic.
+*
+* @since 0.1.0
+*/
+const withFix = dual(2, (diagnostic, fix) => ({
+	...diagnostic,
+	fix
+}));
+/**
+* Attach suggestion fixes to a diagnostic.
+*
+* @since 0.1.0
+*/
+const withSuggestions = dual(2, (diagnostic, suggestions) => ({
+	...diagnostic,
+	suggest: Array.from(suggestions)
+}));
+/**
+* Composable fix operations.
+*
+* Each function returns a `FixFn` that can be passed to `withFix`
+* or composed via `composeFixes`.
+*
+* @since 0.1.0
+*/
+/**
+* Replace the text of a node or token.
+*
+* @since 0.1.0
+*/
+const replaceText = (nodeOrToken, text) => (fixer) => fixer.replaceText(nodeOrToken, text);
+/**
+* Insert text before a node or token.
+*
+* @since 0.1.0
+*/
+const insertBefore = (nodeOrToken, text) => (fixer) => fixer.insertTextBefore(nodeOrToken, text);
+/**
+* Insert text after a node or token.
+*
+* @since 0.1.0
+*/
+const insertAfter = (nodeOrToken, text) => (fixer) => fixer.insertTextAfter(nodeOrToken, text);
+/**
+* Remove a node or token.
+*
+* @since 0.1.0
+*/
+const removeFix = (nodeOrToken) => (fixer) => fixer.remove(nodeOrToken);
+/** @internal Type guard for an oxlint Fix value (has `range` and `text`). */
+const isFix = (value) => P.isObject(value) && "range" in value && "text" in value;
+/**
+* Extract fixes from a single `FixFn` result.
+*
+* The parameter is typed as `unknown` because oxlint's `FixFn` returns
+* a nullable union (`Fix | Array<Fix | null> | IterableIterator<…> | null`).
+* We guard at the boundary instead of mirroring the nullable upstream type.
+*
+* @internal
+*/
+const extractFixes = (result) => {
+	if (result === null || result === void 0) return [];
+	if (isFix(result)) return [result];
+	if (!P.isIterable(result)) return [];
+	return Arr.filterMap(Array.from(result), (item) => Option.fromNullishOr(item).pipe(Option.filter(isFix), Result.fromOption(() => void 0)));
+};
+/**
+* Compose multiple fix functions into one.
+*
+* All individual fixes are collected into a single array result.
+*
+* @since 0.1.0
+*/
+const composeFixes = (...fixes) => (fixer) => Arr.flatMap(fixes, (fn) => Array.from(extractFixes(fn(fixer))));
+//#endregion
+export { Diagnostic_exports, composeFixes, fromId, insertAfter, insertBefore, make, removeFix, replaceText, withFix, withSuggestions };

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

@@ -0,0 +1,38 @@
+import { CreateRule, Plugin as OxlintPlugin } from "@oxlint/plugins";
+
+//#region src/vendor/effect-oxlint/Plugin.d.ts
+declare namespace Plugin_d_exports {
+  export { OxlintPlugin as Plugin, define, merge };
+}
+/**
+ * Define a typed oxlint plugin from a name and rule map.
+ *
+ * @example
+ * ```ts
+ * import { Plugin, Rule } from 'effect-oxlint'
+ *
+ * export default Plugin.define({
+ *   name: 'my-effect-rules',
+ *   rules: {
+ *     'no-throw-in-gen': myThrowRule,
+ *     'prefer-effect-fn': myFnRule,
+ *   }
+ * })
+ * ```
+ *
+ * @since 0.1.0
+ */
+declare const define: (config: {
+  readonly name: string;
+  readonly rules: Record<string, CreateRule>;
+}) => OxlintPlugin;
+/**
+ * Merge multiple plugins into one.
+ *
+ * If two plugins define a rule with the same name, the later one wins.
+ *
+ * @since 0.1.0
+ */
+declare const merge: (...plugins: ReadonlyArray<OxlintPlugin>) => OxlintPlugin;
+//#endregion
+export { type OxlintPlugin as Plugin, Plugin_d_exports, define, merge };

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

@@ -0,0 +1,45 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import * as Arr from "effect/Array";
+//#region src/vendor/effect-oxlint/Plugin.ts
+var Plugin_exports = /* @__PURE__ */ __exportAll({
+	define: () => define,
+	merge: () => merge
+});
+/**
+* Define a typed oxlint plugin from a name and rule map.
+*
+* @example
+* ```ts
+* import { Plugin, Rule } from 'effect-oxlint'
+*
+* export default Plugin.define({
+*   name: 'my-effect-rules',
+*   rules: {
+*     'no-throw-in-gen': myThrowRule,
+*     'prefer-effect-fn': myFnRule,
+*   }
+* })
+* ```
+*
+* @since 0.1.0
+*/
+const define = (config) => ({
+	meta: { name: config.name },
+	rules: config.rules
+});
+/**
+* Merge multiple plugins into one.
+*
+* If two plugins define a rule with the same name, the later one wins.
+*
+* @since 0.1.0
+*/
+const merge = (...plugins) => ({
+	meta: { name: Arr.join(Arr.map(plugins, (p) => p.meta?.name ?? "unknown"), "+") },
+	rules: Arr.reduce(plugins, {}, (acc, p) => ({
+		...acc,
+		...p.rules
+	}))
+});
+//#endregion
+export { Plugin_exports, define, merge };

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

@@ -0,0 +1,218 @@
+import { RuleContext } from "./RuleContext.js";
+import { EffectVisitor } from "./Visitor.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { CreateRule, RuleDocs, RuleMeta } from "@oxlint/plugins";
+
+//#region src/vendor/effect-oxlint/Rule.d.ts
+declare namespace Rule_d_exports {
+  export { BanSpec, EffectVersion, RuleConfig, banCallOf, banImport, banMember, banMultiple, banNewExpr, banStatement, define, meta };
+}
+/**
+ * Configuration object for `Rule.define`.
+ *
+ * @since 0.1.0
+ */
+interface RuleConfig<Options = undefined> {
+  /** Rule name (used for tracing spans). */
+  readonly name: string;
+  /** Oxlint rule metadata. */
+  readonly meta: RuleMeta;
+  /**
+   * Optional Schema for rule options.
+   *
+   * When provided, the first element of the raw JSON options array
+   * is decoded at `create` time against this schema.
+   */
+  readonly options?: Schema.Decoder<Options> | undefined;
+  /**
+   * The create generator.
+   *
+   * Receives decoded options and returns an `EffectVisitor`.
+   * Runs inside an Effect context where `RuleContext` is available.
+   *
+   * May `yield* Ref.make(...)` for state, `yield* RuleContext` for
+   * context access, and return a visitor built with `Visitor.*` helpers.
+   */
+  readonly create: (options: Options) => Effect.gen.Return<EffectVisitor, never, RuleContext>;
+}
+/**
+ * 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
+ */
+declare const define: <Options = undefined>(config: RuleConfig<Options>) => CreateRule;
+/**
+ * Which Effect version a rule applies to.
+ *
+ * Stored on `meta.docs.effectVersion` so preset authors can filter rules
+ * per project. Default `both`, meaning the rule is version-agnostic.
+ *
+ * @since 0.2.0
+ */
+type EffectVersion = 'v3' | 'v4' | 'both';
+/**
+ * Build `RuleMeta` with sensible defaults.
+ *
+ * @since 0.1.0
+ */
+declare const meta: (opts: {
+  readonly type: "problem" | "suggestion" | "layout";
+  readonly description: string;
+  readonly fixable?: "code" | "whitespace" | undefined;
+  readonly hasSuggestions?: boolean | undefined;
+  readonly messages?: Record<string, string> | undefined;
+  readonly docs?: RuleDocs | undefined;
+  readonly effectVersion?: EffectVersion | undefined;
+}) => RuleMeta;
+/**
+ * Create a rule that bans `obj.prop` member expression access.
+ *
+ * Replaces the common `memberExprRule` utility pattern.
+ *
+ * @since 0.1.0
+ */
+declare const banMember: (obj: string, prop: string | ReadonlyArray<string>, opts: {
+  readonly message: string;
+  readonly meta?: {
+    readonly type?: "problem" | "suggestion";
+    readonly effectVersion?: EffectVersion;
+  } | undefined;
+}) => CreateRule;
+/**
+ * Create a rule that bans imports matching a source string or predicate.
+ *
+ * Replaces the common `importRule` utility pattern.
+ *
+ * @since 0.1.0
+ */
+declare const banImport: (source: string | ((source: string) => boolean), opts: {
+  readonly message: string;
+  readonly meta?: {
+    readonly type?: "problem" | "suggestion";
+    readonly effectVersion?: EffectVersion;
+  } | undefined;
+}) => CreateRule;
+/**
+ * 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
+ */
+declare const banCallOf: (name: string | ReadonlyArray<string>, opts: {
+  readonly message: string;
+  readonly meta?: {
+    readonly type?: "problem" | "suggestion";
+    readonly effectVersion?: EffectVersion;
+  } | undefined;
+}) => CreateRule;
+/**
+ * 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
+ */
+declare const banNewExpr: (name: string | ReadonlyArray<string>, opts: {
+  readonly message: string;
+  readonly meta?: {
+    readonly type?: "problem" | "suggestion";
+    readonly effectVersion?: EffectVersion;
+  } | undefined;
+}) => CreateRule;
+/**
+ * Create a rule that bans a specific statement type.
+ *
+ * @since 0.1.0
+ */
+declare const banStatement: (nodeType: string, opts: {
+  readonly message: string;
+  readonly meta?: {
+    readonly type?: "problem" | "suggestion";
+    readonly effectVersion?: EffectVersion;
+  } | undefined;
+}) => CreateRule;
+/**
+ * A single ban specification. Each spec carries its own message so
+ * diagnostics are specific to the exact pattern matched.
+ *
+ * @since 0.3.0
+ */
+type BanSpec = {
+  readonly type: 'member';
+  readonly object: string;
+  readonly property: string | ReadonlyArray<string>;
+  readonly message: string;
+} | {
+  readonly type: 'call';
+  readonly name: string | ReadonlyArray<string>;
+  readonly message: string;
+} | {
+  readonly type: 'new';
+  readonly name: string | ReadonlyArray<string>;
+  readonly message: string;
+} | {
+  readonly type: 'import';
+  readonly source: string | ((source: string) => boolean);
+  readonly message: string;
+} | {
+  readonly type: 'statement';
+  readonly nodeType: string;
+  readonly message: string;
+};
+/**
+ * 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
+ */
+declare const banMultiple: (config: {
+  readonly name: string;
+  readonly meta?: {
+    readonly type?: "problem" | "suggestion";
+    readonly effectVersion?: EffectVersion;
+  } | undefined;
+  readonly specs: ReadonlyArray<BanSpec>;
+}) => CreateRule;
+//#endregion
+export { BanSpec, EffectVersion, RuleConfig, Rule_d_exports, banCallOf, banImport, banMember, banMultiple, banNewExpr, banStatement, define, meta };