@rspack/dev-server 1.1.5 → 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

@@ -108,8 +108,9 @@ 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', {
@@ -162,7 +163,6 @@ export default function ansiHTML(text) {
 }
 /**
  * Customize colors.
- * @param {Object} colors reference to _defColors
  */
 ansiHTML.setColors = function (colors) {
     if (typeof colors !== 'object') {
@@ -209,7 +209,6 @@ ansiHTML.reset = function () {
 };
 /**
  * Expose tags, including open and close.
- * @type {Object}
  */
 ansiHTML.tags = {};
 if (Object.defineProperty) {

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>;
+    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;
+    webSocketServer: false | WebSocketServerConfiguration;
     proxy: Required<DevServer['proxy']>;
-    client: WebpackDevServer.ClientConfiguration;
+    client: ClientConfiguration;
     allowedHosts: 'auto' | string[] | 'all';
-    bonjour: false | Record<string, never> | WebpackDevServer.BonjourOptions;
+    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 { 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; } });