@rslint/core 0.6.2 → 0.6.4

package/dist/index.js

@@ -1,121 +1,10 @@
-import { spawn } from "child_process";
-import { createRequire } from "node:module";
+import node_path from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+import { NodeRslintService } from "./internal.js";
+import { loadConfigFile, normalizeConfig } from "./config-loader.js";
+import { findJSConfigUp, glob } from "./207.js";
 import { RSLintService } from "./service.js";
-const node_require = createRequire(import.meta.url);
-function resolveRslintBinary() {
-    const arch = process.arch;
-    const tuples = 'linux' === process.platform ? [
-        `linux-${arch}-gnu`,
-        `linux-${arch}-musl`
-    ] : 'win32' === process.platform ? [
-        `win32-${arch}-msvc`
-    ] : [
-        `${process.platform}-${arch}`
-    ];
-    for (const tuple of tuples)try {
-        return node_require.resolve(`@rslint/native-${tuple}/bin`);
-    } catch  {}
-    throw new Error(`rslint: no native binary for ${process.platform}-${arch} (looked for @rslint/native-{${tuples.join(',')}})`);
-}
-class NodeRslintService {
-    nextMessageId;
-    pendingMessages;
-    rslintPath;
-    process;
-    chunks;
-    chunkSize;
-    expectedSize;
-    constructor(options = {}){
-        this.nextMessageId = 1;
-        this.pendingMessages = new Map();
-        this.rslintPath = options.rslintPath || resolveRslintBinary();
-        this.process = spawn(this.rslintPath, [
-            '--api'
-        ], {
-            stdio: [
-                'pipe',
-                'pipe',
-                'inherit'
-            ],
-            cwd: options.workingDirectory || process.cwd(),
-            env: {
-                ...process.env
-            }
-        });
-        this.process.stdout.on('data', (data)=>{
-            this.handleChunk(data);
-        });
-        this.chunks = [];
-        this.chunkSize = 0;
-        this.expectedSize = null;
-    }
-    async sendMessage(kind, data) {
-        return new Promise((resolve, reject)=>{
-            const id = this.nextMessageId++;
-            const message = {
-                id,
-                kind,
-                data
-            };
-            this.pendingMessages.set(id, {
-                resolve,
-                reject
-            });
-            const json = JSON.stringify(message);
-            const jsonBuffer = Buffer.from(json, 'utf8');
-            const length = Buffer.alloc(4);
-            length.writeUInt32LE(jsonBuffer.length, 0);
-            this.process.stdin.write(Buffer.concat([
-                length,
-                jsonBuffer
-            ]));
-        });
-    }
-    handleChunk(chunk) {
-        this.chunks.push(chunk);
-        this.chunkSize += chunk.length;
-        while(true){
-            if (null === this.expectedSize) {
-                if (this.chunkSize < 4) return;
-                const combined = Buffer.concat(this.chunks);
-                this.expectedSize = combined.readUInt32LE(0);
-                this.chunks = [
-                    combined.subarray(4)
-                ];
-                this.chunkSize -= 4;
-            }
-            if (this.chunkSize < this.expectedSize) return;
-            const combined = Buffer.concat(this.chunks);
-            const message = combined.subarray(0, this.expectedSize).toString('utf8');
-            try {
-                const parsed = JSON.parse(message);
-                this.handleMessage(parsed);
-            } catch (err) {
-                console.error('Error parsing message:', err);
-            }
-            this.chunks = [
-                combined.subarray(this.expectedSize)
-            ];
-            this.chunkSize = this.chunks[0].length;
-            this.expectedSize = null;
-        }
-    }
-    handleMessage(message) {
-        const { id, kind, data } = message;
-        const pending = this.pendingMessages.get(id);
-        if (!pending) return;
-        this.pendingMessages.delete(id);
-        if ('error' === kind) pending.reject(new Error(data.message));
-        else pending.resolve(data);
-    }
-    terminate() {
-        if (this.process && !this.process.killed) {
-            this.process.stdin.end();
-            this.process.kill();
-        }
-    }
-}
-const base = {
+const typescript_base = {
     files: [
         '**/*.ts',
         '**/*.tsx',
@@ -127,7 +16,7 @@ const base = {
     ]
 };
 const recommended = {
-    ...base,
+    ...typescript_base,
     languageOptions: {
         parserOptions: {
             projectService: true
@@ -347,7 +236,8 @@ const promise_recommended = {
         'promise/no-return-wrap': 'error',
         'promise/param-names': 'error',
         'promise/catch-or-return': 'error',
-        'promise/avoid-new': 'off'
+        'promise/avoid-new': 'off',
+        'promise/valid-params': 'warn'
     }
 };
 const jest_recommended = {
@@ -361,6 +251,7 @@ const jest_recommended = {
         'jest/no-deprecated-functions': 'error',
         'jest/no-disabled-tests': 'warn',
         'jest/no-done-callback': 'error',
+        'jest/no-export': 'error',
         'jest/no-focused-tests': 'error',
         'jest/no-identical-title': 'error',
         'jest/no-jasmine-globals': 'error',
@@ -560,7 +451,7 @@ const jsx_a11y_recommended = {
 };
 const ts = {
     configs: {
-        base: base,
+        base: typescript_base,
         recommended: recommended
     }
 };
@@ -605,26 +496,257 @@ const jsxA11yPlugin = {
         recommended: jsx_a11y_recommended
     }
 };
-async function lint(options) {
-    const service = new RSLintService(new NodeRslintService({
-        workingDirectory: options.workingDirectory
-    }));
-    const result = await service.lint(options);
-    await service.close();
-    return result;
+function _to_primitive(input, hint) {
+    if ("object" !== _type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== _type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function _to_property_key(arg) {
+    var key = _to_primitive(arg, "string");
+    return "symbol" === _type_of(key) ? key : String(key);
+}
+function _type_of(obj) {
+    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+let _computedKey;
+_computedKey = _to_property_key(Symbol.asyncDispose);
+class Rslint {
+    #service;
+    #cwd;
+    #overrideConfig;
+    #overrideConfigFile;
+    #fix;
+    #virtualFiles;
+    constructor(options = {}){
+        this.#cwd = options.cwd ? node_path.resolve(options.cwd) : process.cwd();
+        this.#overrideConfig = options.overrideConfig;
+        this.#overrideConfigFile = options.overrideConfigFile;
+        this.#fix = options.fix ?? false;
+        this.#virtualFiles = options.virtualFiles;
+        this.#service = new RSLintService(new NodeRslintService());
+    }
+    async lintText(code, options = {}) {
+        const filePath = node_path.resolve(this.#cwd, options.filePath ?? '__text__.ts');
+        const { config, configDirectory } = await this.#resolveConfig(node_path.dirname(filePath));
+        const response = await this.#service.lint({
+            config,
+            configDirectory,
+            workingDirectory: this.#cwd,
+            files: [
+                filePath
+            ],
+            fileContents: {
+                ...this.#resolveOverlay(),
+                [filePath]: code
+            },
+            fix: this.#fix
+        });
+        const results = this.#toLintResults(response, configDirectory, [
+            filePath
+        ], {
+            [filePath]: code
+        });
+        const primary = results.filter((r)=>r.filePath === filePath);
+        if (null == options.filePath) {
+            for (const r of primary)if (r.filePath === filePath) r.filePath = '<text>';
+        }
+        return primary;
+    }
+    async lintFiles(patterns) {
+        const globs = Array.isArray(patterns) ? patterns : [
+            patterns
+        ];
+        const matched = await glob(globs, {
+            cwd: this.#cwd,
+            absolute: true,
+            onlyFiles: true
+        });
+        const files = matched.map((f)=>node_path.normalize(f));
+        if (0 === files.length) return [];
+        const { config, configDirectory } = await this.#resolveConfig(this.#cwd);
+        const response = await this.#service.lint({
+            config,
+            configDirectory,
+            workingDirectory: this.#cwd,
+            files,
+            fileContents: this.#resolveOverlay(),
+            fix: this.#fix
+        });
+        const contents = {};
+        const bomFiles = new Set();
+        for (const d of response.diagnostics ?? []){
+            const abs = node_path.isAbsolute(d.filePath) ? node_path.normalize(d.filePath) : node_path.resolve(configDirectory, d.filePath);
+            if (!(abs in contents)) try {
+                const raw = await readFile(abs, 'utf8');
+                if (0xfeff === raw.charCodeAt(0)) {
+                    bomFiles.add(abs);
+                    contents[abs] = raw.slice(1);
+                } else contents[abs] = raw;
+            } catch  {}
+        }
+        const linted = response.lintedFiles ? response.lintedFiles.map((f)=>node_path.isAbsolute(f) ? node_path.normalize(f) : node_path.resolve(configDirectory, f)) : files;
+        return this.#toLintResults(response, configDirectory, linted, contents, bomFiles);
+    }
+    static async outputFixes(results) {
+        await Promise.all(results.map(async (r)=>{
+            if ('string' == typeof r.output && node_path.isAbsolute(r.filePath)) await writeFile(r.filePath, r.output);
+        }));
+    }
+    async close() {
+        await this.#service.close();
+    }
+    async [_computedKey]() {
+        await this.close();
+    }
+    #resolveOverlay() {
+        if (!this.#virtualFiles) return;
+        const resolved = {};
+        for (const [p, content] of Object.entries(this.#virtualFiles))resolved[node_path.resolve(this.#cwd, p)] = content;
+        return resolved;
+    }
+    async #resolveConfig(fromDir) {
+        let base = [];
+        let configDirectory = this.#cwd;
+        if (true === this.#overrideConfigFile) ;
+        else if ('string' == typeof this.#overrideConfigFile) {
+            const configPath = node_path.resolve(this.#cwd, this.#overrideConfigFile);
+            base = normalizeConfig(await loadConfigFile(configPath));
+            configDirectory = node_path.dirname(configPath);
+        } else {
+            const configPath = findJSConfigUp(fromDir);
+            if (configPath) {
+                base = normalizeConfig(await loadConfigFile(configPath));
+                configDirectory = node_path.dirname(configPath);
+            }
+        }
+        if (null != this.#overrideConfig) {
+            const override = Array.isArray(this.#overrideConfig) ? this.#overrideConfig : [
+                this.#overrideConfig
+            ];
+            base = [
+                ...base,
+                ...normalizeConfig(override)
+            ];
+        }
+        return {
+            config: base,
+            configDirectory
+        };
+    }
+    #toLintResults(response, configDirectory, files, contents, bomFiles) {
+        const toAbs = (p)=>node_path.isAbsolute(p) ? node_path.normalize(p) : node_path.resolve(configDirectory, p);
+        const byFile = new Map();
+        for (const f of files)byFile.set(node_path.normalize(f), []);
+        for (const d of response.diagnostics ?? []){
+            const abs = toAbs(d.filePath);
+            let messages = byFile.get(abs);
+            if (!messages) {
+                messages = [];
+                byFile.set(abs, messages);
+            }
+            messages.push(toLintMessage(d, contents?.[abs]));
+        }
+        const outputByAbs = new Map();
+        for (const [rel, fixed] of Object.entries(response.output ?? {}))outputByAbs.set(toAbs(rel), fixed);
+        const results = [];
+        for (const [filePath, messages] of byFile){
+            let errorCount = 0;
+            let warningCount = 0;
+            let fixableErrorCount = 0;
+            let fixableWarningCount = 0;
+            for (const m of messages)if (2 === m.severity) {
+                errorCount++;
+                if (m.fix) fixableErrorCount++;
+            } else {
+                warningCount++;
+                if (m.fix) fixableWarningCount++;
+            }
+            const result = {
+                filePath,
+                messages,
+                errorCount,
+                warningCount,
+                fixableErrorCount,
+                fixableWarningCount
+            };
+            const output = outputByAbs.get(filePath);
+            if (void 0 !== output) result.output = bomFiles?.has(filePath) ? '\uFEFF' + output : output;
+            results.push(result);
+        }
+        return results;
+    }
 }
-async function applyFixes(options) {
-    const service = new RSLintService(new NodeRslintService());
-    const result = await service.applyFixes(options);
-    await service.close();
-    return result;
+function toLintMessage(d, sourceText) {
+    const message = {
+        ruleId: d.ruleName || null,
+        severity: 'error' === d.severity ? 2 : 1,
+        message: d.message,
+        line: d.range.start.line,
+        column: d.range.start.column,
+        endLine: d.range.end.line,
+        endColumn: d.range.end.column
+    };
+    if (d.messageId) message.messageId = d.messageId;
+    const fix = mergeFixes(d.fixes, sourceText);
+    if (fix) message.fix = fix;
+    if (d.suggestions && d.suggestions.length > 0) message.suggestions = d.suggestions.map((s)=>{
+        const sFix = mergeFixes(s.fixes, sourceText);
+        return {
+            messageId: s.messageId,
+            ...s.data ? {
+                data: s.data
+            } : {},
+            desc: s.message,
+            fix: sFix ?? {
+                range: [
+                    0,
+                    0
+                ],
+                text: ''
+            }
+        };
+    });
+    return message;
 }
-async function getAstInfo(options) {
-    const service = new RSLintService(new NodeRslintService());
-    const result = await service.getAstInfo(options);
-    await service.close();
-    return result;
+function mergeFixes(fixes, sourceText) {
+    if (!fixes || 0 === fixes.length) return;
+    if (1 === fixes.length) return {
+        range: [
+            fixes[0].startPos,
+            fixes[0].endPos
+        ],
+        text: fixes[0].text
+    };
+    const sorted = [
+        ...fixes
+    ].sort((a, b)=>a.startPos - b.startPos || a.endPos - b.endPos);
+    const start = sorted[0].startPos;
+    const end = sorted[sorted.length - 1].endPos;
+    if (void 0 === sourceText) return {
+        range: [
+            sorted[0].startPos,
+            sorted[0].endPos
+        ],
+        text: sorted[0].text
+    };
+    let text = '';
+    let lastPos = start;
+    for (const f of sorted)if (!(f.startPos < lastPos)) {
+        text += sourceText.slice(lastPos, f.startPos) + f.text;
+        lastPos = f.endPos;
+    }
+    return {
+        range: [
+            start,
+            end
+        ],
+        text
+    };
 }
-export { RSLintService } from "./service.js";
-export { defineConfig, globalIgnores } from "./34.js";
-export { NodeRslintService, applyFixes, getAstInfo, importPlugin, jestPlugin, js, jsxA11yPlugin, lint, promisePlugin, reactHooksPlugin, reactPlugin, ts, unicornPlugin };
+export { defineConfig, globalIgnores } from "./config-loader.js";
+export { Rslint, importPlugin, jestPlugin, js, jsxA11yPlugin, promisePlugin, reactHooksPlugin, reactPlugin, ts, unicornPlugin };

package/dist/internal.d.ts

@@ -0,0 +1,135 @@
+export declare interface Diagnostic {
+    ruleName: string;
+    message: string;
+    messageId: string;
+    filePath: string;
+    range: Range;
+    severity?: string;
+    fixes?: Fix[];
+    suggestions?: Suggestion[];
+}
+
+declare interface Fix {
+    text: string;
+    startPos: number;
+    endPos: number;
+}
+
+/**
+ * One-shot convenience: spin up a Node-backed service, run a single lint
+ * request, then tear it down. This is an internal/tooling surface (the
+ * rule-tester and the ESLint-plugin conformance harnesses) reached via the
+ * `@rslint/core/internal` subpath — the package root deliberately exposes only
+ * the high-level `Rslint` class as its linting surface, not this low-level engine.
+ */
+export declare function lint(options: LintOptions): Promise<LintResponse>;
+
+export declare interface LintOptions {
+    files?: string[];
+    config?: Record<string, unknown>[];
+    configDirectory?: string;
+    workingDirectory?: string;
+    fileContents?: Record<string, string>;
+    includeEncodedSourceFiles?: boolean;
+    fix?: boolean;
+}
+
+export declare interface LintResponse {
+    diagnostics: Diagnostic[];
+    errorCount: number;
+    warningCount: number;
+    fixableErrorCount: number;
+    fixableWarningCount: number;
+    fileCount: number;
+    ruleCount: number;
+    lintedFiles?: string[];
+    output?: Record<string, string>;
+    encodedSourceFiles?: Record<string, string>;
+}
+
+/**
+ * Node.js implementation of RslintService using child processes
+ */
+export declare class NodeRslintService implements RslintServiceInterface {
+    private nextMessageId;
+    private readonly pendingMessages;
+    private readonly rslintPath;
+    private readonly process;
+    private chunks;
+    private chunkSize;
+    private expectedSize;
+    private dead;
+    private closing;
+    constructor(options?: RSlintOptions);
+    /**
+     * Keep the Node event loop alive only while a request is in flight. The
+     * resident child and its stdio pipes are unref'd while idle so a caller that
+     * never calls close() still lets the process exit; they are ref'd around an
+     * in-flight request because a pending promise alone does NOT keep the loop
+     * alive — without the ref the loop could drain before the response arrives,
+     * leaving the await unsettled (Node would exit with code 13). The piped stdio
+     * streams are net.Socket at runtime (with ref/unref); child_process widens
+     * them to Readable/Writable, so narrow via `instanceof Socket` to reach those.
+     */
+    private setLoopActive;
+    /**
+     * Send a message to the rslint process
+     */
+    sendMessage(kind: string, data: any): Promise<any>;
+    /**
+     * Handle incoming binary data chunks
+     */
+    private handleChunk;
+    /**
+     * Handle a complete message from rslint
+     */
+    private handleMessage;
+    /**
+     * Reject every in-flight request and clear the queue. Called when the process
+     * dies (exit/error) or is terminated, so callers never hang on a process that
+     * can no longer reply. No-op when nothing is pending (the normal close path).
+     */
+    private rejectAllPending;
+    /**
+     * Resolve every in-flight request (no payload) and clear the queue. Used on
+     * the expected close() shutdown path so the 'exit' request settles cleanly
+     * instead of rejecting. No-op when nothing is pending.
+     */
+    private resolveAllPending;
+    /**
+     * Terminate the rslint process
+     */
+    terminate(): void;
+}
+
+/**
+ * Shared types for rslint IPC protocol across all environments
+ */
+declare interface Position {
+    line: number;
+    column: number;
+}
+
+declare interface Range {
+    start: Position;
+    end: Position;
+}
+
+declare interface RSlintOptions {
+    rslintPath?: string;
+    workingDirectory?: string;
+}
+
+declare interface RslintServiceInterface {
+    sendMessage(kind: string, data: any): Promise<any>;
+    terminate(): void;
+}
+
+declare interface Suggestion {
+    messageId: string;
+    message: string;
+    data?: Record<string, string>;
+    fixes?: Fix[];
+}
+
+export { }