@rslint/core 0.5.2 → 0.5.4-canary.1781059600

package/bin/rslint.cjs

@@ -6,16 +6,33 @@ const os = require('node:os');
 const fs = require('node:fs');
 
 function getBinPath() {
+  // dev / local `build:bin` output sits next to this script
   if (fs.existsSync(path.resolve(__dirname, './rslint'))) {
     return path.resolve(__dirname, './rslint');
   }
   if (fs.existsSync(path.resolve(__dirname, './rslint.exe'))) {
     return path.resolve(__dirname, './rslint.exe');
   }
-  let platformKey = `${process.platform}-${os.arch()}`;
-
-  return require.resolve(
-    `@rslint/${platformKey}/rslint${process.platform === 'win32' ? '.exe' : ''}`,
+  // published: the Go binary lives in the @rslint/native-{tuple} subpackage,
+  // reached via its `./bin` export. npm installs only the subpackage matching
+  // the host os/cpu/libc, so on linux we just try gnu then musl and use
+  // whichever got installed — no libc sniffing (Go binaries are static, the
+  // gnu/musl distinction doesn't matter to them).
+  const arch = os.arch();
+  const tuples =
+    process.platform === 'linux'
+      ? [`linux-${arch}-gnu`, `linux-${arch}-musl`]
+      : process.platform === 'win32'
+        ? [`win32-${arch}-msvc`]
+        : [`${process.platform}-${arch}`];
+  for (const tuple of tuples) {
+    try {
+      return require.resolve(`@rslint/native-${tuple}/bin`);
+    } catch {}
+  }
+  throw new Error(
+    `rslint: no native binary for ${process.platform}-${arch} ` +
+      `(looked for @rslint/native-{${tuples.join(',')}})`,
   );
 }
 

package/dist/0~engine.js

@@ -0,0 +1,406 @@
+import { spawn } from "node:child_process";
+const RESPONSE_KIND = 'response';
+const ERROR_KIND = 'error';
+const HEADER_BYTES = 4;
+const MAX_FRAME_BYTES = 268435456;
+class IpcClient {
+    input;
+    output;
+    pending = new Map();
+    notificationHandlers = new Map();
+    inboundHandler = null;
+    chunks = [];
+    bufferedBytes = 0;
+    nextId = 1;
+    closed = false;
+    started = false;
+    constructor(input, output, opts = {}){
+        this.input = input;
+        this.output = output;
+    }
+    setInboundHandler(handler) {
+        this.inboundHandler = handler;
+    }
+    registerNotification(kind, handler) {
+        this.notificationHandlers.set(kind, handler);
+    }
+    start() {
+        if (this.started) return;
+        this.started = true;
+        this.input.on('data', this.onChunk);
+        this.input.on('end', this.onEnd);
+        this.input.on('error', this.onStreamError);
+        this.output.on('error', this.onOutputError);
+        this.output.on('close', this.onOutputClose);
+        this.output.on('finish', this.onOutputClose);
+    }
+    close() {
+        if (this.closed) return;
+        this.closed = true;
+        this.input.off('data', this.onChunk);
+        this.input.off('end', this.onEnd);
+        this.input.off('error', this.onStreamError);
+        this.output.off('error', this.onOutputError);
+        this.output.off('close', this.onOutputClose);
+        this.output.off('finish', this.onOutputClose);
+        const err = new Error('IpcClient: closed');
+        for (const [, p] of this.pending)p.reject(err);
+        this.pending.clear();
+    }
+    async sendRequest(kind, data) {
+        if (this.closed) throw new Error('IpcClient: cannot sendRequest on closed client');
+        const id = this.nextId++;
+        const frame = encodeFrame({
+            kind,
+            id,
+            data
+        });
+        const promise = new Promise((resolve, reject)=>{
+            this.pending.set(id, {
+                resolve: resolve,
+                reject
+            });
+        });
+        this.writeFrameNow(frame);
+        return promise;
+    }
+    sendNotification(kind, data) {
+        if (this.closed) throw new Error('IpcClient: cannot sendNotification on closed client');
+        const frame = encodeFrame({
+            kind,
+            id: 0,
+            data
+        });
+        this.writeFrameNow(frame);
+    }
+    sendResponse(reqId, data) {
+        if (this.closed) return;
+        this.writeFrameNow(encodeFrame({
+            kind: 'response',
+            id: reqId,
+            data
+        }));
+    }
+    sendErrorResponse(reqId, message) {
+        if (this.closed) return;
+        this.writeFrameNow(encodeFrame({
+            kind: 'error',
+            id: reqId,
+            data: {
+                message
+            }
+        }));
+    }
+    writeFrameNow(frame) {
+        try {
+            this.output.write(frame);
+        } catch (err) {
+            this.onOutputError(err);
+        }
+    }
+    onOutputError = (err)=>{
+        if (this.closed) return;
+        process.stderr.write(`rslint: output write error: ${err.message}\n`);
+        const wrapped = new Error(`IpcClient: output write failed: ${err.message}`);
+        for (const [, p] of this.pending)p.reject(wrapped);
+        this.pending.clear();
+        this.closed = true;
+        this.input.off('data', this.onChunk);
+        this.input.off('end', this.onEnd);
+        this.input.off('error', this.onStreamError);
+        this.output.off('error', this.onOutputError);
+        this.output.off('close', this.onOutputClose);
+        this.output.off('finish', this.onOutputClose);
+    };
+    onOutputClose = ()=>{
+        if (this.closed) return;
+        const err = new Error('IpcClient: output stream closed before response received');
+        for (const [, p] of this.pending)p.reject(err);
+        this.pending.clear();
+        this.closed = true;
+        this.input.off('data', this.onChunk);
+        this.input.off('end', this.onEnd);
+        this.input.off('error', this.onStreamError);
+        this.output.off('error', this.onOutputError);
+        this.output.off('close', this.onOutputClose);
+        this.output.off('finish', this.onOutputClose);
+    };
+    onChunk = (chunk)=>{
+        this.chunks.push(chunk);
+        this.bufferedBytes += chunk.length;
+        while(this.bufferedBytes >= HEADER_BYTES){
+            const len = this.peekHeaderLen();
+            if (len > MAX_FRAME_BYTES) return void this.onStreamError(new Error(`ipc-client: frame length ${len} exceeds cap ${MAX_FRAME_BYTES} (likely stream desync). Connection will be closed.`));
+            if (this.bufferedBytes < HEADER_BYTES + len) break;
+            const frame = this.consumeFront(HEADER_BYTES + len);
+            const body = frame.subarray(HEADER_BYTES);
+            let msg;
+            try {
+                msg = JSON.parse(body.toString('utf8'));
+            } catch (err) {
+                process.stderr.write(`rslint: malformed JSON in frame (len=${len}): ${err.message}\n`);
+                continue;
+            }
+            this.dispatch(msg);
+        }
+    };
+    peekHeaderLen() {
+        const first = this.chunks[0];
+        if (first.length >= HEADER_BYTES) return first.readUInt32LE(0);
+        let len = 0;
+        let seen = 0;
+        for (const c of this.chunks){
+            for(let i = 0; i < c.length && seen < HEADER_BYTES; i++, seen++)len |= c[i] << 8 * seen;
+            if (seen >= HEADER_BYTES) break;
+        }
+        return len >>> 0;
+    }
+    consumeFront(n) {
+        this.bufferedBytes -= n;
+        const first = this.chunks[0];
+        if (first.length === n) {
+            this.chunks.shift();
+            return first;
+        }
+        if (first.length > n) {
+            const frame = first.subarray(0, n);
+            this.chunks[0] = Buffer.from(first.subarray(n));
+            return frame;
+        }
+        const parts = [];
+        let need = n;
+        while(need > 0){
+            const c = this.chunks[0];
+            if (c.length <= need) {
+                parts.push(c);
+                need -= c.length;
+                this.chunks.shift();
+            } else {
+                parts.push(c.subarray(0, need));
+                this.chunks[0] = Buffer.from(c.subarray(need));
+                need = 0;
+            }
+        }
+        return Buffer.concat(parts, n);
+    }
+    onEnd = ()=>{
+        if (this.closed) return;
+        this.closed = true;
+        const err = new Error('IpcClient: peer closed input stream');
+        for (const [, p] of this.pending)p.reject(err);
+        this.pending.clear();
+        this.input.off('data', this.onChunk);
+        this.input.off('end', this.onEnd);
+        this.input.off('error', this.onStreamError);
+        this.output.off('error', this.onOutputError);
+        this.output.off('close', this.onOutputClose);
+        this.output.off('finish', this.onOutputClose);
+    };
+    onStreamError = (err)=>{
+        process.stderr.write(`rslint: stream error: ${err.message}\n`);
+        this.onEnd();
+    };
+    dispatch(msg) {
+        if (msg.kind === RESPONSE_KIND || msg.kind === ERROR_KIND) return void this.routeResponse(msg);
+        if (0 === msg.id) return void this.dispatchNotification(msg);
+        this.dispatchInboundRequest(msg);
+    }
+    routeResponse(msg) {
+        const p = this.pending.get(msg.id);
+        if (!p) return void process.stderr.write(`rslint: orphan response id=${msg.id} kind=${msg.kind}\n`);
+        this.pending.delete(msg.id);
+        if (msg.kind === ERROR_KIND) {
+            const data = msg.data;
+            p.reject(new Error(`peer error: ${data?.message ?? '(no message)'}`));
+            return;
+        }
+        p.resolve(msg);
+    }
+    dispatchNotification(msg) {
+        const handler = this.notificationHandlers.get(msg.kind);
+        if (!handler) return void process.stderr.write(`rslint: unhandled notification kind=${msg.kind}\n`);
+        runSafely(async ()=>handler(msg), `notification:${msg.kind}`);
+    }
+    dispatchInboundRequest(msg) {
+        const handler = this.inboundHandler;
+        if (!handler) return void this.sendErrorResponse(msg.id, `no inbound handler registered (kind=${msg.kind})`);
+        (async ()=>{
+            try {
+                const result = await handler(msg);
+                this.sendResponse(msg.id, result);
+            } catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                this.sendErrorResponse(msg.id, message);
+            }
+        })();
+    }
+}
+function encodeFrame(msg) {
+    const body = Buffer.from(JSON.stringify(msg), 'utf8');
+    const out = Buffer.allocUnsafe(HEADER_BYTES + body.length);
+    out.writeUInt32LE(body.length, 0);
+    body.copy(out, HEADER_BYTES);
+    return out;
+}
+async function runSafely(fn, tag) {
+    try {
+        const ret = fn();
+        if (ret instanceof Promise) await ret;
+    } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`rslint: handler ${tag} threw: ${message}\n`);
+    }
+}
+const SIGNAL_EXIT_CODES = {
+    SIGHUP: 129,
+    SIGINT: 130,
+    SIGQUIT: 131,
+    SIGTERM: 143,
+    SIGKILL: 137
+};
+async function runEngine(opts) {
+    const stdout = opts.stdout ?? process.stdout;
+    const stderr = opts.stderr ?? process.stderr;
+    const child = spawn(opts.binPath, opts.goArgs, {
+        stdio: [
+            'pipe',
+            'pipe',
+            'inherit'
+        ],
+        cwd: opts.cwd ?? process.cwd()
+    });
+    const childExit = new Promise((resolve)=>{
+        let resolved = false;
+        const settle = (code)=>{
+            if (!resolved) {
+                resolved = true;
+                resolve({
+                    code
+                });
+            }
+        };
+        child.once('error', (err)=>{
+            stderr.write(`rslint: Go spawn/runtime error: ${err.message}\n`);
+            settle(2);
+        });
+        child.once('exit', (code, signal)=>{
+            settle(null != code ? code : null != signal ? SIGNAL_EXIT_CODES[signal] ?? 128 : 1);
+        });
+    });
+    const raceWithExit = async (task)=>Promise.race([
+            task.then((value)=>({
+                    kind: 'task',
+                    value
+                })),
+            childExit.then((state)=>({
+                    kind: 'exit',
+                    state
+                }))
+        ]);
+    if (!child.stdin || !child.stdout) {
+        safeKillGo(child);
+        throw new Error('engine: Go child process missing stdin/stdout');
+    }
+    const ipc = new IpcClient(child.stdout, child.stdin);
+    let pluginHost = null;
+    const pluginConfigs = opts.pluginConfigs ?? [];
+    if (pluginConfigs.length > 0) {
+        const pluginEntry = './eslint-plugin/index.js';
+        try {
+            const mod = await import(pluginEntry);
+            pluginHost = await mod.createPluginLintHost(pluginConfigs, (rec)=>stderr.write(`[rslint:plugin] ${rec.text}\n`), opts.runtime?.singleThreaded);
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            stderr.write(`rslint: failed to start ESLint-plugin worker: ${msg}\n`);
+            safeKillGo(child);
+            return 2;
+        }
+    }
+    const onSignal = ()=>{
+        safeKillGo(child);
+        pluginHost?.shutdown();
+    };
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+    process.on('SIGHUP', onSignal);
+    const removeSignalHandlers = ()=>{
+        process.off('SIGINT', onSignal);
+        process.off('SIGTERM', onSignal);
+        process.off('SIGHUP', onSignal);
+    };
+    try {
+        ipc.setInboundHandler(async (msg)=>{
+            switch(msg.kind){
+                case 'shutdown':
+                    return {
+                        ok: true
+                    };
+                case 'pluginLint':
+                    return pluginHost ? pluginHost.lint(msg.data) : {
+                        results: []
+                    };
+                default:
+                    throw new Error(`engine: unexpected inbound kind '${msg.kind}'`);
+            }
+        });
+        ipc.registerNotification('output', (msg)=>{
+            const text = msg.data?.text;
+            if (null != text) stdout.write(text);
+        });
+        ipc.start();
+        {
+            let outcome;
+            try {
+                outcome = await raceWithExit(ipc.sendRequest('init', {
+                    ...opts.extraInit ?? {},
+                    configs: opts.configs,
+                    eslintPlugins: opts.eslintPluginEntries,
+                    runtime: {
+                        forceColor: opts.runtime?.forceColor,
+                        singleThreaded: opts.runtime?.singleThreaded
+                    }
+                }));
+            } catch  {
+                safeKillGo(child);
+                const state = await childExit;
+                if (0 === state.code) return 0;
+                stderr.write(`rslint: init failed (Go exited ${state.code})\n`);
+                return state.code;
+            }
+            if ('exit' === outcome.kind) return outcome.state.code;
+            const data = outcome.value.data;
+            const ok = 'object' == typeof data && null !== data && 'ok' in data && true === data.ok;
+            if (!ok) {
+                stderr.write(`rslint: Go rejected init: ${JSON.stringify(outcome.value.data)}\n`);
+                safeKillGo(child);
+                await childExit;
+                return 2;
+            }
+        }
+        const finalExit = await childExit;
+        ipc.close();
+        return finalExit.code;
+    } finally{
+        removeSignalHandlers();
+        await pluginHost?.shutdown();
+    }
+}
+const KILL_GRACE_MS = 5000;
+function safeKillGo(child) {
+    try {
+        if (child.killed) return;
+        child.kill('SIGTERM');
+    } catch  {
+        return;
+    }
+    const killTimer = setTimeout(()=>{
+        if (null == child.exitCode && null == child.signalCode) try {
+            child.kill('SIGKILL');
+        } catch  {}
+    }, KILL_GRACE_MS);
+    if ('function' == typeof killTimer.unref) killTimer.unref();
+    child.once('exit', ()=>{
+        clearTimeout(killTimer);
+    });
+}
+export { runEngine };

package/dist/34.js

@@ -0,0 +1,33 @@
+const NATIVE_PLUGINS = [
+    "@typescript-eslint",
+    'import',
+    'jest',
+    'jsx-a11y',
+    'promise',
+    'react',
+    'react-hooks',
+    'unicorn'
+];
+const NATIVE_PLUGIN_DECL_ALIASES = [
+    'eslint-plugin-import',
+    'eslint-plugin-jest',
+    'eslint-plugin-jsx-a11y',
+    'eslint-plugin-promise',
+    'eslint-plugin-react-hooks',
+    'eslint-plugin-unicorn'
+];
+const NATIVE_PLUGIN_RESERVED_NAMES = new Set([
+    ...NATIVE_PLUGINS,
+    ...NATIVE_PLUGIN_DECL_ALIASES
+]);
+function defineConfig(config) {
+    return config;
+}
+function globalIgnores(ignorePatterns) {
+    if (!Array.isArray(ignorePatterns)) throw new TypeError('ignorePatterns must be an array');
+    if (0 === ignorePatterns.length) throw new TypeError('ignorePatterns must contain at least one pattern');
+    return {
+        ignores: ignorePatterns
+    };
+}
+export { NATIVE_PLUGIN_RESERVED_NAMES, defineConfig, globalIgnores };

package/dist/browser.d.ts

@@ -1,39 +1,52 @@
-import type { RslintServiceInterface, RSlintOptions } from './types.js';
-/**
- * Browser implementation of RslintService using web workers
- */
-export declare class BrowserRslintService implements RslintServiceInterface {
-    private nextMessageId;
-    private readonly pendingMessages;
-    private worker!;
-    private readonly workerUrl;
-    private chunks;
-    private chunkSize;
-    private expectedSize;
-    constructor(options: RSlintOptions & {
-        workerUrl: string;
-        wasmUrl: string;
-    });
-    private ensureWorker;
-    /**
-     * Handle incoming binary data chunks
-     */
-    private handlePacket;
-    /**
-     * Combine multiple Uint8Array chunks into a single Uint8Array
-     */
-    private combineChunks;
-    /**
-     * Send a message to the worker
-     */
-    sendMessage(kind: string, data: any): Promise<any>;
-    /**
-     * Handle messages from the worker
-     */
-    private handleResponse;
-    /**
-     * Terminate the worker
-     */
-    terminate(): void;
-}
-//# sourceMappingURL=browser.d.ts.map
+/**
+ * Browser implementation of RslintService using web workers
+ */
+export declare class BrowserRslintService implements RslintServiceInterface {
+    private nextMessageId;
+    private readonly pendingMessages;
+    private worker;
+    private readonly workerUrl;
+    private chunks;
+    private chunkSize;
+    private expectedSize;
+    constructor(options: RSlintOptions & {
+        workerUrl: string;
+        wasmUrl: string;
+    });
+    /**
+     * Initialize the web worker
+     */
+    private ensureWorker;
+    /**
+     * Handle incoming binary data chunks
+     */
+    private handlePacket;
+    /**
+     * Combine multiple Uint8Array chunks into a single Uint8Array
+     */
+    private combineChunks;
+    /**
+     * Send a message to the worker
+     */
+    sendMessage(kind: string, data: any): Promise<any>;
+    /**
+     * Handle messages from the worker
+     */
+    private handleResponse;
+    /**
+     * Terminate the worker
+     */
+    terminate(): void;
+}
+
+declare interface RSlintOptions {
+    rslintPath?: string;
+    workingDirectory?: string;
+}
+
+declare interface RslintServiceInterface {
+    sendMessage(kind: string, data: any): Promise<any>;
+    terminate(): void;
+}
+
+export { }