@rslint/core 0.6.4 → 0.7.0

package/bin/rslint.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import nodeModule from 'node:module';
+
+// Enable on-disk code caching for modules loaded by Node.js.
+// Available in Node.js >= 22.8.0.
+const { enableCompileCache } = nodeModule;
+if (enableCompileCache) {
+  try {
+    enableCompileCache();
+  } catch {
+    // Ignore cache setup errors; the CLI should still run normally.
+  }
+}
+
+async function main() {
+  const { runCLI } = await import('../dist/cli.js');
+  await runCLI();
+}
+
+main().catch((err) => {
+  process.stderr.write(`rslint: ${err}\n`);
+  process.exitCode = 1;
+});

package/dist/0~engine.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { ConfigModuleHost } from "./519.js";
 const RESPONSE_KIND = 'response';
 const ERROR_KIND = 'error';
 const HEADER_BYTES = 4;
@@ -251,6 +252,21 @@ async function runSafely(fn, tag) {
         process.stderr.write(`rslint: handler ${tag} threw: ${message}\n`);
     }
 }
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+function isPluginHostFactoryModule(value) {
+    return isRecord(value) && 'function' == typeof value.createPluginLintHost;
+}
+function isConfigModuleCandidate(value) {
+    return isRecord(value) && 'string' == typeof value.id && 'string' == typeof value.configPath && 'string' == typeof value.configDirectory;
+}
+function isLoadConfigsRequest(value) {
+    return isRecord(value) && 1 === value.protocolVersion && 'string' == typeof value.transactionId && ('cached' === value.loadMode || 'fresh' === value.loadMode) && (void 0 === value.singleThreaded || 'boolean' == typeof value.singleThreaded) && Array.isArray(value.candidates) && value.candidates.every(isConfigModuleCandidate);
+}
+function isActivateConfigsRequest(value) {
+    return isRecord(value) && 1 === value.protocolVersion && 'string' == typeof value.transactionId && Array.isArray(value.effectiveConfigIds) && value.effectiveConfigIds.every((id)=>'string' == typeof id);
+}
 const SIGNAL_EXIT_CODES = {
     SIGHUP: 129,
     SIGINT: 130,
@@ -304,22 +320,60 @@ async function runEngine(opts) {
     }
     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 configModuleHost = opts.configModuleHost ?? new ConfigModuleHost();
+    const configTransactions = new Set();
+    let shuttingDown = false;
+    const pendingPluginHostBuilds = new Set();
+    const stagedPluginHosts = new Set();
+    const pluginHostShutdowns = new WeakMap();
+    const shutdownPluginHost = async (host)=>{
+        if (!host) return;
+        stagedPluginHosts.delete(host);
+        let shutdown = pluginHostShutdowns.get(host);
+        if (!shutdown) {
+            shutdown = host.shutdown();
+            pluginHostShutdowns.set(host, shutdown);
         }
-    }
+        await shutdown;
+    };
+    const publishPluginHost = async (host)=>{
+        if (!host) return;
+        if (shuttingDown) return void await shutdownPluginHost(host).catch(()=>void 0);
+        stagedPluginHosts.delete(host);
+        pluginHost = host;
+    };
+    const buildPluginHost = async (pluginConfigs)=>{
+        const build = (async ()=>{
+            if (0 === pluginConfigs.length || shuttingDown) return null;
+            let createPluginLintHost = opts.createPluginLintHost;
+            if (!createPluginLintHost) {
+                const pluginEntry = './eslint-plugin/index.js';
+                const mod = await import(pluginEntry);
+                if (!isPluginHostFactoryModule(mod)) throw new Error('rslint ESLint-plugin entry does not export createPluginLintHost');
+                createPluginLintHost = mod.createPluginLintHost;
+            }
+            const host = await createPluginLintHost(pluginConfigs, (rec)=>stderr.write(`[rslint:plugin] ${rec.text}\n`), opts.runtime?.singleThreaded);
+            if (shuttingDown) {
+                await shutdownPluginHost(host).catch(()=>void 0);
+                return null;
+            }
+            stagedPluginHosts.add(host);
+            return host;
+        })();
+        pendingPluginHostBuilds.add(build);
+        build.then(()=>pendingPluginHostBuilds.delete(build), ()=>pendingPluginHostBuilds.delete(build));
+        const host = await build;
+        return host;
+    };
     const onSignal = ()=>{
+        shuttingDown = true;
         safeKillGo(child);
-        pluginHost?.shutdown();
+        Promise.allSettled([
+            shutdownPluginHost(pluginHost),
+            ...[
+                ...stagedPluginHosts
+            ].map(shutdownPluginHost)
+        ]);
     };
     process.on('SIGINT', onSignal);
     process.on('SIGTERM', onSignal);
@@ -332,14 +386,42 @@ async function runEngine(opts) {
     try {
         ipc.setInboundHandler(async (msg)=>{
             switch(msg.kind){
+                case 'loadConfigs':
+                    {
+                        if (!isLoadConfigsRequest(msg.data)) throw new Error('engine: invalid loadConfigs request');
+                        const request = msg.data;
+                        const response = await configModuleHost.loadConfigs(request);
+                        configTransactions.add(request.transactionId);
+                        return response;
+                    }
+                case 'activateConfigs':
+                    {
+                        if (!isActivateConfigsRequest(msg.data)) throw new Error('engine: invalid activateConfigs request');
+                        const request = msg.data;
+                        let stagedPluginHost = null;
+                        try {
+                            const response = await configModuleHost.activateConfigs(request, void 0, async (activation)=>{
+                                if (pluginHost) return;
+                                const createdHost = await buildPluginHost(activation.pluginConfigs);
+                                if (shuttingDown) return void await shutdownPluginHost(createdHost).catch(()=>void 0);
+                                stagedPluginHost = createdHost;
+                            });
+                            const preparedHost = stagedPluginHost;
+                            await publishPluginHost(preparedHost);
+                            stagedPluginHost = null;
+                            return response;
+                        } catch (error) {
+                            await shutdownPluginHost(stagedPluginHost).catch(()=>void 0);
+                            throw error;
+                        }
+                    }
                 case 'shutdown':
                     return {
                         ok: true
                     };
                 case 'pluginLint':
-                    return pluginHost ? pluginHost.lint(msg.data) : {
-                        results: []
-                    };
+                    if (!pluginHost) throw new Error('engine: pluginLint requested without an activated plugin host');
+                    return pluginHost.lint(msg.data);
                 default:
                     throw new Error(`engine: unexpected inbound kind '${msg.kind}'`);
             }
@@ -354,8 +436,6 @@ async function runEngine(opts) {
             try {
                 outcome = await raceWithExit(ipc.sendRequest('init', {
                     ...opts.extraInit ?? {},
-                    configs: opts.configs,
-                    eslintPlugins: opts.eslintPluginEntries,
                     runtime: {
                         stdoutIsTTY,
                         singleThreaded: opts.runtime?.singleThreaded
@@ -383,7 +463,17 @@ async function runEngine(opts) {
         return finalExit.code;
     } finally{
         removeSignalHandlers();
-        await pluginHost?.shutdown();
+        shuttingDown = true;
+        await Promise.allSettled([
+            ...pendingPluginHostBuilds
+        ]);
+        await Promise.allSettled([
+            shutdownPluginHost(pluginHost),
+            ...[
+                ...stagedPluginHosts
+            ].map(shutdownPluginHost)
+        ]);
+        for (const transactionId of configTransactions)configModuleHost.deleteSession(transactionId);
     }
 }
 const KILL_GRACE_MS = 5000;