@rsdoctor/core 1.2.3 → 1.2.4-beta.1

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

@@ -1,46 +1,14 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __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 ('undefined' != 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__, {
-    hasSetEsModuleStatement: ()=>hasSetEsModuleStatement
-});
-const ruleUtils_namespaceObject = require("@rsdoctor/utils/ruleUtils");
-const esmLabelStatement = ruleUtils_namespaceObject.parser.internal.parseExpressionAt('Object.defineProperty(exports, "__esModule", { value: true })', 0, {
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { parser } from "@rsdoctor/utils/ruleUtils";
+const esmLabelStatement = parser.internal.parseExpressionAt('Object.defineProperty(exports, "__esModule", { value: true })', 0, {
     ecmaVersion: 6,
     ranges: false,
     locations: false,
     sourceType: "script"
 });
 function hasSetEsModuleStatement(program) {
-    const expressions = program.body.filter(ruleUtils_namespaceObject.parser.asserts.isExpressionStatement).map((item)=>item.expression).filter(ruleUtils_namespaceObject.parser.asserts.isSimpleCallExpression);
-    return expressions.some((exp)=>ruleUtils_namespaceObject.parser.utils.isSameSemantics(exp, esmLabelStatement));
+    const expressions = program.body.filter(parser.asserts.isExpressionStatement).map((item)=>item.expression).filter(parser.asserts.isSimpleCallExpression);
+    return expressions.some((exp)=>parser.utils.isSameSemantics(exp, esmLabelStatement));
 }
-exports.hasSetEsModuleStatement = __webpack_exports__.hasSetEsModuleStatement;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "hasSetEsModuleStatement"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { hasSetEsModuleStatement };

package/dist/build-utils/build/module-graph/rspack/transform.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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 ('undefined' != 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__, {
+    patchNativeModuleGraph: ()=>patchNativeModuleGraph,
+    patchNativeModuleIds: ()=>patchNativeModuleIds,
+    patchNativeModuleSources: ()=>patchNativeModuleSources
+});
+const graph_namespaceObject = require("@rsdoctor/graph");
+const types_namespaceObject = require("@rsdoctor/types");
+const createDependencyKind = (type)=>{
+    if (type.includes('harmony')) return types_namespaceObject.SDK.DependencyKind.ImportStatement;
+    if (type.includes('cjs')) return types_namespaceObject.SDK.DependencyKind.RequireCall;
+    if (type.includes('import()')) return types_namespaceObject.SDK.DependencyKind.DynamicImport;
+    if (type.includes('amd')) return types_namespaceObject.SDK.DependencyKind.AMDRequire;
+    return types_namespaceObject.SDK.DependencyKind.Unknown;
+};
+function patchNativeModuleGraph(mg, cg, rawModuleGraph) {
+    const { modules: rawModules, dependencies: rawDependencies, chunkModules: rawChunkModules } = rawModuleGraph;
+    const modules = rawModules.map((module)=>{
+        const res = new graph_namespaceObject.Module(module.identifier, module.path, module.isEntry, 'concatenated' === module.kind ? types_namespaceObject.SDK.ModuleKind.Concatenation : types_namespaceObject.SDK.ModuleKind.Normal, void 0, module.layer);
+        res.setId(module.ukey);
+        return res;
+    });
+    mg.setModules(modules);
+    for (const rawModule of rawModules){
+        const module = mg.getModuleById(rawModule.ukey);
+        if (module) module.setImported(rawModule.imported.map((ukey)=>mg.getModuleById(ukey)).filter(Boolean));
+    }
+    for (const rawModule of rawModules){
+        const module = mg.getModuleById(rawModule.ukey);
+        module.setModules(rawModule.modules.map((ukey)=>mg.getModuleById(ukey)).filter(Boolean));
+    }
+    for (const rawModule of rawModules){
+        const module = mg.getModuleById(rawModule.ukey);
+        if (module) module.setConcatenationModules(rawModule.belongModules.map((ukey)=>mg.getModuleById(ukey)).filter(Boolean));
+    }
+    for (const rawModule of rawModules){
+        const module = mg.getModuleById(rawModule.ukey);
+        if (module) module.setChunks(rawModule.chunks.map((ukey)=>cg.getChunkById(ukey.toString())).filter(Boolean));
+    }
+    for (const rawChunkModule of rawChunkModules){
+        const chunk = cg.getChunkById(rawChunkModule.chunk.toString());
+        if (chunk) chunk.setModules(rawChunkModule.modules.map((ukey)=>mg.getModuleById(ukey)).filter(Boolean));
+    }
+    const deppendencies = rawDependencies.map((dep)=>{
+        const res = new graph_namespaceObject.Dependency(dep.request, mg.getModuleById(dep.module), mg.getModuleById(dep.dependency), createDependencyKind(dep.kind));
+        res.setId(dep.ukey);
+        return res;
+    });
+    mg.setDependencies(deppendencies);
+    for (const rawModule of rawModules){
+        const module = mg.getModuleById(rawModule.ukey);
+        module.setDependencies(rawModule.dependencies.map((ukey)=>mg.getDependencyById(ukey)).filter(Boolean));
+    }
+}
+function patchNativeModuleIds(mg, rawModuleIdsPatch) {
+    const { moduleIds: rawModuleIds } = rawModuleIdsPatch;
+    for (const rawModuleId of rawModuleIds){
+        const module = mg.getModuleById(rawModuleId.module);
+        if (module) module.setRenderId(rawModuleId.renderId);
+    }
+}
+function patchNativeModuleSources(mg, rawModuleSourcesPatch) {
+    const { moduleOriginalSources: rawModuleOriginalSources } = rawModuleSourcesPatch;
+    for (const rawModuleOriginalSource of rawModuleOriginalSources){
+        const module = mg.getModuleById(rawModuleOriginalSource.module);
+        if (module) {
+            module.setSource({
+                source: rawModuleOriginalSource.source
+            });
+            module.setSize({
+                sourceSize: rawModuleOriginalSource.size
+            });
+        }
+    }
+}
+exports.patchNativeModuleGraph = __webpack_exports__.patchNativeModuleGraph;
+exports.patchNativeModuleIds = __webpack_exports__.patchNativeModuleIds;
+exports.patchNativeModuleSources = __webpack_exports__.patchNativeModuleSources;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "patchNativeModuleGraph",
+    "patchNativeModuleIds",
+    "patchNativeModuleSources"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/build-utils/build/module-graph/rspack/transform.d.ts

@@ -18,4 +18,3 @@ export declare function patchNativeModuleIds(mg: SDK.ModuleGraphInstance, rawMod
  * @param rawModuleIdsPatch Raw sources patch data from Rspack native plugin
  */
 export declare function patchNativeModuleSources(mg: SDK.ModuleGraphInstance, rawModuleSourcesPatch: Plugin.RspackNativeModuleSourcePatch): void;
-//# sourceMappingURL=transform.d.ts.map

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

@@ -1,46 +1,18 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __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 ('undefined' != 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__, {
-    patchNativeModuleGraph: ()=>patchNativeModuleGraph,
-    patchNativeModuleIds: ()=>patchNativeModuleIds,
-    patchNativeModuleSources: ()=>patchNativeModuleSources
-});
-const graph_namespaceObject = require("@rsdoctor/graph");
-const types_namespaceObject = require("@rsdoctor/types");
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { Dependency, Module } from "@rsdoctor/graph";
+import { SDK } from "@rsdoctor/types";
 const createDependencyKind = (type)=>{
-    if (type.includes('harmony')) return types_namespaceObject.SDK.DependencyKind.ImportStatement;
-    if (type.includes('cjs')) return types_namespaceObject.SDK.DependencyKind.RequireCall;
-    if (type.includes('import()')) return types_namespaceObject.SDK.DependencyKind.DynamicImport;
-    if (type.includes('amd')) return types_namespaceObject.SDK.DependencyKind.AMDRequire;
-    return types_namespaceObject.SDK.DependencyKind.Unknown;
+    if (type.includes('harmony')) return SDK.DependencyKind.ImportStatement;
+    if (type.includes('cjs')) return SDK.DependencyKind.RequireCall;
+    if (type.includes('import()')) return SDK.DependencyKind.DynamicImport;
+    if (type.includes('amd')) return SDK.DependencyKind.AMDRequire;
+    return SDK.DependencyKind.Unknown;
 };
 function patchNativeModuleGraph(mg, cg, rawModuleGraph) {
     const { modules: rawModules, dependencies: rawDependencies, chunkModules: rawChunkModules } = rawModuleGraph;
     const modules = rawModules.map((module)=>{
-        const res = new graph_namespaceObject.Module(module.identifier, module.path, module.isEntry, 'concatenated' === module.kind ? types_namespaceObject.SDK.ModuleKind.Concatenation : types_namespaceObject.SDK.ModuleKind.Normal, void 0, module.layer);
+        const res = new Module(module.identifier, module.path, module.isEntry, 'concatenated' === module.kind ? SDK.ModuleKind.Concatenation : SDK.ModuleKind.Normal, void 0, module.layer);
         res.setId(module.ukey);
         return res;
     });
@@ -66,7 +38,7 @@ function patchNativeModuleGraph(mg, cg, rawModuleGraph) {
         if (chunk) chunk.setModules(rawChunkModule.modules.map((ukey)=>mg.getModuleById(ukey)).filter(Boolean));
     }
     const deppendencies = rawDependencies.map((dep)=>{
-        const res = new graph_namespaceObject.Dependency(dep.request, mg.getModuleById(dep.module), mg.getModuleById(dep.dependency), createDependencyKind(dep.kind));
+        const res = new Dependency(dep.request, mg.getModuleById(dep.module), mg.getModuleById(dep.dependency), createDependencyKind(dep.kind));
         res.setId(dep.ukey);
         return res;
     });
@@ -97,14 +69,4 @@ function patchNativeModuleSources(mg, rawModuleSourcesPatch) {
         }
     }
 }
-exports.patchNativeModuleGraph = __webpack_exports__.patchNativeModuleGraph;
-exports.patchNativeModuleIds = __webpack_exports__.patchNativeModuleIds;
-exports.patchNativeModuleSources = __webpack_exports__.patchNativeModuleSources;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "patchNativeModuleGraph",
-    "patchNativeModuleIds",
-    "patchNativeModuleSources"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { patchNativeModuleGraph, patchNativeModuleIds, patchNativeModuleSources };

package/dist/build-utils/build/module-graph/transform.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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 ('undefined' != 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__, {
+    getModuleGraphByStats: ()=>getModuleGraphByStats
+});
+const graph_namespaceObject = require("@rsdoctor/graph");
+const external_index_cjs_namespaceObject = require("./index.cjs");
+function getModuleGraphByStats(compilation, stats, root, chunkGraph, features, context) {
+    return (0, external_index_cjs_namespaceObject.appendModuleGraphByCompilation)(compilation, graph_namespaceObject.ModuleGraphTrans.getModuleGraphByStats(stats, root, chunkGraph), features, context);
+}
+exports.getModuleGraphByStats = __webpack_exports__.getModuleGraphByStats;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getModuleGraphByStats"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/build-utils/build/module-graph/transform.d.ts

@@ -2,4 +2,3 @@ import { Plugin } from '@rsdoctor/types';
 import { TransformContext } from '.';
 import { SDK } from '@rsdoctor/types';
 export declare function getModuleGraphByStats(compilation: Plugin.BaseCompilation, stats: Plugin.StatsCompilation, root: string, chunkGraph: SDK.ChunkGraphInstance, features?: Plugin.RsdoctorWebpackPluginFeatures, context?: TransformContext): Promise<SDK.ModuleGraphInstance>;
-//# sourceMappingURL=transform.d.ts.map

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

@@ -1,40 +1,8 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __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 ('undefined' != 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__, {
-    getModuleGraphByStats: ()=>getModuleGraphByStats
-});
-const index_js_namespaceObject = require("../../common/module-graph/index.js");
-const external_index_js_namespaceObject = require("./index.js");
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { ModuleGraphTrans } from "@rsdoctor/graph";
+import { appendModuleGraphByCompilation } from "./index.js";
 function getModuleGraphByStats(compilation, stats, root, chunkGraph, features, context) {
-    return (0, external_index_js_namespaceObject.appendModuleGraphByCompilation)(compilation, (0, index_js_namespaceObject.getModuleGraphByStats)(stats, root, chunkGraph), features, context);
+    return appendModuleGraphByCompilation(compilation, ModuleGraphTrans.getModuleGraphByStats(stats, root, chunkGraph), features, context);
 }
-exports.getModuleGraphByStats = __webpack_exports__.getModuleGraphByStats;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "getModuleGraphByStats"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { getModuleGraphByStats };

package/dist/build-utils/build/module-graph/treeShaking.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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 ('undefined' != 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__, {
+    appendTreeShaking: ()=>appendTreeShaking
+});
+const graph_namespaceObject = require("@rsdoctor/graph");
+const external_utils_cjs_namespaceObject = require("./utils.cjs");
+function transformMgm(origin, webpackGraph, graph, cache) {
+    const module = graph.getModuleByWebpackId(origin.identifier());
+    if (!module) return;
+    const mgm = new graph_namespaceObject.ModuleGraphModule(module, graph);
+    const originalMgm = webpackGraph.getExportsInfo(origin);
+    graph.addModuleGraphModule(mgm);
+    for (const info of originalMgm.exports){
+        const { name } = info;
+        const exportIdStatement = (0, external_utils_cjs_namespaceObject.getExportIdentifierStatement)(name, module) ?? graph_namespaceObject.Statement.getDefaultStatement(module);
+        const declareIdStatement = (0, external_utils_cjs_namespaceObject.getDeclarationIdentifier)(name, module);
+        const exportInfo = new graph_namespaceObject.ExportInfo(info.name, exportIdStatement);
+        if (declareIdStatement) {
+            const variable = new graph_namespaceObject.Variable(name, module, info.getUsedInfo(), declareIdStatement);
+            variable.setExportInfo(exportInfo);
+            mgm.addVariable(variable);
+        }
+        cache.set(info, exportInfo);
+        mgm.addExportInfo(exportInfo);
+    }
+    for (const dep of origin.dependencies){
+        if ('harmony import specifier' !== dep.type) continue;
+        const HISDep = dep;
+        const { name, userRequest } = HISDep;
+        const originName = HISDep.getIds(webpackGraph)[0] ?? graph_namespaceObject.SideEffect.NamespaceSymbol;
+        const importIdStatement = module.getStatement(dep.loc);
+        const importInfo = new graph_namespaceObject.SideEffect(name, module, importIdStatement, userRequest, originName);
+        mgm.addSideEffect(importInfo);
+    }
+}
+function appendExportConnection(origin, webpackGraph, graph, cache) {
+    const module = graph.getModuleByWebpackId(origin.identifier());
+    const mgm = graph.getModuleGraphModule(module);
+    const originalMgm = webpackGraph.getExportsInfo(origin);
+    if (!mgm || !module) return;
+    for (const info of originalMgm.exports){
+        if (!info.isReexport()) continue;
+        const lastExport = graph_namespaceObject.Webpack.getLastExportInfo(info, webpackGraph);
+        const lastSdkExport = cache.get(lastExport);
+        const sdkExport = cache.get(info);
+        if (!lastSdkExport || !sdkExport) return;
+        sdkExport.setFromExport(lastSdkExport);
+    }
+}
+function appendImportConnection(origin, graph) {
+    const module = graph.getModuleByWebpackId(origin.identifier());
+    const mgm = graph.getModuleGraphModule(module);
+    if (!mgm || !module) return;
+    for (const info of mgm.getSideEffects()){
+        var _info_fromDependency;
+        const exportName = info.originName ?? info.name;
+        const resolveModule = null == (_info_fromDependency = info.fromDependency) ? void 0 : _info_fromDependency.dependency;
+        if (!resolveModule) continue;
+        const resolveExport = graph.getModuleGraphModule(resolveModule).getExport(exportName);
+        if (resolveExport) info.setExportInfo(resolveExport);
+    }
+}
+function appendTreeShaking(moduleGraph, compilation) {
+    if (!graph_namespaceObject.ModuleGraphTrans.isWebpack5orRspack(compilation)) return moduleGraph;
+    if ('moduleGraph' in compilation) {
+        const exportData = new Map();
+        const webpackCompilation = compilation;
+        const { moduleGraph: webpackGraph } = webpackCompilation;
+        const allModules = graph_namespaceObject.Webpack.getAllModules(webpackCompilation);
+        allModules.forEach((origin)=>transformMgm(origin, webpackGraph, moduleGraph, exportData));
+        allModules.forEach((origin)=>appendExportConnection(origin, webpackGraph, moduleGraph, exportData));
+        allModules.forEach((origin)=>appendImportConnection(origin, moduleGraph));
+        exportData.clear();
+    }
+    return moduleGraph;
+}
+exports.appendTreeShaking = __webpack_exports__.appendTreeShaking;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "appendTreeShaking"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/build-utils/build/module-graph/treeShaking.d.ts

@@ -1,3 +1,2 @@
 import type { SDK, Plugin } from '@rsdoctor/types';
 export declare function appendTreeShaking(moduleGraph: SDK.ModuleGraphInstance, compilation: Plugin.BaseCompilation): SDK.ModuleGraphInstance;
-//# sourceMappingURL=treeShaking.d.ts.map

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

@@ -1,48 +1,20 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __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 ('undefined' != 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__, {
-    appendTreeShaking: ()=>appendTreeShaking
-});
-const graph_namespaceObject = require("@rsdoctor/graph");
-const compatible_js_namespaceObject = require("../../common/webpack/compatible.js");
-const external_utils_js_namespaceObject = require("./utils.js");
-const index_js_namespaceObject = require("../../common/module-graph/index.js");
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { ExportInfo, ModuleGraphModule, ModuleGraphTrans, SideEffect, Statement, Variable, Webpack } from "@rsdoctor/graph";
+import { getDeclarationIdentifier, getExportIdentifierStatement } from "./utils.js";
 function transformMgm(origin, webpackGraph, graph, cache) {
     const module = graph.getModuleByWebpackId(origin.identifier());
     if (!module) return;
-    const mgm = new graph_namespaceObject.ModuleGraphModule(module, graph);
+    const mgm = new ModuleGraphModule(module, graph);
     const originalMgm = webpackGraph.getExportsInfo(origin);
     graph.addModuleGraphModule(mgm);
     for (const info of originalMgm.exports){
         const { name } = info;
-        const exportIdStatement = (0, external_utils_js_namespaceObject.getExportIdentifierStatement)(name, module) ?? graph_namespaceObject.Statement.getDefaultStatement(module);
-        const declareIdStatement = (0, external_utils_js_namespaceObject.getDeclarationIdentifier)(name, module);
-        const exportInfo = new graph_namespaceObject.ExportInfo(info.name, exportIdStatement);
+        const exportIdStatement = getExportIdentifierStatement(name, module) ?? Statement.getDefaultStatement(module);
+        const declareIdStatement = getDeclarationIdentifier(name, module);
+        const exportInfo = new ExportInfo(info.name, exportIdStatement);
         if (declareIdStatement) {
-            const variable = new graph_namespaceObject.Variable(name, module, info.getUsedInfo(), declareIdStatement);
+            const variable = new Variable(name, module, info.getUsedInfo(), declareIdStatement);
             variable.setExportInfo(exportInfo);
             mgm.addVariable(variable);
         }
@@ -53,9 +25,9 @@ function transformMgm(origin, webpackGraph, graph, cache) {
         if ('harmony import specifier' !== dep.type) continue;
         const HISDep = dep;
         const { name, userRequest } = HISDep;
-        const originName = HISDep.getIds(webpackGraph)[0] ?? graph_namespaceObject.SideEffect.NamespaceSymbol;
+        const originName = HISDep.getIds(webpackGraph)[0] ?? SideEffect.NamespaceSymbol;
         const importIdStatement = module.getStatement(dep.loc);
-        const importInfo = new graph_namespaceObject.SideEffect(name, module, importIdStatement, userRequest, originName);
+        const importInfo = new SideEffect(name, module, importIdStatement, userRequest, originName);
         mgm.addSideEffect(importInfo);
     }
 }
@@ -66,7 +38,7 @@ function appendExportConnection(origin, webpackGraph, graph, cache) {
     if (!mgm || !module) return;
     for (const info of originalMgm.exports){
         if (!info.isReexport()) continue;
-        const lastExport = (0, compatible_js_namespaceObject.getLastExportInfo)(info, webpackGraph);
+        const lastExport = Webpack.getLastExportInfo(info, webpackGraph);
         const lastSdkExport = cache.get(lastExport);
         const sdkExport = cache.get(info);
         if (!lastSdkExport || !sdkExport) return;
@@ -87,12 +59,12 @@ function appendImportConnection(origin, graph) {
     }
 }
 function appendTreeShaking(moduleGraph, compilation) {
-    if (!(0, index_js_namespaceObject.isWebpack5orRspack)(compilation)) return moduleGraph;
+    if (!ModuleGraphTrans.isWebpack5orRspack(compilation)) return moduleGraph;
     if ('moduleGraph' in compilation) {
         const exportData = new Map();
         const webpackCompilation = compilation;
         const { moduleGraph: webpackGraph } = webpackCompilation;
-        const allModules = (0, compatible_js_namespaceObject.getAllModules)(webpackCompilation);
+        const allModules = Webpack.getAllModules(webpackCompilation);
         allModules.forEach((origin)=>transformMgm(origin, webpackGraph, moduleGraph, exportData));
         allModules.forEach((origin)=>appendExportConnection(origin, webpackGraph, moduleGraph, exportData));
         allModules.forEach((origin)=>appendImportConnection(origin, moduleGraph));
@@ -100,10 +72,4 @@ function appendTreeShaking(moduleGraph, compilation) {
     }
     return moduleGraph;
 }
-exports.appendTreeShaking = __webpack_exports__.appendTreeShaking;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "appendTreeShaking"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { appendTreeShaking };

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

@@ -0,0 +1,97 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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 ('undefined' != 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__, {
+    getDeclarationIdentifier: ()=>getDeclarationIdentifier,
+    getExportIdentifierStatement: ()=>getExportIdentifierStatement
+});
+const external_lodash_es_namespaceObject = require("lodash-es");
+const ruleUtils_namespaceObject = require("@rsdoctor/utils/ruleUtils");
+function getDefaultExportIdentifier(node, module, searchId) {
+    var _node_declaration_loc;
+    const { declaration } = node;
+    if (ruleUtils_namespaceObject.parser.asserts.isLiteral(declaration) && declaration.loc) return module.getStatement(declaration.loc);
+    if (ruleUtils_namespaceObject.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 (ruleUtils_namespaceObject.parser.asserts.isClassDeclaration(declaration) || ruleUtils_namespaceObject.parser.asserts.isFunctionDeclaration(declaration)) {
+        var _declaration_id;
+        if (null == (_declaration_id = declaration.id) ? void 0 : _declaration_id.loc) return module.getStatement(declaration.id.loc);
+    }
+    const startLine = null == (_node_declaration_loc = node.declaration.loc) ? void 0 : _node_declaration_loc.start.line;
+    if (!(0, external_lodash_es_namespaceObject.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 (ruleUtils_namespaceObject.parser.asserts.isExportDefaultDeclaration(node)) {
+            const result = getDefaultExportIdentifier(node, module, false);
+            if (result) return result;
+        }
+        const id = ruleUtils_namespaceObject.parser.utils.getIdentifierInExport(name, node);
+        if (null == id ? void 0 : 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 = ruleUtils_namespaceObject.parser.utils.getIdentifierInDeclaration(name, node);
+        if (null == id ? void 0 : id.loc) return module.getStatement(id.loc);
+        if (ruleUtils_namespaceObject.parser.asserts.isExportNamedDeclaration(node) && node.declaration) {
+            const id = ruleUtils_namespaceObject.parser.utils.getIdentifierInDeclaration(name, node.declaration);
+            if (null == id ? void 0 : id.loc) return module.getStatement(id.loc);
+        }
+        if ('default' === name && ruleUtils_namespaceObject.parser.asserts.isExportDefaultDeclaration(node)) {
+            const result = getDefaultExportIdentifier(node, module, true);
+            if (result) return result;
+        }
+    }
+}
+exports.getDeclarationIdentifier = __webpack_exports__.getDeclarationIdentifier;
+exports.getExportIdentifierStatement = __webpack_exports__.getExportIdentifierStatement;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getDeclarationIdentifier",
+    "getExportIdentifierStatement"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});