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

package/lib/webpack/loaders/route-component-loader.js

@@ -1,12 +1,32 @@
 "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"));
+const loaderUtils = __importStar(require("loader-utils"));
 const routeComponentLoader = function () {
-    const { componentAbsolutePath } = loader_utils_1.default.getOptions(this);
-    const stringifyRequest = loader_utils_1.default.stringifyRequest(this, `${componentAbsolutePath}?__shuvi-route`);
+    const { componentAbsolutePath } = loaderUtils.getOptions(this);
+    const stringifyRequest = loaderUtils.stringifyRequest(this, `${componentAbsolutePath}?__shuvi-route`);
     return `
 const = require(${stringifyRequest})
 `.trim();

package/lib/webpack/loaders/shuvi-swc-loader/getLoaderSWCOptions.d.ts

@@ -0,0 +1,94 @@
+declare type Obj = Record<string, any>;
+export declare type LoaderSWCOptions = {
+    filename: string;
+    isServer: boolean;
+    isPageFile: boolean;
+    development: boolean;
+    minify: boolean | Obj;
+    hasReactRefresh: boolean;
+    supportedBrowsers: any[];
+    experimental: Obj;
+    compiler: Obj;
+    swcCacheDir: string;
+    keep: string[];
+};
+export declare function getParserOptions({ filename, compiler, ...rest }: {
+    filename: string;
+    compiler: Obj;
+}): {
+    syntax: string;
+    dynamicImport: boolean;
+    decorators: boolean;
+    importAssertions: boolean;
+};
+export default function getLoaderSWCOptions({ filename, development, isServer, minify, isPageFile, hasReactRefresh, experimental, compiler, supportedBrowsers, swcCacheDir, keep }: LoaderSWCOptions): {
+    jsc: {
+        externalHelpers: boolean;
+        parser: {
+            syntax: string;
+            dynamicImport: boolean;
+            decorators: boolean;
+            importAssertions: boolean;
+        };
+        experimental: {
+            keepImportAssertions: boolean;
+            plugins: any;
+            cacheRoot: string;
+        };
+        transform: {
+            legacyDecorator: boolean;
+            decoratorMetadata: boolean;
+            useDefineForClassFields: boolean;
+            react: {
+                importSource: any;
+                runtime: string;
+                pragma: string;
+                pragmaFrag: string;
+                throwIfNamespace: boolean;
+                development: boolean;
+                useBuiltins: boolean;
+                refresh: boolean;
+            };
+            optimizer: {
+                simplify: boolean;
+                globals: {
+                    typeofs: {
+                        window: string;
+                    };
+                    envs: {
+                        NODE_ENV: string;
+                    };
+                };
+            };
+            regenerator: {
+                importPath: string;
+            };
+        };
+    };
+    minify: boolean | Obj;
+    isDevelopment: boolean;
+    isServer: boolean;
+    isPageFile: boolean;
+    shakeExports: {
+        ignore: string[];
+    } | null;
+    disableShuviDynamic: any;
+    cssModuleFlag: string;
+    sourceMaps: undefined;
+    styledComponents: any;
+    removeConsole: any;
+    reactRemoveProperties: any;
+    modularizeImports: any;
+    emotion: {
+        enabled: boolean;
+        autoLabel: boolean;
+        sourcemap: boolean;
+        labelFormat?: undefined;
+    } | {
+        enabled: boolean;
+        autoLabel: boolean;
+        labelFormat: any;
+        sourcemap: any;
+    } | null;
+};
+export {};

package/lib/webpack/loaders/shuvi-swc-loader/getLoaderSWCOptions.js

@@ -0,0 +1,162 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParserOptions = void 0;
+function getParserOptions(_a) {
+    var { filename, compiler } = _a, rest = __rest(_a, ["filename", "compiler"]);
+    const isTSFile = filename.endsWith('.ts');
+    const isTypeScript = isTSFile || filename.endsWith('.tsx');
+    const enableDecorators = Boolean(compiler === null || compiler === void 0 ? void 0 : compiler.experimentalDecorators);
+    return Object.assign(Object.assign({}, rest), { syntax: isTypeScript ? 'typescript' : 'ecmascript', dynamicImport: true, decorators: enableDecorators, 
+        // Exclude regular TypeScript files from React transformation to prevent e.g. generic parameters and angle-bracket type assertion from being interpreted as JSX tags.
+        [isTypeScript ? 'tsx' : 'jsx']: !isTSFile, importAssertions: true });
+}
+exports.getParserOptions = getParserOptions;
+function getBaseSWCOptions({ filename, isPageFile, minify, development, hasReactRefresh, isServer, experimental, compiler, swcCacheDir, keep }) {
+    var _a, _b;
+    const parserConfig = getParserOptions({ filename, compiler });
+    const enableDecorators = Boolean(compiler === null || compiler === void 0 ? void 0 : compiler.experimentalDecorators);
+    const emitDecoratorMetadata = Boolean(compiler === null || compiler === void 0 ? void 0 : compiler.emitDecoratorMetadata);
+    const useDefineForClassFields = Boolean(compiler === null || compiler === void 0 ? void 0 : compiler.useDefineForClassFields);
+    const plugins = ((_a = experimental === null || experimental === void 0 ? void 0 : experimental.swcPlugins) !== null && _a !== void 0 ? _a : [])
+        .filter(Array.isArray)
+        .map(([name, options]) => [require.resolve(name), options]);
+    return {
+        jsc: {
+            externalHelpers: true,
+            parser: parserConfig,
+            experimental: {
+                keepImportAssertions: true,
+                plugins,
+                cacheRoot: swcCacheDir
+            },
+            transform: {
+                legacyDecorator: enableDecorators,
+                decoratorMetadata: emitDecoratorMetadata,
+                useDefineForClassFields: useDefineForClassFields,
+                react: {
+                    importSource: (_b = compiler === null || compiler === void 0 ? void 0 : compiler.jsxImportSource) !== null && _b !== void 0 ? _b : ((compiler === null || compiler === void 0 ? void 0 : compiler.emotion) ? '@emotion/react' : 'react'),
+                    runtime: 'automatic',
+                    pragma: 'React.createElement',
+                    pragmaFrag: 'React.Fragment',
+                    throwIfNamespace: true,
+                    development: !!development,
+                    useBuiltins: true,
+                    refresh: !!hasReactRefresh
+                },
+                optimizer: {
+                    simplify: false,
+                    globals: {
+                        typeofs: {
+                            window: isServer ? 'undefined' : 'object'
+                        },
+                        envs: {
+                            NODE_ENV: development ? '"development"' : '"production"'
+                        }
+                        // TODO: handle process.browser to match babel replacing as well
+                    }
+                },
+                regenerator: {
+                    importPath: require.resolve('regenerator-runtime')
+                }
+            }
+        },
+        minify,
+        isDevelopment: development,
+        isServer,
+        isPageFile,
+        shakeExports: keep.length > 0 ? { ignore: keep } : null,
+        disableShuviDynamic: (compiler === null || compiler === void 0 ? void 0 : compiler.disableShuviDynamic) || false,
+        cssModuleFlag: 'cssmodules',
+        sourceMaps: undefined,
+        styledComponents: getStyledComponentsOptions(compiler, development),
+        removeConsole: compiler === null || compiler === void 0 ? void 0 : compiler.removeConsole,
+        reactRemoveProperties: compiler === null || compiler === void 0 ? void 0 : compiler.reactRemoveProperties,
+        modularizeImports: experimental === null || experimental === void 0 ? void 0 : experimental.modularizeImports,
+        emotion: getEmotionOptions(compiler, development)
+    };
+}
+function getStyledComponentsOptions(compiler, development) {
+    var _a;
+    let styledComponentsOptions = compiler === null || compiler === void 0 ? void 0 : compiler.styledComponents;
+    if (!styledComponentsOptions) {
+        return null;
+    }
+    return Object.assign(Object.assign({}, styledComponentsOptions), { displayName: (_a = styledComponentsOptions.displayName) !== null && _a !== void 0 ? _a : Boolean(development) });
+}
+function getEmotionOptions(compiler, development) {
+    var _a;
+    const emotion = compiler === null || compiler === void 0 ? void 0 : compiler.emotion;
+    if (!emotion) {
+        return null;
+    }
+    // default 'dev-only'
+    let autoLabel = !!development;
+    if (emotion === true) {
+        return {
+            enabled: true,
+            autoLabel,
+            sourcemap: autoLabel
+        };
+    }
+    switch (emotion.autoLabel) {
+        case 'never':
+            autoLabel = false;
+            break;
+        case 'always':
+            autoLabel = true;
+            break;
+        default:
+            break;
+    }
+    return {
+        enabled: true,
+        autoLabel,
+        labelFormat: emotion.labelFormat,
+        sourcemap: development ? (_a = emotion.sourceMap) !== null && _a !== void 0 ? _a : true : false
+    };
+}
+function getLoaderSWCOptions({ filename, development, isServer, minify, isPageFile, hasReactRefresh, experimental, compiler, supportedBrowsers, swcCacheDir, keep }) {
+    let baseOptions = getBaseSWCOptions({
+        filename,
+        isPageFile,
+        development,
+        isServer,
+        minify,
+        hasReactRefresh,
+        experimental,
+        compiler,
+        swcCacheDir,
+        keep
+    });
+    if (isServer) {
+        baseOptions.env = {
+            targets: {
+                // Targets the current version of Node.js
+                node: process.versions.node
+            }
+        };
+    }
+    else {
+        // Matches default @babel/preset-env behavior
+        baseOptions.jsc.target =
+            'es5';
+        if (supportedBrowsers && supportedBrowsers.length > 0) {
+            baseOptions.env = {
+                targets: supportedBrowsers
+            };
+        }
+    }
+    return baseOptions;
+}
+exports.default = getLoaderSWCOptions;

package/lib/webpack/loaders/shuvi-swc-loader/index.d.ts

@@ -0,0 +1,2 @@
+export default function swcLoader(inputSource: any, inputSourceMap: any): void;
+export const raw: true;

package/lib/webpack/loaders/shuvi-swc-loader/index.js

@@ -0,0 +1,119 @@
+"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.raw = void 0;
+/*
+Copyright (c) 2017 The swc Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+const querystring_1 = __importDefault(require("querystring"));
+const constants_1 = require("@shuvi/shared/lib/constants");
+const escapeRegExp_1 = require("@shuvi/utils/lib/escapeRegExp");
+const compiler_1 = require("@shuvi/compiler");
+const getLoaderSWCOptions_1 = __importDefault(require("./getLoaderSWCOptions"));
+const IS_PAGE_FILE = RegExp((0, escapeRegExp_1.escapeRegExp)(`?${constants_1.ROUTE_RESOURCE_QUERYSTRING}`));
+function loaderTransform(source, inputSourceMap) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Make the loader async
+        const filename = this.resourcePath;
+        let loaderOptions = this.getOptions() || {};
+        const { isServer, experimental, compiler, supportedBrowsers, swcCacheDir, hasReactRefresh, minify = false } = loaderOptions;
+        const isPageFile = !!(this.resourceQuery && IS_PAGE_FILE.test(this.resourceQuery));
+        let keep = [];
+        if (isPageFile) {
+            const query = querystring_1.default.parse(this.resourceQuery.slice(1));
+            if (query.keep) {
+                if (Array.isArray(query.keep)) {
+                    keep = query.keep;
+                }
+                else {
+                    keep.push(query.keep);
+                }
+            }
+        }
+        const isDevelopment = this.mode === 'development';
+        const swcOptions = (0, getLoaderSWCOptions_1.default)({
+            filename,
+            isServer,
+            isPageFile,
+            minify,
+            development: this.mode === 'development',
+            hasReactRefresh: hasReactRefresh !== undefined
+                ? hasReactRefresh
+                : isDevelopment && !isServer,
+            experimental,
+            compiler,
+            supportedBrowsers,
+            swcCacheDir,
+            keep
+        });
+        const programmaticOptions = Object.assign(Object.assign({}, swcOptions), { filename, inputSourceMap: inputSourceMap ? JSON.stringify(inputSourceMap) : undefined, 
+            // Set the default sourcemap behavior based on Webpack's mapping flag,
+            sourceMaps: this.sourceMap, inlineSourcesContent: this.sourceMap, 
+            // Ensure that Webpack will get a full absolute path in the sourcemap
+            // so that it can properly map the module back to its internal cached
+            // modules.
+            sourceFileName: filename });
+        if (!programmaticOptions.inputSourceMap) {
+            delete programmaticOptions.inputSourceMap;
+        }
+        // auto detect development mode
+        if (this.mode &&
+            programmaticOptions.jsc &&
+            programmaticOptions.jsc.transform &&
+            programmaticOptions.jsc.transform.react &&
+            !Object.prototype.hasOwnProperty.call(programmaticOptions.jsc.transform.react, 'development')) {
+            programmaticOptions.jsc.transform.react.development =
+                this.mode === 'development';
+        }
+        return (0, compiler_1.transform)(source, programmaticOptions).then(output => {
+            return [output.code, output.map ? JSON.parse(output.map) : undefined];
+        });
+    });
+}
+function swcLoader(inputSource, inputSourceMap) {
+    const callback = this.async && this.async();
+    loaderTransform.call(this, inputSource, inputSourceMap).then(([transformedSource, outputSourceMap]) => {
+        callback &&
+            callback(null, transformedSource, outputSourceMap || inputSourceMap);
+    }, err => {
+        callback && callback(err);
+    });
+}
+exports.default = swcLoader;
+// accept Buffers instead of strings
+exports.raw = true;

package/lib/webpack/plugins/build-manifest-plugin.js

@@ -45,11 +45,23 @@ class BuildManifestPlugin {
             chunkRequest: {},
             loadble: {}
         });
+        const chunkRootModulesMap = new Map();
+        compilation.chunks.forEach(chunk => {
+            const { chunkGraph } = compilation;
+            if (chunkGraph) {
+                chunkGraph.getChunkRootModules(chunk).forEach(module => {
+                    const id = chunkGraph.getModuleId(module);
+                    if (id !== '') {
+                        chunkRootModulesMap.set(id, true);
+                    }
+                });
+            }
+        });
         compilation.chunkGroups.forEach(chunkGroup => {
             if (chunkGroup instanceof Entrypoint_1.default) {
                 this._collectEntries(chunkGroup);
             }
-            this._collect(chunkGroup, compiler, compilation);
+            this._collect(chunkGroup, compiler, compilation, chunkRootModulesMap);
         });
         this._manifest.loadble = Object.keys(this._manifest.loadble)
             .sort()
@@ -82,11 +94,11 @@ class BuildManifestPlugin {
             }
         }
     }
-    _collect(chunkGroup, compiler, compilation) {
+    _collect(chunkGroup, compiler, compilation, chunkRootModulesMap) {
         const collectModules = this._options.modules;
         chunkGroup.origins.forEach(chunkGroupOrigin => {
             const { request } = chunkGroupOrigin;
-            const ctx = { request, compiler, compilation };
+            const ctx = { request, compiler, compilation, chunkRootModulesMap };
             chunkGroup.chunks.forEach(chunk => {
                 this._collectChunk(chunk, ctx);
                 if (collectModules) {
@@ -120,7 +132,7 @@ class BuildManifestPlugin {
             }
         }
     }
-    _collectChunkModule(chunk, { request, compiler, compilation }) {
+    _collectChunkModule(chunk, { request, compiler, compilation, chunkRootModulesMap }) {
         if (chunk.canBeInitial()) {
             return;
         }
@@ -132,21 +144,26 @@ class BuildManifestPlugin {
                 this._pushLoadableModules(request, file);
             }
         });
-        for (const module of compilation.chunkGraph.getChunkModulesIterable(chunk)) {
-            let id = compilation.chunkGraph.getModuleId(module);
-            if (!module.type.startsWith('javascript')) {
-                continue;
-            }
-            let name = typeof module.libIdent === 'function'
-                ? module.libIdent({ context })
-                : null;
-            if (!name || name.endsWith('.css')) {
-                continue;
+        const { chunkGraph } = compilation;
+        if (chunkGraph) {
+            for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+                let id = chunkGraph.getModuleId(module);
+                if (!module.type.startsWith('javascript')) {
+                    continue;
+                }
+                let name = typeof module.libIdent === 'function'
+                    ? module.libIdent({ context })
+                    : null;
+                if (!name || name.endsWith('.css')) {
+                    continue;
+                }
+                if (chunkRootModulesMap.has(id)) {
+                    this._pushLoadableModules(request, {
+                        id,
+                        name
+                    });
+                }
             }
-            this._pushLoadableModules(request, {
-                id,
-                name
-            });
         }
     }
     _pushEntries(name, ext, value) {
@@ -182,12 +199,16 @@ class BuildManifestPlugin {
             };
         }
         if (typeof value === 'string') {
-            modules[request].files.push(value);
+            const existed = modules[request].files.some(file => file === value);
+            if (!existed) {
+                modules[request].files.push(value);
+            }
         }
-        else if (
-        // Avoid duplicate files
-        !modules[request].children.some(item => item.id === module.id)) {
-            modules[request].children.push(value);
+        else {
+            const existed = modules[request].children.some(item => item.id === value.id);
+            if (!existed) {
+                modules[request].children.push(value);
+            }
         }
     }
 }

package/lib/webpack/plugins/dynamic-public-path-plugin.d.ts

@@ -0,0 +1,9 @@
+import { Compiler, Plugin } from 'webpack';
+export default class DynamicPublicPathPlugin implements Plugin {
+    /**
+     * Apply the plugin
+     * @param {Compiler} compiler the compiler instance
+     * @returns {void}
+     */
+    apply(compiler: Compiler): void;
+}

package/lib/webpack/plugins/dynamic-public-path-plugin.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = require("webpack");
+const constants_1 = require("@shuvi/shared/lib/constants");
+const GLOBALTHIS = 'globalThis';
+/**
+ * blog: use webpack build for production, just define __webpack_public_path__ to change asset url to quick release, without build again
+ *
+ * user define __webpack_public_path__, when async chunk entry contain __webpack_public_path__
+ *
+ * on client side, when load the async chunk, the source url is still webpack runtime __webpack_require__.p,
+ * after chunk loaded, runtime publicPath will change to __webpack_public_path__.
+ *
+ * on server side, first html is from server, the source path is from __webpack_require__.p,
+ * eg: <img src=__webpack_require__.p +xx.png />
+ *
+ * expect: when load async chunk, __webpack_require__.p is can be redefine by user
+ *
+ */
+const PLUGINNAME = 'DynamicPublicPath';
+class DynamicPublicPathPlugin {
+    /**
+     * Apply the plugin
+     * @param {Compiler} compiler the compiler instance
+     * @returns {void}
+     */
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGINNAME, compilation => {
+            compilation.hooks.runtimeRequirementInTree
+                .for(webpack_1.RuntimeGlobals.publicPath)
+                .tap(PLUGINNAME, chunk => {
+                compilation.addRuntimeModule(chunk, new DynamicPublicPath(PLUGINNAME));
+            });
+        });
+    }
+}
+exports.default = DynamicPublicPathPlugin;
+class DynamicPublicPath extends webpack_1.RuntimeModule {
+    constructor(name) {
+        super(name, webpack_1.RuntimeModule.STAGE_ATTACH);
+    }
+    generate() {
+        return `
+      // server runtime public path
+      if (${GLOBALTHIS}["${constants_1.IDENTITY_RUNTIME_PUBLICPATH}"]) {
+        ${webpack_1.RuntimeGlobals.publicPath} = ${GLOBALTHIS}["${constants_1.IDENTITY_RUNTIME_PUBLICPATH}"];
+      }
+      `;
+    }
+}

package/lib/webpack/plugins/fix-watching-plugin.d.ts

@@ -0,0 +1,4 @@
+import { Compiler, Plugin } from 'webpack';
+export default class FixWatchingPlugin implements Plugin {
+    apply(compiler: Compiler): void;
+}

package/lib/webpack/plugins/fix-watching-plugin.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TIME_FIX = 5000;
+const PLUGIN_NAME = 'fix-watching-plugin';
+class FixWatchingPlugin {
+    apply(compiler) {
+        let watching;
+        let restored = false;
+        const aspectWatch = compiler.watch;
+        compiler.watch = function (...args) {
+            watching = aspectWatch.apply(compiler, args);
+            watching.startTime += TIME_FIX;
+            return watching;
+        };
+        compiler.hooks.done.tap(PLUGIN_NAME, stats => {
+            if (watching && !restored) {
+                stats.compilation.startTime -= TIME_FIX;
+                restored = true;
+            }
+        });
+    }
+}
+exports.default = FixWatchingPlugin;

package/lib/webpack/plugins/jsconfig-paths-plugin.d.ts

@@ -0,0 +1,44 @@
+import { ResolvePluginInstance, Resolver } from 'webpack';
+export interface Pattern {
+    prefix: string;
+    suffix: string;
+}
+export declare function hasZeroOrOneAsteriskCharacter(str: string): boolean;
+/**
+ * Determines whether a path starts with a relative path component (i.e. `.` or `..`).
+ */
+export declare function pathIsRelative(testPath: string): boolean;
+export declare function tryParsePattern(pattern: string): Pattern | undefined;
+/** Return the object corresponding to the best pattern to match `candidate`. */
+export declare function findBestPatternMatch<T>(values: readonly T[], getPattern: (value: T) => Pattern, candidate: string): T | undefined;
+/**
+ * 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.)
+ */
+export declare function matchPatternOrExact(patternStrings: readonly string[], candidate: string): string | Pattern | undefined;
+/**
+ * Tests whether a value is string
+ */
+export declare function isString(text: unknown): text is string;
+/**
+ * Given that candidate matches pattern, returns the text matching the '*'.
+ * E.g.: matchedText(tryParsePattern("foo*baz"), "foobarbaz") === "bar"
+ */
+export declare function matchedText(pattern: Pattern, candidate: string): string;
+export declare function patternText({ prefix, suffix }: Pattern): string;
+declare type Paths = {
+    [match: string]: string[];
+};
+/**
+ * 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
+ */
+export default class JsConfigPathsPlugin implements ResolvePluginInstance {
+    paths: Paths;
+    resolvedBaseUrl: string;
+    constructor(paths: Paths, resolvedBaseUrl: string);
+    apply(resolver: Resolver): void;
+}
+export {};