npm - @shuvi/toolpack - Versions diffs - 0.0.1-pre.1 - Mend

@shuvi/toolpack 0.0.1-pre.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (65) hide show

package/lib/babel/plugins/auto-css-modules.d.ts +7 -0
package/lib/babel/plugins/auto-css-modules.js +24 -0
package/lib/babel/plugins/jsx-pragma.d.ts +4 -0
package/lib/babel/plugins/jsx-pragma.js +77 -0
package/lib/babel/plugins/loadable-plugin.d.ts +24 -0
package/lib/babel/plugins/loadable-plugin.js +105 -0
package/lib/babel/plugins/optimize-hook-destructuring.d.ts +4 -0
package/lib/babel/plugins/optimize-hook-destructuring.js +59 -0
package/lib/babel/preset.d.ts +14 -0
package/lib/babel/preset.js +106 -0
package/lib/constants.d.ts +1 -0
package/lib/constants.js +3 -0
package/lib/utils/emptyComponent.d.ts +1 -0
package/lib/utils/emptyComponent.js +7 -0
package/lib/utils/forkTsCheckerWebpackPlugin.d.ts +4 -0
package/lib/utils/forkTsCheckerWebpackPlugin.js +9 -0
package/lib/utils/formatWebpackMessages.d.ts +5 -0
package/lib/utils/formatWebpackMessages.js +91 -0
package/lib/utils/hotDevClient/eventsource.d.ts +1 -0
package/lib/utils/hotDevClient/eventsource.js +63 -0
package/lib/utils/hotDevClient/index.d.ts +4 -0
package/lib/utils/hotDevClient/index.js +304 -0
package/lib/utils/verifyTypeScriptSetup.d.ts +5 -0
package/lib/utils/verifyTypeScriptSetup.js +229 -0
package/lib/webpack/config/base.d.ts +16 -0
package/lib/webpack/config/base.js +236 -0
package/lib/webpack/config/browser.d.ts +8 -0
package/lib/webpack/config/browser.js +147 -0
package/lib/webpack/config/index.d.ts +4 -0
package/lib/webpack/config/index.js +9 -0
package/lib/webpack/config/node.d.ts +7 -0
package/lib/webpack/config/node.js +55 -0
package/lib/webpack/config/parts/external.d.ts +4 -0
package/lib/webpack/config/parts/external.js +91 -0
package/lib/webpack/config/parts/helpers.d.ts +3 -0
package/lib/webpack/config/parts/helpers.js +48 -0
package/lib/webpack/config/parts/resolve.d.ts +1 -0
package/lib/webpack/config/parts/resolve.js +10 -0
package/lib/webpack/config/parts/style.d.ts +9 -0
package/lib/webpack/config/parts/style.js +217 -0
package/lib/webpack/loaders/export-global-loader.d.ts +7 -0
package/lib/webpack/loaders/export-global-loader.js +26 -0
package/lib/webpack/loaders/route-component-loader.d.ts +7 -0
package/lib/webpack/loaders/route-component-loader.js +14 -0
package/lib/webpack/loaders/shuvi-babel-loader.d.ts +1 -0
package/lib/webpack/loaders/shuvi-babel-loader.js +60 -0
package/lib/webpack/plugins/build-manifest-plugin.d.ts +27 -0
package/lib/webpack/plugins/build-manifest-plugin.js +215 -0
package/lib/webpack/plugins/chunk-names-plugin.d.ts +4 -0
package/lib/webpack/plugins/chunk-names-plugin.js +43 -0
package/lib/webpack/plugins/fix-watching-plugin.d.ts +4 -0
package/lib/webpack/plugins/fix-watching-plugin.js +23 -0
package/lib/webpack/plugins/module-replace-plugin/index.d.ts +1 -0
package/lib/webpack/plugins/module-replace-plugin/index.js +4 -0
package/lib/webpack/plugins/module-replace-plugin/plugin.d.ts +31 -0
package/lib/webpack/plugins/module-replace-plugin/plugin.js +177 -0
package/lib/webpack/plugins/module-replace-plugin/stub-loader.d.ts +1 -0
package/lib/webpack/plugins/module-replace-plugin/stub-loader.js +34 -0
package/lib/webpack/plugins/prefer-resolver-plugin.d.ts +10 -0
package/lib/webpack/plugins/prefer-resolver-plugin.js +47 -0
package/lib/webpack/plugins/require-cache-hot-reloader-plugin.d.ts +6 -0
package/lib/webpack/plugins/require-cache-hot-reloader-plugin.js +48 -0
package/lib/webpack/types.d.ts +40 -0
package/lib/webpack/types.js +2 -0
package/package.json +80 -0

package/lib/webpack/config/parts/style.js ADDED Viewed

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("@shuvi/shared/lib/constants");
+const Rule_1 = __importDefault(require("webpack-chain/src/Rule"));
+const mini_css_extract_plugin_1 = __importDefault(require("mini-css-extract-plugin"));
+const loader_utils_1 = __importDefault(require("loader-utils"));
+const path_1 = __importDefault(require("path"));
+const helpers_1 = require("./helpers");
+function getCSSModuleLocalIdent(context, localIdentName, localName, options) {
+    // Use the filename or folder name, based on some uses the index.js / index.module.(css|scss|sass) project style
+    const fileNameOrFolder = context.resourcePath.match(/index\.module\.(css|scss|sass)$/)
+        ? '[folder]'
+        : '[name]';
+    // Create a hash based on a the file location and class name. Will be unique across a project, and close to globally unique.
+    const hash = loader_utils_1.default.getHashDigest(
+    // @ts-ignore
+    path_1.default.posix.relative(context.rootContext, context.resourcePath) + localName, 'md5', 'base64', 5);
+    // Use loaderUtils to find the file or folder name
+    const className = loader_utils_1.default.interpolateName(context, fileNameOrFolder + '_' + localName + '__' + hash, options);
+    // remove the .module that appears in every classname when based on the file.
+    return className.replace('.module_', '_');
+}
+// style files regexes
+const cssRegex = /\.css$/;
+const cssModuleQueryRegex = /cssmodules/;
+const sassRegex = /\.(scss|sass)$/;
+function ssrCssRule({ test, resourceQuery, scss }) {
+    const rule = new Rule_1.default();
+    rule.test(test);
+    if (resourceQuery) {
+        rule.resourceQuery(resourceQuery);
+    }
+    rule
+        .use('css-loader')
+        .loader(require.resolve('css-loader'))
+        .options({
+        sourceMap: false,
+        importLoaders: scss ? 1 : 0,
+        esModule: true,
+        modules: {
+            getLocalIdent: getCSSModuleLocalIdent,
+            exportOnlyLocals: true
+        }
+    });
+    if (scss) {
+        rule.use('sass-loader').loader(require.resolve('sass-loader')).options({
+            sourceMap: false
+        });
+    }
+    return rule;
+}
+function cssRule({ publicPath, test, resourceQuery, cssModule, extractCss, sourceMap, scss }) {
+    const rule = new Rule_1.default();
+    rule.test(test);
+    if (resourceQuery) {
+        rule.resourceQuery(resourceQuery);
+    }
+    // A global CSS import always has side effects. Webpack will tree
+    // shake the CSS without this option if the issuer claims to have
+    // no side-effects.
+    // See https://github.com/webpack/webpack/issues/6571
+    rule.set('sideEffects', true);
+    if (extractCss) {
+        rule
+            .use('extract-loader')
+            .loader(mini_css_extract_plugin_1.default.loader)
+            .options(Object.assign({}, (publicPath && helpers_1.shouldUseRelativeAssetPaths(publicPath)
+            ? {
+                // path relative to outdir from the generated css file
+                publicPath: '../../'
+            }
+            : {})));
+    }
+    else {
+        rule
+            .use('style-loader')
+            .loader(require.resolve('style-loader'))
+            .options({
+            insert: new Function('element', `
+          // These elements should always exist. If they do not,
+          // this code should fail.
+          var anchorElement = document.querySelector("#${constants_1.DEV_STYLE_ANCHOR_ID}");
+          var parentNode = anchorElement.parentNode; // Normally <head>
+          // Each style tag should be placed right before our
+          // anchor. By inserting before and not after, we do not
+          // need to track the last inserted element.
+          parentNode.insertBefore(element, anchorElement);
+          window["${constants_1.DEV_STYLE_PREPARE}"] = new Promise(function(resolve) {
+            (window.requestAnimationFrame || setTimeout)(function() {
+              resolve();
+            });
+          });
+        `),
+            esModule: true
+        });
+    }
+    rule
+        .use('css-loader')
+        .loader(require.resolve('css-loader'))
+        .options(Object.assign({ sourceMap, importLoaders: scss ? 2 : 1, esModule: true }, (cssModule && {
+        modules: {
+            getLocalIdent: getCSSModuleLocalIdent
+            // exportOnlyLocals: true,
+        }
+    })));
+    rule
+        .use('postcss-loader')
+        .loader(require.resolve('postcss-loader'))
+        .options({
+        sourceMap,
+        postcssOptions: {
+            plugins: [
+                // Make Flexbox behave like the spec cross-browser.
+                require('postcss-flexbugs-fixes'),
+                // Run Autoprefixer and compile new CSS features.
+                require('postcss-preset-env')({
+                    autoprefixer: {
+                        flexbox: 'no-2009'
+                    },
+                    stage: 3
+                })
+            ]
+        }
+    });
+    if (scss) {
+        rule.use('sass-loader').loader(require.resolve('sass-loader')).options({
+            sourceMap
+        });
+    }
+    return rule;
+}
+function withStyle(chain, { extractCss, sourceMap, ssr, publicPath }) {
+    const oneOfs = chain.module.rule('main').oneOfs;
+    if (ssr) {
+        oneOfs.set('css-module',
+        // @ts-ignore
+        ssrCssRule({
+            test: cssRegex,
+            resourceQuery: cssModuleQueryRegex,
+            scss: false
+        }).after('js'));
+        oneOfs.set('scss-module',
+        // @ts-ignore
+        ssrCssRule({
+            test: sassRegex,
+            resourceQuery: cssModuleQueryRegex,
+            scss: true
+        }).after('css-module'));
+        const ignoreRule = new Rule_1.default();
+        ignoreRule
+            .test([cssRegex, sassRegex])
+            .use('ignore-loader')
+            .loader(require.resolve('ignore-loader'))
+            .end()
+            .after('scss-module');
+        // @ts-ignore
+        oneOfs.set('ignore', ignoreRule);
+        return chain;
+    }
+    if (extractCss) {
+        chain.plugin('mini-css-extract-plugin').use(mini_css_extract_plugin_1.default, [
+            {
+                filename: 'static/css/[contenthash:8].css',
+                chunkFilename: 'static/css/[contenthash:8].chunk.css'
+            }
+        ]);
+    }
+    oneOfs.set('css-module',
+    // @ts-ignore
+    cssRule({
+        test: cssRegex,
+        resourceQuery: cssModuleQueryRegex,
+        cssModule: true,
+        scss: false,
+        extractCss,
+        sourceMap,
+        publicPath
+    }).after('js'));
+    oneOfs.set('css',
+    // @ts-ignore
+    cssRule({
+        test: cssRegex,
+        cssModule: false,
+        scss: false,
+        extractCss,
+        sourceMap,
+        publicPath
+    }).after('css-module'));
+    oneOfs.set('scss-module',
+    // @ts-ignore
+    cssRule({
+        test: sassRegex,
+        resourceQuery: cssModuleQueryRegex,
+        cssModule: true,
+        scss: true,
+        extractCss,
+        sourceMap,
+        publicPath
+    }).after('css'));
+    oneOfs.set('scss',
+    // @ts-ignore
+    cssRule({
+        test: sassRegex,
+        cssModule: false,
+        scss: true,
+        extractCss,
+        sourceMap,
+        publicPath
+    }).after('scss-module'));
+    return chain;
+}
+exports.withStyle = withStyle;

package/lib/webpack/loaders/export-global-loader.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import { loader } from 'webpack';
+export declare type ClientPagesLoaderOptions = {
+    absolutePagePath: string;
+    page: string;
+};
+declare const nextClientPagesLoader: loader.Loader;
+export default nextClientPagesLoader;

package/lib/webpack/loaders/export-global-loader.js ADDED Viewed

@@ -0,0 +1,26 @@
+"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 nextClientPagesLoader = function () {
+    const { absolutePath, exportName, globalName } = loader_utils_1.default.getOptions(this);
+    const stringifyGlobalName = JSON.stringify(globalName);
+    const stringifyAbsolutePath = loader_utils_1.default.stringifyRequest(this, absolutePath);
+    const stringifyName = JSON.stringify(exportName);
+    return `
+var mod = require(${stringifyAbsolutePath})
+(window[${stringifyGlobalName}] = window[${stringifyGlobalName}] || {})[${stringifyName}] = mod.default || mod
+if(module.hot) {
+  module.hot.accept(${stringifyAbsolutePath}, function() {
+    if(!${stringifyGlobalName} in window) return
+    var updatedMod = require(${stringifyAbsolutePath})
+    window[${stringifyGlobalName}] = updatedMod.default || updatedMod
+  })
+}
+`;
+};
+exports.default = nextClientPagesLoader;

package/lib/webpack/loaders/route-component-loader.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import { loader } from 'webpack';
+export declare type RouteComponentLoaderOptions = {
+    componentAbsolutePath: string;
+    active: boolean;
+};
+declare const routeComponentLoader: loader.Loader;
+export default routeComponentLoader;

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

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

package/lib/webpack/loaders/shuvi-babel-loader.d.ts ADDED Viewed

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

package/lib/webpack/loaders/shuvi-babel-loader.js ADDED Viewed

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const babel_loader_1 = __importDefault(require("babel-loader"));
+const preset_1 = __importDefault(require("../../babel/preset"));
+function hasBuiltPreset(presets) {
+    return presets.some(preset => preset && preset.value === preset_1.default);
+}
+module.exports = babel_loader_1.default.custom((babel) => {
+    const presetItem = babel.createConfigItem(preset_1.default, {
+        type: 'preset'
+    });
+    const configs = new Set();
+    return {
+        customOptions(opts) {
+            const custom = {
+                isNode: opts.isNode
+            };
+            const loader = Object.assign(opts.cacheDirectory
+                ? {
+                    cacheCompression: false
+                }
+                : {
+                    cacheDirectory: false
+                }, opts);
+            delete loader.isNode;
+            return { loader, custom };
+        },
+        config(cfg, { source, customOptions: { isNode } }) {
+            const options = Object.assign({}, cfg.options);
+            if (cfg.hasFilesystemConfig()) {
+                for (const file of [cfg.babelrc, cfg.config]) {
+                    // We only log for client compilation otherwise there will be double output
+                    if (file && !isNode && !configs.has(file)) {
+                        configs.add(file);
+                        console.log(`> Using external babel configuration`);
+                        console.log(`> Location: "${file}"`);
+                    }
+                }
+            }
+            // Add built-in preset
+            if (!hasBuiltPreset(options.presets)) {
+                options.presets = [presetItem, ...options.presets];
+            }
+            // pass option to babel-preset
+            options.caller.isNode = isNode;
+            options.plugins = options.plugins || [];
+            options.plugins.push([
+                require.resolve('babel-plugin-transform-define'),
+                {
+                    'typeof window': isNode ? 'undefined' : 'object'
+                },
+                'shuvi-transform-define-instance'
+            ]);
+            return options;
+        }
+    };
+});

package/lib/webpack/plugins/build-manifest-plugin.d.ts ADDED Viewed

@@ -0,0 +1,27 @@
+import { Compiler, Compilation, Plugin } from 'webpack';
+interface Options {
+    filename: string;
+    modules: boolean;
+    chunkRequest: boolean;
+}
+export default class BuildManifestPlugin implements Plugin {
+    private _options;
+    private _manifest;
+    constructor(options?: Partial<Options>);
+    createAssets(compiler: Compiler, compilation: Compilation): {
+        entries: {};
+        bundles: {};
+        chunkRequest: {};
+        loadble: {};
+    };
+    apply(compiler: Compiler): void;
+    private _collectEntries;
+    private _collect;
+    private _collectChunk;
+    private _collectChunkModule;
+    private _pushEntries;
+    private _pushBundle;
+    private _pushChunkRequest;
+    private _pushLoadableModules;
+}
+export {};

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

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = __importDefault(require("webpack"));
+const Entrypoint_1 = __importDefault(require("webpack/lib/Entrypoint"));
+const { RawSource } = webpack_1.default.sources;
+const defaultOptions = {
+    filename: 'build-manifest.json',
+    modules: false,
+    chunkRequest: false
+};
+function getFileExt(filepath) {
+    const match = filepath.match(/\.(\w+)$/);
+    if (!match)
+        return '';
+    return match[1];
+}
+// function findEntrypointName(chunkGroup: any): string[] {
+//   const entrypoints: any[] = [];
+//   const queue: any[] = [chunkGroup];
+//   while (queue.length) {
+//     const item = queue.shift();
+//     for (const parent of item.getParents()) {
+//       if (parent instanceof Entrypoint) {
+//         entrypoints.push(parent.name);
+//       } else {
+//         queue.push(parent);
+//       }
+//     }
+//   }
+//   return entrypoints;
+// }
+// This plugin creates a build-manifest.json for all assets that are being output
+// It has a mapping of "entry" filename to real filename. Because the real filename can be hashed in production
+class BuildManifestPlugin {
+    constructor(options = {}) {
+        this._options = Object.assign(Object.assign({}, defaultOptions), options);
+    }
+    createAssets(compiler, compilation) {
+        const assetMap = (this._manifest = {
+            entries: {},
+            bundles: {},
+            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, chunkRootModulesMap);
+        });
+        this._manifest.loadble = Object.keys(this._manifest.loadble)
+            .sort()
+            // eslint-disable-next-line no-sequences
+            .reduce((a, c) => ((a[c] = this._manifest.loadble[c]), a), {});
+        return assetMap;
+    }
+    apply(compiler) {
+        compiler.hooks.make.tap('BuildManifestPlugin', compilation => {
+            compilation.hooks.processAssets.tap({
+                name: 'BuildManifestPlugin',
+                stage: webpack_1.default.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            }, assets => {
+                assets[this._options.filename] = new RawSource(JSON.stringify(this.createAssets(compiler, compilation), null, 2), true);
+            });
+        });
+    }
+    _collectEntries(entrypoint) {
+        for (const chunk of entrypoint.chunks) {
+            // If there's no name or no files
+            if (!chunk.name || !chunk.files) {
+                continue;
+            }
+            for (const file of chunk.files) {
+                if (/\.map$/.test(file) || /\.hot-update\.js$/.test(file)) {
+                    continue;
+                }
+                const ext = getFileExt(file);
+                this._pushEntries(entrypoint.name, ext, file.replace(/\\/g, '/'));
+            }
+        }
+    }
+    _collect(chunkGroup, compiler, compilation, chunkRootModulesMap) {
+        const collectModules = this._options.modules;
+        chunkGroup.origins.forEach(chunkGroupOrigin => {
+            const { request } = chunkGroupOrigin;
+            const ctx = { request, compiler, compilation, chunkRootModulesMap };
+            chunkGroup.chunks.forEach(chunk => {
+                this._collectChunk(chunk, ctx);
+                if (collectModules) {
+                    this._collectChunkModule(chunk, ctx);
+                }
+            });
+        });
+    }
+    _collectChunk(chunk, { request }) {
+        if (!chunk.files) {
+            return;
+        }
+        for (const file of chunk.files) {
+            if (/\.map$/.test(file) || /\.hot-update\.js$/.test(file)) {
+                continue;
+            }
+            const ext = getFileExt(file);
+            const normalizedPath = file.replace(/\\/g, '/');
+            // normal chunk
+            if (ext === 'js') {
+                if (chunk.isOnlyInitial()) {
+                    this._pushBundle({
+                        name: chunk.name,
+                        file: normalizedPath
+                    });
+                }
+                this._pushChunkRequest({
+                    file: normalizedPath,
+                    request
+                });
+            }
+        }
+    }
+    _collectChunkModule(chunk, { request, compiler, compilation, chunkRootModulesMap }) {
+        if (chunk.canBeInitial()) {
+            return;
+        }
+        const context = compiler.options.context;
+        chunk.files.forEach((file) => {
+            const isJs = file.match(/\.js$/) && file.match(/^static\/chunks\//);
+            const isCss = file.match(/\.css$/) && file.match(/^static\/css\//);
+            if (isJs || isCss) {
+                this._pushLoadableModules(request, file);
+            }
+        });
+        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
+                    });
+                }
+            }
+        }
+    }
+    _pushEntries(name, ext, value) {
+        const entries = this._manifest.entries;
+        if (!entries[name]) {
+            entries[name] = {
+                js: []
+            };
+        }
+        if (!entries[name][ext]) {
+            entries[name][ext] = [value];
+        }
+        else {
+            entries[name][ext].push(value);
+        }
+    }
+    _pushBundle({ name, file }) {
+        if (name) {
+            this._manifest.bundles[name] = file;
+        }
+    }
+    _pushChunkRequest({ file, request }) {
+        if (this._options.chunkRequest && request) {
+            this._manifest.chunkRequest[file] = request;
+        }
+    }
+    _pushLoadableModules(request, value) {
+        const modules = this._manifest.loadble;
+        if (!modules[request]) {
+            modules[request] = {
+                files: [],
+                children: []
+            };
+        }
+        if (typeof value === 'string') {
+            const existed = modules[request].files.some(file => file === value);
+            if (!existed) {
+                modules[request].files.push(value);
+            }
+        }
+        else {
+            const existed = modules[request].children.some(item => item.id === value.id);
+            if (!existed) {
+                modules[request].children.push(value);
+            }
+        }
+    }
+}
+exports.default = BuildManifestPlugin;

package/lib/webpack/plugins/chunk-names-plugin.d.ts ADDED Viewed

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

package/lib/webpack/plugins/chunk-names-plugin.js ADDED Viewed

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = require("webpack");
+// This plugin mirrors webpack 3 `filename` and `chunkfilename` behavior
+// This fixes https://github.com/webpack/webpack/issues/6598
+// This plugin is based on https://github.com/researchgate/webpack/commit/2f28947fa0c63ccbb18f39c0098bd791a2c37090
+class ChunkNamesPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('ChunkNamesPlugin', compilation => {
+            compilation.hooks.renderManifest.intercept({
+                register(tapInfo) {
+                    if (tapInfo.name === 'JavascriptModulesPlugin') {
+                        const originalMethod = tapInfo.fn;
+                        tapInfo.fn = (result, options) => {
+                            let filenameTemplate;
+                            const chunk = options.chunk;
+                            const outputOptions = options.outputOptions;
+                            // Note: fix Conflict: Multiple assets emit different content to the same filename static/chunks/page-xxxx.js
+                            if (chunk instanceof webpack_1.HotUpdateChunk) {
+                                return originalMethod(result, options);
+                            }
+                            const chunkGraph = options.chunkGraph;
+                            const hasEntryModule = chunkGraph.getNumberOfEntryModules(chunk) > 0;
+                            if (chunk.filenameTemplate) {
+                                filenameTemplate = chunk.filenameTemplate;
+                            }
+                            else if (chunk.hasRuntime() || hasEntryModule) {
+                                filenameTemplate = outputOptions.filename;
+                            }
+                            else {
+                                filenameTemplate = outputOptions.chunkFilename;
+                            }
+                            options.chunk.filenameTemplate = filenameTemplate;
+                            return originalMethod(result, options);
+                        };
+                    }
+                    return tapInfo;
+                }
+            });
+        });
+    }
+}
+exports.default = ChunkNamesPlugin;

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

@@ -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 ADDED Viewed

@@ -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/module-replace-plugin/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { default } from "./plugin";

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var plugin_1 = require("./plugin");
+exports.default = plugin_1.default;