@umijs/bundler-webpack 3.5.20 → 4.0.0-beta.12

package/README.md

@@ -1 +1,3 @@
 # @umijs/bundler-webpack
+
+See our website [umijs](https://umijs.org) for more information.

package/bin/bundler-webpack.js

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
-
-require('../lib/cli');
+require('../dist/cli');

package/client/client/client.js

@@ -0,0 +1,202 @@
+import stripAnsi from '@umijs/utils/compiled/strip-ansi';
+// @ts-ignore
+import * as ErrorOverlay from 'react-error-overlay';
+import { MESSAGE_TYPE } from '../constants';
+import { formatWebpackMessages } from '../utils/formatWebpackMessages';
+console.log('[webpack] connecting...');
+let pingTimer = null;
+const host = location.host;
+const wsUrl = `ws://${host}`;
+let isFirstCompilation = true;
+let mostRecentCompilationHash = null;
+let hasCompileErrors = false;
+let hadRuntimeError = false;
+const socket = new WebSocket(wsUrl, 'webpack-hmr');
+socket.addEventListener('message', async ({ data }) => {
+    data = JSON.parse(data);
+    if (data.type === 'connected') {
+        console.log(`[webpack] connected.`);
+        // proxy(nginx, docker) hmr ws maybe caused timeout,
+        // so send ping package let ws keep alive.
+        pingTimer = setInterval(() => socket.send('ping'), 30000);
+    }
+    else {
+        handleMessage(data).catch(console.error);
+    }
+});
+async function waitForSuccessfulPing(ms = 1000) {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            await fetch(`/__umi_ping`);
+            break;
+        }
+        catch (e) {
+            await new Promise((resolve) => setTimeout(resolve, ms));
+        }
+    }
+}
+socket.addEventListener('close', async () => {
+    if (pingTimer)
+        clearInterval(pingTimer);
+    console.info('[webpack] Dev server disconnected. Polling for restart...');
+    await waitForSuccessfulPing();
+    location.reload();
+});
+ErrorOverlay.startReportingRuntimeErrors({
+    onError: function () {
+        hadRuntimeError = true;
+    },
+    filename: '/static/js/bundle.js',
+});
+// @ts-ignore
+if (module.hot && typeof module.hot.dispose === 'function') {
+    // @ts-ignore
+    module.hot.dispose(function () {
+        // TODO: why do we need this?
+        ErrorOverlay.stopReportingRuntimeErrors();
+    });
+}
+// There is a newer version of the code available.
+function handleAvailableHash(hash) {
+    // Update last known compilation hash.
+    mostRecentCompilationHash = hash;
+}
+function handleSuccess() {
+    const isHotUpdate = !isFirstCompilation;
+    isFirstCompilation = false;
+    hasCompileErrors = false;
+    // Attempt to apply hot updates or reload.
+    if (isHotUpdate) {
+        tryApplyUpdates(function onHotUpdateSuccess() {
+            // Only dismiss it when we're sure it's a hot update.
+            // Otherwise it would flicker right before the reload.
+            tryDismissErrorOverlay();
+        });
+    }
+}
+function handleWarnings(warnings) {
+    const isHotUpdate = !isFirstCompilation;
+    isFirstCompilation = false;
+    hasCompileErrors = false;
+    const formatted = formatWebpackMessages({
+        warnings,
+        errors: [],
+    });
+    // print warnings
+    if (typeof console !== 'undefined' && typeof console.warn === 'function') {
+        for (let i = 0; i < formatted.warnings.length; i++) {
+            if (i === 5) {
+                console.warn('There were more warnings in other files.\n' +
+                    'You can find a complete log in the terminal.');
+                break;
+            }
+            console.warn(stripAnsi(formatted.warnings[i]));
+        }
+    }
+    // Attempt to apply hot updates or reload.
+    if (isHotUpdate) {
+        tryApplyUpdates(function onSuccessfulHotUpdate() {
+            // Only dismiss it when we're sure it's a hot update.
+            // Otherwise it would flicker right before the reload.
+            tryDismissErrorOverlay();
+        });
+    }
+}
+function handleErrors(errors) {
+    isFirstCompilation = false;
+    hasCompileErrors = true;
+    const formatted = formatWebpackMessages({
+        warnings: [],
+        errors,
+    });
+    // Only show the first error.
+    ErrorOverlay.reportBuildError(formatted.errors[0]);
+    // Also log them to the console.
+    if (typeof console !== 'undefined' && typeof console.error === 'function') {
+        for (let i = 0; i < formatted.errors.length; i++) {
+            console.error(stripAnsi(formatted.errors[i]));
+        }
+    }
+}
+function tryDismissErrorOverlay() {
+    if (!hasCompileErrors) {
+        ErrorOverlay.dismissBuildError();
+    }
+}
+// Is there a newer version of this code available?
+function isUpdateAvailable() {
+    // @ts-ignore
+    return mostRecentCompilationHash !== __webpack_hash__;
+}
+function canApplyUpdates() {
+    // @ts-ignore
+    return module.hot.status() === 'idle';
+}
+function canAcceptErrors() {
+    // NOTE: This var is injected by Webpack's DefinePlugin, and is a boolean instead of string.
+    const hasReactRefresh = process.env.FAST_REFRESH;
+    // @ts-ignore
+    const status = module.hot.status();
+    // React refresh can handle hot-reloading over errors.
+    // However, when hot-reload status is abort or fail,
+    // it indicates the current update cannot be applied safely,
+    // and thus we should bail out to a forced reload for consistency.
+    return hasReactRefresh && ['abort', 'fail'].indexOf(status) === -1;
+}
+function tryApplyUpdates(onHotUpdateSuccess) {
+    // @ts-ignore
+    if (!module.hot) {
+        window.location.reload();
+        return;
+    }
+    if (!isUpdateAvailable() || !canApplyUpdates()) {
+        return;
+    }
+    function handleApplyUpdates(err, updatedModules) {
+        const haveErrors = err || hadRuntimeError;
+        // When there is no error but updatedModules is unavailable,
+        // it indicates a critical failure in hot-reloading,
+        // e.g. server is not ready to serve new bundle,
+        // and hence we need to do a forced reload.
+        const needsForcedReload = !err && !updatedModules;
+        if ((haveErrors && !canAcceptErrors()) || needsForcedReload) {
+            window.location.reload();
+        }
+        if (onHotUpdateSuccess)
+            onHotUpdateSuccess();
+        // While we were updating, there was a new update! Do it again.
+        if (isUpdateAvailable()) {
+            tryApplyUpdates();
+        }
+    }
+    // @ts-ignore
+    module.hot
+        .check(/* autoApply */ true)
+        .then((updatedModules) => {
+        handleApplyUpdates(null, updatedModules);
+    })
+        .catch((err) => {
+        handleApplyUpdates(err, null);
+    });
+}
+async function handleMessage(payload) {
+    // console.log('[payload]', payload);
+    switch (payload.type) {
+        case MESSAGE_TYPE.hash:
+            handleAvailableHash(payload.data);
+            break;
+        case MESSAGE_TYPE.stillOk:
+        case MESSAGE_TYPE.ok:
+            handleSuccess();
+            break;
+        case MESSAGE_TYPE.errors:
+            handleErrors(payload.data);
+            break;
+        case MESSAGE_TYPE.warnings:
+            handleWarnings(payload.data);
+            break;
+        default:
+        // Do nothing
+    }
+}

package/client/constants.js

@@ -0,0 +1,12 @@
+export const DEFAULT_DEVTOOL = 'cheap-module-source-map';
+export const DEFAULT_OUTPUT_PATH = 'dist';
+export const MFSU_NAME = 'MFSU';
+export var MESSAGE_TYPE;
+(function (MESSAGE_TYPE) {
+    MESSAGE_TYPE["ok"] = "ok";
+    MESSAGE_TYPE["warnings"] = "warnings";
+    MESSAGE_TYPE["errors"] = "errors";
+    MESSAGE_TYPE["hash"] = "hash";
+    MESSAGE_TYPE["stillOk"] = "still-ok";
+    MESSAGE_TYPE["invalid"] = "invalid";
+})(MESSAGE_TYPE || (MESSAGE_TYPE = {}));

package/client/utils/formatWebpackMessages.js

@@ -0,0 +1,92 @@
+import stripAnsi from '@umijs/utils/compiled/strip-ansi';
+const friendlySyntaxErrorLabel = 'Syntax error:';
+function isLikelyASyntaxError(message) {
+    return stripAnsi(message).indexOf(friendlySyntaxErrorLabel) !== -1;
+}
+export function formatMessage(message) {
+    let lines = [];
+    if (typeof message === 'string') {
+        lines = message.split('\n');
+    }
+    else if ('message' in message) {
+        lines = message['message'].split('\n');
+    }
+    else if (Array.isArray(message)) {
+        message.forEach((message) => {
+            if ('message' in message) {
+                lines = message['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.+sass/)) {
+        lines[1] = 'To import Sass files, you first need to install sass.\n';
+        lines[1] +=
+            'Run `npm install sass` or `yarn add sass` inside your workspace.';
+    }
+    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();
+}
+export function formatWebpackMessages(json) {
+    const formattedErrors = json.errors.map(function (message) {
+        return formatMessage(message);
+    });
+    const formattedWarnings = json.warnings.map(function (message) {
+        return formatMessage(message);
+    });
+    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;
+}

package/compiled/autoprefixer/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2013 Andrey Sitnik <andrey@sitnik.ru>
+
+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.

package/compiled/autoprefixer/browserslist/index.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Return array of browsers by selection queries.
+ *
+ * ```js
+ * browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
+ * ```
+ *
+ * @param queries Browser queries.
+ * @returns Array with browser names in Can I Use.
+ */
+declare function browserslist(
+  queries?: string | readonly string[] | null,
+  opts?: browserslist.Options
+): string[]
+
+declare namespace browserslist {
+  interface Options {
+    /**
+     * Path to processed file. It will be used to find config files.
+     */
+    path?: string | false
+    /**
+     * Processing environment. It will be used to take right queries
+     * from config file.
+     */
+    env?: string
+    /**
+     * Custom browser usage statistics for "> 1% in my stats" query.
+     */
+    stats?: Stats | string
+    /**
+     * Path to config file with queries.
+     */
+    config?: string
+    /**
+     * Do not throw on unknown version in direct query.
+     */
+    ignoreUnknownVersions?: boolean
+    /**
+     * Disable security checks for extend query.
+     */
+    dangerousExtend?: boolean
+    /**
+     * Alias mobile browsers to the desktop version when Can I Use
+     * doesn’t have data about the specified version.
+     */
+    mobileToDesktop?: boolean
+  }
+
+  type Config = {
+    defaults: string[]
+    [section: string]: string[] | undefined
+  }
+
+  interface Stats {
+    [browser: string]: {
+      [version: string]: number
+    }
+  }
+
+  /**
+   * Browser names aliases.
+   */
+  let aliases: {
+    [alias: string]: string | undefined
+  }
+
+  /**
+   * Aliases to work with joined versions like `ios_saf 7.0-7.1`.
+   */
+  let versionAliases: {
+    [browser: string]:
+      | {
+          [version: string]: string | undefined
+        }
+      | undefined
+  }
+
+  /**
+   * Can I Use only provides a few versions for some browsers (e.g. `and_chr`).
+   *
+   * Fallback to a similar browser for unknown versions.
+   */
+  let desktopNames: {
+    [browser: string]: string | undefined
+  }
+
+  let data: {
+    [browser: string]:
+      | {
+          name: string
+          versions: string[]
+          released: string[]
+          releaseDate: {
+            [version: string]: number | undefined | null
+          }
+        }
+      | undefined
+  }
+
+  interface Usage {
+    [version: string]: number
+  }
+
+  let usage: {
+    global?: Usage
+    custom?: Usage | null
+    [country: string]: Usage | undefined | null
+  }
+
+  let cache: {
+    [feature: string]: {
+      [name: string]: 'y' | 'n'
+    }
+  }
+
+  /**
+   * Default browsers query
+   */
+  let defaults: readonly string[]
+
+  /**
+   * Which statistics should be used. Country code or custom statistics.
+   * Pass `"my stats"` to load statistics from `Browserslist` files.
+   */
+  type StatsOptions = string | 'my stats' | Stats | { dataByBrowser: Stats }
+
+  /**
+   * Return browsers market coverage.
+   *
+   * ```js
+   * browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1
+   * ```
+   *
+   * @param browsers Browsers names in Can I Use.
+   * @param stats Which statistics should be used.
+   * @returns Total market coverage for all selected browsers.
+   */
+  function coverage(browsers: readonly string[], stats?: StatsOptions): number
+
+  function clearCaches(): void
+
+  function parseConfig(string: string): Config
+
+  function readConfig(file: string): Config
+
+  function findConfig(...pathSegments: string[]): Config | undefined
+
+  interface LoadConfigOptions {
+    config?: string
+    path?: string
+    env?: string
+  }
+
+  function loadConfig(options: LoadConfigOptions): string[] | undefined
+}
+
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+      BROWSERSLIST?: string
+      BROWSERSLIST_CONFIG?: string
+      BROWSERSLIST_DANGEROUS_EXTEND?: string
+      BROWSERSLIST_DISABLE_CACHE?: string
+      BROWSERSLIST_ENV?: string
+      BROWSERSLIST_IGNORE_OLD_DATA?: string
+      BROWSERSLIST_STATS?: string
+    }
+  }
+}
+
+export = browserslist