@rslint/core 0.6.3 → 0.6.5

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/770.js

@@ -0,0 +1,18 @@
+import { createRequire } from "node:module";
+const resolve_binary_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 resolve_binary_require.resolve(`@rslint/native-${tuple}/bin`);
+    } catch  {}
+    throw new Error(`rslint: no native binary for ${process.platform}-${arch} (looked for @rslint/native-{${tuples.join(',')}})`);
+}
+export { resolveRslintBinary };

package/dist/cli.d.ts

@@ -1,3 +1,13 @@
 export declare function run(binPath: string, argv: string[], startTime: number): Promise<number>;
 
+export declare function runCLI({ argv, }?: RunCLIOptions): Promise<void>;
+
+export declare type RunCLIOptions = {
+    /**
+     * The command-line arguments to parse, matching the shape of Node.js `process.argv`
+     * @default process.argv
+     */
+    argv?: string[];
+};
+
 export { }

package/dist/cli.js

@@ -1,101 +1,13 @@
-import node_path from "node:path";
-import node_fs from "node:fs";
-import { parseArgs } from "node:util";
-import picomatch from "picomatch";
 import fs_0, * as __rspack_external_fs from "fs";
 import path_0, { basename, dirname, normalize, posix, relative as external_path_relative, resolve, sep } from "path";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
+import picomatch from "picomatch";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { parseArgs } from "node:util";
 import { loadConfigFile, collectPluginMeta, normalizeConfig } from "./config-loader.js";
-function isJSConfigFile(filePath) {
-    return /\.(ts|mts|js|mjs)$/.test(filePath);
-}
-function args_parseArgs(argv) {
-    const { values, tokens } = parseArgs({
-        args: argv,
-        strict: false,
-        tokens: true,
-        options: {
-            config: {
-                type: 'string'
-            },
-            init: {
-                type: 'boolean'
-            },
-            singleThreaded: {
-                type: 'boolean'
-            },
-            format: {
-                type: 'string'
-            },
-            'max-warnings': {
-                type: 'string'
-            },
-            rule: {
-                type: 'string',
-                multiple: true
-            },
-            trace: {
-                type: 'string'
-            },
-            cpuprof: {
-                type: 'string'
-            },
-            'start-time': {
-                type: 'string'
-            }
-        }
-    });
-    const flags = [];
-    const positionalsBefore = [];
-    const positionalsAfter = [];
-    let seenTerminator = false;
-    for (const token of tokens)if ('option' === token.kind) {
-        if ('config' === token.name || 'init' === token.name || 'start-time' === token.name) continue;
-        flags.push(token.rawName);
-        if (null != token.value) flags.push(token.value);
-    } else if ('option-terminator' === token.kind) seenTerminator = true;
-    else if ('positional' === token.kind) if (seenTerminator) positionalsAfter.push(token.value);
-    else positionalsBefore.push(token.value);
-    const positionals = [
-        ...positionalsBefore,
-        ...positionalsAfter
-    ];
-    const rest = seenTerminator ? [
-        ...flags,
-        ...positionalsBefore,
-        '--',
-        ...positionalsAfter
-    ] : [
-        ...flags,
-        ...positionalsBefore
-    ];
-    return {
-        config: values.config ?? null,
-        init: values.init ?? false,
-        singleThreaded: values.singleThreaded ?? false,
-        rest,
-        positionals
-    };
-}
-function classifyArgs(positionals, cwd) {
-    const files = [];
-    const dirs = [];
-    for (const arg of positionals){
-        const resolved = node_path.resolve(cwd, arg);
-        try {
-            const real = node_fs.realpathSync(resolved);
-            if (node_fs.statSync(real).isDirectory()) dirs.push(real);
-            else files.push(real);
-        } catch  {
-            files.push(resolved);
-        }
-    }
-    return {
-        files,
-        dirs
-    };
-}
+import { resolveRslintBinary } from "./770.js";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 function cleanPath(path) {
     let normalized = normalize(path);
@@ -898,12 +810,12 @@ async function findJSConfigsInDir(startDir) {
 }
 async function discoverConfigs(files, dirs, cwd, explicitConfig) {
     const configs = new Map();
-    const addConfig = (configPath)=>{
-        if (!configs.has(configPath)) configs.set(configPath, node_path.dirname(configPath));
+    const addConfig = (configPath, configDirectory = node_path.dirname(configPath))=>{
+        if (!configs.has(configPath)) configs.set(configPath, configDirectory);
     };
     if (explicitConfig) {
         const resolved = node_path.resolve(cwd, explicitConfig);
-        addConfig(resolved);
+        addConfig(resolved, cwd);
         return configs;
     }
     const startDirs = new Set();
@@ -985,6 +897,96 @@ function filterConfigsByParentIgnores(configEntries) {
     }
     return result;
 }
+function isJSConfigFile(filePath) {
+    return /\.(ts|mts|js|mjs)$/.test(filePath);
+}
+function args_parseArgs(argv) {
+    const { values, tokens } = parseArgs({
+        args: argv,
+        strict: false,
+        tokens: true,
+        options: {
+            config: {
+                type: 'string',
+                short: 'c'
+            },
+            init: {
+                type: 'boolean'
+            },
+            singleThreaded: {
+                type: 'boolean'
+            },
+            format: {
+                type: 'string'
+            },
+            'max-warnings': {
+                type: 'string'
+            },
+            rule: {
+                type: 'string',
+                multiple: true
+            },
+            trace: {
+                type: 'string'
+            },
+            cpuprof: {
+                type: 'string'
+            },
+            'start-time': {
+                type: 'string'
+            }
+        }
+    });
+    const flags = [];
+    const positionalsBefore = [];
+    const positionalsAfter = [];
+    let seenTerminator = false;
+    for (const token of tokens)if ('option' === token.kind) {
+        if ('config' === token.name || 'init' === token.name || 'start-time' === token.name) continue;
+        flags.push(token.rawName);
+        if (null != token.value) flags.push(token.value);
+    } else if ('option-terminator' === token.kind) seenTerminator = true;
+    else if ('positional' === token.kind) if (seenTerminator) positionalsAfter.push(token.value);
+    else positionalsBefore.push(token.value);
+    const positionals = [
+        ...positionalsBefore,
+        ...positionalsAfter
+    ];
+    const rest = seenTerminator ? [
+        ...flags,
+        ...positionalsBefore,
+        '--',
+        ...positionalsAfter
+    ] : [
+        ...flags,
+        ...positionalsBefore
+    ];
+    return {
+        config: values.config ?? null,
+        init: values.init ?? false,
+        singleThreaded: values.singleThreaded ?? false,
+        rest,
+        positionals
+    };
+}
+function classifyArgs(positionals, cwd) {
+    const files = [];
+    const dirs = [];
+    for (const arg of positionals){
+        const resolved = node_path.resolve(cwd, arg);
+        try {
+            const real = node_fs.realpathSync(resolved);
+            if (node_fs.statSync(real).isDirectory()) dirs.push(real);
+            else files.push(real);
+        } catch  {
+            files.push(resolved);
+        }
+    }
+    return {
+        files,
+        dirs
+    };
+}
 async function runWithJSConfigs(binPath, configs, goArgs, cwd, singleThreaded) {
     const configEntries = [];
     const dirToPath = new Map();
@@ -1088,4 +1090,9 @@ async function run(binPath, argv, startTime) {
         cwd
     });
 }
-export { run };
+async function runCLI({ argv = process.argv } = {}) {
+    const startTime = Date.now();
+    const exitCode = await run(resolveRslintBinary(), argv.slice(2), startTime);
+    process.exitCode = exitCode;
+}
+export { findJSConfigUp, glob, run, runCLI };

package/dist/config-loader.js

@@ -1,6 +1,37 @@
 import node_path from "node:path";
 import { pathToFileURL } from "node:url";
-import { NATIVE_PLUGIN_RESERVED_NAMES } from "./34.js";
+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
+    };
+}
 function selectPluginSource(entry) {
     if (null == entry || 'object' != typeof entry) return null;
     const e = entry;
@@ -127,4 +158,4 @@ function collectPluginMeta(configs) {
         pluginConfigs
     };
 }
-export { collectPluginMeta, loadConfigFile, normalizeConfig };
+export { collectPluginMeta, defineConfig, globalIgnores, loadConfigFile, normalizeConfig };

package/dist/eslint-plugin/index.js

@@ -1,10 +1,10 @@
 import { Worker } from "node:worker_threads";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { StringDecoder } from "node:string_decoder";
-import { createRequire } from "node:module";
+import node_path from "node:path";
+import node_module, { createRequire } from "node:module";
 import { readFileSync } from "node:fs";
 import { execSync } from "node:child_process";
-import node_path from "node:path";
 import { __webpack_require__ } from "./612.js";
 __webpack_require__.add({
     "../../node_modules/.pnpm/esrecurse@4.3.0/node_modules/esrecurse/esrecurse.js" (__unused_rspack_module, exports, __webpack_require__) {
@@ -20396,6 +20396,34 @@ class CancelFlagPool {
 let testWorkerEntry;
 const resolveWorkerFile = ()=>testWorkerEntry ?? fileURLToPath(new URL('./lint-worker.js', import.meta.url));
 const WORKER_EXIT_GRACE_MS = 5000;
+let nodeCompileCacheDir;
+let nodeCompileCacheDirResolved = false;
+function getNodeCompileCacheDir() {
+    if (nodeCompileCacheDirResolved) return nodeCompileCacheDir;
+    nodeCompileCacheDirResolved = true;
+    if (process.env.NODE_DISABLE_COMPILE_CACHE) return;
+    if (process.env.NODE_COMPILE_CACHE) {
+        nodeCompileCacheDir = process.env.NODE_COMPILE_CACHE;
+        return nodeCompileCacheDir;
+    }
+    const { enableCompileCache, getCompileCacheDir } = node_module;
+    if (!enableCompileCache || !getCompileCacheDir) return;
+    try {
+        enableCompileCache();
+        const cacheDirectory = getCompileCacheDir();
+        nodeCompileCacheDir = cacheDirectory ? node_path.dirname(cacheDirectory) : void 0;
+        return nodeCompileCacheDir;
+    } catch  {
+        return;
+    }
+}
+function workerEnvWithCompileCache() {
+    const directory = getNodeCompileCacheDir();
+    return directory ? {
+        ...process.env,
+        NODE_COMPILE_CACHE: directory
+    } : void 0;
+}
 async function terminateWorker(worker) {
     worker.stdout?.destroy();
     worker.stderr?.destroy();
@@ -20590,6 +20618,7 @@ class WorkerPool {
                     cancelSab: this.cancelPool.sharedBuffer,
                     configs: this.opts.configs
                 },
+                env: workerEnvWithCompileCache(),
                 stdout: true,
                 stderr: true
             };