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

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

@@ -1,276 +0,0 @@
-import __rslib_shim_module__ from "node:module";
-const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import node_path from "node:path";
-import { fileURLToPath } from "node:url";
-import fs_extra from "fs-extra";
-import { omit } from "es-toolkit/compat";
-import { Loader } from "@rsdoctor/utils/common";
-import { readPackageJson } from "@rsdoctor/graph";
-import { logger } from "@rsdoctor/utils/logger";
-import { __webpack_require__ } from "../../../rslib-runtime.js";
-import { createRequire as __rspack_createRequire } from "node:module";
-const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
-__webpack_require__.add({
-    "module?2382" (module) {
-        module.exports = __rspack_createRequire_require("module");
-    }
-});
-const loader_filename = fileURLToPath(import.meta.url);
-const loader_dirname = node_path.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?2382");
-    const requireFn = createRequire(import.meta.url);
-    const mod = requireFn(process.env.DOCTOR_TEST ? node_path.resolve(cwd, cleanLoaderPath) : requireFn.resolve(cleanLoaderPath, {
-        paths: [
-            cwd,
-            node_path.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 (!node_path.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 = node_path.isAbsolute(_loaderName) || _loaderName.startsWith('./') || _loaderName.startsWith('../');
-    if (isPath) {
-        const packageJsonData = readPackageJson(_loaderName, (file)=>{
-            try {
-                return fs_extra.readJsonSync(file, {
-                    encoding: 'utf8'
-                });
-            } catch (e) {
-                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 ? node_path.resolve(loader_dirname, '../loader/probeLoader.ts') : require.resolve(node_path.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(`"${Loader.LoaderInternalPropertyName}":\{[^\}]*\},{0,1}`), '');
-                            return res;
-                        }
-                        if ('object' == typeof target.query) {
-                            const options = target.query[Loader.LoaderInternalPropertyName];
-                            if (options.hasOptions) return omit(target.query, [
-                                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 ? ()=>omit(target.getOptions(), [
-                            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());
-}
-export { addProbeLoader2Rules, createLoaderContextTrap, extractLoaderName, getLoaderNameMatch, isESMLoader, loadLoaderModule, mapEachRules, parsePathQueryFragment, parseQuery };

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

@@ -1,283 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __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__, {
-    parseBundle: ()=>parseBundle
-});
-const external_fs_namespaceObject = require("fs");
-var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
-const compat_namespaceObject = require("es-toolkit/compat");
-const external_filesize_namespaceObject = require("filesize");
-const ruleUtils_namespaceObject = require("@rsdoctor/utils/ruleUtils");
-const external_path_namespaceObject = require("path");
-const types_namespaceObject = require("@rsdoctor/types");
-const logger_namespaceObject = require("@rsdoctor/utils/logger");
-const parseBundle = (bundlePath, modulesData)=>{
-    if (bundlePath.indexOf('.worker.') > 0) return {};
-    const ext = (0, external_path_namespaceObject.extname)(bundlePath);
-    if (!types_namespaceObject.Constants.JSExtensions.includes(ext)) return {};
-    let content = external_fs_default().readFileSync(bundlePath, 'utf8');
-    const tagCache = new Map();
-    const sourceMapRegex = /\/\/# sourceMappingURL=[^\n]*$/m;
-    content = content.replace(sourceMapRegex, '');
-    let hasBannerPlugin = content.indexOf('RSDOCTOR_START::') > 0;
-    if (hasBannerPlugin && !tagCache.get(bundlePath)) {
-        const tagMatchResult = getStringBetween(content, 0, /([a-z|A-Z|_]+\.[a-z]+)\(\SRSDOCTOR_START::(.*?)[;,]/, /([a-z|A-Z|_]+\.[a-z]+)\(\SRSDOCTOR_END::(.*?)\)/);
-        content = tagMatchResult.result?.trim() || content;
-        tagCache.set(bundlePath, tagMatchResult.loc);
-        hasBannerPlugin = true;
-    } else if (hasBannerPlugin && !tagCache.get(bundlePath)) {
-        const loc = tagCache.get(bundlePath);
-        content = content.slice(loc.start, loc.end);
-        hasBannerPlugin = true;
-    }
-    const ast = ruleUtils_namespaceObject.parser.internal.parse(content, {
-        sourceType: "script",
-        ecmaVersion: 'latest'
-    });
-    const walkState = {
-        locations: null,
-        expressionStatementDepth: 0
-    };
-    ruleUtils_namespaceObject.parser.walk.recursive(ast, walkState, {
-        ExpressionStatement (node, state, c) {
-            if (state.locations) return;
-            state.expressionStatementDepth++;
-            try {
-                if (1 === state.expressionStatementDepth && isIIFE(node)) {
-                    const fn = getIIFECallExpression(node);
-                    if (0 === fn.arguments.length && 0 === fn.callee.params.length) {
-                        const firstVariableDeclaration = fn.callee.body.body.find((node)=>'VariableDeclaration' === node.type);
-                        if (firstVariableDeclaration) {
-                            for (const declaration of firstVariableDeclaration.declarations)if (declaration.init) {
-                                state.locations = getModulesLocations(declaration.init);
-                                if (state.locations) break;
-                            }
-                        }
-                    }
-                }
-                if (!state.locations) c(node.expression, state);
-            } catch (e) {
-                logger_namespaceObject.logger.debug(e);
-            }
-            state.expressionStatementDepth--;
-        },
-        Program (node, state, _c) {
-            if (state.locations) return;
-            try {
-                if (hasBannerPlugin) {
-                    const firstVariableDeclaration = node.body.find((node)=>'VariableDeclaration' === node.type && node.declarations?.[0]?.init?.type === 'ObjectExpression' && node.declarations?.[0]?.init?.properties?.length);
-                    if (firstVariableDeclaration) {
-                        for (const declaration of firstVariableDeclaration.declarations)if (declaration.init) {
-                            state.locations = getModulesLocations(declaration.init);
-                            if (state.locations) break;
-                        }
-                    }
-                }
-                if (!state.locations) node.body.forEach((n)=>_c(n, state));
-            } catch (e) {
-                logger_namespaceObject.logger.debug(e);
-            }
-            state.expressionStatementDepth--;
-        },
-        AssignmentExpression (node, state) {
-            if (state.locations) return;
-            const { left, right } = node;
-            if (left?.object && 'exports' === left.object.name && left.property && 'modules' === left.property.name && isModulesHash(right)) state.locations = getModulesLocations(right);
-        },
-        CallExpression (node, state, c) {
-            if (state.locations) return;
-            const args = node.arguments;
-            if ('FunctionExpression' === node.callee.type && !node.callee.id && 1 === args.length && isSimpleModulesList(args[0])) {
-                state.locations = getModulesLocations(args[0]);
-                return;
-            }
-            if ('Identifier' === node.callee.type && mayBeAsyncChunkArguments(args) && isModulesList(args[1])) {
-                state.locations = getModulesLocations(args[1]);
-                return;
-            }
-            if (isAsyncChunkPushExpression(node)) {
-                state.locations = getModulesLocations(args[0].elements[1]);
-                return;
-            }
-            if (isAsyncWebWorkerChunkExpression(node)) {
-                state.locations = getModulesLocations(args[1]);
-                return;
-            }
-            args.forEach((arg)=>c(arg, state));
-        }
-    });
-    let modules;
-    modules = walkState.locations ? (0, compat_namespaceObject.mapValues)(walkState.locations, (loc)=>content.slice(loc.start, loc.end)) : {};
-    const modulesObj = {};
-    for(const module in modules){
-        if (!module) return {};
-        const moduleContent = modules[module];
-        const size = moduleContent && Buffer.byteLength(moduleContent);
-        const identifier = (0, compat_namespaceObject.find)(modulesData, {
-            renderId: module
-        })?.identifier || '';
-        modulesObj[identifier] = {
-            size,
-            sizeConvert: (0, external_filesize_namespaceObject.filesize)(size || 0),
-            content: moduleContent
-        };
-    }
-    return {
-        modules: modulesObj,
-        src: content,
-        runtimeSrc: getBundleRuntime(content, walkState.locations)
-    };
-};
-function getBundleRuntime(content, modulesLocations) {
-    const sortedLocations = Object.values(modulesLocations || {}).sort((a, b)=>a.start - b.start);
-    let result = '';
-    let lastIndex = 0;
-    for (const { start, end } of sortedLocations){
-        result += content.slice(lastIndex, start);
-        lastIndex = end;
-    }
-    return result + content.slice(lastIndex, content.length);
-}
-function isIIFE(node) {
-    return 'ExpressionStatement' === node.type && ('CallExpression' === node.expression.type || 'UnaryExpression' === node.expression.type && 'CallExpression' === node.expression.argument.type);
-}
-function getIIFECallExpression(node) {
-    if ('UnaryExpression' === node.expression.type) return node.expression.argument;
-    return node.expression;
-}
-function isModulesList(node) {
-    return isSimpleModulesList(node) || isOptimizedModulesArray(node);
-}
-function isSimpleModulesList(node) {
-    return isModulesHash(node) || isModulesArray(node);
-}
-function isModulesHash(node) {
-    return 'ObjectExpression' === node.type && node.properties.map((node)=>node.value).every(isModuleWrapper);
-}
-function isModulesArray(node) {
-    return 'ArrayExpression' === node.type && node.elements.every((elem)=>!elem || isModuleWrapper(elem));
-}
-function isOptimizedModulesArray(node) {
-    return 'CallExpression' === node.type && 'MemberExpression' === node.callee.type && 'CallExpression' === node.callee.object.type && 'Identifier' === node.callee.object.callee.type && 'Array' === node.callee.object.callee.name && 1 === node.callee.object.arguments.length && isNumericId(node.callee.object.arguments[0]) && 'Identifier' === node.callee.property.type && 'concat' === node.callee.property.name && 1 === node.arguments.length && isModulesArray(node.arguments[0]);
-}
-function isModuleWrapper(node) {
-    return ('FunctionExpression' === node.type || 'ArrowFunctionExpression' === node.type) && !node.id || isModuleId(node) || 'ArrayExpression' === node.type && node.elements.length > 1 && isModuleId(node.elements[0]);
-}
-function isModuleId(node) {
-    return 'Literal' === node.type && (isNumericId(node) || 'string' == typeof node.value);
-}
-function isNumericId(node) {
-    return 'Literal' === node.type && Number.isInteger(node.value) && node.value >= 0;
-}
-function isChunkIds(node) {
-    return 'ArrayExpression' === node.type && node.elements.every(isModuleId);
-}
-function isAsyncChunkPushExpression(node) {
-    const { callee, arguments: args } = node;
-    return 'MemberExpression' === callee.type && 'push' === callee.property.name && 'AssignmentExpression' === callee.object.type && 1 === args.length && 'ArrayExpression' === args[0].type && mayBeAsyncChunkArguments(args[0].elements) && isModulesList(args[0].elements[1]);
-}
-function mayBeAsyncChunkArguments(args) {
-    return args.length >= 2 && isChunkIds(args[0]);
-}
-function isAsyncWebWorkerChunkExpression(node) {
-    const { callee, type, arguments: args } = node;
-    return 'CallExpression' === type && 'MemberExpression' === callee.type && 2 === args.length && isChunkIds(args[0]) && isModulesList(args[1]);
-}
-function getModulesLocations(node) {
-    if ('ObjectExpression' === node.type) {
-        const modulesNodes = node.properties;
-        return modulesNodes.reduce((result, moduleNode)=>{
-            const moduleId = moduleNode.key.name || moduleNode.key.value;
-            result[moduleId] = getModuleLocation(moduleNode.value);
-            return result;
-        }, {});
-    }
-    const isOptimizedArray = 'CallExpression' === node.type;
-    if ('ArrayExpression' === node.type || isOptimizedArray) {
-        const minId = isOptimizedArray ? node.callee.object.arguments[0].value : 0;
-        const modulesNodes = isOptimizedArray ? node.arguments[0].elements : node.elements;
-        return modulesNodes.reduce((result, moduleNode, i)=>{
-            if (moduleNode) result[i + minId] = getModuleLocation(moduleNode);
-            return result;
-        }, {});
-    }
-    return {};
-}
-function getModuleLocation(node) {
-    return {
-        start: node.start,
-        end: node.end
-    };
-}
-function getStringBetween(raw, position, start, end) {
-    try {
-        const matchStart = raw.match(start);
-        const startFlagIndex = matchStart?.length ? raw.indexOf(matchStart[0], position) : -1;
-        if (-1 === startFlagIndex || !matchStart?.length) return {
-            result: null,
-            remain: position
-        };
-        const startTagLength = matchStart[0].length;
-        const matchEnd = raw.match(end);
-        const endFlagIndex = matchEnd?.length ? raw.indexOf(matchEnd[0], startFlagIndex + startTagLength) : -1;
-        if (-1 === endFlagIndex || !matchEnd?.length) return {
-            result: null,
-            remain: position
-        };
-        let innerContent = raw.slice(startFlagIndex + startTagLength, endFlagIndex).trim();
-        if (innerContent.endsWith(',')) innerContent = innerContent.slice(0, -1);
-        return {
-            result: innerContent,
-            remain: matchEnd?.length ? endFlagIndex + matchEnd[0].length : endFlagIndex,
-            loc: {
-                start: startFlagIndex + startTagLength,
-                end: endFlagIndex
-            }
-        };
-    } catch (e) {
-        logger_namespaceObject.logger.debug(()=>e);
-        return {
-            result: null,
-            remain: position
-        };
-    }
-}
-exports.parseBundle = __webpack_exports__.parseBundle;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "parseBundle"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

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

@@ -1,12 +0,0 @@
-import type { ParseBundle } from '@rsdoctor/graph';
-/**
- * The following code is based on
- * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/src/parseUtils.js#L10
- *
- *
- * MIT Licensed
- * Author th0r
- * Copyright JS Foundation and other contributors.
- * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/LICENSE
- */
-export declare const parseBundle: ParseBundle;