@umijs/bundler-webpack 4.0.0-rc.8 → 4.0.1

package/client/client/client.js

@@ -1,18 +1,42 @@
+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());
+    });
+};
 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...');
+function getHost() {
+    if (process.env.SOCKET_SERVER) {
+        return new URL(process.env.SOCKET_SERVER);
+    }
+    return location;
+}
+function getSocketUrl() {
+    let h = getHost();
+    const host = h.host;
+    const isHttps = h.protocol === 'https:';
+    return `${isHttps ? 'wss' : 'ws'}://${host}`;
+}
+function getPingUrl() {
+    const h = getHost();
+    return `${h.protocol}//${h.host}/__umi_ping`;
+}
 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 }) => {
+const pingUrl = getPingUrl();
+const socket = new WebSocket(getSocketUrl(), 'webpack-hmr');
+socket.addEventListener('message', ({ data }) => __awaiter(void 0, void 0, void 0, function* () {
     data = JSON.parse(data);
     if (data.type === 'connected') {
         console.log(`[webpack] connected.`);
@@ -23,26 +47,28 @@ socket.addEventListener('message', async ({ data }) => {
     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));
+}));
+function waitForSuccessfulPing(ms = 1000) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            try {
+                yield fetch(pingUrl);
+                break;
+            }
+            catch (e) {
+                yield new Promise((resolve) => setTimeout(resolve, ms));
+            }
         }
-    }
+    });
 }
-socket.addEventListener('close', async () => {
+socket.addEventListener('close', () => __awaiter(void 0, void 0, void 0, function* () {
     if (pingTimer)
         clearInterval(pingTimer);
     console.info('[webpack] Dev server disconnected. Polling for restart...');
-    await waitForSuccessfulPing();
+    yield waitForSuccessfulPing();
     location.reload();
-});
+}));
 ErrorOverlay.startReportingRuntimeErrors({
     onError: function () {
         hadRuntimeError = true;
@@ -180,23 +206,25 @@ function tryApplyUpdates(onHotUpdateSuccess) {
         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
-    }
+function handleMessage(payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 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

@@ -10,3 +10,12 @@ export var MESSAGE_TYPE;
     MESSAGE_TYPE["stillOk"] = "still-ok";
     MESSAGE_TYPE["invalid"] = "invalid";
 })(MESSAGE_TYPE || (MESSAGE_TYPE = {}));
+export const DEFAULT_BROWSER_TARGETS = {
+    chrome: 80,
+};
+export const DEFAULT_ESBUILD_TARGET_KEYS = [
+    'chrome',
+    'firefox',
+    'edge',
+    'safari',
+];