@rsdoctor/core 2.0.0-alpha.1 → 2.0.0-alpha.2

package/dist/rspack-plugin/plugin.js

@@ -1,133 +0,0 @@
-import "node:module";
-import { Loader } from "../build-utils/index.js";
-import { InternalBundlePlugin, InternalErrorReporterPlugin, InternalLoaderPlugin, InternalPluginsPlugin, InternalResolverPlugin, InternalRulesPlugin, InternalSummaryPlugin, ensureModulesChunksGraphFn, handleBriefModeReport, normalizeRspackUserOptions, processCompilerConfig, setSDK } from "../inner-plugins/index.js";
-import { RsdoctorSDK, findRoot } from "../sdk.js";
-import { Constants, Manifest, SDK } from "@rsdoctor/shared/types";
-import path from "path";
-import { pkg, pluginTapName, pluginTapPostOptions } from "./constants.js";
-import { ModuleGraph } from "../graph/index.js";
-import { Loader as index_js_Loader } from "../common/index.js";
-import { logger, time, timeEnd } from "../logger.js";
-import { getRspackNativePlugin } from "../inner-plugins/plugins/rspack.js";
-let hasGreeted = false;
-class RsdoctorRspackPlugin {
-    apply(compiler) {
-        time('RsdoctorRspackPlugin.apply');
-        try {
-            if (!hasGreeted && !compiler.isChild()) {
-                hasGreeted = true;
-                logger.greet(`
-        \nRsdoctor v${pkg.version}\n`);
-            }
-            if (!this._bootstrapTask) this._bootstrapTask = this.sdk.bootstrap();
-            if (compiler.options.name) this.sdk.setName(compiler.options.name);
-            setSDK(this.sdk);
-            compiler.hooks.afterPlugins.tap(pluginTapPostOptions, this.afterPlugins.bind(this, compiler));
-            compiler.hooks.done.tapPromise({
-                ...pluginTapPostOptions,
-                stage: pluginTapPostOptions.stage + 100
-            }, this.done.bind(this, compiler));
-            new InternalSummaryPlugin(this).apply(compiler);
-            if (this.options.features.loader) {
-                new Loader.ProbeLoaderPlugin().apply(compiler);
-                this.sdk.addClientRoutes([
-                    Manifest.RsdoctorManifestClientRoutes.Loaders
-                ]);
-                if (!index_js_Loader.isVue(compiler)) new InternalLoaderPlugin(this).apply(compiler);
-            }
-            if (this.options.features.plugins) new InternalPluginsPlugin(this).apply(compiler);
-            if (this.options.features.bundle) new InternalBundlePlugin(this).apply(compiler);
-            if (this.options.features.resolver) new InternalResolverPlugin(this).apply(compiler);
-            new InternalRulesPlugin(this).apply(compiler);
-            new InternalErrorReporterPlugin(this).apply(compiler);
-            const RsdoctorRspackNativePlugin = getRspackNativePlugin(compiler);
-            logger.debug('[RspackNativePlugin] Enabled');
-            new RsdoctorRspackNativePlugin({
-                moduleGraphFeatures: true,
-                chunkGraphFeatures: true,
-                sourceMapFeatures: {
-                    cheap: false,
-                    module: false
-                }
-            }).apply(compiler);
-        } finally{
-            timeEnd('RsdoctorRspackPlugin.apply');
-        }
-    }
-    ensureModulesChunksGraphApplied(compiler) {
-        ensureModulesChunksGraphFn(compiler, this);
-    }
-    getRspackConfig(compiler) {
-        time('RsdoctorRspackPlugin.getRspackConfig');
-        try {
-            if (compiler.isChild()) return;
-            const configuration = processCompilerConfig(compiler.options);
-            const rspackVersion = compiler.webpack?.rspackVersion || compiler.webpack?.version;
-            this.sdk.reportConfiguration({
-                name: 'rspack',
-                version: rspackVersion || 'unknown',
-                config: configuration,
-                root: findRoot() || ''
-            });
-        } finally{
-            timeEnd('RsdoctorRspackPlugin.getRspackConfig');
-        }
-    }
-    constructor(options){
-        this.name = pluginTapName;
-        this.browserIsOpened = false;
-        this.afterPlugins = (compiler)=>{
-            time('RsdoctorRspackPlugin.afterPlugins');
-            try {
-                this.getRspackConfig(compiler);
-            } finally{
-                timeEnd('RsdoctorRspackPlugin.afterPlugins');
-            }
-        };
-        this.done = async (compiler)=>{
-            time('RsdoctorRspackPlugin.done');
-            try {
-                logger.debug('[RsdoctorRspackPlugin] bootstrap(start) in done()');
-                await this.sdk.bootstrap();
-                logger.debug('[RsdoctorRspackPlugin] bootstrap(end) in done()');
-                this.sdk.addClientRoutes([
-                    Manifest.RsdoctorManifestClientRoutes.Overall
-                ]);
-                if (this.outsideInstance && 'parent' in this.sdk) this.sdk.parent.master.setOutputDir(path.resolve(this.options.output.reportDir || compiler.outputPath, this.options.output.mode === SDK.IMode[SDK.IMode.brief] ? '' : `./${Constants.RsdoctorOutputFolder}`));
-                this.sdk.setOutputDir(path.resolve(this.options.output.reportDir || compiler.outputPath, this.options.output.mode === SDK.IMode[SDK.IMode.brief] ? '' : `./${Constants.RsdoctorOutputFolder}`));
-                await this.sdk.writeStore();
-                if (!this.options.disableClientServer) if (this.options.output.mode === SDK.IMode[SDK.IMode.brief]) await handleBriefModeReport(this.sdk, this.options, this.options.disableClientServer);
-                else await this.sdk.server.openClientPage('homepage');
-                if (this.options.disableClientServer || this.options.output.mode === SDK.IMode[SDK.IMode.brief] && Array.isArray(this.options.output.options?.type) && 1 === this.options.output.options.type.length && 'json' === this.options.output.options.type[0]) await this.sdk.dispose();
-            } finally{
-                timeEnd('RsdoctorRspackPlugin.done');
-            }
-        };
-        this.options = normalizeRspackUserOptions(Object.assign(options || {}, {
-            supports: {
-                ...options?.supports
-            }
-        }));
-        const { port, server, output, innerClientPath, printLog, sdkInstance } = this.options;
-        this.sdk = this.options.sdkInstance ?? new RsdoctorSDK({
-            port,
-            name: pluginTapName,
-            root: process.cwd(),
-            type: output.reportCodeType,
-            config: {
-                innerClientPath,
-                printLog,
-                server,
-                mode: output.mode ? output.mode : void 0,
-                brief: output.mode === SDK.IMode[SDK.IMode.brief] ? output.options || void 0 : void 0,
-                features: {
-                    treeShaking: this.options.features.treeShaking
-                }
-            }
-        });
-        this.outsideInstance = Boolean(sdkInstance);
-        this.modulesGraph = new ModuleGraph();
-        this.isRsdoctorPlugin = true;
-    }
-}
-export { RsdoctorRspackPlugin };

package/dist/rule-utils/document/document.js

@@ -1,46 +0,0 @@
-import "node:module";
-import { Lodash } from "../../common/index.js";
-import { LinesAndColumns } from "lines-and-columns";
-class Document {
-    createFinder() {
-        const find = new LinesAndColumns(this._text);
-        this.positionAt = (offset)=>{
-            if (offset >= this._text.length) offset = this._text.length - 1;
-            if (offset < 0) offset = 0;
-            const result = find.locationForIndex(offset);
-            if (!result) return;
-            return {
-                line: result.line + 1,
-                column: result.column
-            };
-        };
-        this.offsetAt = (position)=>find.indexForLocation({
-                line: position.line - 1,
-                column: position.column
-            }) ?? void 0;
-    }
-    getText(range) {
-        if (!range) return this._text;
-        const start = 'number' == typeof range.start ? range.start : this.offsetAt(range.start);
-        const end = 'number' == typeof range.end ? range.end : this.offsetAt(range.end);
-        if (Lodash.isUndefined(start)) throw new Error(`Location ${JSON.stringify(start)} is illegal`);
-        if (Lodash.isUndefined(end)) throw new Error(`Location ${JSON.stringify(end)} is illegal`);
-        return this._text.slice(start, end);
-    }
-    edit(data) {
-        let { _text: content } = this;
-        const startOffset = Lodash.isNumber(data.start) ? data.start : this.offsetAt(data.start);
-        const endOffset = Lodash.isNumber(data.end) ? data.end : this.offsetAt(data.end);
-        if (Lodash.isUndefined(startOffset) || Lodash.isUndefined(endOffset)) return;
-        const startTxt = content.substring(0, startOffset);
-        const endTxt = content.substring(endOffset, content.length);
-        content = startTxt + data.newText + endTxt;
-        return content;
-    }
-    constructor(content){
-        this._text = '';
-        this._text = content;
-        this.createFinder();
-    }
-}
-export { Document };

package/dist/rule-utils/document/index.js

@@ -1,4 +0,0 @@
-import "node:module";
-export * from "./document.js";
-export * from "./types.js";
-export * from "./server.js";

package/dist/rule-utils/document/server.js

@@ -1,13 +0,0 @@
-import "node:module";
-import { Document } from "./document.js";
-const store = new Map();
-function getDocument(content) {
-    if (store.has(content)) return store.get(content);
-    const doc = new Document(content);
-    store.set(content, doc);
-    return doc;
-}
-function clearDocument() {
-    store.clear();
-}
-export { clearDocument, getDocument };

package/dist/rule-utils/document/types.js

@@ -1 +0,0 @@
-import "node:module";

package/dist/rule-utils/index.js

@@ -1,3 +0,0 @@
-import "node:module";
-export * from "./document/index.js";
-export * from "./parser/index.js";

package/dist/rule-utils/parser/asserts.js

@@ -1,105 +0,0 @@
-import "node:module";
-import { Lodash } from "../../common/index.js";
-function isSyntaxNode(node) {
-    return Lodash.isObject(node) && 'type' in node;
-}
-function assertCreator(type) {
-    return (node)=>isSyntaxNode(node) && node.type === type;
-}
-const asserts = {
-    isProgram: assertCreator('Program'),
-    isEmptyStatement: assertCreator('EmptyStatement'),
-    isBlockStatement: assertCreator('BlockStatement'),
-    isStaticBlock: assertCreator('StaticBlock'),
-    isExpressionStatement: assertCreator('ExpressionStatement'),
-    isIfStatement: assertCreator('IfStatement'),
-    isLabeledStatement: assertCreator('LabeledStatement'),
-    isBreakStatement: assertCreator('BreakStatement'),
-    isContinueStatement: assertCreator('ContinueStatement'),
-    isWithStatement: assertCreator('WithStatement'),
-    isSwitchStatement: assertCreator('SwitchStatement'),
-    isReturnStatement: assertCreator('ReturnStatement'),
-    isThrowStatement: assertCreator('ThrowStatement'),
-    isTryStatement: assertCreator('TryStatement'),
-    isWhileStatement: assertCreator('WhileStatement'),
-    isDoWhileStatement: assertCreator('DoWhileStatement'),
-    isForStatement: assertCreator('ForStatement'),
-    isForInStatement: assertCreator('ForInStatement'),
-    isForOfStatement: assertCreator('ForOfStatement'),
-    isDebuggerStatement: assertCreator('DebuggerStatement'),
-    isFunctionDeclaration: assertCreator('FunctionDeclaration'),
-    isVariableDeclaration: assertCreator('VariableDeclaration'),
-    isVariableDeclarator: assertCreator('VariableDeclarator'),
-    isChainExpression: assertCreator('ChainExpression'),
-    isThisExpression: assertCreator('ThisExpression'),
-    isArrayExpression: assertCreator('ArrayExpression'),
-    isObjectExpression: assertCreator('ObjectExpression'),
-    isPrivateIdentifier: assertCreator('PrivateIdentifier'),
-    isProperty: assertCreator('Property'),
-    isPropertyDefinition: assertCreator('PropertyDefinition'),
-    isFunctionExpression: assertCreator('FunctionExpression'),
-    isSequenceExpression: assertCreator('SequenceExpression'),
-    isUnaryExpression: assertCreator('UnaryExpression'),
-    isBinaryExpression: assertCreator('BinaryExpression'),
-    isAssignmentExpression: assertCreator('AssignmentExpression'),
-    isUpdateExpression: assertCreator('UpdateExpression'),
-    isLogicalExpression: assertCreator('LogicalExpression'),
-    isConditionalExpression: assertCreator('ConditionalExpression'),
-    isNewExpression: assertCreator('NewExpression'),
-    isSwitchCase: assertCreator('SwitchCase'),
-    isCatchClause: assertCreator('CatchClause'),
-    isIdentifier: assertCreator('Identifier'),
-    isLiteral: assertCreator('Literal'),
-    isSuper: assertCreator('Super'),
-    isSpreadElement: assertCreator('SpreadElement'),
-    isArrowFunctionExpression: assertCreator('ArrowFunctionExpression'),
-    isYieldExpression: assertCreator('YieldExpression'),
-    isTemplateLiteral: assertCreator('TemplateLiteral'),
-    isTaggedTemplateExpression: assertCreator('TaggedTemplateExpression'),
-    isTemplateElement: assertCreator('TemplateElement'),
-    isObjectPattern: assertCreator('ObjectPattern'),
-    isArrayPattern: assertCreator('ArrayPattern'),
-    isRestElement: assertCreator('RestElement'),
-    isAssignmentPattern: assertCreator('AssignmentPattern'),
-    isClassBody: assertCreator('ClassBody'),
-    isClassDeclaration: assertCreator('ClassDeclaration'),
-    isClassExpression: assertCreator('ClassExpression'),
-    isMetaProperty: assertCreator('MetaProperty'),
-    isImportDeclaration: assertCreator('ImportDeclaration'),
-    isImportSpecifier: assertCreator('ImportSpecifier'),
-    isImportExpression: assertCreator('ImportExpression'),
-    isImportDefaultSpecifier: assertCreator('ImportDefaultSpecifier'),
-    isImportNamespaceSpecifier: assertCreator('ImportNamespaceSpecifier'),
-    isExportNamedDeclaration: assertCreator('ExportNamedDeclaration'),
-    isExportSpecifier: assertCreator('ExportSpecifier'),
-    isExportDefaultDeclaration: assertCreator('ExportDefaultDeclaration'),
-    isExportAllDeclaration: assertCreator('ExportAllDeclaration'),
-    isAwaitExpression: assertCreator('AwaitExpression'),
-    isMethodDefinition: assertCreator('MethodDefinition'),
-    isMemberExpression: assertCreator('MemberExpression'),
-    isComment (node) {
-        return isSyntaxNode(node) && ('Line' === node.type || 'Block' === node.type);
-    },
-    isDirective (node) {
-        return asserts.isExpressionStatement(node) && 'directive' in node;
-    },
-    isSimpleCallExpression (node) {
-        return isSyntaxNode(node) && 'CallExpression' === node.type;
-    },
-    isAssignmentProperty (node) {
-        return asserts.isProperty(node) && 'init' === node.kind;
-    },
-    isSimpleLiteral (node) {
-        return asserts.isLiteral(node) && !asserts.isRegExpLiteral(node) && !asserts.isBigIntLiteral(node);
-    },
-    isRegExpLiteral (node) {
-        return asserts.isLiteral(node) && 'regex' in node;
-    },
-    isBigIntLiteral (node) {
-        return asserts.isLiteral(node) && 'bigint' in node;
-    },
-    isExportStatement (node) {
-        return asserts.isExportAllDeclaration(node) || asserts.isExportDefaultDeclaration(node) || asserts.isExportNamedDeclaration(node);
-    }
-};
-export { asserts };

package/dist/rule-utils/parser/index.js

@@ -1,5 +0,0 @@
-import "node:module";
-export * from "./asserts.js";
-export * from "./parser.js";
-export * from "./utils.js";
-export * from "./types.js";

package/dist/rule-utils/parser/parser.js

@@ -1,24 +0,0 @@
-import "node:module";
-import { Parser } from "acorn";
-import { importAttributes } from "acorn-import-attributes";
-import * as __rspack_external_acorn_walk_1e4235a7 from "acorn-walk";
-import { asserts } from "./asserts.js";
-import * as __rspack_external__utils_js_a9c81ddd from "./utils.js";
-const acornParserInternal = Parser.extend(importAttributes);
-let acornParserExport = Parser.extend(importAttributes);
-const parser = {
-    walk: __rspack_external_acorn_walk_1e4235a7,
-    parse: (input, options)=>acornParserExport.parse(input, options),
-    parseExpressionAt: (input, pos, options)=>acornParserExport.parseExpressionAt(input, pos, options),
-    extend (...args) {
-        acornParserExport = acornParserExport.extend(...args);
-        return acornParserExport;
-    },
-    asserts: asserts,
-    utils: __rspack_external__utils_js_a9c81ddd,
-    internal: {
-        parse: (input, options)=>acornParserInternal.parse(input, options),
-        parseExpressionAt: (input, pos, options)=>acornParserInternal.parseExpressionAt(input, pos, options)
-    }
-};
-export { parser };

package/dist/rule-utils/parser/types.js

@@ -1,8 +0,0 @@
-import "node:module";
-var types_ECMAVersion = /*#__PURE__*/ function(ECMAVersion) {
-    ECMAVersion["ES5"] = "ES5";
-    ECMAVersion["ES6"] = "ES6";
-    ECMAVersion["ES7P"] = "ES7+";
-    return ECMAVersion;
-}({});
-export { types_ECMAVersion as ECMAVersion };

package/dist/rule-utils/parser/utils.js

@@ -1,106 +0,0 @@
-import "node:module";
-import { parse } from "acorn";
-import { ECMAVersion } from "./types.js";
-import { asserts } from "./asserts.js";
-function isSameSemantics(node1, node2) {
-    if (node1.type !== node2.type) return false;
-    switch(node1.type){
-        case 'CallExpression':
-            {
-                const next = node2;
-                return node1.arguments.length === next.arguments.length && Boolean(node1.optional) === Boolean(next.optional) && isSameSemantics(node1.callee, next.callee) && node1.arguments.every((node, i)=>isSameSemantics(node, next.arguments[i]));
-            }
-        case 'MemberExpression':
-            {
-                const next = node2;
-                return node1.computed === next.computed && Boolean(node1.optional) === Boolean(next.optional) && isSameSemantics(node1.object, next.object) && isSameSemantics(node1.property, next.property);
-            }
-        case 'Identifier':
-            return node1.name === node2.name;
-        case 'Literal':
-            if (asserts.isSimpleLiteral(node1) && asserts.isSimpleLiteral(node2)) return node1.value === node2.value;
-            return node1.raw === node2.raw;
-        case 'ObjectExpression':
-            {
-                const next = node2;
-                return node1.properties.length === next.properties.length && node1.properties.every((prop, i)=>isSameSemantics(prop, next.properties[i]));
-            }
-        case 'Property':
-            {
-                const next = node2;
-                return node1.computed === next.computed && node1.kind === next.kind && node1.method === next.method && isSameSemantics(node1.key, next.key) && isSameSemantics(node1.value, next.value);
-            }
-        default:
-            throw new Error(`Unknown node type: ${node1.type}`);
-    }
-}
-function getDefaultImports(node) {
-    return node.body.filter((statement)=>{
-        if ('ImportDeclaration' !== statement.type) return false;
-        const specifier = statement?.specifiers?.[0];
-        if (specifier?.type === 'ImportDefaultSpecifier') return true;
-        return false;
-    });
-}
-function getIdentifierInPattern(name, node) {
-    if (asserts.isIdentifier(node) && node.name === name) return node;
-    if (asserts.isObjectPattern(node)) for (const prop of node.properties){
-        if (asserts.isAssignmentProperty(prop)) return getIdentifierInPattern(name, prop.value);
-        if (asserts.isRestElement(prop)) return getIdentifierInPattern(name, prop);
-    }
-    if (asserts.isArrayPattern(node)) {
-        for (const el of node.elements)if (el) {
-            const result = getIdentifierInPattern(name, el);
-            if (result) return result;
-        }
-    }
-    if (asserts.isRestElement(node)) return getIdentifierInPattern(name, node.argument);
-    if (asserts.isAssignmentPattern(node)) return getIdentifierInPattern(name, node.left);
-}
-function getIdentifierInDeclaration(name, node) {
-    function getId(node) {
-        return asserts.isIdentifier(node.id) && node.id.name === name ? node.id : void 0;
-    }
-    if (asserts.isFunctionDeclaration(node)) return getId(node);
-    if (asserts.isClassDeclaration(node)) return getId(node);
-    if (asserts.isVariableDeclaration(node)) return node.declarations.find((item)=>getIdentifierInPattern(name, item.id))?.id;
-}
-function getIdentifierInImport(name, node) {
-    if (asserts.isImportDeclaration(node)) {
-        for (const specifier of node.specifiers ?? [])if (specifier.local.name === name) return specifier.local;
-    }
-}
-function getIdentifierInExport(name, node) {
-    if (asserts.isExportNamedDeclaration(node)) {
-        if (node.declaration) return getIdentifierInDeclaration(name, node.declaration);
-        for (const specifier of node.specifiers ?? [])if (specifier.exported.name === name) return specifier.exported;
-    }
-    if (asserts.isExportAllDeclaration(node) && node.exported) {
-        if (node.exported.name === name) return node.exported;
-    }
-}
-function canParse(code, ecmaVersion) {
-    try {
-        parse(code, {
-            ecmaVersion,
-            sourceType: 'number' == typeof ecmaVersion && ecmaVersion <= 5 ? "script" : 'module'
-        });
-        return true;
-    } catch  {
-        return false;
-    }
-}
-function isES5(code) {
-    return canParse(code, 5);
-}
-function isES6(code) {
-    return canParse(code, 6);
-}
-function detectECMAVersion(code) {
-    if (isES6(code)) {
-        if (isES5(code)) return ECMAVersion.ES5;
-        return ECMAVersion.ES6;
-    }
-    return ECMAVersion.ES7P;
-}
-export { canParse, detectECMAVersion, getDefaultImports, getIdentifierInDeclaration, getIdentifierInExport, getIdentifierInImport, getIdentifierInPattern, isES5, isES6, isSameSemantics };

package/dist/rules/index.js

@@ -1,4 +0,0 @@
-import "node:module";
-export * from "./linter.js";
-export * from "./rule.js";
-export { rules } from "./rules/index.js";

package/dist/rules/linter.js

@@ -1,36 +0,0 @@
-import "node:module";
-import { Linter } from "@rsdoctor/shared/types";
-import { Rule } from "./rule.js";
-import { rules as index_js_rules } from "./rules/index.js";
-import { toSeverity } from "./utils.js";
-class linter_Linter {
-    getRules(ruleMap, extendRules, filterLevel) {
-        const outside = extendRules.map((item)=>Rule.from(item));
-        const rules = index_js_rules.map((item)=>new Rule(item)).concat(outside);
-        rules.forEach((rule)=>{
-            const config = ruleMap[rule.title];
-            if (null != config) rule.setOption(config);
-        });
-        return rules.filter((rule)=>rule.match(filterLevel));
-    }
-    async validate(context) {
-        const lintResult = {
-            errors: [],
-            replace: []
-        };
-        await Promise.all(this.rules.map(async (rule)=>{
-            const result = await rule.validate(context);
-            lintResult.errors.push(...result.errors);
-            lintResult.replace.push(...result.replace);
-        }));
-        return lintResult;
-    }
-    async afterValidate(context) {
-        await Promise.all(this.rules.map((rule)=>rule.afterValidate(context)));
-    }
-    constructor({ rules, extends: extendRules, level } = {}){
-        this.rules = [];
-        this.rules = this.getRules(rules ?? {}, extendRules ?? [], toSeverity(level ?? 'Error', Linter.Severity.Error));
-    }
-}
-export { Linter as LinterType, linter_Linter as Linter };

package/dist/rules/rule.js

@@ -1,101 +0,0 @@
-import "node:module";
-import { Linter, Rule } from "@rsdoctor/shared/types";
-import { Lodash } from "../common/index.js";
-import { noop, toSeverity } from "./utils.js";
-class rule_Rule {
-    static from(data) {
-        return new rule_Rule({
-            check: data.check,
-            onCheckEnd: data.onCheckEnd,
-            meta: {
-                ...data.meta,
-                code: Rule.RuleMessageCodeEnumerated.Extend,
-                severity: toSeverity(data.meta.severity, Linter.Severity.Warn)
-            }
-        });
-    }
-    get code() {
-        return this.meta.code;
-    }
-    get title() {
-        return this.meta.title;
-    }
-    get severity() {
-        return this._severity;
-    }
-    get config() {
-        return this._config;
-    }
-    get category() {
-        return this.meta.category;
-    }
-    setOption(opt) {
-        let severity;
-        let config;
-        if (Array.isArray(opt)) {
-            severity = toSeverity(opt[0], this.meta.severity);
-            config = opt[1];
-        } else {
-            severity = toSeverity(opt, this.meta.severity);
-            config = void 0;
-        }
-        this._severity = severity;
-        this._config = Lodash.isPlainObject(config) ? {
-            ...this.meta.defaultConfig,
-            ...config
-        } : config || this.meta.defaultConfig;
-    }
-    match(level) {
-        if (level === Linter.Severity.Ignore || this.severity === Linter.Severity.Ignore) return false;
-        if (level === Linter.Severity.Error) return this.severity === Linter.Severity.Error || this.severity === Linter.Severity.Warn;
-        if (level === Linter.Severity.Warn) return this.severity === Linter.Severity.Warn;
-        return false;
-    }
-    async validate(context) {
-        const errors = [];
-        const replace = [];
-        const report = (data, remove)=>{
-            if (remove) replace.push(remove);
-            const severity = data.severity ? toSeverity(data.severity, this.severity) : this.severity;
-            const error = {
-                ...data,
-                code: this.code,
-                severity,
-                category: this.category,
-                title: this.title.toUpperCase()
-            };
-            if (severity !== Linter.Severity.Ignore) errors.push(error);
-        };
-        await this.check({
-            ...context,
-            ruleConfig: this.config,
-            report
-        });
-        return {
-            errors,
-            replace
-        };
-    }
-    async afterValidate({ hooks, validateResult, data }) {
-        if (this.onCheckEnd === noop) return;
-        await this.onCheckEnd({
-            data: {
-                ...data,
-                ruleConfig: this.config
-            },
-            hooks,
-            validateResult
-        });
-    }
-    constructor(data){
-        this.check = data.check;
-        this.meta = data.meta;
-        this.onCheckEnd = 'function' == typeof data.onCheckEnd ? data.onCheckEnd : noop;
-        this._severity = this.meta.severity;
-        this._config = this.meta.defaultConfig;
-    }
-}
-function defineRule(ruleCreator) {
-    return ruleCreator();
-}
-export { defineRule, rule_Rule as Rule };

package/dist/rules/rules/cjs-require/index.js

@@ -1,50 +0,0 @@
-import "node:module";
-import { Linter } from "@rsdoctor/shared/types";
-import { defineRule } from "../../rule.js";
-const title = 'cjs-require';
-const CJS_REQUIRE_TYPE = 'cjs require';
-const NODE_MODULES_PATH_REGEXP = /[/\\]node_modules[/\\]/;
-function isNodeModulesPath(modulePath) {
-    return NODE_MODULES_PATH_REGEXP.test(modulePath);
-}
-const rule = defineRule(()=>({
-        meta: {
-            code: 'E1008',
-            title: title,
-            category: 'bundle',
-            severity: Linter.Severity.Warn,
-            defaultConfig: {
-                ignore: []
-            }
-        },
-        check ({ moduleGraph, report, ruleConfig }) {
-            const dependencies = moduleGraph.getDependencies();
-            for (const dep of dependencies){
-                if (dep.typeString !== CJS_REQUIRE_TYPE) continue;
-                const issuerPath = dep.module.path;
-                if (isNodeModulesPath(issuerPath)) continue;
-                const requiredModule = dep.dependency;
-                if (ruleConfig.ignore.some((pattern)=>issuerPath.includes(pattern) || requiredModule.path.includes(pattern))) continue;
-                const detail = {
-                    type: title,
-                    issuerModule: {
-                        id: dep.module.id,
-                        path: dep.module.path,
-                        identifier: dep.module.identifier
-                    },
-                    requiredModule: {
-                        id: requiredModule.id,
-                        path: requiredModule.path,
-                        identifier: requiredModule.identifier
-                    },
-                    request: dep.request
-                };
-                const message = `"${issuerPath}" uses \`require('${dep.request}')\` (CJS require) which prevents tree-shaking of the entire module "${requiredModule.path}". Consider using \`require('${dep.request}').property\` or ESM \`import\` instead.`;
-                report({
-                    message,
-                    detail
-                });
-            }
-        }
-    }));
-export { rule };

package/dist/rules/rules/cjs-require/types.js

@@ -1 +0,0 @@
-import "node:module";