@rslint/core 0.3.0 → 0.3.1

package/dist/browser.d.ts

@@ -0,0 +1,39 @@
+import type { RslintServiceInterface, RSlintOptions } from './types.js';
+/**
+ * Browser implementation of RslintService using web workers
+ */
+export declare class BrowserRslintService implements RslintServiceInterface {
+    private nextMessageId;
+    private pendingMessages;
+    private worker!;
+    private 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

package/dist/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,sBAAsB,EAKtB,aAAa,EAGd,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,qBAAa,oBAAqB,YAAW,sBAAsB;IACjE,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,MAAM,CAAC,CAAgB;IAC/B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,YAAY,CAAgB;IAEpC,YAAY,OAAO,EAAE,aAAa,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAW1E;YAKa,YAAY;IAwB1B;;OAEG;IACH,OAAO,CAAC,YAAY;IA+CpB;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAWvD;IAED;;OAEG;IACH,OAAO,CAAC,cAAc;IActB;;OAEG;IACH,SAAS,IAAI,IAAI,CAWhB;CACF"}

package/dist/browser.js

@@ -0,0 +1,147 @@
+/**
+ * Browser implementation of RslintService using web workers
+ */
+export class BrowserRslintService {
+    nextMessageId;
+    pendingMessages;
+    worker;
+    workerUrl;
+    chunks;
+    chunkSize;
+    expectedSize;
+    constructor(options) {
+        this.nextMessageId = 1;
+        this.pendingMessages = new Map();
+        this.chunks = [];
+        this.chunkSize = 0;
+        this.expectedSize = null;
+        // In browser, we need to use a web worker that can run the rslint binary
+        // This would typically be a WASM version or a worker that can spawn processes
+        this.workerUrl = options.workerUrl;
+        this.ensureWorker(options.wasmUrl);
+    }
+    /**
+     * Initialize the web worker
+     */
+    async ensureWorker(wasmUrl) {
+        if (!this.worker) {
+            this.worker = new Worker(this.workerUrl, { name: 'rslint-worker.js' });
+            this.worker.onmessage = event => {
+                this.handlePacket(event.data);
+            };
+            this.worker.onerror = error => {
+                console.error('Worker error:', error);
+                // Reject all pending messages
+                for (const [id, pending] of this.pendingMessages) {
+                    pending.reject(new Error(`Worker error: ${error.message}`));
+                }
+                this.pendingMessages.clear();
+            };
+            this.worker.postMessage({
+                kind: 'init',
+                data: { version: '1.0.0', wasmURL: wasmUrl },
+            });
+        }
+        return this.worker;
+    }
+    /**
+     * Handle incoming binary data chunks
+     */
+    handlePacket(chunk) {
+        this.chunks.push(chunk);
+        this.chunkSize += chunk.length;
+        // Process complete messages
+        while (true) {
+            // Read message length if we don't have it yet
+            if (this.expectedSize === null) {
+                if (this.chunkSize < 4)
+                    return;
+                // Combine chunks to read the message length
+                const combined = this.combineChunks();
+                const dataView = new DataView(combined.buffer, combined.byteOffset, combined.byteLength);
+                this.expectedSize = dataView.getUint32(0, true); // true for little-endian
+                // Remove length bytes from buffer
+                this.chunks = [combined.slice(4)];
+                this.chunkSize -= 4;
+            }
+            // Check if we have the full message
+            if (this.chunkSize < this.expectedSize)
+                return;
+            // Read the message content
+            const combined = this.combineChunks();
+            const messageBytes = combined.slice(0, this.expectedSize);
+            const message = new TextDecoder().decode(messageBytes);
+            // Handle the message
+            try {
+                const parsed = JSON.parse(message);
+                this.handleResponse(parsed);
+            }
+            catch (err) {
+                console.error('Error parsing message:', err);
+            }
+            // Reset for next message
+            this.chunks = [combined.slice(this.expectedSize)];
+            this.chunkSize = this.chunks[0].length;
+            this.expectedSize = null;
+        }
+    }
+    /**
+     * Combine multiple Uint8Array chunks into a single Uint8Array
+     */
+    combineChunks() {
+        if (this.chunks.length === 1) {
+            return this.chunks[0];
+        }
+        const totalLength = this.chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const combined = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of this.chunks) {
+            combined.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return combined;
+    }
+    /**
+     * Send a message to the worker
+     */
+    async sendMessage(kind, data) {
+        return new Promise((resolve, reject) => {
+            const id = this.nextMessageId++;
+            const message = { id, kind, data };
+            // Register promise callbacks
+            this.pendingMessages.set(id, { resolve, reject });
+            // Send message to worker
+            this.worker.postMessage(message);
+        });
+    }
+    /**
+     * Handle messages from the worker
+     */
+    handleResponse(message) {
+        const { id, kind, data } = message;
+        const pending = this.pendingMessages.get(id);
+        if (!pending)
+            return;
+        this.pendingMessages.delete(id);
+        if (kind === 'error') {
+            pending.reject(new Error(data.message));
+        }
+        else {
+            pending.resolve(data);
+        }
+    }
+    /**
+     * Terminate the worker
+     */
+    terminate() {
+        if (this.worker) {
+            // Reject all pending messages
+            for (const [id, pending] of this.pendingMessages) {
+                pending.reject(new Error('Service terminated'));
+            }
+            this.pendingMessages.clear();
+            this.worker.terminate();
+            this.worker = null;
+        }
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export declare function run(binPath: string, argv: string[]): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAsHA,wBAAsB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA4B1E"}

package/dist/cli.js

@@ -0,0 +1,128 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { parseArgs as nodeParseArgs } from 'node:util';
+import { loadConfigFile, normalizeConfig, findJSConfig, } from './config-loader.js';
+/**
+ * Pass-through execution of the Go binary with stdio inherited.
+ */
+function execBinary(binPath, argv) {
+    try {
+        execFileSync(binPath, argv, { stdio: 'inherit' });
+        return 0;
+    }
+    catch (error) {
+        if (isExecError(error))
+            return error.status;
+        process.stderr.write(`Failed to execute ${binPath}: ${String(error)}\n`);
+        return 1;
+    }
+}
+function isExecError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'status' in error &&
+        typeof error.status === 'number');
+}
+function parseArgs(argv) {
+    const { values, tokens } = nodeParseArgs({
+        args: argv,
+        strict: false,
+        tokens: true,
+        options: {
+            config: { type: 'string' },
+            init: { type: 'boolean' },
+        },
+    });
+    // Collect args that are not --config or --init for pass-through to Go
+    const rest = [];
+    for (const token of tokens) {
+        if (token.kind === 'option') {
+            if (token.name === 'config' || token.name === 'init')
+                continue;
+            rest.push(token.rawName);
+            if (token.value != null)
+                rest.push(token.value);
+        }
+        else if (token.kind === 'option-terminator') {
+            rest.push('--');
+        }
+        else if (token.kind === 'positional') {
+            rest.push(token.value);
+        }
+    }
+    return {
+        raw: argv,
+        config: values.config ?? null,
+        init: values.init ?? false,
+        rest,
+    };
+}
+function isJSConfigFile(filePath) {
+    return /\.(ts|mts|js|mjs)$/.test(filePath);
+}
+/**
+ * Load JS config, serialize to JSON, and pipe to Go binary via stdin.
+ */
+async function runWithJSConfig(binPath, configPath, restArgs, cwd) {
+    let rawConfig;
+    try {
+        rawConfig = await loadConfigFile(configPath);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Error: failed to load config ${configPath}: ${msg}\n`);
+        return 1;
+    }
+    let entries;
+    try {
+        entries = normalizeConfig(rawConfig);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Error: invalid config in ${configPath}: ${msg}\n`);
+        return 1;
+    }
+    const configDir = path.dirname(path.resolve(cwd, configPath));
+    const payload = JSON.stringify({ configDirectory: configDir, entries });
+    try {
+        execFileSync(binPath, ['--config-stdin', ...restArgs], {
+            input: payload,
+            stdio: ['pipe', 'inherit', 'inherit'],
+            cwd,
+        });
+        return 0;
+    }
+    catch (error) {
+        if (isExecError(error))
+            return error.status;
+        process.stderr.write(`Failed to execute ${binPath}: ${String(error)}\n`);
+        return 1;
+    }
+}
+export async function run(binPath, argv) {
+    const cwd = process.cwd();
+    const args = parseArgs(argv);
+    // --init: pass through to Go
+    if (args.init) {
+        return execBinary(binPath, ['--init']);
+    }
+    // Determine config file
+    let configPath = null;
+    if (args.config) {
+        configPath = path.resolve(cwd, args.config);
+        if (!fs.existsSync(configPath)) {
+            process.stderr.write(`Error: config file not found: ${configPath}\n`);
+            return 1;
+        }
+    }
+    else {
+        configPath = findJSConfig(cwd);
+    }
+    // JS config file: load + stdin pipe
+    if (configPath && isJSConfigFile(configPath)) {
+        return runWithJSConfig(binPath, configPath, args.rest, cwd);
+    }
+    // Fall back to Go binary (handles JSON config + deprecation warning)
+    return execBinary(binPath, args.raw);
+}

package/dist/config-loader.d.ts

@@ -0,0 +1,14 @@
+export declare const JS_CONFIG_FILES: string[];
+export declare function findJSConfig(cwd: string): string | null;
+/**
+ * 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

package/dist/config-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../src/config-loader.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,UAK3B,CAAC;AAEF,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMvD;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAqCzE;AAuBD;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAqC1E"}

package/dist/config-loader.js

@@ -0,0 +1,107 @@
+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 fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+export const JS_CONFIG_FILES = [
+    'rslint.config.js',
+    'rslint.config.mjs',
+    'rslint.config.ts',
+    'rslint.config.mts',
+];
+export function findJSConfig(cwd) {
+    for (const name of JS_CONFIG_FILES) {
+        const p = path.join(cwd, name);
+        if (fs.existsSync(p))
+            return p;
+    }
+    return null;
+}
+/**
+ * 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));
+        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.
+        const useNative = Boolean(process.features.typescript);
+        if (useNative) {
+            const mod = await import(__rewriteRelativeImportExtension(pathToFileURL(configPath).href));
+            return mod.default ?? mod;
+        }
+        const jiti = await loadJiti(configPath);
+        if (jiti) {
+            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(`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 {
+        return null;
+    }
+}
+function extractDefault(mod) {
+    if (typeof mod === 'object' && mod !== null && '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.`);
+            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}`);
+        }
+        return {
+            files: entry.files,
+            ignores: entry.ignores,
+            languageOptions: entry.languageOptions,
+            rules: entry.rules,
+            plugins: entry.plugins,
+            settings: entry.settings,
+        };
+    });
+}

package/dist/configs/import.d.ts

@@ -0,0 +1,6 @@
+import type { RslintConfigEntry } from '../define-config.js';
+// Aligned with official eslint-plugin-import recommended.
+// Rules commented out with "not implemented" are in the official preset but not yet available.
+declare const recommended: RslintConfigEntry;
+export { recommended };
+//# sourceMappingURL=import.d.ts.map

package/dist/configs/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/configs/import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,0DAA0D;AAC1D,+FAA+F;AAC/F,QAAA,MAAM,WAAW,EAAE,iBAclB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/configs/import.js

@@ -0,0 +1,7 @@
+// Aligned with official eslint-plugin-import recommended.
+// Rules commented out with "not implemented" are in the official preset but not yet available.
+const recommended = {
+    plugins: ['eslint-plugin-import'],
+    rules: {},
+};
+export { recommended };

package/dist/configs/index.d.ts

@@ -0,0 +1,12 @@
+import type { RslintConfigEntry } from '../define-config.js';
+interface PluginExport {
+    configs: {
+        recommended: RslintConfigEntry;
+    };
+}
+export declare const ts: PluginExport;
+export declare const js: PluginExport;
+export declare const reactPlugin: PluginExport;
+export declare const importPlugin: PluginExport;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/configs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/configs/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAM7D,UAAU,YAAY;IACpB,OAAO,EAAE;QAAE,WAAW,EAAE,iBAAiB,CAAA;KAAE,CAAC;CAC7C;AAED,eAAO,MAAM,EAAE,EAAE,YAEhB,CAAC;AAEF,eAAO,MAAM,EAAE,EAAE,YAEhB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,YAEzB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,YAE1B,CAAC"}

package/dist/configs/index.js

@@ -0,0 +1,16 @@
+import { recommended as tsRecommended } from './typescript.js';
+import { recommended as jsRecommended } from './javascript.js';
+import { recommended as reactRecommended } from './react.js';
+import { recommended as importRecommended } from './import.js';
+export const ts = {
+    configs: { recommended: tsRecommended },
+};
+export const js = {
+    configs: { recommended: jsRecommended },
+};
+export const reactPlugin = {
+    configs: { recommended: reactRecommended },
+};
+export const importPlugin = {
+    configs: { recommended: importRecommended },
+};

package/dist/configs/javascript.d.ts

@@ -0,0 +1,6 @@
+import type { RslintConfigEntry } from '../define-config.js';
+// Aligned with official eslint:recommended.
+// Rules commented out with "not implemented" are in the official preset but not yet available.
+declare const recommended: RslintConfigEntry;
+export { recommended };
+//# sourceMappingURL=javascript.d.ts.map

package/dist/configs/javascript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript.d.ts","sourceRoot":"","sources":["../../src/configs/javascript.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,4CAA4C;AAC5C,+FAA+F;AAC/F,QAAA,MAAM,WAAW,EAAE,iBAqElB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/configs/javascript.js

@@ -0,0 +1,73 @@
+// Aligned with official eslint:recommended.
+// Rules commented out with "not implemented" are in the official preset but not yet available.
+const recommended = {
+    files: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.cjs'],
+    rules: {
+        'constructor-super': 'error',
+        // 'no-control-regex': 'error', // not implemented
+        // 'no-delete-var': 'error', // not implemented
+        // 'no-dupe-class-members': 'error', // not implemented
+        // 'no-dupe-else-if': 'error', // not implemented
+        // 'no-empty-character-class': 'error', // not implemented
+        // 'no-empty-static-block': 'error', // not implemented
+        // 'no-ex-assign': 'error', // not implemented
+        // 'no-extra-boolean-cast': 'error', // not implemented
+        // 'no-fallthrough': 'error', // not implemented
+        // 'no-func-assign': 'error', // not implemented
+        // 'no-global-assign': 'error', // not implemented
+        // 'no-import-assign': 'error', // not implemented
+        // 'no-invalid-regexp': 'error', // not implemented
+        // 'no-irregular-whitespace': 'error', // not implemented
+        // 'no-misleading-character-class': 'error', // not implemented
+        // 'no-new-native-nonconstructor': 'error', // not implemented
+        // 'no-new-symbol': 'error', // not implemented (deprecated, use no-new-native-nonconstructor)
+        // 'no-nonoctal-decimal-escape': 'error', // not implemented
+        // 'no-obj-calls': 'error', // not implemented
+        // 'no-octal': 'error', // not implemented
+        // 'no-prototype-builtins': 'error', // not implemented
+        // 'no-redeclare': 'error', // not implemented
+        // 'no-regex-spaces': 'error', // not implemented
+        // 'no-self-assign': 'error', // not implemented
+        // 'no-setter-return': 'error', // not implemented
+        // 'no-shadow-restricted-names': 'error', // not implemented
+        // 'no-this-before-super': 'error', // not implemented
+        // 'no-undef': 'error', // not implemented
+        // 'no-unexpected-multiline': 'error', // not implemented
+        // 'no-unreachable': 'error', // not implemented
+        // 'no-unsafe-finally': 'error', // not implemented
+        // 'no-unsafe-negation': 'error', // not implemented
+        // 'no-unsafe-optional-chaining': 'error', // not implemented
+        // 'no-unused-labels': 'error', // not implemented
+        // 'no-unused-private-class-members': 'error', // not implemented
+        // 'no-unused-vars': 'error', // not implemented
+        // 'no-unassigned-vars': 'error', // not implemented
+        // 'no-useless-assignment': 'error', // not implemented
+        // 'no-useless-backreference': 'error', // not implemented
+        // 'no-useless-catch': 'error', // not implemented
+        // 'no-useless-escape': 'error', // not implemented
+        // 'no-with': 'error', // not implemented
+        // 'preserve-caught-error': 'error', // not implemented
+        // 'require-yield': 'error', // not implemented
+        // 'use-isnan': 'error', // not implemented
+        // 'valid-typeof': 'error', // not implemented
+        'for-direction': 'error',
+        'getter-return': 'error',
+        'no-async-promise-executor': 'error',
+        'no-case-declarations': 'error',
+        'no-class-assign': 'error',
+        'no-compare-neg-zero': 'error',
+        'no-cond-assign': 'error',
+        'no-const-assign': 'error',
+        'no-constant-binary-expression': 'error',
+        'no-constant-condition': 'error',
+        'no-debugger': 'error',
+        'no-dupe-args': 'error',
+        'no-dupe-keys': 'error',
+        'no-duplicate-case': 'error',
+        'no-empty': 'error',
+        'no-empty-pattern': 'error',
+        'no-loss-of-precision': 'error',
+        'no-sparse-arrays': 'error',
+    },
+};
+export { recommended };

package/dist/configs/react.d.ts

@@ -0,0 +1,6 @@
+import type { RslintConfigEntry } from '../define-config.js';
+// Aligned with official eslint-plugin-react recommended.
+// Rules commented out with "not implemented" are in the official preset but not yet available.
+declare const recommended: RslintConfigEntry;
+export { recommended };
+//# sourceMappingURL=react.d.ts.map

package/dist/configs/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/configs/react.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,yDAAyD;AACzD,+FAA+F;AAC/F,QAAA,MAAM,WAAW,EAAE,iBA2BlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/configs/react.js

@@ -0,0 +1,31 @@
+// Aligned with official eslint-plugin-react recommended.
+// Rules commented out with "not implemented" are in the official preset but not yet available.
+const recommended = {
+    files: ['**/*.jsx', '**/*.tsx'],
+    plugins: ['react'],
+    rules: {
+        // 'react/display-name': 'error', // not implemented
+        // 'react/jsx-key': 'error', // not implemented
+        // 'react/jsx-no-comment-textnodes': 'error', // not implemented
+        // 'react/jsx-no-duplicate-props': 'error', // not implemented
+        // 'react/jsx-no-target-blank': 'error', // not implemented
+        // 'react/jsx-no-undef': 'error', // not implemented
+        'react/jsx-uses-react': 'error',
+        'react/jsx-uses-vars': 'error',
+        // 'react/no-children-prop': 'error', // not implemented
+        // 'react/no-danger-with-children': 'error', // not implemented
+        // 'react/no-deprecated': 'error', // not implemented
+        // 'react/no-direct-mutation-state': 'error', // not implemented
+        // 'react/no-find-dom-node': 'error', // not implemented
+        // 'react/no-is-mounted': 'error', // not implemented
+        // 'react/no-render-return-value': 'error', // not implemented
+        // 'react/no-string-refs': 'error', // not implemented
+        // 'react/no-unescaped-entities': 'error', // not implemented
+        // 'react/no-unknown-property': 'error', // not implemented
+        'react/no-unsafe': 'off',
+        // 'react/prop-types': 'error', // not implemented
+        'react/react-in-jsx-scope': 'error',
+        // 'react/require-render-return': 'error', // not implemented
+    },
+};
+export { recommended };

package/dist/configs/typescript.d.ts

@@ -0,0 +1,8 @@
+import type { RslintConfigEntry } from '../define-config.js';
+// Aligned with official @typescript-eslint/recommended.
+// Includes the eslint-recommended override layer (disables core rules handled by TS,
+// enables TS-beneficial rules).
+// Rules commented out with "not implemented" are in the official preset but not yet available.
+declare const recommended: RslintConfigEntry;
+export { recommended };
+//# sourceMappingURL=typescript.d.ts.map

package/dist/configs/typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../src/configs/typescript.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,wDAAwD;AACxD,qFAAqF;AACrF,gCAAgC;AAChC,+FAA+F;AAC/F,QAAA,MAAM,WAAW,EAAE,iBA6GlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}