@shuvi/toolpack 0.0.1-pre.1

package/lib/webpack/plugins/module-replace-plugin/plugin.d.ts

@@ -0,0 +1,31 @@
+import { Compiler, Plugin } from 'webpack';
+export declare type ConfigItem = {
+    resourceQuery: Function | RegExp;
+    module: string;
+};
+export interface ModuleReplacePluginOptions {
+    modules: ConfigItem[];
+}
+export interface Loader {
+    loader: string;
+    options: Record<string, any>;
+}
+export interface ModuleInfo {
+    action: typeof ModuleAction[keyof typeof ModuleAction];
+    compiler: Compiler;
+    replacedModule: string;
+    loaders: Loader[];
+}
+declare const ModuleAction: {
+    readonly REPLACE: "replace";
+    readonly RESTORE: "restore";
+};
+export default class ModuleReplacePlugin implements Plugin {
+    private _options;
+    static restoreModule(id: string): false | Promise<any>;
+    constructor(options: Partial<ModuleReplacePluginOptions>);
+    apply(compiler: Compiler): void;
+    private _handleBuildModule;
+    private _collectModules;
+}
+export {};

package/lib/webpack/plugins/module-replace-plugin/plugin.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const REPLACED = Symbol('replaced');
+const stubLoader = require.resolve('./stub-loader');
+const pitchLoader = stubLoader;
+const toString = Object.prototype.toString;
+function isRegExp(target) {
+    return toString.call(target) === `[object RegExp]`;
+}
+function isFunction(target) {
+    return toString.call(target) === `[object Function]`;
+}
+function getModuleId(wpModule) {
+    var _a;
+    return wpModule.rawRequest || ((_a = wpModule === null || wpModule === void 0 ? void 0 : wpModule.createData) === null || _a === void 0 ? void 0 : _a.rawRequest);
+}
+function isPitcher(loader) {
+    return loader.loader === pitchLoader;
+}
+function findReplacedModule(configs, query) {
+    for (let index = 0; index < configs.length; index++) {
+        const { resourceQuery, module } = configs[index];
+        let isMatch = false;
+        if (isRegExp(resourceQuery)) {
+            isMatch = resourceQuery.test(query);
+        }
+        else if (isFunction(resourceQuery)) {
+            isMatch = resourceQuery(query);
+        }
+        if (isMatch) {
+            return module;
+        }
+    }
+    return null;
+}
+const ModuleAction = {
+    REPLACE: 'replace',
+    RESTORE: 'restore'
+};
+// const knownModules = new Map<string, ModuleInfo>();
+const moduleHandler = new Map();
+const compilerInfo = new Map();
+function getKnownModules(id) {
+    const res = [];
+    for (const compiler of compilerInfo.values()) {
+        const module = compiler.modules.get(id);
+        if (module) {
+            res.push(module);
+        }
+    }
+    return res;
+}
+// function forEachModule(id: string, cb: (mod: ModuleInfo) => void) {
+//   for (const compiler of compilerInfo.values()) {
+//     const mod = compiler.modules.get(id);
+//     if (mod) {
+//       cb(mod);
+//     }
+//   }
+// }
+class ModuleReplacePlugin {
+    constructor(options) {
+        this._options = Object.assign({ modules: [] }, options);
+    }
+    static restoreModule(id) {
+        const moduleInfos = getKnownModules(id).filter(m => m.action === ModuleAction.REPLACE);
+        if (moduleInfos.length < 1) {
+            return false;
+        }
+        const handler = {
+            resolve: null,
+            pending: new Map()
+        };
+        moduleHandler.set(id, handler);
+        moduleInfos.forEach(moduleInfo => {
+            moduleInfo.action = ModuleAction.RESTORE;
+            handler.pending.set(moduleInfo.compiler, false);
+            moduleInfo.compiler.hooks.invalid.call('noop', new Date().getTime());
+        });
+        return new Promise(resolve => {
+            handler.resolve = resolve;
+        });
+    }
+    apply(compiler) {
+        var _a;
+        const { modules } = this._options;
+        // init compiler info
+        compilerInfo.set(compiler, {
+            modules: new Map()
+        });
+        const pitcher = {
+            loader: pitchLoader,
+            resourceQuery(query) {
+                const find = findReplacedModule(modules, query);
+                return !!find;
+            },
+            options: {}
+        };
+        // replace original rules
+        (_a = compiler.options.module.rules) === null || _a === void 0 ? void 0 : _a.unshift(pitcher);
+        compiler.hooks.done.tap('done', () => {
+            const finished = [];
+            for (const [id, handler] of moduleHandler) {
+                if (handler.pending.get(compiler)) {
+                    handler.pending.delete(compiler);
+                }
+                if (handler.pending.size <= 0) {
+                    handler.resolve();
+                    finished.push(id);
+                }
+            }
+            for (const id of finished) {
+                moduleHandler.delete(id);
+            }
+        });
+        compiler.hooks.beforeCompile.tapAsync('ModuleReplacePlugin', ({ normalModuleFactory }, callback) => {
+            normalModuleFactory.hooks.afterResolve.tap('ModuleReplacePlugin', wpModule => {
+                this._collectModules(compiler, wpModule);
+            });
+            callback();
+        });
+        compiler.hooks.compilation.tap('ModuleReplacePlugin', compilation => {
+            compilation.hooks.buildModule.tap('ModuleReplacePlugin', wpModule => this._handleBuildModule(compiler, wpModule));
+        });
+    }
+    _handleBuildModule(compiler, wpModule) {
+        const knownModules = compilerInfo.get(compiler).modules;
+        const id = getModuleId(wpModule);
+        if (!id) {
+            return;
+        }
+        const moduleInfo = knownModules.get(id);
+        if (!moduleInfo) {
+            return;
+        }
+        if (moduleInfo.action === ModuleAction.RESTORE) {
+            const handler = moduleHandler.get(id);
+            if (handler) {
+                handler.pending.set(compiler, true);
+            }
+            const pitcher = (wpModule.loaders || []).find(isPitcher);
+            if (pitcher) {
+                pitcher.options = {};
+            }
+            return;
+        }
+        if (moduleInfo.action === ModuleAction.REPLACE) {
+            if (!wpModule.loaders || wpModule.loaders[REPLACED] !== true) {
+                wpModule.loaders[REPLACED] = true;
+                const pitcher = (wpModule.loaders || []).find(isPitcher);
+                if (pitcher) {
+                    pitcher.options = {
+                        replacedModule: moduleInfo.replacedModule
+                    };
+                }
+            }
+        }
+    }
+    _collectModules(compiler, wpModule) {
+        const knownModules = compilerInfo.get(compiler).modules;
+        const id = getModuleId(wpModule);
+        if (knownModules.has(id) || !id) {
+            return;
+        }
+        const { createData: { resourceResolveData } } = wpModule;
+        const replacedModule = findReplacedModule(this._options.modules, resourceResolveData.query);
+        if (replacedModule) {
+            knownModules.set(id, {
+                action: ModuleAction.REPLACE,
+                replacedModule,
+                compiler,
+                loaders: []
+            });
+        }
+    }
+}
+exports.default = ModuleReplacePlugin;

package/lib/webpack/plugins/module-replace-plugin/stub-loader.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/webpack/plugins/module-replace-plugin/stub-loader.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const loader_utils_1 = __importDefault(require("loader-utils"));
+const isSelfLoader = (l) => l.path !== __filename;
+const genRequest = (loaderCtx, loaders) => {
+    const loaderStrings = [];
+    loaders.forEach(loader => {
+        const request = typeof loader === 'string' ? loader : loader.request;
+        // loader.request contains both the resolved loader path and its options
+        // query (e.g. ??ref-0)
+        loaderStrings.push(request);
+    });
+    return loader_utils_1.default.stringifyRequest(loaderCtx, '!' +
+        [...loaderStrings, loaderCtx.resourcePath + loaderCtx.resourceQuery].join('!'));
+};
+module.exports = (code) => code;
+module.exports.pitch = function () {
+    this.cacheable(false);
+    const { replacedModule } = loader_utils_1.default.getOptions(this) || {};
+    let loaders = this.loaders;
+    // remove self
+    loaders = loaders.filter(isSelfLoader);
+    const request = replacedModule
+        ? loader_utils_1.default.stringifyRequest(this, replacedModule)
+        : genRequest(this, loaders);
+    return `
+import mod from ${request}; 
+export * from ${request}
+export default mod;
+`.trim();
+};

package/lib/webpack/plugins/prefer-resolver-plugin.d.ts

@@ -0,0 +1,10 @@
+import { ResolvePlugin, Resolver } from 'webpack';
+interface Options {
+    suffix: string;
+}
+export default class PreferResolverPlugin implements ResolvePlugin {
+    private _options;
+    constructor(options: Options);
+    apply(resolver: Resolver): void;
+}
+export {};

package/lib/webpack/plugins/prefer-resolver-plugin.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PreferResolverPlugin {
+    constructor(options) {
+        this._options = options;
+    }
+    apply(resolver) {
+        const target = resolver.ensureHook('resolve');
+        const { suffix } = this._options;
+        resolver
+            .getHook('described-resolve')
+            .tapAsync('FileExistsPlugin', (request, resolveContext, callback) => {
+            const innerRequest = request.request || request.path;
+            if (!innerRequest)
+                return callback();
+            if (innerRequest.endsWith('.' + suffix)) {
+                return callback();
+            }
+            const suffixList = [suffix];
+            const resolveWithPrefer = (append, cb) => {
+                const obj = Object.assign(Object.assign({}, request), { request: innerRequest + '.' + append, relativePath: request.relativePath && request.relativePath + '.' + append });
+                return resolver.doResolve(target, obj, 'resolve with prefer request', resolveContext, (err, result) => {
+                    if (err)
+                        return cb(err);
+                    if (result)
+                        return cb(null, result);
+                    return cb();
+                });
+            };
+            const next = (err, result) => {
+                if (err) {
+                    return callback(err);
+                }
+                if (result) {
+                    return callback(err, result);
+                }
+                const nextSuffix = suffixList.pop();
+                if (!nextSuffix) {
+                    return callback();
+                }
+                resolveWithPrefer(nextSuffix, next);
+            };
+            next(null);
+        });
+    }
+}
+exports.default = PreferResolverPlugin;

package/lib/webpack/plugins/require-cache-hot-reloader-plugin.d.ts

@@ -0,0 +1,6 @@
+import { Compiler, Plugin } from 'webpack';
+export default class RequireCacheHotReloader implements Plugin {
+    previousOutputPathsWebpack5: Set<string>;
+    currentOutputPathsWebpack5: Set<string>;
+    apply(compiler: Compiler): void;
+}

package/lib/webpack/plugins/require-cache-hot-reloader-plugin.js

@@ -0,0 +1,48 @@
+"use strict";
+// ref: https://github.com/vercel/next.js/blob/canary/packages/next/build/webpack/plugins/nextjs-require-cache-hot-reloader.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = require("webpack");
+const fs_1 = require("fs");
+function deleteCache(filePath) {
+    try {
+        delete require.cache[fs_1.realpathSync(filePath)];
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    finally {
+        delete require.cache[filePath];
+    }
+}
+const PLUGIN_NAME = 'RequireCacheHotReloader';
+// This plugin flushes require.cache after emitting the files. Providing 'hot reloading' of server files.
+class RequireCacheHotReloader {
+    constructor() {
+        this.previousOutputPathsWebpack5 = new Set();
+        this.currentOutputPathsWebpack5 = new Set();
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+            compilation.hooks.additionalTreeRuntimeRequirements.tap(PLUGIN_NAME, (_chunk, runtimeRequirements) => {
+                // add this so that the server.js would be emitted after every compilation
+                // @ts-ignore webpack typing bug
+                runtimeRequirements.add(webpack_1.RuntimeGlobals.getFullHash);
+            });
+        });
+        compiler.hooks.assetEmitted.tap(PLUGIN_NAME, (_file, { targetPath }) => {
+            this.currentOutputPathsWebpack5.add(targetPath);
+            deleteCache(targetPath);
+        });
+        compiler.hooks.afterEmit.tap(PLUGIN_NAME, compilation => {
+            for (const outputPath of this.previousOutputPathsWebpack5) {
+                if (!this.currentOutputPathsWebpack5.has(outputPath)) {
+                    deleteCache(outputPath);
+                }
+            }
+            this.previousOutputPathsWebpack5 = new Set(this.currentOutputPathsWebpack5);
+            this.currentOutputPathsWebpack5.clear();
+        });
+    }
+}
+exports.default = RequireCacheHotReloader;

package/lib/webpack/types.d.ts

@@ -0,0 +1,40 @@
+import WebpackChain from 'webpack-chain';
+export interface IModuleItem {
+    id: string;
+    name: string;
+}
+export interface IModule {
+    files: string[];
+    children: IModuleItem[];
+}
+export declare type IAssetMap = {
+    js: string[];
+    css?: string[];
+} & {
+    [ext: string]: string[];
+};
+export interface IChunk {
+    file: string;
+    request: string;
+}
+export interface IManifest {
+    entries: {
+        [s: string]: IAssetMap;
+    };
+    bundles: {
+        [name: string]: string;
+    };
+    chunkRequest: {
+        [file: string]: string;
+    };
+    loadble: {
+        [s: string]: IModule;
+    };
+}
+export declare type ExternalsFunction = (data: {
+    context: string;
+    request: string;
+}, callback: (err: Error | null, result: string | undefined) => void) => void;
+export interface IWebpackHelpers {
+    addExternals: (chain: WebpackChain, externalsFn: ExternalsFunction) => void;
+}

package/lib/webpack/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@shuvi/toolpack",
+  "version": "0.0.1-pre.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shuvijs/shuvi.git",
+    "directory": "packages/toolpack"
+  },
+  "author": "liximomo",
+  "license": "MIT",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "dev": "tsc -p tsconfig.build.json -w",
+    "prebuild": "rimraf lib",
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "engines": {
+    "node": ">= 12.0.0"
+  },
+  "dependencies": {
+    "@babel/core": "7.12.10",
+    "@babel/plugin-proposal-class-properties": "7.12.1",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "7.10.1",
+    "@babel/plugin-proposal-numeric-separator": "7.12.7",
+    "@babel/plugin-proposal-object-rest-spread": "7.12.1",
+    "@babel/plugin-proposal-optional-chaining": "7.12.7",
+    "@babel/plugin-syntax-bigint": "7.8.3",
+    "@babel/plugin-syntax-dynamic-import": "7.8.3",
+    "@babel/plugin-transform-runtime": "7.12.10",
+    "@babel/preset-env": "7.12.11",
+    "@babel/preset-react": "7.10.1",
+    "@babel/preset-typescript": "7.12.7",
+    "@babel/runtime": "7.12.5",
+    "@shuvi/shared": "0.0.1-pre.1",
+    "@shuvi/utils": "0.0.1-pre.1",
+    "babel-loader": "8.2.2",
+    "babel-plugin-syntax-jsx": "6.18.0",
+    "babel-plugin-transform-define": "2.0.0",
+    "babel-plugin-transform-react-remove-prop-types": "0.4.24",
+    "buffer": "6.0.3",
+    "crypto-browserify": "3.12.0",
+    "css-loader": "5.0.1",
+    "file-loader": "6.2.0",
+    "fork-ts-checker-webpack-plugin": "6.0.8",
+    "ignore-loader": "0.1.2",
+    "loader-utils": "2.0.0",
+    "mini-css-extract-plugin": "1.3.9",
+    "path-browserify": "1.0.1",
+    "postcss": "8.2.3",
+    "postcss-flexbugs-fixes": "5.0.2",
+    "postcss-loader": "4.1.0",
+    "postcss-preset-env": "6.7.0",
+    "process": "0.11.10",
+    "react-error-overlay": "6.0.8",
+    "sass": "1.32.2",
+    "sass-loader": "10.1.0",
+    "stream-browserify": "3.0.0",
+    "strip-ansi": "6.0.0",
+    "style-loader": "2.0.0",
+    "terser-webpack-plugin": "5.1.1",
+    "vm-browserify": "1.1.2",
+    "webpack-bundle-analyzer": "4.3.0",
+    "webpack-chain": "6.5.1",
+    "webpack-sources": "2.2.0"
+  },
+  "devDependencies": {
+    "@types/loader-utils": "2.0.1",
+    "@types/mini-css-extract-plugin": "^1.2.2",
+    "@types/terser-webpack-plugin": "5.0.2",
+    "@types/webpack-bundle-analyzer": "^3.8.0",
+    "memfs": "^3.1.2",
+    "webpack": "5.36.0"
+  },
+  "peerDependencies": {
+    "webpack": "5.36.0"
+  },
+  "gitHead": "0bc0bc76e72ca5a339341e8b71d6bb6bb41409e8"
+}