@rsdoctor/core 1.6.1 → 2.0.0-alpha.1

package/dist/sdk/server/router.js

@@ -0,0 +1,83 @@
+import "node:module";
+const normalizeAPIKey = (key)=>{
+    if (key && 'object' == typeof key && 'name' in key) return key.name;
+    return key;
+};
+class Router {
+    static get(pathname) {
+        return (target, propertyKey, descriptor)=>{
+            const routes = Router.routes.get;
+            const constructor = target.constructor;
+            if (!routes.has(constructor)) routes.set(constructor, []);
+            routes.get(constructor).push([
+                normalizeAPIKey(propertyKey),
+                pathname
+            ]);
+            return descriptor;
+        };
+    }
+    static post(pathname) {
+        return (target, propertyKey, descriptor)=>{
+            const routes = Router.routes.post;
+            const constructor = target.constructor;
+            if (!routes.has(constructor)) routes.set(constructor, []);
+            routes.get(constructor).push([
+                normalizeAPIKey(propertyKey),
+                pathname
+            ]);
+            return descriptor;
+        };
+    }
+    async setup() {
+        const { apis, sdk, server } = this.options;
+        apis.forEach((API)=>{
+            const obj = new API(sdk, server);
+            Router.routes.get.get(API)?.forEach(([key, pathname])=>{
+                server.get(pathname, this.wrapAPIFunction(obj, key));
+            });
+            Router.routes.post.get(API)?.forEach(([key, pathname])=>{
+                server.post(pathname, this.wrapAPIFunction(obj, key));
+            });
+        });
+    }
+    wrapAPIFunction(api, key) {
+        const { sdk, server } = this.options;
+        return async (req, res)=>{
+            const ctx = {
+                req,
+                res,
+                sdk,
+                server
+            };
+            const trap = new Proxy(api, {
+                get (target, key, receiver) {
+                    switch(key){
+                        case 'ctx':
+                            return ctx;
+                        default:
+                            return Reflect.get(target, key, receiver);
+                    }
+                },
+                set (target, key, value, receiver) {
+                    return Reflect.set(target, key, value, receiver);
+                },
+                defineProperty (target, p, attrs) {
+                    return Reflect.defineProperty(target, p, attrs);
+                }
+            });
+            const fn = api[key];
+            const result = await fn.call(trap, trap);
+            if ('string' == typeof result) return Buffer.from(result, 'utf-8');
+            if (result && 'object' == typeof result) return Buffer.from(JSON.stringify(result), 'utf-8');
+            return result;
+        };
+    }
+    constructor(options){
+        this.options = options;
+    }
+}
+Router.routes = {
+    get: new Map(),
+    post: new Map()
+};
+export { Router };

package/dist/sdk/server/security.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_ALLOWED_CORS_ORIGINS: RegExp;
+export declare function isAllowedRequestOrigin(origin: string | string[] | undefined): boolean;
+export declare function isAllowedRequestHost(host: string | string[] | undefined): boolean;
+export declare function isAllowedCorsRequest(origin: string | string[] | undefined, host: string | string[] | undefined): boolean;
+export declare function isAllowedOpenInEditorToken(token: string | null, expectedToken: string): boolean;

package/dist/sdk/server/security.js

@@ -0,0 +1,47 @@
+import "node:module";
+import { isIP } from "node:net";
+import { timingSafeEqual } from "node:crypto";
+const DEFAULT_ALLOWED_CORS_ORIGINS = /^https?:\/\/(?:(?:[^:]+\.)?localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/;
+const LOCAL_HOSTNAMES = /^(?:localhost|[^:]+\.localhost)$/;
+function isAllowedRequestOrigin(origin) {
+    if (void 0 === origin) return true;
+    return 'string' == typeof origin && DEFAULT_ALLOWED_CORS_ORIGINS.test(origin);
+}
+function getHostnameFromOrigin(origin) {
+    try {
+        const hostname = new URL(origin).hostname.toLowerCase();
+        return hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname;
+    } catch  {
+        return '';
+    }
+}
+function isIpAddress(hostname) {
+    return 0 !== isIP(hostname);
+}
+function getHostnameFromHost(host) {
+    if (host.startsWith('[')) {
+        const endIndex = host.indexOf(']');
+        return -1 === endIndex ? '' : host.slice(1, endIndex);
+    }
+    return host.split(':')[0];
+}
+function isAllowedRequestHost(host) {
+    if ('string' != typeof host) return false;
+    const hostname = getHostnameFromHost(host).toLowerCase();
+    return LOCAL_HOSTNAMES.test(hostname) || isIpAddress(hostname);
+}
+function isAllowedCorsRequest(origin, host) {
+    if (void 0 === origin) return true;
+    if ('string' != typeof origin || 'string' != typeof host || !isAllowedRequestOrigin(origin)) return false;
+    const originHostname = getHostnameFromOrigin(origin);
+    const hostHostname = getHostnameFromHost(host).toLowerCase();
+    if (originHostname.endsWith('.localhost')) return originHostname === hostHostname;
+    return true;
+}
+function isAllowedOpenInEditorToken(token, expectedToken) {
+    if ('string' != typeof token || !expectedToken) return false;
+    const tokenBuffer = Buffer.from(token);
+    const expectedTokenBuffer = Buffer.from(expectedToken);
+    return tokenBuffer.length === expectedTokenBuffer.length && timingSafeEqual(tokenBuffer, expectedTokenBuffer);
+}
+export { DEFAULT_ALLOWED_CORS_ORIGINS, isAllowedCorsRequest, isAllowedOpenInEditorToken, isAllowedRequestHost, isAllowedRequestOrigin };

package/dist/sdk/server/socket/api.d.ts

@@ -0,0 +1,15 @@
+import { Data } from '../../../common/index.js';
+import { Manifest, SDK } from '@rsdoctor/shared/types';
+interface SocketAPILoaderOptions {
+    sdk: SDK.RsdoctorBuilderSDKInstance;
+}
+export declare class SocketAPILoader implements Manifest.ManifestDataLoader {
+    protected options: SocketAPILoaderOptions;
+    protected dataLoader: Data.APIDataLoader;
+    constructor(options: SocketAPILoaderOptions);
+    loadManifest(): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
+    loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+    loadData(key: string): Promise<void>;
+    get loadAPIData(): <T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, body: SDK.ServerAPI.InferRequestBodyType<T>) => Promise<SDK.ServerAPI.InferResponseType<T>>;
+}
+export {};

package/dist/sdk/server/socket/api.js

@@ -0,0 +1,22 @@
+import "node:module";
+import { Data } from "../../../common/index.js";
+class SocketAPILoader {
+    async loadManifest() {
+        return this.options.sdk.getManifestData();
+    }
+    async loadData(key) {
+        const data = this.options.sdk.getStoreData();
+        const sep = '.';
+        let res = data[key];
+        if (key.includes(sep)) res = key.split(sep).reduce((t, k)=>t[k], data);
+        return res;
+    }
+    get loadAPIData() {
+        return this.dataLoader.loadAPI;
+    }
+    constructor(options){
+        this.options = options;
+        this.dataLoader = new Data.APIDataLoader(this);
+    }
+}
+export { SocketAPILoader };

package/dist/sdk/server/socket/index.d.ts

@@ -0,0 +1,48 @@
+import { Common, SDK } from '@rsdoctor/shared/types';
+import type { Server } from 'http';
+import WebSocket, { WebSocketServer } from 'ws';
+import { SocketAPILoader } from './api.js';
+interface SocketOptions {
+    sdk: SDK.RsdoctorBuilderSDKInstance;
+    server: Server;
+    port: number;
+    token: string;
+}
+type Subscription = {
+    api: SDK.ServerAPI.API;
+    body: Common.PlainObject | null;
+};
+type SubscriptionRecord = Subscription & {
+    count: number;
+};
+type ClientMessage = {
+    type?: string;
+    id?: string;
+    api?: SDK.ServerAPI.API;
+    body?: Common.PlainObject | null;
+};
+export declare class Socket {
+    protected options: SocketOptions;
+    protected server?: WebSocketServer;
+    protected clients: Set<WebSocket>;
+    protected loader: SocketAPILoader;
+    protected map: Map<string, SubscriptionRecord>;
+    protected clientSubscriptions: Map<WebSocket, Set<string>>;
+    constructor(options: SocketOptions);
+    bootstrap(): void;
+    attachClient(client: WebSocket): void;
+    handleClientMessage(raw: string, client?: WebSocket): Promise<void>;
+    protected handleAPIRequestMessage(message: ClientMessage, client?: WebSocket): Promise<void>;
+    getSubscriptions(): Subscription[];
+    protected saveRequestToMap<T extends SDK.ServerAPI.API>(api: T, body?: SDK.ServerAPI.InferRequestBodyType<T, null> | null, client?: WebSocket): void;
+    protected removeRequestFromMap<T extends SDK.ServerAPI.API>(api: T, body?: SDK.ServerAPI.InferRequestBodyType<T, null> | null, client?: WebSocket): void;
+    protected removeClientSubscriptions(client: WebSocket): void;
+    protected removeSubscriptionKey(key: string): void;
+    protected getSubscriptionKey(api: SDK.ServerAPI.API, body: Common.PlainObject | null): string;
+    protected getAPIResponse<T extends SDK.ServerAPI.API>(api: T, body: SDK.ServerAPI.InferRequestBodyType<T>): Promise<SDK.ServerAPI.SocketResponseType<SDK.ServerAPI.API>>;
+    protected timer: NodeJS.Immediate | undefined;
+    broadcast(): Promise<void>;
+    sendAPIData<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, payload: SDK.ServerAPI.SocketResponseType<T>): void;
+    dispose(): void;
+}
+export {};

package/dist/sdk/server/socket/index.js

@@ -0,0 +1,166 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import ws, { WebSocketServer } from "ws";
+import { SocketAPILoader } from "./api.js";
+import { isAllowedRequestHost } from "../security.js";
+function isAllowedSocketToken(url, token) {
+    if (!url) return false;
+    return new URL(url, 'http://localhost').searchParams.get('token') === token;
+}
+class Socket {
+    bootstrap() {
+        this.server = new WebSocketServer({
+            server: this.options.server,
+            verifyClient: ({ req })=>{
+                const host = req.headers.host || req.headers[':authority'];
+                return isAllowedRequestHost(host) && isAllowedSocketToken(req.url, this.options.token);
+            }
+        });
+        this.server.on('connection', (client)=>{
+            this.attachClient(client);
+        });
+    }
+    attachClient(client) {
+        this.clients.add(client);
+        if ('function' == typeof client.on) {
+            client.on('message', (message)=>{
+                this.handleClientMessage(message.toString(), client);
+            });
+            client.on('close', ()=>{
+                this.clients.delete(client);
+                this.removeClientSubscriptions(client);
+            });
+        }
+    }
+    async handleClientMessage(raw, client) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        } catch  {
+            return;
+        }
+        if (!message.api || !Object.values(SDK.ServerAPI.API).includes(message.api)) return;
+        if ('request' === message.type) return void await this.handleAPIRequestMessage(message, client);
+        if ('subscribe' === message.type) return void this.saveRequestToMap(message.api, message.body ?? null, client);
+        if ('unsubscribe' === message.type) this.removeRequestFromMap(message.api, message.body ?? null, client);
+    }
+    async handleAPIRequestMessage(message, client) {
+        if (!message.id || !client || client.readyState !== ws.OPEN) return;
+        try {
+            const response = await this.getAPIResponse(message.api, message.body);
+            client.send(JSON.stringify({
+                type: 'response',
+                id: message.id,
+                payload: response.res
+            }));
+        } catch (err) {
+            client.send(JSON.stringify({
+                type: 'response',
+                id: message.id,
+                error: err instanceof Error ? err.message : String(err)
+            }));
+        }
+    }
+    getSubscriptions() {
+        return [
+            ...this.map.values()
+        ].map(({ api, body })=>({
+                api,
+                body
+            }));
+    }
+    saveRequestToMap(api, body = null, client) {
+        const key = this.getSubscriptionKey(api, body);
+        if (client) {
+            if (!this.clientSubscriptions.has(client)) this.clientSubscriptions.set(client, new Set());
+            const subscriptions = this.clientSubscriptions.get(client);
+            if (subscriptions.has(key)) return;
+            subscriptions.add(key);
+        }
+        const record = this.map.get(key);
+        if (record) {
+            record.count += 1;
+            return;
+        }
+        this.map.set(key, {
+            api,
+            body,
+            count: 1
+        });
+    }
+    removeRequestFromMap(api, body = null, client) {
+        const key = this.getSubscriptionKey(api, body);
+        if (client) {
+            const subscriptions = this.clientSubscriptions.get(client);
+            if (!subscriptions?.has(key)) return;
+            subscriptions.delete(key);
+            if (0 === subscriptions.size) this.clientSubscriptions.delete(client);
+        }
+        this.removeSubscriptionKey(key);
+    }
+    removeClientSubscriptions(client) {
+        const subscriptions = this.clientSubscriptions.get(client);
+        if (!subscriptions) return;
+        subscriptions.forEach((key)=>this.removeSubscriptionKey(key));
+        this.clientSubscriptions.delete(client);
+    }
+    removeSubscriptionKey(key) {
+        const record = this.map.get(key);
+        if (!record) return;
+        record.count -= 1;
+        if (record.count <= 0) this.map.delete(key);
+    }
+    getSubscriptionKey(api, body) {
+        return `${api}:${JSON.stringify(body ?? null)}`;
+    }
+    async getAPIResponse(api, body) {
+        const data = await this.loader.loadAPIData(api, body);
+        const response = {
+            req: {
+                api,
+                body
+            },
+            res: data
+        };
+        return response;
+    }
+    async broadcast() {
+        clearImmediate(this.timer);
+        this.timer = setImmediate(async ()=>{
+            const promises = [];
+            this.map.forEach(({ api, body })=>{
+                promises.push((async ()=>{
+                    const res = await this.getAPIResponse(api, body);
+                    this.sendAPIData(api, res);
+                })());
+            });
+            await Promise.all(promises);
+        });
+    }
+    sendAPIData(api, payload) {
+        const message = JSON.stringify({
+            api,
+            payload
+        });
+        this.clients.forEach((client)=>{
+            if (client.readyState === ws.OPEN) client.send(message);
+        });
+    }
+    dispose() {
+        this.clients.forEach((client)=>{
+            client.close();
+        });
+        this.clients.clear();
+        this.server?.close();
+    }
+    constructor(options){
+        this.options = options;
+        this.clients = new Set();
+        this.map = new Map();
+        this.clientSubscriptions = new Map();
+        this.loader = new SocketAPILoader({
+            sdk: options.sdk
+        });
+    }
+}
+export { Socket };

package/dist/sdk/server/utils.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+export declare function getDataByPagination<T>(data: T[], pagination: SDK.ServerAPI.PaginationRequest): {
+    data: T[];
+    pagination: SDK.ServerAPI.PaginationResponse;
+};
+export declare function getLocalIpAddress(): string;

package/dist/sdk/server/utils.js

@@ -0,0 +1,19 @@
+import "node:module";
+import os from "os";
+function getDataByPagination(data, pagination) {
+    const { page = 1, pageSize = 1000 } = pagination;
+    return {
+        data: data.slice((page - 1) * pageSize, page * pageSize),
+        pagination: {
+            page,
+            pageSize,
+            hasNextPage: page <= 0 ? false : page * pageSize < data.length
+        }
+    };
+}
+function getLocalIpAddress() {
+    const interfaces = os.networkInterfaces();
+    for (const iface of Object.values(interfaces))for (const alias of iface)if ('IPv4' === alias.family && !alias.internal) return alias.address;
+    return '127.0.0.1';
+}
+export { getDataByPagination, getLocalIpAddress };

package/dist/sdk/utils/base.d.ts

@@ -0,0 +1 @@
+export declare function findRoot(startDir?: string): string | null;

package/dist/sdk/utils/base.js

@@ -0,0 +1,22 @@
+import "node:module";
+import path from "path";
+import fs from "fs";
+function findRoot(startDir = process.cwd()) {
+    let dir = startDir;
+    let firstPkgDir = null;
+    while(dir !== path.parse(dir).root){
+        if (fs.existsSync(path.join(dir, 'pnpm-workspace.yaml'))) return dir;
+        if (fs.existsSync(path.join(dir, 'yarn.lock'))) return dir;
+        if (fs.existsSync(path.join(dir, 'lerna.json'))) return dir;
+        const pkgPath = path.join(dir, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            if (!firstPkgDir) firstPkgDir = dir;
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            if (pkg.workspaces) return dir;
+        }
+        dir = path.dirname(dir);
+    }
+    if (firstPkgDir) return firstPkgDir;
+    return null;
+}
+export { findRoot };

package/dist/sdk/utils/constant.d.ts

@@ -0,0 +1 @@
+export declare const CLOUD_DIR: string;

package/dist/sdk/utils/constant.js

@@ -0,0 +1,4 @@
+import "node:module";
+import dayjs from "dayjs";
+const CLOUD_DIR = `rsdoctor/manifests/${dayjs().format('YYYYMMDD')}`;
+export { CLOUD_DIR };

package/dist/sdk/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constant.js';
+export * from './base.js';
+export * from './upload.js';

package/dist/sdk/utils/index.js

@@ -0,0 +1,4 @@
+import "node:module";
+export * from "./constant.js";
+export * from "./base.js";
+export * from "./upload.js";

package/dist/sdk/utils/openBrowser.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Reads the BROWSER environment variable and decides what to do with it.
+ */
+export declare function openBrowser(url: string, needEncodeURI?: boolean): Promise<boolean | undefined>;

package/dist/sdk/utils/openBrowser.js

@@ -0,0 +1,53 @@
+import "node:module";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { logger } from "../../logger.js";
+import { join } from "node:path";
+const execAsync = promisify(exec);
+const supportedChromiumBrowsers = [
+    'Google Chrome Canary',
+    'Google Chrome Dev',
+    'Google Chrome Beta',
+    'Google Chrome',
+    'Microsoft Edge',
+    'Brave Browser',
+    'Vivaldi',
+    'Chromium'
+];
+const getTargetBrowser = async ()=>{
+    let targetBrowser = process.env.BROWSER;
+    if (!targetBrowser || !supportedChromiumBrowsers.includes(targetBrowser)) {
+        const { stdout: ps } = await execAsync('ps cax');
+        targetBrowser = supportedChromiumBrowsers.find((b)=>ps.includes(b));
+    }
+    return targetBrowser;
+};
+const openWithDefaultBrowser = async (url)=>{
+    try {
+        const { default: open } = await import("open");
+        await open(url);
+        return true;
+    } catch (err) {
+        logger.error('Failed to open Rsdoctor URL.');
+        logger.error(err);
+        return false;
+    }
+};
+async function openBrowser(url, needEncodeURI = true) {
+    const shouldTryOpenChromeWithAppleScript = 'darwin' === process.platform;
+    if (shouldTryOpenChromeWithAppleScript) try {
+        const targetBrowser = await getTargetBrowser();
+        if (targetBrowser) {
+            await execAsync(`osascript openChrome.applescript "${needEncodeURI ? encodeURI(url) : url}" "${targetBrowser}"`, {
+                cwd: join(__dirname, '../static')
+            });
+            return true;
+        }
+        logger.debug('Failed to find the target browser.');
+    } catch (err) {
+        logger.debug("Failed to open Rsdoctor URL with apple script.");
+        logger.debug(err);
+    }
+    return openWithDefaultBrowser(url);
+}
+export { openBrowser };

package/dist/sdk/utils/upload.d.ts

@@ -0,0 +1,2 @@
+import { DataWithUrl } from '../sdk/types.js';
+export declare const transformDataUrls: (d: DataWithUrl[]) => Record<string, string[] | string>;

package/dist/sdk/utils/upload.js

@@ -0,0 +1,6 @@
+import "node:module";
+const transformDataUrls = (d)=>d.reduce((t, item)=>{
+        t[item.name] = Array.isArray(item.files) ? item.files.map((e)=>e.path).concat(t[item.name] || []) : item.files;
+        return t;
+    }, {});
+export { transformDataUrls };

package/dist/sdk.d.ts

@@ -0,0 +1 @@
+export * from './sdk/index.js';

package/dist/sdk.js

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "./sdk/index.js";

package/dist/types/index.d.ts

@@ -1,4 +1,3 @@
-export * from './chunks.js';
 export * from './rules.js';
 export * from './loader.js';
 export * from './plugin.js';

package/dist/types/index.js

@@ -1,5 +1,4 @@
 import "node:module";
-export * from "./chunks.js";
 export * from "./rules.js";
 export * from "./loader.js";
 export * from "./plugin.js";

package/dist/types/loader.d.ts

@@ -1,4 +1,4 @@
-import { Loader } from '@rsdoctor/utils/common';
+import { Loader } from '../common/index.js';
 export interface ProxyLoaderInternalOptions {
     cwd: string;
     /**

package/dist/types/plugin.d.ts

@@ -1,6 +1,7 @@
-import type { RsdoctorPrimarySDK } from '@rsdoctor/sdk';
-import type { Linter, Linter as LinterType, Plugin, SDK } from '@rsdoctor/types';
-export interface RsdoctorMultiplePluginOptions<Rules extends LinterType.ExtendRuleData[] = LinterType.ExtendRuleData[]> extends Omit<Plugin.RsdoctorWebpackPluginOptions<Rules>, 'sdkInstance'>, Pick<ConstructorParameters<typeof RsdoctorPrimarySDK>[0], 'stage'> {
+import type { Linter, Linter as LinterType, Plugin, SDK } from '@rsdoctor/shared/types';
+export interface RsdoctorMultiplePluginOptions<Rules extends LinterType.ExtendRuleData[] = LinterType.ExtendRuleData[]> extends Omit<Plugin.RsdoctorRspackPluginOptions<Rules>, 'sdkInstance'>, Pick<{
+    stage?: number;
+}, 'stage'> {
     /**
      * name of builder
      */
@@ -24,28 +25,6 @@ export interface RsdoctorPluginInstance<T extends Plugin.BaseCompiler, Rules ext
     modulesGraph: SDK.ModuleGraphInstance;
     ensureModulesChunksGraphApplied(compiler: T): void;
 }
-export interface RsdoctorRspackPluginInstance<Rules extends LinterType.ExtendRuleData[] = []> extends RsdoctorPluginInstance<Plugin.BaseCompilerType<'rspack'>, Rules> {
-}
-export interface NativePluginConfig {
-    moduleGraph?: boolean;
-    chunkGraph?: boolean;
-}
-export interface RsdoctorRspackPluginExperiments {
-    /**
-     * Whether to enable the native plugin to improve the performance.
-     * @default true
-     */
-    enableNativePlugin?: boolean;
-}
-export interface RsdoctorRspackPluginExperimentsNormalized {
-    enableNativePlugin?: NativePluginConfig;
-}
-export interface RsdoctorRspackPluginOptions<Rules extends LinterType.ExtendRuleData[]> extends Plugin.RsdoctorWebpackPluginOptions<Rules> {
-    /**
-     * The experiments of the Rsdoctor Rspack plugin.
-     */
-    experiments?: RsdoctorRspackPluginExperiments;
-}
-export type RsdoctorRspackPluginOptionsNormalized<Rules extends Linter.ExtendRuleData[]> = Plugin.RsdoctorPluginOptionsNormalized<Rules> & {
-    experiments?: RsdoctorRspackPluginExperimentsNormalized;
-};
+export type RsdoctorRspackPluginInstance<Rules extends LinterType.ExtendRuleData[] = []> = RsdoctorPluginInstance<Plugin.BaseCompilerType<'rspack'>, Rules>;
+export type RsdoctorRspackPluginOptions<Rules extends LinterType.ExtendRuleData[]> = Plugin.RsdoctorRspackPluginOptions<Rules>;
+export type RsdoctorRspackPluginOptionsNormalized<Rules extends Linter.ExtendRuleData[]> = Plugin.RsdoctorPluginOptionsNormalized<Rules>;

package/dist/types/rules.d.ts

@@ -1,7 +1,7 @@
-import { RuleSetRule } from 'webpack';
-export interface Rule extends RuleSetRule {
+import type { RuleSetRule } from '@rspack/core';
+export type Rule = RuleSetRule & {
     /**
-     * https://webpack.js.org/configuration/module/#ruleloaders
+     * The legacy `loaders` field used by rule normalizers.
      */
     loaders: RuleSetRule['use'];
-}
+};