@rsdoctor/core 2.0.0-alpha.1 → 2.0.0-beta.0

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";

package/dist/rules/rules/cross-chunks-package/index.js

@@ -1,41 +0,0 @@
-import "node:module";
-import { Linter } from "@rsdoctor/shared/types";
-import { defineRule } from "../../rule.js";
-import { getErrorMsgForDupPckChunks } from "./utils.js";
-import { uniq } from "../../../collection.js";
-const title = 'cross-chunks-package';
-const rule = defineRule(()=>({
-        meta: {
-            code: 'E1002',
-            title: title,
-            category: 'bundle',
-            severity: Linter.Severity.Warn,
-            defaultConfig: {
-                ignore: []
-            }
-        },
-        check ({ packageGraph, report }) {
-            const packages = packageGraph.getPackages().filter((pkg)=>(pkg.duplicates?.length ?? 0) > 0);
-            for (const pkg of packages){
-                const duplicates = pkg.duplicates;
-                const detail = {
-                    type: title,
-                    chunks: duplicates,
-                    package: {
-                        name: pkg.name,
-                        id: pkg.id,
-                        size: pkg.getSize(),
-                        version: pkg.version
-                    }
-                };
-                const chunks = [];
-                duplicates.forEach((dup)=>chunks.push(...dup.chunks.map((ck)=>ck.name)));
-                const message = getErrorMsgForDupPckChunks(uniq(chunks), pkg.name);
-                report({
-                    message,
-                    detail
-                });
-            }
-        }
-    }));
-export { rule };

package/dist/rules/rules/cross-chunks-package/types.js

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

package/dist/rules/rules/cross-chunks-package/utils.js

@@ -1,7 +0,0 @@
-import "node:module";
-function getErrorMsgForDupPckChunks(chunks, pkgName) {
-    let message = `The same package ${pkgName} was bundled into different chunks:\n`;
-    for (const chunkName of chunks)message += ` ${chunkName}\n`;
-    return message.slice(0, -1);
-}
-export { getErrorMsgForDupPckChunks };

package/dist/rules/rules/default-import-check/index.js

@@ -1,83 +0,0 @@
-import "node:module";
-import { builtinModules } from "module";
-import { Linter } from "@rsdoctor/shared/types";
-import { getDocument, parser } from "../../../rule-utils/index.js";
-import { getDefaultImportByRequest, getFixData, getSourceRangeFromTransformedOffset, hasSameLeftInAssignStatement } from "./utils.js";
-import { defineRule } from "../../rule.js";
-const title = 'default-import-check';
-const rule = defineRule(()=>{
-    const parserOpt = {
-        ecmaVersion: 6
-    };
-    const exportsDefault = parser.internal.parseExpressionAt('exports.default', 0, parserOpt);
-    const moduleExportsDefault = parser.internal.parseExpressionAt('module.exports.default', 0, parserOpt);
-    return {
-        meta: {
-            code: 'E1005',
-            title: title,
-            category: 'compile',
-            severity: Linter.Severity.Warn,
-            defaultConfig: {
-                ignore: []
-            }
-        },
-        check ({ moduleGraph, report, ruleConfig }) {
-            const dependencyWithNode = moduleGraph.getDependencies().filter((dep)=>'dynamic' === dep.meta.exportsType).filter((dep)=>!dep.module.path.includes('node_modules')).filter((dep)=>!ruleConfig.ignore.includes(dep.request) && !builtinModules.includes(dep.request)).filter((dep)=>dep.dependency.meta.hasSetEsModuleStatement).filter((dep)=>dep.dependency.getProgram()).filter((dep)=>!hasSameLeftInAssignStatement(dep.dependency.getProgram(), [
-                    exportsDefault,
-                    moduleExportsDefault
-                ])).map((dependency)=>{
-                const { module, request } = dependency;
-                const node = module.getProgram() && getDefaultImportByRequest(module.getProgram(), request);
-                return node ? {
-                    dependency,
-                    node
-                } : {};
-            }).filter((dep)=>dep?.dependency);
-            for (const { dependency, node } of dependencyWithNode){
-                if (!dependency) continue;
-                const document = getSourceRangeFromTransformedOffset(dependency.module, node);
-                if (!document) continue;
-                const message = 'Do not to use the default import when you import a cjs module.';
-                const canFix = !document.isTransformed && !document.path.includes('node_modules');
-                if (canFix) {
-                    const fixData = getFixData(dependency.module, node, document.range);
-                    const detail = {
-                        type: 'code-change',
-                        file: {
-                            path: document.path,
-                            actual: document.content,
-                            line: document.range.start.line,
-                            expected: getDocument(document.content).edit(fixData)
-                        }
-                    };
-                    report({
-                        message,
-                        document,
-                        detail,
-                        suggestions: {
-                            description: 'Use namespace import instead.',
-                            fixData
-                        }
-                    });
-                } else {
-                    const detail = {
-                        type: 'code-view',
-                        file: {
-                            path: document.path,
-                            content: document.content,
-                            ranges: [
-                                node.loc
-                            ]
-                        }
-                    };
-                    report({
-                        message,
-                        document,
-                        detail
-                    });
-                }
-            }
-        }
-    };
-});
-export { rule };

package/dist/rules/rules/default-import-check/types.js

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

package/dist/rules/rules/default-import-check/utils.js

@@ -1,52 +0,0 @@
-import "node:module";
-import { getDocument, parser } from "../../../rule-utils/index.js";
-import { Lodash } from "../../../common/index.js";
-function getDefaultImportByRequest(node, request) {
-    return parser.utils.getDefaultImports(node).find((decl)=>decl.source.value === request);
-}
-function hasSameLeftInAssignStatement(node, compare) {
-    return node.body.filter(parser.asserts.isExpressionStatement).map((node)=>node.expression).filter(parser.asserts.isAssignmentExpression).map((node)=>node.left).find((node)=>compare.some((item)=>parser.utils.isSameSemantics(node, item)));
-}
-function importDeclarationToString(node) {
-    const defaultSpecifier = node.specifiers[0];
-    const rawRequest = (node.source.raw ?? '').trim();
-    return `import * as ${defaultSpecifier.local.name} from ${rawRequest}`;
-}
-function getFixData(module, node, originalRange) {
-    const { source, transformed } = module.getSource();
-    const document = getDocument(source);
-    const newImportText = importDeclarationToString(node);
-    const oldText = transformed.substring(node.start, node.end);
-    const hasLastSemi = ';' === oldText[oldText.length - 1];
-    return {
-        start: document.offsetAt(originalRange.start),
-        end: document.offsetAt(originalRange.end),
-        newText: hasLastSemi ? `${newImportText};` : newImportText
-    };
-}
-function getSourceRangeFromTransformedOffset(module, node) {
-    const source = module.getSource();
-    const sourceMap = module.getSourceMap();
-    const transformedStart = node.loc.start;
-    const transformedEnd = node.loc.end;
-    if (!transformedStart || !transformedEnd) return;
-    const transformedReport = {
-        path: module.path,
-        content: source.transformed,
-        isTransformed: true,
-        range: {
-            start: transformedStart,
-            end: transformedEnd
-        }
-    };
-    if (!sourceMap) return transformedReport;
-    const sourceRange = module.getSourceRange(node.loc);
-    if (Lodash.isUndefined(sourceRange?.start.line) || Lodash.isUndefined(sourceRange?.start.column) || Lodash.isUndefined(sourceRange?.end?.line) || Lodash.isUndefined(sourceRange?.end?.column)) return transformedReport;
-    return {
-        path: module.path,
-        isTransformed: false,
-        content: source.source,
-        range: sourceRange
-    };
-}
-export { getDefaultImportByRequest, getFixData, getSourceRangeFromTransformedOffset, hasSameLeftInAssignStatement, importDeclarationToString };

package/dist/rules/rules/duplicate-package/index.js

@@ -1,39 +0,0 @@
-import "node:module";
-import { Linter } from "@rsdoctor/shared/types";
-import { diff, gt } from "semver";
-import { getErrorDetail, getErrorMsg } from "./utils.js";
-import { defineRule } from "../../rule.js";
-import * as __rspack_external__types_js_b06c0ce5 from "./types.js";
-const title = 'duplicate-package';
-const { CheckVersionMap: CheckVersionMap } = __rspack_external__types_js_b06c0ce5;
-const rule = defineRule(()=>({
-        meta: {
-            code: 'E1001',
-            title: title,
-            category: 'bundle',
-            severity: Linter.Severity.Warn,
-            defaultConfig: {
-                checkVersion: 'major',
-                ignore: []
-            }
-        },
-        check ({ packageGraph, report, root, ruleConfig }) {
-            const checkVersion = CheckVersionMap[ruleConfig.checkVersion];
-            const packages = packageGraph.getDuplicatePackages().filter((pkg)=>!ruleConfig.ignore.includes(pkg[0].name)).map((pkgs)=>pkgs.filter((current)=>{
-                    const check = pkgs.reduce((ans, pkg)=>ans | CheckVersionMap[diff(current.version, pkg.version) ?? 'null'], 0);
-                    return check <= checkVersion;
-                }).sort((_packA, _packB)=>gt(_packA.version, _packB.version) ? 1 : -1)).filter((pkgs)=>pkgs.length > 1 && pkgs.filter((pkg)=>pkg.getSize().parsedSize > 0).length > 1);
-            for (const pkg of packages){
-                const message = getErrorMsg(pkg, root);
-                const detail = {
-                    type: 'package-relation',
-                    packages: pkg.map((item)=>getErrorDetail(item, packageGraph))
-                };
-                report({
-                    message,
-                    detail
-                });
-            }
-        }
-    }));
-export { rule };

package/dist/rules/rules/duplicate-package/types.js

@@ -1,24 +0,0 @@
-import "node:module";
-var types_CheckVersion = /*#__PURE__*/ function(CheckVersion) {
-    CheckVersion[CheckVersion["null"] = 0] = "null";
-    CheckVersion[CheckVersion["prerelease"] = 1] = "prerelease";
-    CheckVersion[CheckVersion["prepatch"] = 16] = "prepatch";
-    CheckVersion[CheckVersion["patch"] = 256] = "patch";
-    CheckVersion[CheckVersion["preminor"] = 4096] = "preminor";
-    CheckVersion[CheckVersion["minor"] = 65536] = "minor";
-    CheckVersion[CheckVersion["premajor"] = 1048576] = "premajor";
-    CheckVersion[CheckVersion["major"] = 16777216] = "major";
-    return CheckVersion;
-}({});
-var types_CheckVersionMap = /*#__PURE__*/ function(CheckVersionMap) {
-    CheckVersionMap[CheckVersionMap["null"] = 0] = "null";
-    CheckVersionMap[CheckVersionMap["prerelease"] = 1] = "prerelease";
-    CheckVersionMap[CheckVersionMap["prepatch"] = 17] = "prepatch";
-    CheckVersionMap[CheckVersionMap["patch"] = 273] = "patch";
-    CheckVersionMap[CheckVersionMap["preminor"] = 4369] = "preminor";
-    CheckVersionMap[CheckVersionMap["minor"] = 69905] = "minor";
-    CheckVersionMap[CheckVersionMap["premajor"] = 1118481] = "premajor";
-    CheckVersionMap[CheckVersionMap["major"] = 17895697] = "major";
-    return CheckVersionMap;
-}({});
-export { types_CheckVersion as CheckVersion, types_CheckVersionMap as CheckVersionMap };

package/dist/rules/rules/duplicate-package/utils.js

@@ -1,38 +0,0 @@
-import "node:module";
-import path from "path";
-import { filesize } from "filesize";
-function getErrorMsg(packages, root) {
-    const pkgName = packages[0].name;
-    let message = `Multiple packages of ${pkgName} found:\n`;
-    for (const pkg of packages)message += `  ${pkg.version} ${filesize(pkg.getSize().parsedSize)} ${path.relative(root, pkg.root)}\n`;
-    return message.slice(0, -1);
-}
-function getErrorDetail(pkg, pkgGraph) {
-    function getImported(pkg, ans) {
-        const dependencies = pkgGraph.getDependenciesFromPackage(pkg);
-        for (const dep of dependencies)if (dep.refDependency) {
-            if (!ans.some((dep)=>dep.dependency === pkg)) {
-                if (!dep.package) return ans.concat(dep);
-                return getImported(dep.package, ans.concat(dep));
-            }
-        }
-        return ans;
-    }
-    const packageImportLinks = getImported(pkg, []);
-    return {
-        target: {
-            name: pkg.name,
-            version: pkg.version,
-            root: pkg.root
-        },
-        targetSize: {
-            sourceSize: pkg.getSize().sourceSize,
-            parsedSize: pkg.getSize().parsedSize
-        },
-        dependencies: packageImportLinks.map((item)=>({
-                dependencyId: item.refDependency.id,
-                group: item.package ? `${item.package.name}@${item.package.version}` : void 0
-            }))
-    };
-}
-export { getErrorDetail, getErrorMsg };

package/dist/rules/rules/ecma-version-check/index.js

@@ -1,53 +0,0 @@
-import "node:module";
-import path from "path";
-import { CheckSyntax } from "@rsbuild/plugin-check-syntax";
-import { loadConfig } from "browserslist-load-config";
-import { defineRule } from "../../rule.js";
-import { Linter } from "@rsdoctor/shared/types";
-const title = 'ecma-version-check';
-const rule = defineRule(()=>({
-        meta: {
-            code: 'E1004',
-            title: title,
-            category: 'bundle',
-            severity: Linter.Severity.Warn,
-            defaultConfig: {
-                ecmaVersion: void 0,
-                targets: []
-            }
-        },
-        async check ({ chunkGraph, report, ruleConfig, root, configs }) {
-            for (const asset of chunkGraph.getAssets()){
-                if ('.js' !== path.extname(asset.path) && '.bundle' !== path.extname(asset.path)) continue;
-                const browserslistConfig = loadConfig({
-                    path: root,
-                    env: 'production'
-                });
-                const { exclude, excludeOutput, targets, ecmaVersion } = ruleConfig;
-                const finalTargets = targets || browserslistConfig || [];
-                if (!finalTargets.length && !ecmaVersion) return;
-                const buildConfig = configs[0]?.config;
-                const context = buildConfig?.context || root;
-                const checkSyntax = new CheckSyntax({
-                    exclude,
-                    excludeOutput,
-                    ecmaVersion,
-                    rootPath: context,
-                    targets: finalTargets
-                });
-                const outputDir = buildConfig?.output?.path || path.resolve(root, 'dist');
-                const assetPath = path.resolve(outputDir, asset.path);
-                await checkSyntax.check(assetPath, asset.content);
-                checkSyntax.errors.forEach((err)=>{
-                    report({
-                        message: `Found syntax that does not match "ecmaVersion <= ${checkSyntax.ecmaVersion}"`,
-                        detail: {
-                            error: err,
-                            type: 'link'
-                        }
-                    });
-                });
-            }
-        }
-    }));
-export { rule };

package/dist/rules/rules/ecma-version-check/types.js

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

package/dist/rules/rules/ecma-version-check/utils.js

@@ -1,6 +0,0 @@
-import "node:module";
-function getVersionNumber(ECMAString) {
-    const version = ECMAString.match(/\d/);
-    return version?.length ? Number(version[0]) : void 0;
-}
-export { getVersionNumber };