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

package/dist/rules/rules/esm-resolved-to-cjs/index.js

@@ -1,193 +0,0 @@
-import "node:module";
-import fs from "fs";
-import path from "path";
-import { Linter, SDK } from "@rsdoctor/shared/types";
-import { defineRule } from "../../rule.js";
-const title = 'esm-resolved-to-cjs';
-function normalizePathForCompare(filePath) {
-    const queryIndex = filePath.indexOf('?');
-    const hashIndex = filePath.indexOf('#');
-    const splitIndex = [
-        queryIndex,
-        hashIndex
-    ].filter((index)=>index >= 0).reduce((min, index)=>Math.min(min, index), 1 / 0);
-    const cleanPath = splitIndex === 1 / 0 ? filePath : filePath.slice(0, splitIndex);
-    return path.normalize(cleanPath);
-}
-function isDefinitelyEsmFile(filePath) {
-    return '.mjs' === path.extname(normalizePathForCompare(filePath));
-}
-function isDeclaredEsmEntry(filePath, esmEntries, toRealPath) {
-    const realPath = toRealPath(filePath);
-    return esmEntries.some((esmEntry)=>realPath === toRealPath(esmEntry));
-}
-function isRecord(value) {
-    return null !== value && 'object' == typeof value && !Array.isArray(value);
-}
-function substituteExportPattern(target, wildcard) {
-    return target.replace(/\*/g, wildcard);
-}
-function toPackagePath(pkgRoot, target, wildcard) {
-    return path.resolve(pkgRoot, substituteExportPattern(target, wildcard));
-}
-function collectStringTargets(value, wildcard) {
-    if ('string' == typeof value) return [
-        substituteExportPattern(value, wildcard)
-    ];
-    if (Array.isArray(value)) return value.flatMap((item)=>collectStringTargets(item, wildcard));
-    if (!isRecord(value)) return [];
-    return Object.values(value).flatMap((child)=>collectStringTargets(child, wildcard));
-}
-function collectEsmTargets(exportEntry, pkgRoot, wildcard) {
-    const entries = new Set();
-    const addTargets = (value)=>{
-        for (const target of collectStringTargets(value, wildcard))entries.add(toPackagePath(pkgRoot, target, ''));
-    };
-    const visit = (value)=>{
-        if ('string' == typeof value || Array.isArray(value)) return void addTargets(value);
-        if (!isRecord(value)) return;
-        addTargets(value['import']);
-        addTargets(value['module']);
-        for (const child of Object.values(value))if (isRecord(child) || Array.isArray(child)) visit(child);
-    };
-    visit(exportEntry);
-    return entries;
-}
-function hasSubpathExportKeys(exports) {
-    return Object.keys(exports).some((key)=>'.' === key || key.startsWith('./'));
-}
-function matchPatternExportKey(patternKey, exportKey) {
-    const wildcardIndex = patternKey.indexOf('*');
-    if (wildcardIndex < 0) return null;
-    const prefix = patternKey.slice(0, wildcardIndex);
-    const suffix = patternKey.slice(wildcardIndex + 1);
-    if (!exportKey.startsWith(prefix) || !exportKey.endsWith(suffix)) return null;
-    return exportKey.slice(prefix.length, exportKey.length - suffix.length);
-}
-function resolveExportEntry(exports, exportKey) {
-    if (Object.prototype.hasOwnProperty.call(exports, exportKey)) return {
-        value: exports[exportKey],
-        wildcard: ''
-    };
-    for (const [key, value] of Object.entries(exports)){
-        const wildcard = matchPatternExportKey(key, exportKey);
-        if (null !== wildcard) return {
-            value,
-            wildcard
-        };
-    }
-    return null;
-}
-function resolveExportEntryForKey(exportsField, exportKey) {
-    if (!isRecord(exportsField)) return null;
-    if (!hasSubpathExportKeys(exportsField)) return '.' === exportKey ? {
-        value: exportsField,
-        wildcard: ''
-    } : null;
-    return resolveExportEntry(exportsField, exportKey);
-}
-function extractEsmEntries(pkgJson, pkgRoot, exportKey) {
-    const { exports: exportsField, module: moduleField } = pkgJson;
-    const resolvedExport = resolveExportEntryForKey(exportsField, exportKey);
-    const entries = resolvedExport ? collectEsmTargets(resolvedExport.value, pkgRoot, resolvedExport.wildcard) : new Set();
-    if ('.' === exportKey && 'string' == typeof moduleField) entries.add(path.resolve(pkgRoot, moduleField));
-    return entries;
-}
-function getExportKeyFromRequest(packageName, request) {
-    if (request === packageName) return '.';
-    if (request.startsWith(`${packageName}/`)) return `.${request.slice(packageName.length)}`;
-    return null;
-}
-const rule = defineRule(()=>({
-        meta: {
-            code: 'E1009',
-            title: title,
-            category: 'bundle',
-            severity: Linter.Severity.Warn,
-            defaultConfig: {
-                ignore: []
-            }
-        },
-        check ({ moduleGraph, packageGraph, report, ruleConfig }) {
-            const pkgJsonCache = new Map();
-            const realPathCache = new Map();
-            const readPkgJson = (pkgRoot)=>{
-                if (pkgJsonCache.has(pkgRoot)) return pkgJsonCache.get(pkgRoot);
-                try {
-                    const raw = fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf-8');
-                    const parsed = JSON.parse(raw);
-                    pkgJsonCache.set(pkgRoot, parsed);
-                    return parsed;
-                } catch  {
-                    pkgJsonCache.set(pkgRoot, null);
-                    return null;
-                }
-            };
-            const toRealPath = (filePath)=>{
-                const normalized = normalizePathForCompare(filePath);
-                if (realPathCache.has(normalized)) return realPathCache.get(normalized);
-                try {
-                    const realPath = 'function' == typeof fs.realpathSync.native ? fs.realpathSync.native(normalized) : fs.realpathSync(normalized);
-                    const normalizedRealPath = path.normalize(realPath);
-                    realPathCache.set(normalized, normalizedRealPath);
-                    return normalizedRealPath;
-                } catch  {
-                    realPathCache.set(normalized, normalized);
-                    return normalized;
-                }
-            };
-            const groups = new Map();
-            const inNodeModules = /[/\\]node_modules[/\\]/;
-            for (const dep of moduleGraph.getDependencies()){
-                if (dep.kind !== SDK.DependencyKind.ImportStatement || inNodeModules.test(dep.module.path) || !inNodeModules.test(dep.dependency.path) || dep.dependency.meta.strictHarmonyModule || ruleConfig.ignore.some((p)=>dep.request.includes(p))) continue;
-                const pkg = packageGraph.getPackageByModule(dep.dependency);
-                if (!pkg?.root) continue;
-                const pkgJson = readPkgJson(pkg.root);
-                if (ruleConfig.ignore.some((p)=>pkg.name.includes(p)) || !pkgJson) continue;
-                const exportKey = getExportKeyFromRequest(pkg.name, dep.request);
-                if (!exportKey) continue;
-                const esmEntries = extractEsmEntries(pkgJson, pkg.root, exportKey);
-                if (0 === esmEntries.size) continue;
-                const esmEntryList = Array.from(esmEntries);
-                const resolvedModuleRealPath = toRealPath(dep.dependency.path);
-                if (isDefinitelyEsmFile(resolvedModuleRealPath)) continue;
-                if (isDeclaredEsmEntry(resolvedModuleRealPath, esmEntryList, toRealPath)) continue;
-                const groupKey = `${pkg.name}::${resolvedModuleRealPath}`;
-                const issuer = {
-                    id: dep.module.id,
-                    path: dep.module.path,
-                    request: dep.request
-                };
-                if (groups.has(groupKey)) groups.get(groupKey).issuers.push(issuer);
-                else groups.set(groupKey, {
-                    packageName: pkg.name,
-                    packageVersion: pkg.version,
-                    esmEntry: esmEntryList[0],
-                    resolvedModule: {
-                        id: dep.dependency.id,
-                        path: dep.dependency.path,
-                        identifier: dep.dependency.identifier
-                    },
-                    issuers: [
-                        issuer
-                    ]
-                });
-            }
-            for (const group of groups.values()){
-                const detail = {
-                    type: title,
-                    packageName: group.packageName,
-                    packageVersion: group.packageVersion,
-                    esmEntry: group.esmEntry,
-                    resolvedModule: group.resolvedModule,
-                    issuers: group.issuers
-                };
-                const message = `"${group.packageName}" declares an ESM entry ("${group.esmEntry}") but was resolved to CJS by ${group.issuers.length} ESM import(s). Check your bundler's \`resolve.mainFields\` or \`resolve.conditionNames\` config.`;
-                report({
-                    message,
-                    detail
-                });
-            }
-        }
-    }));
-export { rule };

package/dist/rules/rules/esm-resolved-to-cjs/types.js

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

package/dist/rules/rules/index.js

@@ -1,22 +0,0 @@
-import "node:module";
-import { rule } from "./duplicate-package/index.js";
-import { rule as index_js_rule } from "./default-import-check/index.js";
-import { rule as external_loader_performance_optimization_index_js_rule } from "./loader-performance-optimization/index.js";
-import { rule as external_ecma_version_check_index_js_rule } from "./ecma-version-check/index.js";
-import { rule as external_cross_chunks_package_index_js_rule } from "./cross-chunks-package/index.js";
-import { rule as external_module_mixed_chunks_index_js_rule } from "./module-mixed-chunks/index.js";
-import { rule as external_side_effects_only_imports_index_js_rule } from "./side-effects-only-imports/index.js";
-import { rule as external_cjs_require_index_js_rule } from "./cjs-require/index.js";
-import { rule as external_esm_resolved_to_cjs_index_js_rule } from "./esm-resolved-to-cjs/index.js";
-const rules = [
-    rule,
-    index_js_rule,
-    external_loader_performance_optimization_index_js_rule,
-    external_ecma_version_check_index_js_rule,
-    external_cross_chunks_package_index_js_rule,
-    external_module_mixed_chunks_index_js_rule,
-    external_side_effects_only_imports_index_js_rule,
-    external_cjs_require_index_js_rule,
-    external_esm_resolved_to_cjs_index_js_rule
-];
-export { rules };

package/dist/rules/rules/loader-performance-optimization/index.js

@@ -1,86 +0,0 @@
-import "node:module";
-import { Linter } from "@rsdoctor/shared/types";
-import { Loader, Time } from "../../../common/index.js";
-import { defineRule } from "../../rule.js";
-import { match } from "./utils.js";
-const title = 'loader-performance-optimization';
-const rule = defineRule(()=>({
-        meta: {
-            code: 'E1003',
-            title: title,
-            category: 'compile',
-            severity: Linter.Severity.Warn,
-            defaultConfig: {
-                ignore: [],
-                threshold: 5000,
-                extensions: [
-                    'js',
-                    'css',
-                    'jpg',
-                    'jpeg',
-                    'png',
-                    'gif',
-                    'webp',
-                    'svg'
-                ]
-            }
-        },
-        check ({ loader, configs, root, ruleConfig, report }) {
-            const { extensions, ignore = [], threshold = 5000 } = ruleConfig;
-            if (!extensions || extensions?.length === 0) return;
-            if (0 === loader.length) return;
-            const { config } = configs.find((e)=>'rspack' === e.name) || {
-                config: void 0
-            };
-            if (!config) return;
-            const cwd = config.context || root;
-            const nodeModulesPathRegexp = /\/node_modules\//;
-            const resultMap = new Map();
-            const loaders = loader.flatMap((el)=>el.loaders);
-            for (const item of loader){
-                const { path, ext } = item.resource;
-                if (match(ext, extensions)) {
-                    if (nodeModulesPathRegexp.test(path) || !path.startsWith(cwd)) item.loaders.forEach((el)=>{
-                        if (match(el.loader, ignore)) return;
-                        const costs = Loader.getLoaderCosts(el, loaders);
-                        const v = {
-                            ...el,
-                            __resource__: item.resource,
-                            __costs__: costs
-                        };
-                        if (resultMap.has(el.loader)) resultMap.get(el.loader).push(v);
-                        else resultMap.set(el.loader, [
-                            v
-                        ]);
-                    });
-                }
-            }
-            const sum = (arr)=>{
-                const v1 = arr.reduce((t, c)=>t + c.__costs__, 0);
-                const v2 = Math.max.apply(null, arr.map((e)=>e.endAt)) - Math.min.apply(arr.map((e)=>e.startAt));
-                if (v2 >= v1 || v2 === -1 / 0) return v1;
-                return v2;
-            };
-            for (const [loaderName, v] of resultMap.entries()){
-                const nodeModulesFiles = v.filter((e)=>nodeModulesPathRegexp.test(e.__resource__.path));
-                const nodeModulesFilesCosts = sum(nodeModulesFiles);
-                const outofCwdFiles = v.filter((e)=>!e.__resource__.path.startsWith(cwd));
-                const outofCwdFilesCosts = sum(outofCwdFiles);
-                const msg = [
-                    nodeModulesFilesCosts >= threshold && `${nodeModulesFiles.length} node_modules files (costs: ${Time.formatCosts(nodeModulesFilesCosts)})`,
-                    outofCwdFilesCosts >= threshold && `${outofCwdFiles.length} outside project files (costs: ${Time.formatCosts(outofCwdFilesCosts)})`
-                ].filter(Boolean).join(' and ');
-                if (msg) {
-                    const message = `${loaderName} has processed ${msg}.`;
-                    report({
-                        message,
-                        detail: {
-                            description: message,
-                            type: 'link'
-                        }
-                    });
-                }
-            }
-        }
-    }));
-export { rule };

package/dist/rules/rules/loader-performance-optimization/types.js

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

package/dist/rules/rules/loader-performance-optimization/utils.js

@@ -1,10 +0,0 @@
-import "node:module";
-function match(str, patterns) {
-    if (0 === patterns.length) return false;
-    return patterns.some((p)=>{
-        if ('string' == typeof p) return str === p;
-        if (p instanceof RegExp) return p.test(str);
-        return false;
-    });
-}
-export { match };

package/dist/rules/rules/module-mixed-chunks/index.js

@@ -1,52 +0,0 @@
-import "node:module";
-import { Linter } from "@rsdoctor/shared/types";
-import { defineRule } from "../../rule.js";
-const title = 'module-mixed-chunks';
-const rule = defineRule(()=>({
-        meta: {
-            code: 'E1006',
-            title: title,
-            category: 'bundle',
-            severity: Linter.Severity.Warn,
-            defaultConfig: {
-                ignore: []
-            }
-        },
-        check ({ moduleGraph, report, ruleConfig }) {
-            const modules = moduleGraph.getModules();
-            for (const module of modules){
-                if (ruleConfig.ignore.some((pattern)=>module.path.includes(pattern))) continue;
-                const moduleChunks = module.getChunks();
-                if (0 === moduleChunks.length) continue;
-                const hasInitial = moduleChunks.some((chunk)=>chunk.initial);
-                const hasAsync = moduleChunks.some((chunk)=>!chunk.initial);
-                if (hasInitial && hasAsync) {
-                    const initialChunks = moduleChunks.filter((chunk)=>chunk.initial);
-                    const asyncChunks = moduleChunks.filter((chunk)=>!chunk.initial);
-                    const detail = {
-                        type: title,
-                        module: {
-                            id: module.id,
-                            path: module.path,
-                            identifier: module.identifier
-                        },
-                        initialChunks: initialChunks.map((chunk)=>({
-                                id: chunk.id,
-                                name: chunk.name
-                            })),
-                        asyncChunks: asyncChunks.map((chunk)=>({
-                                id: chunk.id,
-                                name: chunk.name
-                            }))
-                    };
-                    const chunkNames = moduleChunks.map((chunk)=>chunk.name || `chunk-${chunk.id}`).join(', ');
-                    const message = `Module "${module.path}" is included in both initial and async chunks: ${chunkNames}. This should be optimized to avoid code duplication.`;
-                    report({
-                        message,
-                        detail
-                    });
-                }
-            }
-        }
-    }));
-export { rule };

package/dist/rules/rules/module-mixed-chunks/types.js

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

package/dist/rules/rules/side-effects-only-imports/index.js

@@ -1,81 +0,0 @@
-import "node:module";
-import { Linter } from "@rsdoctor/shared/types";
-import { defineRule } from "../../rule.js";
-const title = 'tree-shaking-side-effects-only';
-function isSideEffectDependencyType(dependencyType) {
-    return 'esm import' === dependencyType.toLowerCase();
-}
-function isImportSpecifierDependencyType(dependencyType) {
-    return 'esm import specifier' === dependencyType.toLowerCase();
-}
-function isStyleFile(modulePath) {
-    const normalizedPath = modulePath.split('?')[0].split('#')[0].toLowerCase();
-    return /\.(css|less|sass|scss|styl|stylus|pcss|postcss)$/.test(normalizedPath);
-}
-function shouldCheckModule(modulePath, include) {
-    const isNodeModulesModule = modulePath.includes('/node_modules/');
-    if (!isNodeModulesModule) return true;
-    return include.some((pattern)=>modulePath.includes(pattern));
-}
-function getSideEffectsImportConnections(connections, fallbackOriginModule) {
-    const byOrigin = new Map();
-    for (const connection of connections){
-        const originModule = connection.originModule ?? fallbackOriginModule;
-        const existing = byOrigin.get(originModule);
-        if (existing) existing.push(connection);
-        else byOrigin.set(originModule, [
-            connection
-        ]);
-    }
-    const result = [];
-    for (const group of byOrigin.values()){
-        const hasEsmImport = group.some((connection)=>isSideEffectDependencyType(connection.dependencyType));
-        const hasEsmImportSpecifier = group.some((connection)=>isImportSpecifierDependencyType(connection.dependencyType));
-        if (hasEsmImport && !hasEsmImportSpecifier) result.push(...group.filter((connection)=>isSideEffectDependencyType(connection.dependencyType)));
-    }
-    return result;
-}
-const rule = defineRule(()=>({
-        meta: {
-            code: 'E1007',
-            title: title,
-            category: 'bundle',
-            severity: Linter.Severity.Warn,
-            defaultConfig: {
-                ignore: [],
-                include: []
-            }
-        },
-        check ({ moduleGraph, report, ruleConfig }) {
-            const precomputed = moduleGraph.getConnectionsOnlyImports();
-            for (const item of precomputed){
-                if (isStyleFile(item.modulePath)) continue;
-                if (ruleConfig.ignore.some((pattern)=>item.modulePath.includes(pattern))) continue;
-                if (!shouldCheckModule(item.modulePath, ruleConfig.include)) continue;
-                const module = moduleGraph.getModuleById(item.moduleUkey);
-                if (!module) continue;
-                const sideEffectConnections = getSideEffectsImportConnections(item.connections, item.moduleUkey);
-                if (!sideEffectConnections.length) continue;
-                const detail = {
-                    type: title,
-                    module: {
-                        id: module.id,
-                        path: module.path,
-                        identifier: module.identifier
-                    },
-                    connections: sideEffectConnections.map((c)=>({
-                            originModule: c.originModule ?? module.id,
-                            dependencyType: c.dependencyType,
-                            userRequest: c.userRequest
-                        }))
-                };
-                const importerCount = new Set(sideEffectConnections.map((c)=>c.originModule ?? module.id)).size;
-                const message = `Module "${item.modulePath}" is only imported for its side effects by ${importerCount} importer(s). This may indicate an unintended tree-shaking failure causing redundant bundle output.`;
-                report({
-                    message,
-                    detail
-                });
-            }
-        }
-    }));
-export { rule };

package/dist/rules/rules/side-effects-only-imports/types.js

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

package/dist/rules/utils.js

@@ -1,10 +0,0 @@
-import "node:module";
-import { Linter } from "@rsdoctor/shared/types";
-function toSeverity(input, defaultLevel) {
-    if ('off' === input) return Linter.Severity.Ignore;
-    if ('on' === input) return defaultLevel;
-    const key = `${input[0].toUpperCase()}${input.slice(1)}`;
-    return Linter.Severity[key];
-}
-function noop() {}
-export { noop, toSeverity };

package/dist/sdk/index.js

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

package/dist/sdk/multiple/controller.js

@@ -1,42 +0,0 @@
-import "node:module";
-import { RsdoctorPrimarySDK } from "./primary.js";
-class RsdoctorSDKController {
-    get master() {
-        return this.slaves[0];
-    }
-    getLastSdk() {
-        return this.slaves[this.slaves.length - 1];
-    }
-    hasName(name) {
-        return Boolean(this.slaves.find((item)=>item.name === name));
-    }
-    getSeriesData(serverUrl = false) {
-        return this.slaves.map((item)=>{
-            const data = {
-                name: item.name,
-                path: item.diskManifestPath,
-                stage: item.stage
-            };
-            if (serverUrl) data.origin = item.server.origin;
-            return data;
-        });
-    }
-    createSlave({ name, stage, extraConfig, type }) {
-        const slave = new RsdoctorPrimarySDK({
-            name,
-            stage,
-            controller: this,
-            extraConfig,
-            type
-        });
-        this.slaves.push(slave);
-        this.slaves.sort((a, b)=>a.stage - b.stage);
-        return slave;
-    }
-    constructor(root = process.cwd()){
-        this.slaves = [];
-        this.root = '';
-        this.root = root;
-    }
-}
-export { RsdoctorSDKController };

package/dist/sdk/multiple/index.js

@@ -1,3 +0,0 @@
-import "node:module";
-export * from "./controller.js";
-export * from "./primary.js";

package/dist/sdk/multiple/primary.js

@@ -1,64 +0,0 @@
-import "node:module";
-import path from "path";
-import { RsdoctorSDK } from "../sdk/index.js";
-import { RsdoctorSlaveServer } from "./server.js";
-let id = 1;
-class RsdoctorPrimarySDK extends RsdoctorSDK {
-    clearSwitch() {
-        this.uploadPieces = new Promise((resolve)=>{
-            this.finishUploadPieceSwitch = resolve;
-        });
-    }
-    get isMaster() {
-        return this.parent.master === this;
-    }
-    async writePieces() {
-        const { name, parent, isMaster, outputDir, finishUploadPieceSwitch } = this;
-        this.setOutputDir(isMaster ? outputDir : path.join(parent.master.outputDir, '.slaves', name.replace(/\s+/g, '-')));
-        await super.writePieces(this.getStoreData());
-        finishUploadPieceSwitch?.();
-    }
-    async writeManifest() {
-        const { parent, cloudData, dependencies } = this;
-        if (!dependencies?.length) await Promise.all(this.parent.slaves.filter((item)=>!item.dependencies?.length).map((item)=>item.uploadPieces));
-        if (cloudData) {
-            cloudData.name = this.name;
-            cloudData.series = parent.getSeriesData();
-        }
-        const result = await super.writeManifest();
-        this.clearSwitch();
-        return result;
-    }
-    getSeriesData(serverUrl = false) {
-        return this.parent.getSeriesData(serverUrl);
-    }
-    setName(name) {
-        this._name = this.parent.hasName(name) ? `${name}-${id}` : name;
-    }
-    getManifestData() {
-        const data = super.getManifestData();
-        data.name = this.name;
-        data.series = this.getSeriesData(true);
-        return data;
-    }
-    constructor({ name, stage, controller, extraConfig, type }){
-        super({
-            name,
-            root: controller.root,
-            config: extraConfig
-        });
-        const lastSdk = controller.getLastSdk();
-        const port = lastSdk ? lastSdk.server.port + 1 : extraConfig?.server?.port ?? this.server.port;
-        this.id = id++;
-        this.stage = 'number' == typeof stage ? stage : 1;
-        this.extraConfig = extraConfig;
-        this.parent = controller;
-        this.server = new RsdoctorSlaveServer(this, port, {
-            cors: extraConfig?.server?.cors
-        });
-        this.type = type;
-        this.setName(name);
-        this.clearSwitch();
-    }
-}
-export { RsdoctorPrimarySDK };

package/dist/sdk/multiple/server.js

@@ -1,14 +0,0 @@
-import "node:module";
-import { Server } from "../../build-utils/index.js";
-import { RsdoctorServer } from "../server/index.js";
-class RsdoctorSlaveServer extends RsdoctorServer {
-    async openClientPage(...args) {
-        if (this.sdk.isMaster) return super.openClientPage(...args);
-        return Promise.resolve();
-    }
-    constructor(sdk, port = Server.defaultPort, config){
-        super(sdk, port, config);
-        this.sdk = sdk;
-    }
-}
-export { RsdoctorSlaveServer };