@shuvi/toolpack 0.0.1-rc.9 → 1.0.0-rc.10

package/lib/webpack/dynamic-dll/bundler/index.js

@@ -0,0 +1,211 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bundler = void 0;
+const webpack_1 = require("webpack");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+const constants_1 = require("../constants");
+const dep_1 = require("../dep");
+const metadata_1 = require("../metadata");
+const utils_1 = require("../utils");
+const webpack_config_1 = require("./webpack-config");
+function getHash(text) {
+    return (0, crypto_1.createHash)('sha256').update(text).digest('hex').substring(0, 8);
+}
+/**
+ * hash everything that can change the build result
+ *
+ * @param {BuildOptions} options
+ * @returns {string}
+ */
+function getMainHash(options) {
+    let content = JSON.stringify({
+        shared: options.shared
+    });
+    return getHash([utils_1.version, content].join(''));
+}
+function getBuildHash(hash, snapshot) {
+    return getHash(hash + JSON.stringify(snapshot));
+}
+function getWebpackConfig({ deps, entry, outputDir, shared, externals, esmFullSpecific }) {
+    const exposes = deps.reduce((memo, dep) => {
+        memo[`./${dep.request}`] = dep.filename;
+        return memo;
+    }, {});
+    const chain = (0, webpack_config_1.getConfig)({
+        name: constants_1.NAME,
+        entry,
+        filename: constants_1.DLL_FILENAME,
+        outputDir,
+        publicPath: constants_1.DEFAULT_PUBLIC_PATH,
+        shared,
+        externals,
+        esmFullSpecific,
+        exposes
+    });
+    return chain.toConfig();
+}
+function buildDeps({ deps, dir }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        (0, fs_extra_1.mkdirpSync)(dir);
+        // expose files
+        yield Promise.all(deps.map((dep) => __awaiter(this, void 0, void 0, function* () {
+            const content = yield dep.buildExposeContent();
+            yield (0, fs_extra_1.writeFile)(dep.filename, content, 'utf-8');
+        })));
+        // index file
+        (0, fs_extra_1.writeFileSync)((0, path_1.join)(dir, 'index.js'), 'export default "dynamicDll index.js";', 'utf-8');
+        return deps;
+    });
+}
+function webpackBuild(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            console.log(`[@shuvi/dll]: Bundle start`);
+            const compiler = (0, webpack_1.webpack)(config);
+            compiler.run((err, stats) => {
+                if (err || (stats === null || stats === void 0 ? void 0 : stats.hasErrors())) {
+                    if (err) {
+                        reject(err);
+                    }
+                    if (stats) {
+                        const errorMsg = stats.toString('errors-only');
+                        reject(new Error(errorMsg));
+                    }
+                }
+                else {
+                    resolve(stats);
+                }
+                compiler.close(() => { });
+            });
+        });
+    });
+}
+function isSnapshotSame(pre, cur) {
+    const keys = Object.keys(cur);
+    for (let index = 0; index < keys.length; index++) {
+        const id = keys[index];
+        const preItem = pre[id];
+        const nextItem = cur[id];
+        if (!preItem) {
+            return false;
+        }
+        if (preItem.version !== nextItem.version) {
+            return false;
+        }
+    }
+    return true;
+}
+class Bundler {
+    constructor() {
+        this._nextBuild = null;
+        this._completeFns = [];
+        this._isBuilding = false;
+    }
+    build(snapshot, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._isBuilding) {
+                this._nextBuild = snapshot;
+                return;
+            }
+            let error = null;
+            this._isBuilding = true;
+            let hasBuild = false;
+            let timer = new Date().getTime();
+            try {
+                [hasBuild] = yield this._buildDll(snapshot, options);
+            }
+            catch (err) {
+                error = err;
+            }
+            this._isBuilding = false;
+            if (error) {
+                console.error(`[@shuvi/dll]: Bundle Error`);
+                console.error(error);
+            }
+            this._completeFns.forEach(fn => fn(error));
+            this._completeFns = [];
+            if (hasBuild) {
+                console.log(`[@shuvi/dll]: Bundle Success, cost ${new Date().getTime() - timer}ms`);
+                timer = new Date().getTime();
+            }
+        });
+    }
+    _buildDll(snapshot, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { externals = {}, shared = {}, outputDir, force, esmFullSpecific = true } = options;
+            const mainHash = getMainHash(options);
+            const dllDir = (0, utils_1.getDllDir)(outputDir);
+            const preMetadata = (0, metadata_1.getMetadata)(outputDir);
+            const metadata = {
+                hash: mainHash,
+                buildHash: preMetadata.buildHash,
+                modules: snapshot
+            };
+            if (!force &&
+                preMetadata.hash === metadata.hash &&
+                isSnapshotSame(preMetadata.modules, snapshot)) {
+                return [false, preMetadata];
+            }
+            const dllPendingDir = (0, utils_1.getDllPendingDir)(outputDir);
+            // create a temporal dir to build. This avoids leaving the dll
+            // in a corrupted state if there is an error during the build
+            if ((0, fs_extra_1.existsSync)(dllPendingDir)) {
+                (0, fs_extra_1.emptyDirSync)(dllPendingDir);
+            }
+            const depsDir = (0, utils_1.getDepsDir)(dllPendingDir);
+            const deps = Object.entries(snapshot).map(([request, { version, libraryPath }]) => {
+                return new dep_1.Dep({
+                    request,
+                    libraryPath,
+                    version,
+                    outputPath: depsDir
+                });
+            });
+            yield buildDeps({
+                deps,
+                dir: depsDir
+            });
+            let timer = new Date().getTime();
+            yield webpackBuild(getWebpackConfig({
+                deps,
+                entry: (0, path_1.join)(depsDir, 'index.js'),
+                shared,
+                externals,
+                esmFullSpecific,
+                outputDir: dllPendingDir
+            }));
+            console.log(`[dll Bundle time]: ${new Date().getTime() - timer}ms`);
+            if (this._nextBuild) {
+                const param = this._nextBuild;
+                this._nextBuild = null;
+                return yield this._buildDll(param, options);
+            }
+            metadata.buildHash = getBuildHash(metadata.hash, snapshot);
+            // finish build
+            (0, metadata_1.writeMetadata)(dllPendingDir, metadata);
+            (0, fs_extra_1.removeSync)(dllDir);
+            (0, fs_extra_1.renameSync)(dllPendingDir, dllDir);
+            return [true, metadata];
+        });
+    }
+    onBuildComplete(fn) {
+        if (this._isBuilding) {
+            this._completeFns.push(fn);
+        }
+        else {
+            fn();
+        }
+    }
+}
+exports.Bundler = Bundler;

package/lib/webpack/dynamic-dll/bundler/webpack-config.d.ts

@@ -0,0 +1,16 @@
+import WebpackChain from 'webpack-chain';
+import type { Configuration } from 'webpack';
+declare type ShareConfig = Record<string, any>;
+export interface ConfigOptions {
+    name: string;
+    entry: string;
+    filename: string;
+    outputDir: string;
+    publicPath: string;
+    shared?: ShareConfig;
+    externals: Configuration['externals'];
+    esmFullSpecific: Boolean;
+    exposes: Record<string, string>;
+}
+export declare function getConfig({ name, entry, filename, outputDir, publicPath, shared, externals, esmFullSpecific, exposes }: ConfigOptions): WebpackChain;
+export {};

package/lib/webpack/dynamic-dll/bundler/webpack-config.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const webpack_1 = __importDefault(require("webpack"));
+const webpack_chain_1 = __importDefault(require("webpack-chain"));
+const moduleFileExtensions = [
+    '.web.mjs',
+    '.mjs',
+    '.web.js',
+    '.js',
+    '.json',
+    '.web.jsx',
+    '.jsx'
+];
+function getConfig({ name, entry, filename, outputDir, publicPath, shared, externals, esmFullSpecific, exposes }) {
+    const config = new webpack_chain_1.default();
+    config.mode('development');
+    config.entry('main').add(entry);
+    config.devtool('cheap-module-source-map');
+    config.bail(true);
+    config.watch(false);
+    config.set('infrastructureLogging', {
+        level: 'none'
+    });
+    config.output.merge({
+        pathinfo: false,
+        path: outputDir,
+        chunkFilename: '[name].js',
+        publicPath,
+        uniqueName: name
+    });
+    config.performance.hints(false);
+    config.optimization.merge({
+        emitOnErrors: true,
+        checkWasmTypes: false,
+        // need to use DefinePlugin to set process.env.NODE_ENV
+        nodeEnv: false,
+        runtimeChunk: false,
+        minimize: false,
+        realContentHash: false
+    });
+    config.optimization.splitChunks({
+        chunks: 'all',
+        maxInitialRequests: Infinity,
+        minSize: 0,
+        cacheGroups: {
+            vendor: {
+                test: /.+/,
+                name(_module, _chunks, cacheGroupKey) {
+                    return `_${cacheGroupKey}`;
+                }
+            }
+        }
+    });
+    config.resolve.extensions.merge(moduleFileExtensions);
+    config.module.set('strictExportPresence', true);
+    // x-ref: https://github.com/webpack/webpack/issues/11467
+    if (!esmFullSpecific) {
+        config.module
+            .rule('webpackPatch')
+            .test(/\.m?js/)
+            .resolve.set('fullySpecified', false);
+    }
+    config.module
+        .rule('js')
+        .test(/\.(js|mjs|cjs|jsx)$/)
+        .use('esbuild-loader')
+        .loader(require.resolve('esbuild-loader'))
+        .options({
+        loader: 'jsx',
+        target: 'es2015' // Syntax to compile to (see options below for possible values)
+    });
+    const DLL_VERSION = require('../../../../package.json').version;
+    const stringifiedConfig = Object.entries({
+        esmFullSpecific,
+        shared
+    }).reduce((prev, [key, value]) => {
+        return `${prev}|${key}=${JSON.stringify(value)}`;
+    }, '');
+    config.cache({
+        cacheDirectory: path_1.default.join(outputDir, '../cache'),
+        type: 'filesystem',
+        name: `dll-cache}-${config.get('mode')}`,
+        version: `${DLL_VERSION}|${stringifiedConfig}`
+    });
+    config.plugin('private/ignore-plugin').use(webpack_1.default.IgnorePlugin, [
+        {
+            resourceRegExp: /^\.\/locale$/,
+            contextRegExp: /moment$/
+        }
+    ]);
+    config.plugin('define').use(webpack_1.default.DefinePlugin, [
+        {
+            'process.env.NODE_ENV': JSON.stringify('development')
+        }
+    ]);
+    config.plugin('private/mf').use(webpack_1.default.container.ModuleFederationPlugin, [
+        {
+            library: {
+                type: 'global',
+                name
+            },
+            name,
+            filename,
+            exposes,
+            shared
+        }
+    ]);
+    config.externals(externals);
+    return config;
+}
+exports.getConfig = getConfig;

package/lib/webpack/dynamic-dll/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const NAME = "dll";
+export declare const MF_VA_PREFIX = "vf_";
+export declare const DEFAULT_PUBLIC_PATH: string;
+export declare const DLL_FILENAME = "dll.js";
+export declare const METADATA_FILENAME = "_metadata.json";
+export declare const UPDATE_FILENAME = "_update.json";

package/lib/webpack/dynamic-dll/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPDATE_FILENAME = exports.METADATA_FILENAME = exports.DLL_FILENAME = exports.DEFAULT_PUBLIC_PATH = exports.MF_VA_PREFIX = exports.NAME = void 0;
+exports.NAME = 'dll';
+exports.MF_VA_PREFIX = 'vf_';
+exports.DEFAULT_PUBLIC_PATH = `/__${exports.NAME}/`;
+exports.DLL_FILENAME = 'dll.js';
+exports.METADATA_FILENAME = '_metadata.json';
+exports.UPDATE_FILENAME = '_update.json';

package/lib/webpack/dynamic-dll/dep/getCJSExports.d.ts

@@ -0,0 +1,3 @@
+export declare function getCJSExports({ content }: {
+    content: string;
+}): string[];

package/lib/webpack/dynamic-dll/dep/getCJSExports.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCJSExports = void 0;
+function getCJSExports({ content }) {
+    return matchAll(/Object\.defineProperty\(\s*exports\s*\,\s*[\"|\'](\w+)[\"|\']/g, content)
+        .concat(
+    // Support export['default']
+    // ref: https://unpkg.alibaba-inc.com/browse/echarts-for-react@2.0.16/lib/core.js
+    matchAll(/exports(?:\.|\[(?:\'|\"))(\w+)(?:\s*|(?:\'|\")\])\s*\=/g, content))
+        .concat(
+    // Support __webpack_exports__["default"]
+    // ref: https://github.com/margox/braft-editor/blob/master/dist/index.js#L8429
+    matchAll(/__webpack_exports__\[(?:\"|\')(\w+)(?:\"|\')\]\s*\=/g, content))
+        .concat(
+    // Support __webpack_require__.d(__webpack_exports, "EditorState")
+    // ref: https://github.com/margox/braft-editor/blob/master/dist/index.js#L8347
+    matchAll(/__webpack_require__\.d\(\s*__webpack_exports__\s*,\s*(?:\"|\')(\w+)(?:\"|\')\s*,/g, content))
+        .concat(
+    // Support __webpack_require__.d(__webpack_exports__, {"default": function() { return /* binding */ clipboard; }});
+    // ref: https://unpkg.alibaba-inc.com/browse/clipboard@2.0.8/dist/clipboard.js L26
+    ...matchAll(/__webpack_require__\.d\(\s*__webpack_exports__\s*,\s*(\{)/g, content).map(matchResult => {
+        const { index } = matchResult;
+        let idx = index;
+        let deep = 0;
+        let isMeetSymbol = false;
+        let symbolBeginIndex = index;
+        while (idx < content.length) {
+            if (!deep && isMeetSymbol) {
+                break;
+            }
+            if (content[idx] === '{') {
+                if (!isMeetSymbol) {
+                    isMeetSymbol = true;
+                    symbolBeginIndex = idx;
+                }
+                deep++;
+            }
+            if (content[idx] === '}') {
+                deep--;
+            }
+            idx++;
+        }
+        let result = content.slice(symbolBeginIndex, idx);
+        return [
+            ...matchAll(/(?:\"|\')(\w+)(?:\"|\')\s*\:\s*(?:function|\()/g, result)
+        ];
+    }))
+        .map(result => result[1]);
+}
+exports.getCJSExports = getCJSExports;
+function matchAll(regexp, str) {
+    const result = [];
+    let match;
+    while ((match = regexp.exec(str)) !== null) {
+        result.push(match);
+    }
+    return result;
+}

package/lib/webpack/dynamic-dll/dep/getExposeFromContent.d.ts

@@ -0,0 +1 @@
+export declare function getExposeFromContent(libraryPath: string): Promise<string>;

package/lib/webpack/dynamic-dll/dep/getExposeFromContent.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExposeFromContent = void 0;
+const assert_1 = __importDefault(require("assert"));
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const getModuleExports_1 = require("./getModuleExports");
+function getExposeFromContent(libraryPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Support CSS
+        if (/\.(css|less|scss|sass|stylus|styl)$/.test(libraryPath)) {
+            return `import '${libraryPath}';`;
+        }
+        // Support Assets Files
+        if (/\.(json|svg|png|jpe?g|avif|gif|webp|ico|eot|woff|woff2|ttf|txt|text|mdx?)$/.test(libraryPath)) {
+            return `
+import _ from '${libraryPath}';
+export default _;`.trim();
+        }
+        (0, assert_1.default)(/(js|jsx|mjs|ts|tsx)$/.test(libraryPath), `file type not supported for ${(0, path_1.basename)(libraryPath)}.`);
+        const content = (0, fs_extra_1.readFileSync)(libraryPath, 'utf-8');
+        const { exports, isCJS } = yield (0, getModuleExports_1.getModuleExports)({
+            content,
+            libraryPath
+        });
+        // cjs
+        if (isCJS) {
+            return [
+                `import _ from '${libraryPath}';`,
+                `export default _;`,
+                `export * from '${libraryPath}';`
+            ].join('\n');
+        }
+        // esm
+        else {
+            const ret = [];
+            let hasExports = false;
+            if (exports.includes('default')) {
+                ret.push(`import _ from '${libraryPath}';`);
+                ret.push(`export default _;`);
+                hasExports = true;
+            }
+            if (hasNonDefaultExports(exports) ||
+                // export * from 不会有 exports，只会有 imports
+                /export\s+\*\s+from/.test(content)) {
+                ret.push(`export * from '${libraryPath}';`);
+                hasExports = true;
+            }
+            if (!hasExports) {
+                // 只有 __esModule 的全量导出
+                if (exports.includes('__esModule') && exports.length > 1) {
+                    ret.push(`import _ from '${libraryPath}';`);
+                    ret.push(`export default _;`);
+                    ret.push(`export * from '${libraryPath}';`);
+                }
+                else {
+                    ret.push(`import '${libraryPath}';`);
+                }
+            }
+            return ret.join('\n');
+        }
+    });
+}
+exports.getExposeFromContent = getExposeFromContent;
+function hasNonDefaultExports(exports) {
+    return (exports.filter((exp) => !['__esModule', 'default'].includes(exp))
+        .length > 0);
+}

package/lib/webpack/dynamic-dll/dep/getModuleExports.d.ts

@@ -0,0 +1,7 @@
+export declare function getModuleExports({ content, libraryPath }: {
+    libraryPath: string;
+    content: string;
+}): Promise<{
+    exports: any;
+    isCJS: boolean;
+}>;

package/lib/webpack/dynamic-dll/dep/getModuleExports.js

@@ -0,0 +1,46 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModuleExports = void 0;
+// @ts-ignore: es-module-lexer misconfigure its package.exports
+const es_module_lexer_1 = require("es-module-lexer");
+const esbuild_1 = require("esbuild");
+const path_1 = require("path");
+const getCJSExports_1 = require("./getCJSExports");
+function getModuleExports({ content, libraryPath }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Support tsx and jsx
+        if (/\.(tsx|jsx)$/.test(libraryPath)) {
+            content = (yield (0, esbuild_1.transform)(content, {
+                sourcemap: false,
+                sourcefile: libraryPath,
+                format: 'esm',
+                target: 'es6',
+                loader: (0, path_1.extname)(libraryPath).slice(1)
+            })).code;
+        }
+        yield es_module_lexer_1.init;
+        const [imports, exports] = (0, es_module_lexer_1.parse)(content);
+        let isCJS = !imports.length && !exports.length;
+        let cjsEsmExports = null;
+        if (isCJS) {
+            cjsEsmExports = (0, getCJSExports_1.getCJSExports)({ content });
+            if (cjsEsmExports.includes('__esModule')) {
+                isCJS = false;
+            }
+        }
+        return {
+            exports: cjsEsmExports || exports,
+            isCJS
+        };
+    });
+}
+exports.getModuleExports = getModuleExports;

package/lib/webpack/dynamic-dll/dep/index.d.ts

@@ -0,0 +1,13 @@
+export declare class Dep {
+    request: string;
+    version: string | null;
+    libraryPath: string;
+    filename: string;
+    constructor(opts: {
+        outputPath: string;
+        request: string;
+        libraryPath: string;
+        version: string | null;
+    });
+    buildExposeContent(): Promise<string>;
+}

package/lib/webpack/dynamic-dll/dep/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dep = void 0;
+const path_1 = require("path");
+const constants_1 = require("../constants");
+const getExposeFromContent_1 = require("./getExposeFromContent");
+function trimFileContent(content) {
+    return content.trim() + '\n';
+}
+class Dep {
+    constructor(opts) {
+        this.request = opts.request;
+        this.libraryPath = opts.libraryPath;
+        this.version = opts.version;
+        const name = this.request.replace(/\//g, '_').replace(/:/g, '_');
+        this.filename = (0, path_1.join)(opts.outputPath, `${constants_1.MF_VA_PREFIX}${name}.js`);
+    }
+    buildExposeContent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // node natives
+            // @ts-ignore
+            const isNodeNatives = !!process.binding('natives')[this.request];
+            if (isNodeNatives) {
+                return trimFileContent(`
+import _ from '${this.request}';
+export default _;
+export * from '${this.request}';
+      `);
+            }
+            return yield (0, getExposeFromContent_1.getExposeFromContent)(this.libraryPath);
+        });
+    }
+}
+exports.Dep = Dep;

package/lib/webpack/dynamic-dll/helper/check-not-in-node-modules.d.ts

@@ -0,0 +1 @@
+export declare const checkNotInNodeModules: (libraryName: string, rootDir: string) => boolean;

package/lib/webpack/dynamic-dll/helper/check-not-in-node-modules.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNotInNodeModules = void 0;
+const checkNotInNodeModules = (libraryName, rootDir) => {
+    try {
+        require.resolve(libraryName, {
+            paths: [rootDir]
+        });
+        return false;
+    }
+    catch (e) {
+        return true;
+    }
+};
+exports.checkNotInNodeModules = checkNotInNodeModules;

package/lib/webpack/dynamic-dll/index.d.ts

@@ -0,0 +1,35 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import type * as webpackType from 'webpack';
+import type { Configuration } from 'webpack';
+import type WebpackChain from 'webpack-chain';
+import { ShareConfig } from './bundler';
+declare type IResolveWebpackModule = <T extends string>(path: T) => T extends `webpack` ? typeof webpackType : T extends `webpack/${infer R}` ? any : never;
+interface IOpts {
+    cwd?: string;
+    rootDir: string;
+    cacheDir: string;
+    resolveWebpackModule?: IResolveWebpackModule;
+    include?: RegExp[];
+    exclude?: RegExp[];
+    shared?: ShareConfig;
+    externals?: Configuration['externals'];
+    esmFullSpecific?: Boolean;
+}
+export declare class DynamicDll {
+    private _opts;
+    private _bundler;
+    private _rootDir;
+    private _cacheDir;
+    private _resolveWebpackModule;
+    private _dllPlugin;
+    private _hasBuilt;
+    constructor(opts: IOpts);
+    private getRemovedModules;
+    private handleSnapshot;
+    middleware: (req: IncomingMessage, res: ServerResponse, next: (...args: any[]) => any) => Promise<any>;
+    modifyWebpackChain: (chain: WebpackChain) => WebpackChain;
+    modifyWebpack: (config: Configuration) => Configuration;
+    private _buildDLL;
+    private _getMFconfig;
+}
+export {};