@rspack/dev-server 1.1.4 → 1.2.0

package/client/socket.js

@@ -0,0 +1,60 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+import WebSocketClient from './clients/WebSocketClient.js';
+import { log } from './utils/log.js';
+// this WebsocketClient is here as a default fallback, in case the client is not injected
+var Client = typeof __webpack_dev_server_client__ !== 'undefined'
+    ? typeof __webpack_dev_server_client__.default !== 'undefined'
+        ? __webpack_dev_server_client__.default
+        : __webpack_dev_server_client__
+    : WebSocketClient;
+var retries = 0;
+var maxRetries = 10;
+// Initialized client is exported so external consumers can utilize the same instance
+// It is mutable to enforce singleton
+export var client = null;
+var timeout;
+function socket(url, handlers, reconnect) {
+    client = new Client(url);
+    client.onOpen(function () {
+        retries = 0;
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        if (typeof reconnect !== 'undefined') {
+            maxRetries = reconnect;
+        }
+    });
+    client.onClose(function () {
+        if (retries === 0) {
+            handlers.close();
+        }
+        // Try to reconnect.
+        client = null;
+        // After 10 retries stop trying, to prevent logspam.
+        if (retries < maxRetries) {
+            // Exponentially increase timeout to reconnect.
+            // Respectfully copied from the package `got`.
+            var retryInMs = 1000 * Math.pow(2, retries) + Math.random() * 100;
+            retries += 1;
+            log.info('Trying to reconnect...');
+            timeout = setTimeout(function () {
+                socket(url, handlers, reconnect);
+            }, retryInMs);
+        }
+    });
+    client.onMessage(function (data) {
+        var message = JSON.parse(data);
+        if (handlers[message.type]) {
+            handlers[message.type](message.data, message.params);
+        }
+    });
+}
+export default socket;

package/client/utils/ansiHTML.js

@@ -1,41 +1,41 @@
 // Reference to https://github.com/sindresorhus/ansi-regex
 var _regANSI = /(?:(?:\u001b\[)|\u009b)(?:(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?[A-M|f-m])|\u001b[A-M]/;
 var _defColors = {
-    reset: ["fff", "000"],
-    black: "000",
-    red: "ff0000",
-    green: "209805",
-    yellow: "e8bf03",
-    blue: "0000ff",
-    magenta: "ff00ff",
-    cyan: "00ffee",
-    lightgrey: "f0f0f0",
-    darkgrey: "888",
+    reset: ['fff', '000'],
+    black: '000',
+    red: 'ff0000',
+    green: '209805',
+    yellow: 'e8bf03',
+    blue: '0000ff',
+    magenta: 'ff00ff',
+    cyan: '00ffee',
+    lightgrey: 'f0f0f0',
+    darkgrey: '888',
 };
 var _styles = {
-    30: "black",
-    31: "red",
-    32: "green",
-    33: "yellow",
-    34: "blue",
-    35: "magenta",
-    36: "cyan",
-    37: "lightgrey",
+    30: 'black',
+    31: 'red',
+    32: 'green',
+    33: 'yellow',
+    34: 'blue',
+    35: 'magenta',
+    36: 'cyan',
+    37: 'lightgrey',
 };
 var _colorMode = {
-    2: "rgb",
+    2: 'rgb',
 };
 var _openTags = {
-    1: "font-weight:bold",
-    2: "opacity:0.5",
-    3: "<i>",
-    4: "<u>",
-    8: "display:none",
-    9: "<del>",
+    1: 'font-weight:bold',
+    2: 'opacity:0.5',
+    3: '<i>',
+    4: '<u>',
+    8: 'display:none',
+    9: '<del>',
     38: function (match) {
         // color
         var mode = _colorMode[match[0]];
-        if (mode === "rgb") {
+        if (mode === 'rgb') {
             var r = match[1];
             var g = match[2];
             var b = match[3];
@@ -46,7 +46,7 @@ var _openTags = {
     48: function (match) {
         // background color
         var mode = _colorMode[match[0]];
-        if (mode === "rgb") {
+        if (mode === 'rgb') {
             var r = match[1];
             var g = match[2];
             var b = match[3];
@@ -56,35 +56,35 @@ var _openTags = {
     },
 };
 var _openTagToCloseTag = {
-    3: "23",
-    4: "24",
-    9: "29",
+    3: '23',
+    4: '24',
+    9: '29',
 };
 var _closeTags = {
     0: function (ansiCodes) {
         if (!ansiCodes)
-            return "</span>";
+            return '</span>';
         if (!ansiCodes.length)
-            return "";
+            return '';
         var code;
-        var ret = "";
+        var ret = '';
         while ((code = ansiCodes.pop())) {
             var closeTag = _openTagToCloseTag[code];
             if (closeTag) {
                 ret += _closeTags[closeTag];
                 continue;
             }
-            ret += "</span>";
+            ret += '</span>';
         }
         return ret;
     },
-    23: "</i>",
-    24: "</u>",
-    29: "</del>", // reset delete
+    23: '</i>',
+    24: '</u>',
+    29: '</del>', // reset delete
 };
 for (var _i = 0, _a = [21, 22, 27, 28, 39, 49]; _i < _a.length; _i++) {
     var n = _a[_i];
-    _closeTags[n] = "</span>";
+    _closeTags[n] = '</span>';
 }
 /**
  * Normalize ';<seq>' | '<seq>' -> '<seq>'
@@ -92,7 +92,7 @@ for (var _i = 0, _a = [21, 22, 27, 28, 39, 49]; _i < _a.length; _i++) {
 function normalizeSeq(seq) {
     if (seq === null || seq === undefined)
         return null;
-    if (seq.startsWith(";")) {
+    if (seq.startsWith(';')) {
         return seq.slice(1);
     }
     return seq;
@@ -108,16 +108,17 @@ export default function ansiHTML(text) {
     // Cache opened sequence.
     var ansiCodes = [];
     // Replace with markup.
+    var ret = text.replace(
     //@ts-ignore TS1487 error
-    var ret = text.replace(/\033\[(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?m/g, function (m) {
+    /\033\[(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?m/g, function (m) {
         var _a;
         var match = (_a = m.match(/(;?\d+)/g)) === null || _a === void 0 ? void 0 : _a.map(normalizeSeq);
-        Object.defineProperty(match, "advance", {
+        Object.defineProperty(match, 'advance', {
             value: function (count) {
                 this.splice(0, count);
             },
         });
-        var rep = "";
+        var rep = '';
         var seq;
         while ((seq = match[0])) {
             match.advance(1);
@@ -128,23 +129,23 @@ export default function ansiHTML(text) {
             var other = _openTags[seq];
             if (other &&
                 (other =
-                    typeof other === "function" ? other(match) : other)) {
+                    typeof other === 'function' ? other(match) : other)) {
                 // If reset signal is encountered, we have to reset everything.
-                var ret_1 = "";
-                if (seq === "0") {
+                var ret_1 = '';
+                if (seq === '0') {
                     ret_1 += _closeTags[seq](ansiCodes);
                 }
                 // If current sequence has been opened, close it.
                 if (ansiCodes.indexOf(seq) !== -1) {
                     ansiCodes.pop();
-                    return "</span>";
+                    return '</span>';
                 }
                 // Open tag.
                 ansiCodes.push(seq);
-                return ret_1 + (other[0] === "<" ? other : "<span style=\"".concat(other, ";\">"));
+                return ret_1 + (other[0] === '<' ? other : "<span style=\"".concat(other, ";\">"));
             }
             var ct = _closeTags[seq];
-            if (typeof ct === "function") {
+            if (typeof ct === 'function') {
                 return ct(ansiCodes);
             }
             if (ct) {
@@ -152,21 +153,20 @@ export default function ansiHTML(text) {
                 ansiCodes.pop();
                 return ct;
             }
-            return "";
+            return '';
         }
     });
     // Make sure tags are closed.
     var l = ansiCodes.length;
-    l > 0 && (ret += Array(l + 1).join("</span>"));
+    l > 0 && (ret += Array(l + 1).join('</span>'));
     return ret;
 }
 /**
  * Customize colors.
- * @param {Object} colors reference to _defColors
  */
 ansiHTML.setColors = function (colors) {
-    if (typeof colors !== "object") {
-        throw new Error("`colors` parameter must be an Object.");
+    if (typeof colors !== 'object') {
+        throw new Error('`colors` parameter must be an Object.');
     }
     var _finalColors = {};
     for (var key in _defColors) {
@@ -175,13 +175,13 @@ ansiHTML.setColors = function (colors) {
             _finalColors[key] = _defColors[key];
             continue;
         }
-        if ("reset" === key) {
-            if (typeof hex === "string") {
+        if ('reset' === key) {
+            if (typeof hex === 'string') {
                 hex = [hex];
             }
             if (!Array.isArray(hex) ||
                 hex.length === 0 ||
-                hex.some(function (h) { return typeof h !== "string"; })) {
+                hex.some(function (h) { return typeof h !== 'string'; })) {
                 throw new Error("The value of `".concat(key, "` property must be an Array and each item could only be a hex string, e.g.: FF0000"));
             }
             var defHexColor = _defColors[key];
@@ -194,7 +194,7 @@ ansiHTML.setColors = function (colors) {
             }
             hex = hex.slice(0, 2);
         }
-        else if (typeof hex !== "string") {
+        else if (typeof hex !== 'string') {
             throw new Error("The value of `".concat(key, "` property must be a hex string, e.g.: FF0000"));
         }
         _finalColors[key] = hex;
@@ -209,14 +209,13 @@ ansiHTML.reset = function () {
 };
 /**
  * Expose tags, including open and close.
- * @type {Object}
  */
 ansiHTML.tags = {};
 if (Object.defineProperty) {
-    Object.defineProperty(ansiHTML.tags, "open", {
+    Object.defineProperty(ansiHTML.tags, 'open', {
         get: function () { return _openTags; },
     });
-    Object.defineProperty(ansiHTML.tags, "close", {
+    Object.defineProperty(ansiHTML.tags, 'close', {
         get: function () { return _closeTags; },
     });
 }
@@ -226,15 +225,15 @@ else {
 }
 function _setTags(colors) {
     // reset all
-    _openTags["0"] =
+    _openTags['0'] =
         "font-weight:normal;opacity:1;color:#".concat(colors.reset[0], ";background:#").concat(colors.reset[1]);
     // inverse
-    _openTags["7"] = "color:#".concat(colors.reset[1], ";background:#").concat(colors.reset[0]);
+    _openTags['7'] = "color:#".concat(colors.reset[1], ";background:#").concat(colors.reset[0]);
     // dark grey
-    _openTags["90"] = "color:#".concat(colors.darkgrey);
+    _openTags['90'] = "color:#".concat(colors.darkgrey);
     for (var code in _styles) {
         var color = _styles[code];
-        var oriColor = colors[color] || "000";
+        var oriColor = colors[color] || '000';
         _openTags[code] = "color:#".concat(oriColor);
         var codeInt = Number.parseInt(code);
         _openTags[(codeInt + 10).toString()] = "background:#".concat(oriColor);

package/client/utils/log.js

@@ -0,0 +1,21 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+import logger from '../modules/logger/index';
+var name = 'webpack-dev-server';
+// default level is set on the client side, so it does not need
+// to be set by the CLI or API
+var defaultLevel = 'info';
+// options new options, merge with old options
+function setLogLevel(level) {
+    logger.configureDefaultLogger({ level: level });
+}
+setLogLevel(defaultLevel);
+var log = logger.getLogger(name);
+export { log, setLogLevel };

package/client/utils/sendMessage.js

@@ -0,0 +1,17 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+function sendMsg(type, data) {
+    if (typeof self !== 'undefined' &&
+        (typeof WorkerGlobalScope === 'undefined' ||
+            !(self instanceof WorkerGlobalScope))) {
+        self.postMessage({ type: "webpack".concat(type), data: data }, '*');
+    }
+}
+export default sendMsg;

package/dist/config.d.ts

@@ -1,24 +1,23 @@
-import type { DevServer } from "@rspack/core";
-import type WebpackDevServer from "webpack-dev-server";
-export type { DevServer };
+/// <reference types="connect-history-api-fallback" />
+import type { BonjourOptions, ClientConfiguration, ConnectHistoryApiFallbackOptions, DevServer, NormalizedStatic, Open, ServerConfiguration, WatchFiles, WebSocketServerConfiguration } from './types';
 export interface ResolvedDevServer extends DevServer {
     port: number | string;
-    static: false | Array<WebpackDevServer.NormalizedStatic>;
-    devMiddleware: DevServer["devMiddleware"];
-    hot: boolean | "only";
+    static: false | Array<NormalizedStatic>;
+    devMiddleware: DevServer['devMiddleware'];
+    hot: boolean | 'only';
     host?: string;
-    open: WebpackDevServer.Open[];
+    open: Open[];
     magicHtml: boolean;
     liveReload: boolean;
-    webSocketServer: false | WebpackDevServer.WebSocketServerConfiguration;
-    proxy: Required<DevServer["proxy"]>;
-    client: WebpackDevServer.ClientConfiguration;
-    allowedHosts: "auto" | string[] | "all";
-    bonjour: false | Record<string, never> | WebpackDevServer.BonjourOptions;
+    webSocketServer: false | WebSocketServerConfiguration;
+    proxy: Required<DevServer['proxy']>;
+    client: ClientConfiguration;
+    allowedHosts: 'auto' | string[] | 'all';
+    bonjour: false | Record<string, never> | BonjourOptions;
     compress: boolean;
-    historyApiFallback: false | WebpackDevServer.ConnectHistoryApiFallbackOptions;
-    server: WebpackDevServer.ServerConfiguration;
+    historyApiFallback: false | ConnectHistoryApiFallbackOptions;
+    server: ServerConfiguration;
     ipc: string | undefined;
     setupExitSignals: boolean;
-    watchFiles: WebpackDevServer.WatchFiles[];
+    watchFiles: WatchFiles[];
 }

package/dist/getPort.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+export {};

package/dist/getPort.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+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 });
+/*
+ * Based on the packages get-port https://www.npmjs.com/package/get-port
+ * and portfinder https://www.npmjs.com/package/portfinder
+ * The code structure is similar to get-port, but it searches
+ * ports deterministically like portfinder
+ */
+const net = __importStar(require("node:net"));
+const os = __importStar(require("node:os"));
+const minPort = 1024;
+const maxPort = 65535;
+/**
+ * Get all local hosts
+ */
+const getLocalHosts = () => {
+    const interfaces = os.networkInterfaces();
+    // Add undefined value for createServer function to use default host,
+    // and default IPv4 host in case createServer defaults to IPv6.
+    const results = new Set([undefined, '0.0.0.0']);
+    for (const _interface of Object.values(interfaces)) {
+        if (_interface) {
+            for (const config of _interface) {
+                results.add(config.address);
+            }
+        }
+    }
+    return results;
+};
+/**
+ * Check if a port is available on a given host
+ */
+const checkAvailablePort = (basePort, host) => new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on('error', reject);
+    server.listen(basePort, host, () => {
+        // Next line should return AddressInfo because we're calling it after listen() and before close()
+        const { port } = server.address();
+        server.close(() => {
+            resolve(port);
+        });
+    });
+});
+/**
+ * Get available port from hosts
+ */
+const getAvailablePort = async (port, hosts) => {
+    /**
+     * Errors that mean that host is not available.
+     */
+    const nonExistentInterfaceErrors = new Set(['EADDRNOTAVAIL', 'EINVAL']);
+    /* Check if the post is available on every local host name */
+    for (const host of hosts) {
+        try {
+            await checkAvailablePort(port, host);
+        }
+        catch (error) {
+            /* We throw an error only if the interface exists */
+            if (!nonExistentInterfaceErrors.has(error.code || '')) {
+                throw error;
+            }
+        }
+    }
+    return port;
+};
+/**
+ * Get available ports
+ */
+async function getPorts(basePort, host) {
+    if (basePort < minPort || basePort > maxPort) {
+        throw new Error(`Port number must lie between ${minPort} and ${maxPort}`);
+    }
+    let port = basePort;
+    const localhosts = getLocalHosts();
+    const hosts = host && !localhosts.has(host)
+        ? new Set([host])
+        : /* If the host is equivalent to localhost
+         we need to check every equivalent host
+         else the port might falsely appear as available
+         on some operating systems  */
+            localhosts;
+    const portUnavailableErrors = new Set(['EADDRINUSE', 'EACCES']);
+    while (port <= maxPort) {
+        try {
+            const availablePort = await getAvailablePort(port, hosts);
+            return availablePort;
+        }
+        catch (error) {
+            /* Try next port if port is busy; throw for any other error */
+            if (!portUnavailableErrors.has(error.code || '')) {
+                throw error;
+            }
+            port += 1;
+        }
+    }
+    throw new Error('No available ports found');
+}
+module.exports = getPorts;

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { RspackDevServer } from "./server";
-export type { DevServer as Configuration } from "@rspack/core";
+export { default as RspackDevServer } from './server';
+export type { DevServer as Configuration } from '@rspack/core';

package/dist/index.js

@@ -1,5 +1,8 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RspackDevServer = void 0;
 var server_1 = require("./server");
-Object.defineProperty(exports, "RspackDevServer", { enumerable: true, get: function () { return server_1.RspackDevServer; } });
+Object.defineProperty(exports, "RspackDevServer", { enumerable: true, get: function () { return __importDefault(server_1).default; } });