@rslint/core 0.5.3 → 0.6.0

package/dist/config-loader.d.ts

@@ -1,14 +1,45 @@
-// Re-export utilities that external consumers may depend on
-export { JS_CONFIG_FILES, findJSConfig, findJSConfigUp, findJSConfigsInDir, } from './utils/config-discovery.js';
-/**
- * Load a JS/TS config file.
- * - .js/.mjs: native import()
- * - .ts/.mts: native import() when Node.js has TypeScript support (>= 22.6),
- *             otherwise fall back to jiti
- */
-export declare function loadConfigFile(configPath: string): Promise<unknown>;
-/**
- * Validate and strip non-serializable fields from the config.
- */
-export declare function normalizeConfig(config: unknown): Record<string, unknown>[];
-//# sourceMappingURL=config-loader.d.ts.map
+/**
+ * Derive, from normalized configs, the ESLint-plugin metadata the Go core
+ * needs (`{prefix, ruleNames}` for placeholder rules) and the worker-pool
+ * descriptors (only for configs that mount plugins — others stay
+ * zero-overhead). Shared by the CLI (cli.ts) and the VS Code extension
+ * (Rslint.ts) so both produce the identical `eslintPlugins` shape Go parses.
+ * ruleNames for a shared prefix are merged (set union) across configs: Go's
+ * placeholder registry is a per-prefix superset, while the worker routes the
+ * actual rules per-config. This is NOT a validation — a genuinely conflicting
+ * redefinition (same prefix, different plugin object) is caught at worker init
+ * (plugin-loader throws ESLint's `Cannot redefine plugin` error), not here.
+ */
+export declare function collectPluginMeta(configs: ReadonlyArray<{
+    configPath: string;
+    configDirectory: string;
+    entries: ReadonlyArray<unknown>;
+}>): {
+    eslintPluginEntries: Array<{
+        prefix: string;
+        ruleNames: string[];
+    }>;
+    pluginConfigs: PluginConfigDescriptor[];
+};
+
+/**
+ * Load a JS/TS config file.
+ * - .js/.mjs: native import()
+ * - .ts/.mts: native import() when Node.js has TypeScript support (>= 22.6),
+ *             otherwise fall back to jiti
+ */
+export declare function loadConfigFile(configPath: string): Promise<unknown>;
+
+/**
+ * Validate and strip non-serializable fields from the config.
+ */
+export declare function normalizeConfig(config: unknown): Record<string, unknown>[];
+
+/** A worker-pool config descriptor: which config file to import and the
+ *  directory key per-file plugin-lint tasks route on. */
+export declare interface PluginConfigDescriptor {
+    configPath: string;
+    configDirectory: string;
+}
+
+export { }

package/dist/config-loader.js

@@ -1,33 +1,28 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-// Re-export utilities that external consumers may depend on
-export { JS_CONFIG_FILES, findJSConfig, findJSConfigUp, findJSConfigsInDir, } from './utils/config-discovery.js';
-/**
- * Load a JS/TS config file.
- * - .js/.mjs: native import()
- * - .ts/.mts: native import() when Node.js has TypeScript support (>= 22.6),
- *             otherwise fall back to jiti
- */
-export async function loadConfigFile(configPath) {
-    const ext = path.extname(configPath);
-    if (ext === '.js' || ext === '.mjs') {
-        const mod = await import(__rewriteRelativeImportExtension(pathToFileURL(configPath).href));
+import node_path from "node:path";
+import { pathToFileURL } from "node:url";
+import { NATIVE_PLUGIN_RESERVED_NAMES } from "./34.js";
+function selectPluginSource(entry) {
+    if (null == entry || 'object' != typeof entry) return null;
+    const e = entry;
+    if (null != e.plugins && 'object' == typeof e.plugins && !Array.isArray(e.plugins)) return e.plugins;
+    return null;
+}
+function unwrapPluginModule(mod) {
+    if (null == mod || 'object' != typeof mod) return null;
+    const m = mod;
+    if (null != m.default && 'object' == typeof m.default) return m.default;
+    return mod;
+}
+async function loadConfigFile(configPath) {
+    const ext = node_path.extname(configPath);
+    if ('.js' === ext || '.mjs' === ext) {
+        const mod = await import(pathToFileURL(configPath).href);
         return mod.default ?? mod;
     }
-    if (ext === '.ts' || ext === '.mts') {
-        // Use feature detection to decide the loading strategy (same as rsbuild).
-        // process.features.typescript is available in Node.js >= 22.6.
+    if ('.ts' === ext || '.mts' === ext) {
         const useNative = Boolean(process.features.typescript);
         if (useNative) {
-            const mod = await import(__rewriteRelativeImportExtension(pathToFileURL(configPath).href));
+            const mod = await import(pathToFileURL(configPath).href);
             return mod.default ?? mod;
         }
         const jiti = await loadJiti(configPath);
@@ -35,60 +30,101 @@ export async function loadConfigFile(configPath) {
             const resolved = await jiti.import(configPath);
             return extractDefault(resolved);
         }
-        throw new Error(`Failed to load TypeScript config file: ${configPath}\n` +
-            `To load .ts config files, either:\n` +
-            `  1. Use Node.js >= 22.6 (with native TypeScript support)\n` +
-            `  2. Install jiti as a dependency: npm install -D jiti`);
+        throw new Error(`Failed to load TypeScript config file: ${configPath}\nTo load .ts config files, either:\n  1. Use Node.js >= 22.6 (with native TypeScript support)\n  2. Install jiti as a dependency: npm install -D jiti`);
     }
     throw new Error(`Unsupported config file extension: ${ext}`);
 }
-/**
- * Try to load jiti (optional peer dependency).
- */
 async function loadJiti(configPath) {
     try {
-        const { createJiti } = await import('jiti');
-        return createJiti(path.dirname(configPath), { interopDefault: true });
-    }
-    catch {
+        const { createJiti } = await import("jiti");
+        return createJiti(node_path.dirname(configPath), {
+            interopDefault: true
+        });
+    } catch  {
         return null;
     }
 }
 function extractDefault(mod) {
-    if (typeof mod === 'object' && mod !== null && 'default' in mod) {
-        return mod.default;
-    }
+    if ('object' == typeof mod && null !== mod && 'default' in mod) return mod.default;
     return mod;
 }
-/**
- * Validate and strip non-serializable fields from the config.
- */
-export function normalizeConfig(config) {
-    if (!Array.isArray(config)) {
-        throw new Error(`rslint config must export an array (flat config format), got ${typeof config}`);
-    }
-    return config
-        .filter((entry, index) => {
-        if (entry == null || typeof entry !== 'object') {
-            console.warn(`[rslint] Config entry at index ${index} is not an object (got ${entry === null ? 'null' : typeof entry}), skipping.`);
+function normalizeConfig(config) {
+    if (!Array.isArray(config)) throw new Error(`rslint config must export an array (flat config format), got ${typeof config}`);
+    return config.filter((entry, index)=>{
+        if (null == entry || 'object' != typeof entry) {
+            console.warn(`[rslint] Config entry at index ${index} is not an object (got ${null === entry ? 'null' : typeof entry}), skipping.`);
             return false;
         }
         return true;
-    })
-        .map((entry, index) => {
-        if (entry.files != null && !Array.isArray(entry.files)) {
-            throw new Error(`[rslint] Config entry at index ${index}: "files" must be an array, got ${typeof entry.files}`);
-        }
-        if (entry.ignores != null && !Array.isArray(entry.ignores)) {
-            throw new Error(`[rslint] Config entry at index ${index}: "ignores" must be an array, got ${typeof entry.ignores}`);
+    }).map((entry, index)=>{
+        if (null != entry.files && !Array.isArray(entry.files)) throw new Error(`[rslint] Config entry at index ${index}: "files" must be an array, got ${typeof entry.files}`);
+        if (null != entry.ignores && !Array.isArray(entry.ignores)) throw new Error(`[rslint] Config entry at index ${index}: "ignores" must be an array, got ${typeof entry.ignores}`);
+        const pluginSource = selectPluginSource(entry);
+        const eslintPluginMeta = {};
+        const pluginPrefixes = [];
+        if (null != pluginSource) for (const prefix of Object.keys(pluginSource)){
+            if (NATIVE_PLUGIN_RESERVED_NAMES.has(prefix)) throw new Error(`[rslint] Config entry at index ${index}: plugins prefix "${prefix}" collides with the built-in plugin of the same name; choose a different prefix.`);
+            const plugin = unwrapPluginModule(pluginSource[prefix]);
+            const pluginRules = plugin?.rules;
+            if (null == pluginRules || 'object' != typeof pluginRules) throw new Error(`[rslint] Config entry at index ${index}: plugins["${prefix}"] must expose a "rules" object.`);
+            eslintPluginMeta[prefix] = {
+                ruleNames: Object.keys(pluginRules).sort()
+            };
+            pluginPrefixes.push(prefix);
         }
+        const stringPlugins = Array.isArray(entry.plugins) ? entry.plugins.filter((p)=>'string' == typeof p) : [];
+        const plugins = [
+            ...new Set([
+                ...stringPlugins,
+                ...pluginPrefixes
+            ])
+        ];
         return {
             files: entry.files,
             ignores: entry.ignores,
             languageOptions: entry.languageOptions,
             rules: entry.rules,
-            plugins: entry.plugins,
+            plugins,
             settings: entry.settings,
+            ...pluginPrefixes.length > 0 ? {
+                eslintPlugins: eslintPluginMeta
+            } : {}
         };
     });
 }
+function collectPluginMeta(configs) {
+    const isPluginMetaMap = (v)=>null !== v && 'object' == typeof v;
+    const byPrefix = new Map();
+    const pluginConfigs = [];
+    for (const c of configs){
+        let hasPlugins = false;
+        for (const entry of c.entries){
+            if (null === entry || 'object' != typeof entry || !('eslintPlugins' in entry)) continue;
+            const ep = entry.eslintPlugins;
+            if (isPluginMetaMap(ep)) for (const [prefix, meta] of Object.entries(ep)){
+                hasPlugins = true;
+                const existing = byPrefix.get(prefix);
+                if (existing) {
+                    for (const name of meta.ruleNames)if (!existing.includes(name)) existing.push(name);
+                } else byPrefix.set(prefix, [
+                    ...meta.ruleNames
+                ]);
+            }
+        }
+        if (hasPlugins) pluginConfigs.push({
+            configPath: c.configPath,
+            configDirectory: c.configDirectory
+        });
+    }
+    const eslintPluginEntries = [
+        ...byPrefix.entries()
+    ].map(([prefix, ruleNames])=>({
+            prefix,
+            ruleNames
+        }));
+    return {
+        eslintPluginEntries,
+        pluginConfigs
+    };
+}
+export { collectPluginMeta, loadConfigFile, normalizeConfig };

package/dist/eslint-plugin/612.js

@@ -0,0 +1,43 @@
+var __webpack_modules__ = {};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.d = (exports, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+export { __webpack_require__ };