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

package/lib/webpack/plugins/jsconfig-paths-plugin.js

@@ -0,0 +1,228 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patternText = exports.matchedText = exports.isString = exports.matchPatternOrExact = exports.findBestPatternMatch = exports.tryParsePattern = exports.pathIsRelative = exports.hasZeroOrOneAsteriskCharacter = void 0;
+/**
+ * This webpack resolver is largely based on TypeScript's "paths" handling
+ * The TypeScript license can be found here:
+ * https://github.com/microsoft/TypeScript/blob/214df64e287804577afa1fea0184c18c40f7d1ca/LICENSE.txt
+ */
+const path = __importStar(require("path"));
+const asterisk = 0x2a;
+function hasZeroOrOneAsteriskCharacter(str) {
+    let seenAsterisk = false;
+    for (let i = 0; i < str.length; i++) {
+        if (str.charCodeAt(i) === asterisk) {
+            if (!seenAsterisk) {
+                seenAsterisk = true;
+            }
+            else {
+                // have already seen asterisk
+                return false;
+            }
+        }
+    }
+    return true;
+}
+exports.hasZeroOrOneAsteriskCharacter = hasZeroOrOneAsteriskCharacter;
+/**
+ * Determines whether a path starts with a relative path component (i.e. `.` or `..`).
+ */
+function pathIsRelative(testPath) {
+    return /^\.\.?($|[\\/])/.test(testPath);
+}
+exports.pathIsRelative = pathIsRelative;
+function tryParsePattern(pattern) {
+    // This should be verified outside of here and a proper error thrown.
+    const indexOfStar = pattern.indexOf('*');
+    return indexOfStar === -1
+        ? undefined
+        : {
+            prefix: pattern.slice(0, indexOfStar),
+            suffix: pattern.slice(indexOfStar + 1)
+        };
+}
+exports.tryParsePattern = tryParsePattern;
+function isPatternMatch({ prefix, suffix }, candidate) {
+    return (candidate.length >= prefix.length + suffix.length &&
+        candidate.startsWith(prefix) &&
+        candidate.endsWith(suffix));
+}
+/** Return the object corresponding to the best pattern to match `candidate`. */
+function findBestPatternMatch(values, getPattern, candidate) {
+    let matchedValue;
+    // use length of prefix as betterness criteria
+    let longestMatchPrefixLength = -1;
+    for (const v of values) {
+        const pattern = getPattern(v);
+        if (isPatternMatch(pattern, candidate) &&
+            pattern.prefix.length > longestMatchPrefixLength) {
+            longestMatchPrefixLength = pattern.prefix.length;
+            matchedValue = v;
+        }
+    }
+    return matchedValue;
+}
+exports.findBestPatternMatch = findBestPatternMatch;
+/**
+ * patternStrings contains both pattern strings (containing "*") and regular strings.
+ * Return an exact match if possible, or a pattern match, or undefined.
+ * (These are verified by verifyCompilerOptions to have 0 or 1 "*" characters.)
+ */
+function matchPatternOrExact(patternStrings, candidate) {
+    const patterns = [];
+    for (const patternString of patternStrings) {
+        if (!hasZeroOrOneAsteriskCharacter(patternString))
+            continue;
+        const pattern = tryParsePattern(patternString);
+        if (pattern) {
+            patterns.push(pattern);
+        }
+        else if (patternString === candidate) {
+            // pattern was matched as is - no need to search further
+            return patternString;
+        }
+    }
+    return findBestPatternMatch(patterns, _ => _, candidate);
+}
+exports.matchPatternOrExact = matchPatternOrExact;
+/**
+ * Tests whether a value is string
+ */
+function isString(text) {
+    return typeof text === 'string';
+}
+exports.isString = isString;
+/**
+ * Given that candidate matches pattern, returns the text matching the '*'.
+ * E.g.: matchedText(tryParsePattern("foo*baz"), "foobarbaz") === "bar"
+ */
+function matchedText(pattern, candidate) {
+    return candidate.substring(pattern.prefix.length, candidate.length - pattern.suffix.length);
+}
+exports.matchedText = matchedText;
+function patternText({ prefix, suffix }) {
+    return `${prefix}*${suffix}`;
+}
+exports.patternText = patternText;
+/**
+ * Calls the iterator function for each entry of the array
+ * until the first result or error is reached
+ */
+function forEachBail(array, iterator, callback) {
+    if (array.length === 0)
+        return callback();
+    let i = 0;
+    const next = () => {
+        let loop = undefined;
+        iterator(array[i++], (err, result) => {
+            if (err || result !== undefined || i >= array.length) {
+                return callback(err, result);
+            }
+            if (loop === false)
+                while (next())
+                    ;
+            loop = true;
+        });
+        if (!loop)
+            loop = false;
+        return loop;
+    };
+    while (next())
+        ;
+}
+const NODE_MODULES_REGEX = /node_modules/;
+/**
+ * Handles tsconfig.json or jsconfig.js "paths" option for webpack
+ * Largely based on how the TypeScript compiler handles it:
+ * https://github.com/microsoft/TypeScript/blob/1a9c8197fffe3dace5f8dca6633d450a88cba66d/src/compiler/moduleNameResolver.ts#L1362
+ */
+class JsConfigPathsPlugin {
+    constructor(paths, resolvedBaseUrl) {
+        this.paths = paths;
+        this.resolvedBaseUrl = resolvedBaseUrl;
+    }
+    apply(resolver) {
+        const paths = this.paths;
+        const pathsKeys = Object.keys(paths);
+        // If no aliases are added bail out
+        if (pathsKeys.length === 0) {
+            return;
+        }
+        const baseDirectory = this.resolvedBaseUrl;
+        const target = resolver.ensureHook('resolve');
+        resolver
+            .getHook('described-resolve')
+            .tapAsync('JsConfigPathsPlugin', (request, resolveContext, callback) => {
+            const moduleName = request.request;
+            // Exclude node_modules from paths support (speeds up resolving)
+            if (request.path.match(NODE_MODULES_REGEX)) {
+                return callback();
+            }
+            if (path.posix.isAbsolute(moduleName) ||
+                (process.platform === 'win32' && path.win32.isAbsolute(moduleName))) {
+                return callback();
+            }
+            if (pathIsRelative(moduleName)) {
+                return callback();
+            }
+            // If the module name does not match any of the patterns in `paths` we hand off resolving to webpack
+            const matchedPattern = matchPatternOrExact(pathsKeys, moduleName);
+            if (!matchedPattern) {
+                return callback();
+            }
+            const matchedStar = isString(matchedPattern)
+                ? undefined
+                : matchedText(matchedPattern, moduleName);
+            const matchedPatternText = isString(matchedPattern)
+                ? matchedPattern
+                : patternText(matchedPattern);
+            let triedPaths = [];
+            forEachBail(paths[matchedPatternText], (subst, pathCallback) => {
+                const curPath = matchedStar
+                    ? subst.replace('*', matchedStar)
+                    : subst;
+                // Ensure .d.ts is not matched
+                if (curPath.endsWith('.d.ts')) {
+                    // try next path candidate
+                    return pathCallback();
+                }
+                const candidate = path.join(baseDirectory, curPath);
+                const obj = Object.assign({}, request, {
+                    request: candidate
+                });
+                resolver.doResolve(target, obj, `Aliased with tsconfig.json or jsconfig.json ${matchedPatternText} to ${candidate}`, resolveContext, (resolverErr, resolverResult) => {
+                    if (resolverErr || resolverResult === undefined) {
+                        triedPaths.push(candidate);
+                        // try next path candidate
+                        return pathCallback();
+                    }
+                    return pathCallback(resolverErr, resolverResult);
+                });
+            }, callback);
+        });
+    }
+}
+exports.default = JsConfigPathsPlugin;

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

@@ -1,4 +1,8 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
 var plugin_1 = require("./plugin");
-exports.default = plugin_1.default;
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(plugin_1).default; } });

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

@@ -1,19 +1,20 @@
 import { Compiler, Plugin } from 'webpack';
 export declare type ConfigItem = {
-    test: Function | RegExp;
+    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: string;
-        options: Record<string, any>;
-    }[];
+    loaders: Loader[];
 }
 declare const ModuleAction: {
     readonly REPLACE: "replace";
@@ -22,10 +23,10 @@ declare const ModuleAction: {
 export default class ModuleReplacePlugin implements Plugin {
     private _options;
     static restoreModule(id: string): false | Promise<any>;
+    static replaceModule(id: string): false | void;
     constructor(options: Partial<ModuleReplacePluginOptions>);
     apply(compiler: Compiler): void;
     private _handleBuildModule;
     private _collectModules;
-    private _getReplacedModule;
 }
 export {};

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

@@ -1,6 +1,8 @@
 "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]`;
@@ -12,7 +14,25 @@ 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);
 }
-const stubLoader = require.resolve('./stub-loader');
+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'
@@ -55,17 +75,37 @@ class ModuleReplacePlugin {
         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;
         });
     }
+    static replaceModule(id) {
+        const moduleInfos = getKnownModules(id);
+        if (moduleInfos.length < 1) {
+            return false;
+        }
+        moduleInfos.forEach(moduleInfo => {
+            moduleInfo.action = ModuleAction.REPLACE;
+        });
+    }
     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) {
@@ -105,22 +145,22 @@ class ModuleReplacePlugin {
             const handler = moduleHandler.get(id);
             if (handler) {
                 handler.pending.set(compiler, true);
-                wpModule.loaders = moduleInfo.loaders;
+            }
+            const pitcher = (wpModule.loaders || []).find(isPitcher);
+            if (pitcher) {
+                pitcher.options = {};
             }
             return;
         }
         if (moduleInfo.action === ModuleAction.REPLACE) {
             if (!wpModule.loaders || wpModule.loaders[REPLACED] !== true) {
-                moduleInfo.loaders = wpModule.loaders;
-                wpModule.loaders = [
-                    {
-                        loader: stubLoader,
-                        options: {
-                            module: moduleInfo.replacedModule
-                        }
-                    }
-                ];
                 wpModule.loaders[REPLACED] = true;
+                const pitcher = (wpModule.loaders || []).find(isPitcher);
+                if (pitcher) {
+                    pitcher.options = {
+                        replacedModule: moduleInfo.replacedModule
+                    };
+                }
             }
         }
     }
@@ -130,33 +170,16 @@ class ModuleReplacePlugin {
         if (knownModules.has(id) || !id) {
             return;
         }
-        const replacedModule = this._getReplacedModule(wpModule);
+        const { createData: { resourceResolveData } } = wpModule;
+        const replacedModule = findReplacedModule(this._options.modules, resourceResolveData.query);
         if (replacedModule) {
             knownModules.set(id, {
                 action: ModuleAction.REPLACE,
                 replacedModule,
-                compiler
+                compiler,
+                loaders: []
             });
         }
     }
-    _getReplacedModule(wpModule) {
-        const { request, dependencies } = wpModule;
-        if (dependencies.length <= 0)
-            return null;
-        const { modules } = this._options;
-        for (let index = 0; index < modules.length; index++) {
-            const { test, module } = modules[index];
-            let shouldReplace = false;
-            if (isRegExp(test)) {
-                shouldReplace = test.test(request);
-            }
-            else if (isFunction(test)) {
-                shouldReplace = test(wpModule);
-            }
-            if (shouldReplace)
-                return module;
-        }
-        return null;
-    }
 }
 exports.default = ModuleReplacePlugin;

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

@@ -1,14 +1,54 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const loader_utils_1 = __importDefault(require("loader-utils"));
-module.exports = function () {
-    const { module } = loader_utils_1.default.getOptions(this) || {};
-    const sModule = JSON.stringify(module);
+const loaderUtils = __importStar(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 loaderUtils.stringifyRequest(loaderCtx, '!' +
+        [...loaderStrings, loaderCtx.resourcePath + loaderCtx.resourceQuery].join('!'));
+};
+module.exports = (code) => code;
+module.exports.pitch = function () {
     this.cacheable(false);
+    const { replacedModule } = loaderUtils.getOptions(this) || {};
+    let loaders = this.loaders;
+    // remove self
+    loaders = loaders.filter(isSelfLoader);
+    const request = replacedModule
+        ? loaderUtils.stringifyRequest(this, replacedModule)
+        : genRequest(this, loaders);
     return `
-module.exports = require(${sModule})
+import mod from ${request}; 
+export * from ${request}
+export default mod;
 `.trim();
 };

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

@@ -1,15 +1,11 @@
 "use strict";
 // ref: https://github.com/vercel/next.js/blob/canary/packages/next/build/webpack/plugins/nextjs-require-cache-hot-reloader.ts
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
+const webpack_1 = require("webpack");
 const fs_1 = require("fs");
-const constants_1 = require("@shuvi/shared/lib/constants");
 function deleteCache(filePath) {
     try {
-        delete require.cache[fs_1.realpathSync(filePath)];
+        delete require.cache[(0, fs_1.realpathSync)(filePath)];
     }
     catch (e) {
         if (e.code !== 'ENOENT')
@@ -27,13 +23,18 @@ class RequireCacheHotReloader {
         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 => {
-            const serverRuntimePath = path_1.default.join(compilation.outputOptions.path, constants_1.BUILD_SERVER_FILE_SERVER);
-            deleteCache(serverRuntimePath);
             for (const outputPath of this.previousOutputPathsWebpack5) {
                 if (!this.currentOutputPathsWebpack5.has(outputPath)) {
                     deleteCache(outputPath);

package/lib/webpack/plugins/support-ts-extension-resolver-plugin.d.ts

@@ -0,0 +1,4 @@
+import { Resolver } from 'webpack';
+export default class SupportTsExtensionResolverPlugin {
+    apply(resolver: Resolver): void;
+}

package/lib/webpack/plugins/support-ts-extension-resolver-plugin.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SupportTsExtensionResolverPlugin {
+    apply(resolver) {
+        const exts = ['.tsx', '.ts'];
+        const target = resolver.ensureHook('file');
+        exts.forEach(ext => {
+            resolver
+                .getHook('raw-file')
+                .tapAsync('SupportTsExtensionResolverPlugin', (request, resolveContext, callback) => {
+                const { relativePath } = request;
+                if (relativePath) {
+                    if (/\.shuvi\/(runtime|app)/.test(relativePath)) {
+                        const newRequest = Object.assign(Object.assign({}, request), { path: request.path + ext, relativePath: request.relativePath && request.relativePath + ext });
+                        return resolver.doResolve(target, newRequest, ext, resolveContext, callback);
+                    }
+                }
+                return callback();
+            });
+        });
+    }
+}
+exports.default = SupportTsExtensionResolverPlugin;

package/lib/webpack/types.d.ts

@@ -0,0 +1,40 @@
+import { WebpackChain } from './config';
+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 });