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

package/dist/build-utils/build/module-graph/utils.js

@@ -1,59 +0,0 @@
-import "node:module";
-import { isNumber } from "es-toolkit/compat";
-import { parser } from "@rsdoctor/utils/ruleUtils";
-function getDefaultExportIdentifier(node, module, searchId) {
-    const { declaration } = node;
-    if (parser.asserts.isLiteral(declaration) && declaration.loc) return module.getStatement(declaration.loc);
-    if (parser.asserts.isIdentifier(declaration)) {
-        if (searchId) {
-            const result = getDeclarationIdentifier(declaration.name, module);
-            if (result) return result;
-        } else if (declaration.loc) return module.getStatement(declaration.loc);
-    }
-    if (parser.asserts.isClassDeclaration(declaration) || parser.asserts.isFunctionDeclaration(declaration)) {
-        if (declaration.id?.loc) return module.getStatement(declaration.id.loc);
-    }
-    const startLine = node.declaration.loc?.start.line;
-    if (!isNumber(startLine)) return;
-    const { transformed } = module.getSource();
-    const endColumn = transformed.split('\n')[startLine - 1].length - 1;
-    return module.getStatement({
-        start: {
-            line: startLine,
-            column: 0
-        },
-        end: {
-            line: startLine,
-            column: endColumn
-        }
-    });
-}
-function getExportIdentifierStatement(name, module) {
-    const ast = module.getProgram();
-    if (!ast) return;
-    for (const node of ast.body){
-        if (parser.asserts.isExportDefaultDeclaration(node)) {
-            const result = getDefaultExportIdentifier(node, module, false);
-            if (result) return result;
-        }
-        const id = parser.utils.getIdentifierInExport(name, node);
-        if (id?.loc) return module.getStatement(id.loc);
-    }
-}
-function getDeclarationIdentifier(name, module) {
-    const ast = module.getProgram();
-    if (!ast) return;
-    for (const node of ast.body){
-        const id = parser.utils.getIdentifierInDeclaration(name, node);
-        if (id?.loc) return module.getStatement(id.loc);
-        if (parser.asserts.isExportNamedDeclaration(node) && node.declaration) {
-            const id = parser.utils.getIdentifierInDeclaration(name, node.declaration);
-            if (id?.loc) return module.getStatement(id.loc);
-        }
-        if ('default' === name && parser.asserts.isExportDefaultDeclaration(node)) {
-            const result = getDefaultExportIdentifier(node, module, true);
-            if (result) return result;
-        }
-    }
-}
-export { getDeclarationIdentifier, getExportIdentifierStatement };

package/dist/build-utils/build/utils/index.cjs

@@ -1,72 +0,0 @@
-"use strict";
-var __webpack_modules__ = {
-    "./loader" (module) {
-        module.exports = require("./loader.cjs");
-    },
-    "./parseBundle" (module) {
-        module.exports = require("./parseBundle.cjs");
-    },
-    "./plugin" (module) {
-        module.exports = require("./plugin.cjs");
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-(()=>{
-    __webpack_require__.r(__webpack_exports__);
-    var _loader__rspack_import_0 = __webpack_require__("./loader");
-    var __rspack_reexport = {};
-    for(const __rspack_import_key in _loader__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_loader__rspack_import_0[__rspack_import_key];
-    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _plugin__rspack_import_1 = __webpack_require__("./plugin");
-    var __rspack_reexport = {};
-    for(const __rspack_import_key in _plugin__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_plugin__rspack_import_1[__rspack_import_key];
-    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _parseBundle__rspack_import_2 = __webpack_require__("./parseBundle");
-    var __rspack_reexport = {};
-    for(const __rspack_import_key in _parseBundle__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_parseBundle__rspack_import_2[__rspack_import_key];
-    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-})();
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/build-utils/build/utils/index.d.cts

@@ -1,3 +0,0 @@
-export * from './loader';
-export * from './plugin';
-export * from './parseBundle';

package/dist/build-utils/build/utils/index.js

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

package/dist/build-utils/build/utils/loader.cjs

@@ -1,354 +0,0 @@
-"use strict";
-const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
-    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
-}();
-var __webpack_modules__ = {
-    module (module) {
-        module.exports = require("module");
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-(()=>{
-    __webpack_require__.r(__webpack_exports__);
-    __webpack_require__.d(__webpack_exports__, {
-        addProbeLoader2Rules: ()=>addProbeLoader2Rules,
-        createLoaderContextTrap: ()=>createLoaderContextTrap,
-        extractLoaderName: ()=>extractLoaderName,
-        getLoaderNameMatch: ()=>getLoaderNameMatch,
-        isESMLoader: ()=>isESMLoader,
-        loadLoaderModule: ()=>loadLoaderModule,
-        mapEachRules: ()=>mapEachRules,
-        parsePathQueryFragment: ()=>parsePathQueryFragment,
-        parseQuery: ()=>parseQuery
-    });
-    const external_node_path_namespaceObject = require("node:path");
-    var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-    const external_node_url_namespaceObject = require("node:url");
-    const external_fs_extra_namespaceObject = require("fs-extra");
-    var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_extra_namespaceObject);
-    const compat_namespaceObject = require("es-toolkit/compat");
-    const common_namespaceObject = require("@rsdoctor/utils/common");
-    const graph_namespaceObject = require("@rsdoctor/graph");
-    const logger_namespaceObject = require("@rsdoctor/utils/logger");
-    const loader_filename = (0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__);
-    const loader_dirname = external_node_path_default().dirname(loader_filename);
-    const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
-    function parsePathQueryFragment(str) {
-        const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
-        return {
-            path: match?.[1].replace(/\0(.)/g, '$1') || '',
-            query: match?.[2] ? match[2].replace(/\0(.)/g, '$1') : '',
-            fragment: match?.[3] || ''
-        };
-    }
-    function loadLoaderModule(loaderPath, cwd = process.cwd()) {
-        const cleanLoaderPath = parsePathQueryFragment(loaderPath).path;
-        const { createRequire } = __webpack_require__("module");
-        const requireFn = createRequire(__rslib_import_meta_url__);
-        const mod = requireFn(process.env.DOCTOR_TEST ? external_node_path_default().resolve(cwd, cleanLoaderPath) : requireFn.resolve(cleanLoaderPath, {
-            paths: [
-                cwd,
-                external_node_path_default().resolve(cwd, 'node_modules')
-            ]
-        }));
-        const isESM = mod.__esModule && 'function' == typeof mod.default;
-        return {
-            default: isESM ? mod.default : 'function' == typeof mod ? mod : null,
-            pitch: mod.default?.pitch || mod.pitch,
-            raw: mod.default?.raw || mod.raw || false
-        };
-    }
-    function extractLoaderName(loaderPath, cwd = '') {
-        let res = loaderPath.replace(cwd, '');
-        if (!external_node_path_default().isAbsolute(res)) return res;
-        const nms = '/node_modules/';
-        const idx = res.lastIndexOf(nms);
-        if (-1 !== idx) {
-            res = res.slice(idx + nms.length);
-            const ln = 'loader';
-            const lnIdx = res.lastIndexOf(ln);
-            if (lnIdx > -1) res = res.slice(0, lnIdx + ln.length);
-        }
-        return res;
-    }
-    function mapEachRules(rules, callback) {
-        return rules.filter(Boolean).map((rule)=>{
-            if ('string' == typeof rule) return callback({
-                loader: rule
-            });
-            if (rule.loader && 'string' == typeof rule.loader) return callback(rule);
-            if (Array.isArray(rule.loaders)) {
-                const { loaders, ...rest } = rule;
-                return {
-                    ...rest,
-                    use: mapEachRules(loaders, callback)
-                };
-            }
-            if (rule.use && (!Array.isArray(rule.use) || 0 !== rule.use.length)) {
-                if ('string' == typeof rule.use) return {
-                    ...rule,
-                    use: mapEachRules([
-                        {
-                            loader: rule.use,
-                            options: rule.options
-                        }
-                    ], callback)
-                };
-                if ('function' == typeof rule.use) {
-                    const funcUse = rule.use;
-                    const newRule = {
-                        ...rule,
-                        use: (...args)=>{
-                            const rules = funcUse(...args);
-                            return mapEachRules(rules, callback);
-                        }
-                    };
-                    return newRule;
-                }
-                if (Array.isArray(rule.use)) return {
-                    ...rule,
-                    use: mapEachRules(rule.use, callback)
-                };
-                return {
-                    ...rule,
-                    use: mapEachRules([
-                        rule.use
-                    ], callback)
-                };
-            }
-            if ('rules' in rule && Array.isArray(rule.rules)) return {
-                ...rule,
-                rules: mapEachRules(rule.rules, callback)
-            };
-            if (Array.isArray(rule.oneOf)) return {
-                ...rule,
-                oneOf: mapEachRules(rule.oneOf, callback)
-            };
-            return rule;
-        });
-    }
-    function isESMLoader(r) {
-        const _loaderName = 'object' == typeof r && 'string' == typeof r?.loader ? r.loader : 'string' == typeof r ? r : '';
-        if (!_loaderName) return false;
-        const isPath = external_node_path_default().isAbsolute(_loaderName) || _loaderName.startsWith('./') || _loaderName.startsWith('../');
-        if (isPath) {
-            const packageJsonData = (0, graph_namespaceObject.readPackageJson)(_loaderName, (file)=>{
-                try {
-                    return external_fs_extra_default().readJsonSync(file, {
-                        encoding: 'utf8'
-                    });
-                } catch (e) {
-                    logger_namespaceObject.logger.debug(`isESMLoader function error：${e}`);
-                }
-            });
-            if (packageJsonData?.type === 'module' && !packageJsonData?.name.includes('@rsdoctor/')) return true;
-        }
-        return false;
-    }
-    function appendProbeLoaders(compiler, loaderConfig) {
-        const _options = 'object' == typeof loaderConfig ? 'string' == typeof loaderConfig.options ? {
-            options: loaderConfig.options
-        } : loaderConfig.options : {};
-        const loaderPath = process.env.DOCTOR_TEST ? external_node_path_default().resolve(loader_dirname, '../loader/probeLoader.ts') : require.resolve(external_node_path_default().join(loader_dirname, '../loader/probeLoader'));
-        const loader = 'string' == typeof loaderConfig ? loaderConfig : 'object' == typeof loaderConfig && loaderConfig.loader;
-        const createProbeLoader = (type)=>({
-                loader: loaderPath,
-                options: {
-                    ..._options,
-                    loader,
-                    ident: void 0,
-                    type,
-                    builderName: compiler.options.name
-                }
-            });
-        return [
-            createProbeLoader('end'),
-            loaderConfig,
-            createProbeLoader('start')
-        ];
-    }
-    function getLoaderNameMatch(r, loaderName, strict = true) {
-        if (!strict) return 'object' == typeof r && 'string' == typeof r?.loader && r.loader.includes(loaderName) || 'string' == typeof r && r.includes(loaderName);
-        return 'object' == typeof r && 'string' == typeof r?.loader && r.loader === loaderName || 'string' == typeof r && r === loaderName;
-    }
-    function addProbeLoader2Rules(rules, compiler, fn) {
-        return rules.map((rule)=>{
-            if (!rule || 'string' == typeof rule) return rule;
-            if (fn(rule) && !rule.use) {
-                const loaderConfig = {
-                    loader: rule.loader ?? '',
-                    options: rule.options,
-                    ident: 'ident' in rule && 'string' == typeof rule.ident ? rule.ident : void 0
-                };
-                return {
-                    ...rule,
-                    use: appendProbeLoaders(compiler, loaderConfig),
-                    loader: void 0,
-                    options: void 0
-                };
-            }
-            if (rule.use) {
-                if (Array.isArray(rule.use)) rule.use = rule.use.flatMap((loaderConfig)=>{
-                    if ('string' == typeof loaderConfig || 'object' == typeof loaderConfig && loaderConfig && 'loader' in loaderConfig) return fn(loaderConfig) ? appendProbeLoaders(compiler, loaderConfig) : [
-                        loaderConfig
-                    ];
-                    return [
-                        loaderConfig
-                    ];
-                });
-                else if ('object' != typeof rule.use || Array.isArray(rule.use) || 'function' == typeof rule.use) {
-                    if ('string' == typeof rule.use) rule.use = fn(rule.use) ? appendProbeLoaders(compiler, {
-                        loader: rule.use
-                    }) : [
-                        {
-                            loader: rule.use
-                        }
-                    ];
-                } else if ('loader' in rule.use) rule.use = fn(rule.use) ? appendProbeLoaders(compiler, rule.use) : [
-                    rule.use
-                ];
-            }
-            if ('oneOf' in rule && rule.oneOf) return {
-                ...rule,
-                oneOf: addProbeLoader2Rules(rule.oneOf, compiler, fn)
-            };
-            if ('rules' in rule && rule.rules) return {
-                ...rule,
-                rules: addProbeLoader2Rules(rule.rules, compiler, fn)
-            };
-            return rule;
-        });
-    }
-    function createLoaderContextTrap(final) {
-        const cb = this.callback;
-        let callback = (...args)=>{
-            final(args[0], args[1] ?? null, args[2]);
-            return cb.call(this, ...args);
-        };
-        const ac = this.async;
-        let async = (...args)=>{
-            const cb = ac(...args);
-            return (...args)=>{
-                final(args[0], args[1] ?? null, args[2]);
-                return cb(...args);
-            };
-        };
-        const trap = new Proxy(this, {
-            get (target, key, receiver) {
-                switch(key){
-                    case 'async':
-                        return async;
-                    case 'callback':
-                        return callback;
-                    case 'query':
-                        if (target.query) {
-                            if ('string' == typeof target.query) {
-                                const res = target.query.replace(new RegExp(`"${common_namespaceObject.Loader.LoaderInternalPropertyName}":\{[^\}]*\},{0,1}`), '');
-                                return res;
-                            }
-                            if ('object' == typeof target.query) {
-                                const options = target.query[common_namespaceObject.Loader.LoaderInternalPropertyName];
-                                if (options.hasOptions) return (0, compat_namespaceObject.omit)(target.query, [
-                                    common_namespaceObject.Loader.LoaderInternalPropertyName
-                                ]);
-                                const innerLoaderPath = options?.loader;
-                                const loaderQuery = parsePathQueryFragment(innerLoaderPath).query;
-                                return loaderQuery;
-                            }
-                        }
-                        return Reflect.get(target, key, receiver);
-                    case 'getOptions':
-                        return 'function' == typeof target.getOptions ? ()=>(0, compat_namespaceObject.omit)(target.getOptions(), [
-                                common_namespaceObject.Loader.LoaderInternalPropertyName
-                            ]) : Reflect.get(target, key, receiver);
-                    default:
-                        return target[key];
-                }
-            },
-            set (target, key, value, receiver) {
-                switch(key){
-                    case 'async':
-                        async = value;
-                        return true;
-                    case 'callback':
-                        callback = value;
-                        return true;
-                    default:
-                        return Reflect.set(target, key, value, receiver);
-                }
-            },
-            defineProperty (target, p, attrs) {
-                return Reflect.defineProperty(target, p, attrs);
-            }
-        });
-        return trap;
-    }
-    function parseQuery(query) {
-        if (query.startsWith('?')) query = query.slice(1);
-        const searchParams = new URLSearchParams(query);
-        return Object.fromEntries(searchParams.entries());
-    }
-})();
-exports.addProbeLoader2Rules = __webpack_exports__.addProbeLoader2Rules;
-exports.createLoaderContextTrap = __webpack_exports__.createLoaderContextTrap;
-exports.extractLoaderName = __webpack_exports__.extractLoaderName;
-exports.getLoaderNameMatch = __webpack_exports__.getLoaderNameMatch;
-exports.isESMLoader = __webpack_exports__.isESMLoader;
-exports.loadLoaderModule = __webpack_exports__.loadLoaderModule;
-exports.mapEachRules = __webpack_exports__.mapEachRules;
-exports.parsePathQueryFragment = __webpack_exports__.parsePathQueryFragment;
-exports.parseQuery = __webpack_exports__.parseQuery;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "addProbeLoader2Rules",
-    "createLoaderContextTrap",
-    "extractLoaderName",
-    "getLoaderNameMatch",
-    "isESMLoader",
-    "loadLoaderModule",
-    "mapEachRules",
-    "parsePathQueryFragment",
-    "parseQuery"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/build-utils/build/utils/loader.d.cts

@@ -1,20 +0,0 @@
-import type { Common, Plugin } from '@rsdoctor/types';
-export declare function parsePathQueryFragment(str: string): {
-    path: string;
-    query: string;
-    fragment: string;
-};
-export declare function loadLoaderModule(loaderPath: string, cwd?: string): {
-    default: Plugin.LoaderDefinition<Common.PlainObject, {}>;
-    pitch: Plugin.PitchLoaderDefinitionFunction;
-    raw: boolean | void;
-};
-export declare function extractLoaderName(loaderPath: string, cwd?: string): string;
-export declare function mapEachRules<T extends Plugin.BuildRuleSetRule>(rules: T[], callback: (rule: T) => T): T[];
-export declare function isESMLoader(r: Plugin.BuildRuleSetRule): boolean;
-export declare function getLoaderNameMatch(r: Plugin.BuildRuleSetRule, loaderName: string, strict?: boolean): boolean;
-export declare function addProbeLoader2Rules<T extends Plugin.BuildRuleSetRule>(rules: T[], compiler: Plugin.BaseCompiler, fn: (r: Plugin.BuildRuleSetRule) => boolean): T[];
-export declare function createLoaderContextTrap(this: Plugin.LoaderContext<Common.PlainObject>, final: (err: Error | null | undefined, res: string | Buffer | null, sourceMap?: Plugin.SourceMapInput) => void): Plugin.LoaderContext<Common.PlainObject<any>>;
-export declare function parseQuery(query: string): {
-    [k: string]: string;
-};