@shuvi/toolpack 0.0.1-pre.1

package/lib/babel/plugins/auto-css-modules.d.ts

@@ -0,0 +1,7 @@
+import { Visitor } from '@babel/core';
+export interface IOpts {
+    flag?: string;
+}
+export default function (): {
+    visitor: Visitor<{}>;
+};

package/lib/babel/plugins/auto-css-modules.js

@@ -0,0 +1,24 @@
+"use strict";
+// Based on https://github.com/umijs/umi/blob/83301f25a420daff69ca51a179134c6b1612f5b6/packages/babel-plugin-auto-css-modules/src/index.ts
+// License: https://github.com/umijs/umi/blob/83301f25a420daff69ca51a179134c6b1612f5b6/LICENSE
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const CSS_EXTNAMES = ['.css', '.less', '.sass', '.scss'];
+function default_1() {
+    return {
+        visitor: {
+            ImportDeclaration(path, { opts }) {
+                const { specifiers, source, source: { value }, } = path.node;
+                if (specifiers.length && CSS_EXTNAMES.includes(path_1.extname(value))) {
+                    if (value.indexOf('?') >= 0) {
+                        source.value = `${value}&${opts.flag || 'cssmodules'}`;
+                    }
+                    else {
+                        source.value = `${value}?${opts.flag || 'cssmodules'}`;
+                    }
+                }
+            },
+        },
+    };
+}
+exports.default = default_1;

package/lib/babel/plugins/jsx-pragma.d.ts

@@ -0,0 +1,4 @@
+import { PluginObj, types as BabelTypes } from '@babel/core';
+export default function ({ types: t, }: {
+    types: typeof BabelTypes;
+}): PluginObj<any>;

package/lib/babel/plugins/jsx-pragma.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1({ types: t, }) {
+    return {
+        inherits: require('babel-plugin-syntax-jsx'),
+        visitor: {
+            JSXElement(path, state) {
+                state.set('jsx', true);
+            },
+            // Fragment syntax is still JSX since it compiles to createElement(),
+            // but JSXFragment is not a JSXElement
+            JSXFragment(path, state) {
+                state.set('jsx', true);
+            },
+            Program: {
+                exit(path, state) {
+                    if (state.get('jsx')) {
+                        const pragma = t.identifier(state.opts.pragma);
+                        let importAs = pragma;
+                        // if there's already a React in scope, use that instead of adding an import
+                        const existingBinding = state.opts.reuseImport !== false &&
+                            state.opts.importAs &&
+                            path.scope.getBinding(state.opts.importAs);
+                        // var _jsx = _pragma.createElement;
+                        if (state.opts.property) {
+                            if (state.opts.importAs) {
+                                importAs = t.identifier(state.opts.importAs);
+                            }
+                            else {
+                                importAs = path.scope.generateUidIdentifier('pragma');
+                            }
+                            const mapping = t.variableDeclaration('var', [
+                                t.variableDeclarator(pragma, t.memberExpression(importAs, t.identifier(state.opts.property))),
+                            ]);
+                            // if the React binding came from a require('react'),
+                            // make sure that our usage comes after it.
+                            let newPath;
+                            if (existingBinding &&
+                                t.isVariableDeclarator(existingBinding.path.node) &&
+                                t.isCallExpression(existingBinding.path.node.init) &&
+                                t.isIdentifier(existingBinding.path.node.init.callee) &&
+                                existingBinding.path.node.init.callee.name === 'require') {
+                                [newPath] = existingBinding.path.parentPath.insertAfter(
+                                // @ts-ignore
+                                mapping);
+                            }
+                            else {
+                                // @ts-ignore
+                                [newPath] = path.unshiftContainer('body', mapping);
+                            }
+                            for (const declar of newPath.get('declarations')) {
+                                path.scope.registerBinding(newPath.node.kind, declar);
+                            }
+                        }
+                        if (!existingBinding) {
+                            const importSpecifier = t.importDeclaration([
+                                state.opts.import
+                                    ? // import { $import as _pragma } from '$module'
+                                        t.importSpecifier(importAs, t.identifier(state.opts.import))
+                                    : state.opts.importNamespace
+                                        ? t.importNamespaceSpecifier(importAs)
+                                        : // import _pragma from '$module'
+                                            t.importDefaultSpecifier(importAs),
+                            ], t.stringLiteral(state.opts.module || 'react'));
+                            // @ts-ignore
+                            const [newPath] = path.unshiftContainer('body', importSpecifier);
+                            for (const specifier of newPath.get('specifiers')) {
+                                path.scope.registerBinding('module', specifier);
+                            }
+                        }
+                    }
+                },
+            },
+        },
+    };
+}
+exports.default = default_1;

package/lib/babel/plugins/loadable-plugin.d.ts

@@ -0,0 +1,24 @@
+/**
+COPYRIGHT (c) 2017-present James Kyle <me@thejameskyle.com>
+ MIT License
+ 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 SOFTWAR
+*/
+import { PluginObj, types as BabelTypes } from '@babel/core';
+export default function ({ types: t, }: {
+    types: typeof BabelTypes;
+}): PluginObj;

package/lib/babel/plugins/loadable-plugin.js

@@ -0,0 +1,105 @@
+"use strict";
+// @ts-nocheck
+/**
+COPYRIGHT (c) 2017-present James Kyle <me@thejameskyle.com>
+ MIT License
+ 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 SOFTWAR
+*/
+// This file is https://github.com/jamiebuilds/react-loadable/blob/master/src/babel.js
+// Modified to also look for `shuvi/dynamic`
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1({ types: t, }) {
+    return {
+        visitor: {
+            ImportDeclaration(path) {
+                let source = path.node.source.value;
+                if (source !== '@shuvi/app')
+                    return;
+                let dynamicSpecifier = path.get('specifiers').find((specifier) => {
+                    return specifier.node.imported.name === 'dynamic';
+                });
+                if (!dynamicSpecifier)
+                    return;
+                const bindingName = dynamicSpecifier.node.local.name;
+                const binding = path.scope.getBinding(bindingName);
+                if (!binding) {
+                    return;
+                }
+                binding.referencePaths.forEach((refPath) => {
+                    const callExpression = refPath.parentPath;
+                    if (!callExpression.isCallExpression())
+                        return;
+                    let args = callExpression.get('arguments');
+                    if (args.length > 2) {
+                        throw callExpression.buildCodeFrameError('shuvi/dynamic only accepts 2 arguments');
+                    }
+                    if (!args[0]) {
+                        return;
+                    }
+                    let loader;
+                    let options;
+                    if (args[0].isObjectExpression()) {
+                        options = args[0];
+                    }
+                    else {
+                        if (!args[1]) {
+                            callExpression.node.arguments.push(t.objectExpression([]));
+                        }
+                        args = callExpression.get('arguments');
+                        loader = args[0];
+                        options = args[1];
+                    }
+                    if (!options.isObjectExpression())
+                        return;
+                    let properties = options.get('properties');
+                    let propertiesMap = {};
+                    properties.forEach((property) => {
+                        const key = property.get('key');
+                        propertiesMap[key.node.name] = property;
+                    });
+                    if (propertiesMap.webpack) {
+                        return;
+                    }
+                    if (propertiesMap.loader) {
+                        loader = propertiesMap.loader.get('value');
+                    }
+                    if (!loader || Array.isArray(loader)) {
+                        return;
+                    }
+                    const dynamicImports = [];
+                    loader.traverse({
+                        Import(path) {
+                            const args = path.parentPath.get('arguments');
+                            if (!Array.isArray(args))
+                                return;
+                            const node = args[0].node;
+                            dynamicImports.push(node);
+                        },
+                    });
+                    if (!dynamicImports.length)
+                        return;
+                    options.node.properties.push(t.objectProperty(t.identifier('webpack'), t.arrowFunctionExpression([], t.arrayExpression(dynamicImports.map((dynamicImport) => {
+                        return t.callExpression(t.memberExpression(t.identifier('require'), t.identifier('resolveWeak')), [dynamicImport]);
+                    })))));
+                    options.node.properties.push(t.objectProperty(t.identifier('modules'), t.arrayExpression(dynamicImports)));
+                });
+            },
+        },
+    };
+}
+exports.default = default_1;

package/lib/babel/plugins/optimize-hook-destructuring.d.ts

@@ -0,0 +1,4 @@
+import { PluginObj, types as BabelTypes } from '@babel/core';
+export default function ({ types: t, }: {
+    types: typeof BabelTypes;
+}): PluginObj<any>;

package/lib/babel/plugins/optimize-hook-destructuring.js

@@ -0,0 +1,59 @@
+"use strict";
+// Based on https://github.com/zeit/next.js
+// License: https://github.com/zeit/next.js/blob/977bf8d9ebd2845241b8689317f36e4e487f39d0/license.md
+Object.defineProperty(exports, "__esModule", { value: true });
+// matches any hook-like (the default)
+const isHook = /^use[A-Z]/;
+// matches only built-in hooks provided by React et al
+const isBuiltInHook = /^use(Callback|Context|DebugValue|Effect|ImperativeHandle|LayoutEffect|Memo|Reducer|Ref|State)$/;
+function default_1({ types: t, }) {
+    const visitor = {
+        CallExpression(path, state) {
+            const onlyBuiltIns = state.opts.onlyBuiltIns;
+            // if specified, options.lib is a list of libraries that provide hook functions
+            const libs = state.opts.lib &&
+                (state.opts.lib === true
+                    ? ['react', 'preact/hooks']
+                    : [].concat(state.opts.lib));
+            // skip function calls that are not the init of a variable declaration:
+            if (!t.isVariableDeclarator(path.parent))
+                return;
+            // skip function calls where the return value is not Array-destructured:
+            if (!t.isArrayPattern(path.parent.id))
+                return;
+            // name of the (hook) function being called:
+            const hookName = path.node.callee.name;
+            if (libs) {
+                const binding = path.scope.getBinding(hookName);
+                // not an import
+                if (!binding || binding.kind !== 'module')
+                    return;
+                const specifier = binding.path.parent
+                    .source.value;
+                // not a match
+                if (!libs.some((lib) => lib === specifier))
+                    return;
+            }
+            // only match function calls with names that look like a hook
+            if (!(onlyBuiltIns ? isBuiltInHook : isHook).test(hookName))
+                return;
+            // @ts-ignore
+            path.parent.id = t.objectPattern(path.parent.id.elements.reduce((patterns, element, i) => {
+                if (element === null) {
+                    return patterns;
+                }
+                return patterns.concat(t.objectProperty(t.numericLiteral(i), element));
+            }, []));
+        },
+    };
+    return {
+        name: 'optimize-hook-destructuring',
+        visitor: {
+            // this is a workaround to run before preset-env destroys destructured assignments
+            Program(path, state) {
+                path.traverse(visitor, state);
+            },
+        },
+    };
+}
+exports.default = default_1;

package/lib/babel/preset.d.ts

@@ -0,0 +1,14 @@
+import { PluginItem } from '@babel/core';
+export declare type PresetOptions = {
+    'preset-env'?: any;
+    'preset-react'?: any;
+    'transform-runtime'?: any;
+};
+declare type BabelPreset = {
+    presets?: PluginItem[] | null;
+    plugins?: PluginItem[] | null;
+    sourceType?: 'script' | 'module' | 'unambiguous';
+    overrides?: any[];
+};
+declare const _default: (api: any, options?: PresetOptions) => BabelPreset;
+export default _default;

package/lib/babel/preset.js

@@ -0,0 +1,106 @@
+"use strict";
+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 env = process.env.NODE_ENV;
+const isProduction = env === 'production';
+const isDevelopment = env === 'development';
+const isTest = env === 'test';
+// Taken from https://github.com/babel/babel/commit/d60c5e1736543a6eac4b549553e107a9ba967051#diff-b4beead8ad9195361b4537601cc22532R158
+function supportsStaticESM(caller) {
+    return !!(caller && caller.supportsStaticESM);
+}
+exports.default = (api, options = {}) => {
+    const supportsESM = api.caller(supportsStaticESM);
+    const isNode = api.caller((caller) => !!caller && caller.isNode);
+    const presetEnvConfig = Object.assign({ 
+        // In the test environment `modules` is often needed to be set to true, babel figures that out by itself using the `'auto'` option
+        // In production/development this option is set to `false` so that webpack can handle import/export with tree-shaking
+        modules: 'auto', exclude: ['transform-typeof-symbol'] }, options['preset-env']);
+    // When transpiling for the server or tests, target the current Node version
+    // if not explicitly specified:
+    if ((isNode || isTest) &&
+        (!presetEnvConfig.targets ||
+            !(typeof presetEnvConfig.targets === 'object' &&
+                'node' in presetEnvConfig.targets))) {
+        presetEnvConfig.targets = {
+            // Targets the current process' version of Node. This requires apps be
+            // built and deployed on the same version of Node.
+            node: 'current'
+        };
+    }
+    return {
+        sourceType: 'unambiguous',
+        presets: [
+            [require('@babel/preset-env').default, presetEnvConfig],
+            [
+                require('@babel/preset-react'),
+                Object.assign({ 
+                    // Adds component stack to warning messages
+                    // Adds __self attribute to JSX which React will use for some warnings
+                    development: isDevelopment || isTest, pragma: '__jsx', 
+                    // Will use the native built-in instead of trying to polyfill
+                    // behavior for any plugins that require one.
+                    useBuiltIns: true }, options['preset-react'])
+            ],
+            require('@babel/preset-typescript')
+        ],
+        plugins: [
+            require('./plugins/auto-css-modules'),
+            [
+                require('./plugins/jsx-pragma'),
+                {
+                    // This produces the following injected import for modules containing JSX:
+                    //   import React from 'react';
+                    //   var __jsx = React.createElement;
+                    module: 'react',
+                    importAs: 'React',
+                    pragma: '__jsx',
+                    property: 'createElement'
+                }
+            ],
+            [
+                require('./plugins/optimize-hook-destructuring'),
+                {
+                    // only optimize hook functions imported from React/Preact
+                    lib: true
+                }
+            ],
+            require('@babel/plugin-syntax-dynamic-import'),
+            require('./plugins/loadable-plugin'),
+            require('@babel/plugin-proposal-class-properties'),
+            [
+                require('@babel/plugin-proposal-object-rest-spread'),
+                {
+                    useBuiltIns: true
+                }
+            ],
+            !isNode && [
+                require('@babel/plugin-transform-runtime'),
+                Object.assign({ version: require('@babel/runtime/package.json').version, false: false, helpers: true, regenerator: true, useESModules: supportsESM && presetEnvConfig.modules !== 'commonjs', 
+                    // Undocumented option that lets us encapsulate our runtime, ensuring
+                    // the correct version is used
+                    // https://github.com/babel/babel/blob/090c364a90fe73d36a30707fc612ce037bdbbb24/packages/babel-plugin-transform-runtime/src/index.js#L35-L42
+                    absoluteRuntime: path_1.default.dirname(require.resolve('@babel/runtime/package.json')) }, options['transform-runtime'])
+            ],
+            isProduction && [
+                require('babel-plugin-transform-react-remove-prop-types'),
+                {
+                    removeImport: true
+                }
+            ],
+            require('@babel/plugin-proposal-optional-chaining'),
+            require('@babel/plugin-proposal-nullish-coalescing-operator'),
+            isNode && require('@babel/plugin-syntax-bigint'),
+            [require('@babel/plugin-proposal-numeric-separator').default, false]
+        ].filter(Boolean),
+        overrides: [
+            {
+                test: /\.tsx?$/,
+                plugins: [require('@babel/plugin-proposal-numeric-separator').default]
+            }
+        ]
+    };
+};

package/lib/constants.d.ts

@@ -0,0 +1 @@
+export declare const AppSourceRegexs: RegExp[];

package/lib/constants.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppSourceRegexs = [/[/\\]shuvi-app[/\\]/];

package/lib/utils/emptyComponent.d.ts

@@ -0,0 +1 @@
+export default function (): null;

package/lib/utils/emptyComponent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1() {
+    console.warn('You should compile the module before using it.');
+    return null;
+}
+exports.default = default_1;

package/lib/utils/forkTsCheckerWebpackPlugin.d.ts

@@ -0,0 +1,4 @@
+import ForkTsCheckerWebpackPlugin from 'fork-ts-checker-webpack-plugin';
+export { Issue } from 'fork-ts-checker-webpack-plugin/lib/issue';
+export { createCodeFrameFormatter } from 'fork-ts-checker-webpack-plugin/lib/formatter/CodeFrameFormatter';
+export default ForkTsCheckerWebpackPlugin;

package/lib/utils/forkTsCheckerWebpackPlugin.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fork_ts_checker_webpack_plugin_1 = __importDefault(require("fork-ts-checker-webpack-plugin"));
+var CodeFrameFormatter_1 = require("fork-ts-checker-webpack-plugin/lib/formatter/CodeFrameFormatter");
+exports.createCodeFrameFormatter = CodeFrameFormatter_1.createCodeFrameFormatter;
+exports.default = fork_ts_checker_webpack_plugin_1.default;

package/lib/utils/formatWebpackMessages.d.ts

@@ -0,0 +1,5 @@
+export = formatWebpackMessages;
+declare function formatWebpackMessages(json: any): {
+    errors: any;
+    warnings: any;
+};

package/lib/utils/formatWebpackMessages.js

@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+const chalk = require('@shuvi/utils/lib/chalk').default;
+const friendlySyntaxErrorLabel = 'Syntax error:';
+function isLikelyASyntaxError(message) {
+    return message.indexOf(friendlySyntaxErrorLabel) !== -1;
+}
+// Cleans up webpack error messages.
+function formatMessage(message, isError) {
+    message =
+        (message.moduleName ? message.moduleName + '\n' : '') +
+            (message.file ? message.file + '\n' : '') +
+            message.message;
+    let lines = message.split('\n');
+    // Strip Webpack-added headers off errors/warnings
+    // https://github.com/webpack/webpack/blob/master/lib/ModuleError.js
+    lines = lines.filter(line => !/Module [A-z ]+\(from/.test(line));
+    // Transform parsing error into syntax error
+    // TODO: move this to our ESLint formatter?
+    lines = lines.map(line => {
+        const parsingError = /Line (\d+):(?:(\d+):)?\s*Parsing error: (.+)$/.exec(line);
+        if (!parsingError) {
+            return line;
+        }
+        const [, errorLine, errorColumn, errorMessage] = parsingError;
+        return `${friendlySyntaxErrorLabel} ${errorMessage} (${errorLine}:${errorColumn})`;
+    });
+    message = lines.join('\n');
+    // Smoosh syntax errors (commonly found in CSS)
+    message = message.replace(/SyntaxError\s+\((\d+):(\d+)\)\s*(.+?)\n/g, `${friendlySyntaxErrorLabel} $3 ($1:$2)\n`);
+    // Clean up export errors
+    message = message.replace(/^.*export '(.+?)' was not found in '(.+?)'.*$/gm, `Attempted import error: '$1' is not exported from '$2'.`);
+    message = message.replace(/^.*export 'default' \(imported as '(.+?)'\) was not found in '(.+?)'.*$/gm, `Attempted import error: '$2' does not contain a default export (imported as '$1').`);
+    message = message.replace(/^.*export '(.+?)' \(imported as '(.+?)'\) was not found in '(.+?)'.*$/gm, `Attempted import error: '$1' is not exported from '$3' (imported as '$2').`);
+    lines = message.split('\n');
+    // Remove leading newline
+    if (lines.length > 2 && lines[1].trim() === '') {
+        lines.splice(1, 1);
+    }
+    // Clean up file name
+    lines[0] = lines[0].replace(/^(.*) \d+:\d+-\d+$/, '$1');
+    // Cleans up verbose "module not found" messages for files and packages.
+    if (lines[1] && lines[1].indexOf('Module not found: ') === 0) {
+        lines = [
+            lines[0],
+            lines[1]
+                .replace('Error: ', '')
+                .replace('Module not found: Cannot find file:', 'Cannot find file:')
+        ];
+    }
+    // Add helpful message for users trying to use Sass for the first time
+    if (lines[1] && lines[1].match(/Cannot find module.+node-sass/)) {
+        lines[1] = 'To import Sass files, you first need to install node-sass.\n';
+        lines[1] +=
+            'Run `npm install node-sass` or `yarn add node-sass` inside your workspace.';
+    }
+    lines[0] = chalk.inverse(lines[0]);
+    message = lines.join('\n');
+    // Internal stacks are generally useless so we strip them... with the
+    // exception of stacks containing `webpack:` because they're normally
+    // from user code generated by Webpack. For more information see
+    // https://github.com/facebook/create-react-app/pull/1050
+    message = message.replace(/^\s*at\s((?!webpack:).)*:\d+:\d+[\s)]*(\n|$)/gm, ''); // at ... ...:x:y
+    message = message.replace(/^\s*at\s<anonymous>(\n|$)/gm, ''); // at <anonymous>
+    lines = message.split('\n');
+    // Remove duplicated newlines
+    lines = lines.filter((line, index, arr) => index === 0 || line.trim() !== '' || line.trim() !== arr[index - 1].trim());
+    // Reassemble the message
+    message = lines.join('\n');
+    return message.trim();
+}
+function formatWebpackMessages(json) {
+    const formattedErrors = json.errors.map(function (message) {
+        return formatMessage(message, true);
+    });
+    const formattedWarnings = json.warnings.map(function (message) {
+        return formatMessage(message, false);
+    });
+    const result = { errors: formattedErrors, warnings: formattedWarnings };
+    if (result.errors.some(isLikelyASyntaxError)) {
+        // If there are any syntax errors, show just them.
+        result.errors = result.errors.filter(isLikelyASyntaxError);
+    }
+    return result;
+}
+module.exports = formatWebpackMessages;

package/lib/utils/hotDevClient/eventsource.d.ts

@@ -0,0 +1 @@
+export function getEventSourceWrapper(options: any): any;

package/lib/utils/hotDevClient/eventsource.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const eventCallbacks = [];
+function EventSourceWrapper(options) {
+    var source;
+    var lastActivity = new Date();
+    var listeners = [];
+    if (!options.timeout) {
+        options.timeout = 20 * 1000;
+    }
+    init();
+    var timer = setInterval(function () {
+        if (new Date() - lastActivity > options.timeout) {
+            handleDisconnect();
+        }
+    }, options.timeout / 2);
+    function init() {
+        source = new window.EventSource(options.path);
+        source.onopen = handleOnline;
+        source.onerror = handleDisconnect;
+        source.onmessage = handleMessage;
+    }
+    function handleOnline() {
+        if (options.log)
+            console.log("[HMR] connected");
+        lastActivity = new Date();
+    }
+    function handleMessage(event) {
+        lastActivity = new Date();
+        for (var i = 0; i < listeners.length; i++) {
+            listeners[i](event);
+        }
+        if (event.data.indexOf("action") !== -1) {
+            eventCallbacks.forEach(cb => cb(event));
+        }
+    }
+    function handleDisconnect() {
+        clearInterval(timer);
+        source.close();
+        setTimeout(init, options.timeout);
+    }
+    return {
+        onclose: () => {
+            clearTimeout(timer);
+            source.close();
+        },
+        addMessageListener: function (fn) {
+            listeners.push(fn);
+        }
+    };
+}
+function getEventSourceWrapper(options) {
+    if (!window.__whmEventSourceWrapper) {
+        window.__whmEventSourceWrapper = {};
+    }
+    if (!window.__whmEventSourceWrapper[options.path]) {
+        // cache the wrapper for other entries loaded on
+        // the same page with the same options.path
+        window.__whmEventSourceWrapper[options.path] = EventSourceWrapper(options);
+    }
+    return window.__whmEventSourceWrapper[options.path];
+}
+exports.getEventSourceWrapper = getEventSourceWrapper;

package/lib/utils/hotDevClient/index.d.ts

@@ -0,0 +1,4 @@
+export default function connect(options: any): {
+    subscribeToHmrEvent(handler: any): void;
+    reportRuntimeError(err: any): void;
+};