refactor: make rslint compatible with browser (#303)

Author: hardfist

packages/rslint-wasm/rslint.wasm

@@ -1,2 +1,3 @@
 # don't publish local rslint bin
-./bin/rslint
+./bin/rslint
+dist/tsconfig.build.tsbuildinfo

packages/rslint/.npmignore

@@ -21,7 +21,8 @@
     "test:update": "rstest run -u"
   },
   "files": [
-    "bin/rslint.cjs"
+    "bin/rslint.cjs",
+    "dist/"
   ],
   "bin": {
     "rslint": "./bin/rslint.cjs"
@@ -30,13 +31,15 @@
     "access": "public"
   },
   "license": "MIT",
-  "description": "rslint cli",
+  "description": "rslint core library",
   "publisher": "rslint",
   "keywords": [
     "rslint",
     "linter",
     "typescript",
-    "go"
+    "go",
+    "browser",
+    "webworker"
   ],
   "devDependencies": {
     "@types/node": "24.0.14",

packages/rslint/package.json

@@ -0,0 +1,105 @@
+import type {
+  RslintServiceInterface,
+  LintOptions,
+  LintResponse,
+  ApplyFixesRequest,
+  ApplyFixesResponse,
+  RSlintOptions,
+  PendingMessage,
+  IpcMessage,
+} from './types.js';
+
+/**
+ * Browser implementation of RslintService using web workers
+ */
+export class BrowserRslintService implements RslintServiceInterface {
+  private nextMessageId: number;
+  private pendingMessages: Map<number, PendingMessage>;
+  private worker: Worker | null;
+  private workerUrl: string;
+
+  constructor(options: RSlintOptions = {}) {
+    this.nextMessageId = 1;
+    this.pendingMessages = new Map();
+    this.worker = null;
+
+    // In browser, we need to use a web worker that can run the rslint binary
+    // This would typically be a WASM version or a worker that can spawn processes
+    this.workerUrl =
+      options.rslintPath || new URL('./worker.js', import.meta.url).href;
+  }
+
+  /**
+   * Initialize the web worker
+   */
+  private async ensureWorker(): Promise<Worker> {
+    if (!this.worker) {
+      this.worker = new Worker(this.workerUrl);
+
+      this.worker.onmessage = event => {
+        this.handleWorkerMessage(event.data);
+      };
+
+      this.worker.onerror = error => {
+        console.error('Worker error:', error);
+        // Reject all pending messages
+        for (const [id, pending] of this.pendingMessages) {
+          pending.reject(new Error(`Worker error: ${error.message}`));
+        }
+        this.pendingMessages.clear();
+      };
+    }
+    return this.worker;
+  }
+
+  /**
+   * Send a message to the worker
+   */
+  async sendMessage(kind: string, data: any): Promise<any> {
+    const worker = await this.ensureWorker();
+
+    return new Promise((resolve, reject) => {
+      const id = this.nextMessageId++;
+      const message: IpcMessage = { id, kind, data };
+
+      // Register promise callbacks
+      this.pendingMessages.set(id, { resolve, reject });
+
+      // Send message to worker
+      worker.postMessage(message);
+    });
+  }
+
+  /**
+   * Handle messages from the worker
+   */
+  private handleWorkerMessage(message: IpcMessage): void {
+    const { id, kind, data } = message;
+    const pending = this.pendingMessages.get(id);
+    if (!pending) return;
+
+    this.pendingMessages.delete(id);
+
+    if (kind === 'error') {
+      pending.reject(new Error(data.message));
+    } else {
+      pending.resolve(data);
+    }
+  }
+
+  /**
+   * Terminate the worker
+   */
+  terminate(): void {
+    if (this.worker) {
+      // Reject all pending messages
+      for (const [id, pending] of this.pendingMessages) {
+        pending.reject(new Error('Service terminated'));
+      }
+      this.pendingMessages.clear();
+
+      this.worker.terminate();
+      this.worker = null;
+    }
+  }
+}

packages/rslint/src/browser.ts

@@ -2,12 +2,17 @@ import {
   LintOptions,
   LintResponse,
   RSLintService,
+  createRslintService,
   ApplyFixesRequest,
   ApplyFixesResponse,
-} from './service.ts';
+} from './service.js';
 
-// Export the RSLintService class for direct usage
-export { RSLintService } from './service.ts';
+// Export the main RSLintService class for direct usage
+export { RSLintService, createRslintService } from './service.js';
+
+// Export specific implementations for advanced usage
+export { NodeRslintService } from './node.js';
+export { BrowserRslintService } from './browser.js';
 
 // For backward compatibility and convenience
 export async function lint(options: LintOptions): Promise<LintResponse> {
@@ -29,6 +34,7 @@ export async function applyFixes(
   return result;
 }
 
+// Export all types
 export {
   type Diagnostic,
   type LintOptions,
@@ -37,4 +43,6 @@ export {
   type ApplyFixesResponse,
   type LanguageOptions,
   type ParserOptions,
-} from './service.ts';
+  type RSlintOptions,
+  type RslintServiceInterface,
+} from './types.js';

packages/rslint/src/index.ts

@@ -0,0 +1,142 @@
+import { spawn, ChildProcess } from 'child_process';
+import path from 'path';
+import type {
+  RslintServiceInterface,
+  LintOptions,
+  LintResponse,
+  ApplyFixesRequest,
+  ApplyFixesResponse,
+  RSlintOptions,
+  PendingMessage,
+  IpcMessage,
+} from './types.js';
+
+/**
+ * Node.js implementation of RslintService using child processes
+ */
+export class NodeRslintService implements RslintServiceInterface {
+  private nextMessageId: number;
+  private pendingMessages: Map<number, PendingMessage>;
+  private rslintPath: string;
+  private process: ChildProcess;
+  private chunks: Buffer[];
+  private chunkSize: number;
+  private expectedSize: number | null;
+
+  constructor(options: RSlintOptions = {}) {
+    this.nextMessageId = 1;
+    this.pendingMessages = new Map();
+    this.rslintPath =
+      options.rslintPath || path.join(import.meta.dirname, '../bin/rslint');
+
+    this.process = spawn(this.rslintPath, ['--api'], {
+      stdio: ['pipe', 'pipe', 'inherit'],
+      cwd: options.workingDirectory || process.cwd(),
+      env: {
+        ...process.env,
+      },
+    });
+
+    // Set up binary message reading
+    this.process.stdout!.on('data', data => {
+      this.handleChunk(data);
+    });
+    this.chunks = [];
+    this.chunkSize = 0;
+    this.expectedSize = null;
+  }
+
+  /**
+   * Send a message to the rslint process
+   */
+  async sendMessage(kind: string, data: any): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const id = this.nextMessageId++;
+      const message: IpcMessage = { id, kind, data };
+
+      // Register promise callbacks
+      this.pendingMessages.set(id, { resolve, reject });
+
+      // Write message length as 4 bytes in little endian
+      const json = JSON.stringify(message);
+      const length = Buffer.alloc(4);
+      length.writeUInt32LE(json.length, 0);
+
+      // Send message
+      this.process.stdin!.write(
+        Buffer.concat([length, Buffer.from(json, 'utf8')]),
+      );
+    });
+  }
+
+  /**
+   * Handle incoming binary data chunks
+   */
+  private handleChunk(chunk: Buffer): void {
+    this.chunks.push(chunk);
+    this.chunkSize += chunk.length;
+
+    // Process complete messages
+    while (true) {
+      // Read message length if we don't have it yet
+      if (this.expectedSize === null) {
+        if (this.chunkSize < 4) return;
+
+        // Combine chunks to read the message length
+        const combined = Buffer.concat(this.chunks);
+        this.expectedSize = combined.readUInt32LE(0);
+
+        // Remove length bytes from buffer
+        this.chunks = [combined.slice(4)];
+        this.chunkSize -= 4;
+      }
+
+      // Check if we have the full message
+      if (this.chunkSize < this.expectedSize) return;
+
+      // Read the message content
+      const combined = Buffer.concat(this.chunks);
+      const message = combined.slice(0, this.expectedSize).toString('utf8');
+
+      // Handle the message
+      try {
+        const parsed: IpcMessage = JSON.parse(message);
+        this.handleMessage(parsed);
+      } catch (err) {
+        console.error('Error parsing message:', err);
+      }
+
+      // Reset for next message
+      this.chunks = [combined.slice(this.expectedSize)];
+      this.chunkSize = this.chunks[0].length;
+      this.expectedSize = null;
+    }
+  }
+
+  /**
+   * Handle a complete message from rslint
+   */
+  private handleMessage(message: IpcMessage): void {
+    const { id, kind, data } = message;
+    const pending = this.pendingMessages.get(id);
+    if (!pending) return;
+
+    this.pendingMessages.delete(id);
+
+    if (kind === 'error') {
+      pending.reject(new Error(data.message));
+    } else {
+      pending.resolve(data);
+    }
+  }
+
+  /**
+   * Terminate the rslint process
+   */
+  terminate(): void {
+    if (this.process && !this.process.killed) {
+      this.process.stdin!.end();
+      this.process.kill();
+    }
+  }
+}