extension-develop 4.1.11 → 4.1.13

package/dist/0~dev-server.mjs

@@ -7,11 +7,12 @@ import { RspackDevServer } from "@rspack/dev-server";
 import { merge } from "webpack-merge";
 import { WebSocket, WebSocketServer } from "ws";
 import { classifyReloadFromSources, attachLifecycleStream, readContentScriptCount, humanLine, buildSourceFeatureIndex, createChangedSourcesTracker, createLifecycleStream, dispatchReload } from "./839.mjs";
-import { DEV_COMMAND_DEFAULTS, autoExitForceKill, loadCommandConfig, sanitize, extensionJsRunnerError, portInUse, devServerStartTimeout, autoExitTriggered, asAbsolute, mergeOptionLayers, shouldWarnPortConflict, isGeckoBasedBrowser, createPlaywrightMetadataWriter, autoExitModeEnabled, getSessionRunId, loadCustomConfig, loadBrowserConfig, getDistPath, resolveCompanionExtensionsConfig, getSpecialFoldersDataForProjectRoot } from "./101.mjs";
+import { runnerCleanupError, autoExitForceKill, loadCommandConfig, sanitize, extensionJsRunnerError, portInUse, devServerStartTimeout, autoExitTriggered, loadProjectConfigDefaults, runnerUncaughtException, shouldWarnPortConflict, devServerRestarting, DEV_COMMAND_DEFAULTS, mergeOptionLayers, runnerUnhandledRejection, createPlaywrightMetadataWriter, autoExitModeEnabled, getSessionRunId, isGeckoBasedBrowser, loadCustomConfig, loadBrowserConfig, resolveCompanionExtensionsConfig, getSpecialFoldersDataForProjectRoot } from "./101.mjs";
 import { CONTROL_WS_PATH, writePersistedControlPort, writeControlToken, clearControlToken, readPersistedControlPort } from "./887.mjs";
 import { hasProjectDependency, findNearestProjectManifestDirSync } from "./80.mjs";
-import { setupNoBrowserBannerOnFirstDone, webpackConfig, resolveConnectableHost, setupCompilerLifecycleHooks } from "./0~rspack-config.mjs";
-import { ensureSessionStateInProjectGitignore, logsPath, actionsPath, controlPortFilePath, legacyControlPortFilePath, ensureSessionArtifactsIgnoreFile } from "./494.mjs";
+import { publicFolderOrDefault } from "./278.mjs";
+import { setupNoBrowserBannerOnFirstDone, DevSessionRestartScheduler, resolveConnectableHost, webpackConfig, bindDevSessionRestart, unbindDevSessionRestart, setupCompilerLifecycleHooks } from "./0~rspack-config.mjs";
+import { logsPath, controlPortFilePath, legacyControlPortFilePath, asAbsolute, getDistPath, ensureSessionStateInProjectGitignore, actionsPath, ensureSessionArtifactsIgnoreFile } from "./77.mjs";
 import { isDebug } from "./349.mjs";
 import * as __rspack_external_node_os_74b4b876 from "node:os";
 import * as __rspack_external_node_path_c5b9b54f from "node:path";
@@ -60,11 +61,16 @@ function setupAutoExit(autoExitMsRaw, forceKillMsRaw, onCleanup) {
     }
     return cancelAutoExitTimers;
 }
+function resolveDevServer(handle) {
+    return 'function' == typeof handle ? handle() : handle;
+}
 function closeAll(devServer, portManager) {
-    return devServer.stop().then(async ()=>{
+    const afterStop = async ()=>{
         await portManager.terminateCurrentInstance();
         setTimeout(()=>process.exit(), 500);
-    }).catch(async (error)=>{
+    };
+    if (!devServer || 'function' != typeof devServer.stop) return afterStop();
+    return devServer.stop().then(afterStop).catch(async (error)=>{
         humanLine(extensionJsRunnerError(error));
         await portManager.terminateCurrentInstance();
         setTimeout(()=>process.exit(1), 500);
@@ -76,18 +82,18 @@ function setupCleanupHandlers(devServer, portManager) {
         if (isShuttingDown) return;
         isShuttingDown = true;
         try {
-            await closeAll(devServer, portManager);
+            await closeAll(resolveDevServer(devServer), portManager);
         } catch (error) {
-            console.error('[Extension.js Runner] Error during cleanup.', error);
+            console.error(runnerCleanupError(error));
             process.exit(1);
         }
     };
     process.on('uncaughtException', async (error)=>{
-        console.error('[Extension.js Runner] Uncaught exception.', error);
+        console.error(runnerUncaughtException(error));
         await cleanup();
     });
     process.on('unhandledRejection', (reason, promise)=>{
-        console.error('[Extension.js Runner] Unhandled rejection.', promise, reason);
+        console.error(runnerUnhandledRejection(reason));
     });
     const cancelAutoExit = setupAutoExit(process.env.EXTENSION_AUTO_EXIT_MS, process.env.EXTENSION_FORCE_KILL_MS, cleanup);
     const cancelAndCleanup = async ()=>{
@@ -346,7 +352,10 @@ class BridgeBroker {
             reloadType: instruction.type,
             changedContentScriptEntries: instruction.changedContentScriptEntries,
             label: instruction.label,
-            changedFiles: instruction.changedFiles
+            changedFiles: instruction.changedFiles,
+            ...instruction.changedScriptFiles?.length ? {
+                changedScriptFiles: instruction.changedScriptFiles
+            } : {}
         };
         let notified = 0;
         for (const [conn, role] of this.roles)if ('producer' === role) try {
@@ -1076,6 +1085,7 @@ async function dev_server_devServer(projectStructure, devOptions) {
     const { manifestPath, packageJsonPath, denoJsonPath } = projectStructure;
     const projectManifestPath = packageJsonPath || denoJsonPath;
     const packageJsonDir = projectManifestPath ? __rspack_external_node_path_c5b9b54f.dirname(projectManifestPath) : __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
+    const projectConfig = await loadProjectConfigDefaults(packageJsonDir);
     const commandConfig = await loadCommandConfig(packageJsonDir, 'dev');
     const browserConfig = await loadBrowserConfig(packageJsonDir, devOptions.browser);
     const portManager = new PortManager(8080);
@@ -1192,19 +1202,22 @@ async function dev_server_devServer(projectStructure, devOptions) {
             bridgeActionsFile?.close();
         } catch  {}
         if (bridgeControlToken) clearControlToken(packageJsonDir, browserName);
+        unbindDevSessionRestart();
     });
+    const safeProjectConfig = sanitize(projectConfig);
     const safeBrowserConfig = sanitize(browserConfig);
     const safeCommandConfig = sanitize(commandConfig);
     const safeDevOptions = sanitize(devOptions);
-    const mergedDevOptions = mergeOptionLayers(DEV_COMMAND_DEFAULTS, safeBrowserConfig, safeCommandConfig, safeDevOptions);
+    const mergedDevOptions = mergeOptionLayers(DEV_COMMAND_DEFAULTS, safeProjectConfig, safeBrowserConfig, safeCommandConfig, safeDevOptions);
     const specialFoldersData = getSpecialFoldersDataForProjectRoot(packageJsonDir);
-    const mergedExtensionsConfig = safeDevOptions.extensions ?? safeCommandConfig.extensions ?? safeBrowserConfig.extensions ?? specialFoldersData.extensions;
+    const mergedExtensionsConfig = safeDevOptions.extensions ?? safeCommandConfig.extensions ?? safeBrowserConfig.extensions ?? safeProjectConfig.extensions ?? specialFoldersData.extensions;
     const resolvedExtensionsConfig = await resolveCompanionExtensionsConfig({
         projectRoot: packageJsonDir,
         browser: devOptions.browser,
         config: mergedExtensionsConfig
     });
-    const baseConfig = webpackConfig(projectStructure, {
+    const webpackConfigOptions = {
+        metadataCommand: 'dev',
         ...mergedDevOptions,
         extensions: resolvedExtensionsConfig,
         browser: devOptions.browser,
@@ -1219,39 +1232,8 @@ async function dev_server_devServer(projectStructure, devOptions) {
             clean: false,
             path: primaryDistPath
         }
-    });
-    const customWebpackConfig = await loadCustomConfig(packageJsonDir);
-    const finalConfig = customWebpackConfig(baseConfig);
-    const compilerConfig = merge(finalConfig, {});
-    const compiler = rspack(compilerConfig);
+    };
     const manifestOutputPath = __rspack_external_node_path_c5b9b54f.join(primaryDistPath, 'manifest.json');
-    const uninstallManifestGuard = installManifestDiskWriteGuard(manifestOutputPath);
-    const releaseOutputFsGuard = suppressManifestOutputWrites(compiler, manifestOutputPath);
-    if (!extendedOptions.browsersPlugin && compiler?.hooks?.watchRun) {
-        const changedSources = createChangedSourcesTracker(compiler);
-        let isFirstBridgeCompile = true;
-        compiler.hooks.done.tapPromise('extjs-no-browser-reload', async (stats)=>{
-            const compilation = stats.compilation;
-            if (compilation.errors && compilation.errors.length > 0) return;
-            if (isFirstBridgeCompile) {
-                isFirstBridgeCompile = false;
-                return;
-            }
-            const outputPath = String(compilation.options?.output?.path || '');
-            const contextDir = String(compilation.options?.context || '');
-            const { forcedFull, changedSources: sources } = changedSources.snapshot();
-            const instruction = classifyReloadFromSources({
-                changedSources: sources,
-                forcedFull,
-                getContentScriptCount: ()=>readContentScriptCount(compilation, outputPath),
-                getSourceFeatureIndex: ()=>buildSourceFeatureIndex(compilation, contextDir),
-                outputPath
-            });
-            await dispatchReload(instruction, {
-                broker: bridgeBroker
-            });
-        });
-    }
     const metadata = createPlaywrightMetadataWriter({
         packageJsonDir,
         browser: String(devOptions.browser || 'chromium'),
@@ -1278,21 +1260,12 @@ async function dev_server_devServer(projectStructure, devOptions) {
         requestedPort: Number(devOptions.port),
         port
     });
-    attachLifecycleStream(compiler, lifecycle);
-    setupCompilerLifecycleHooks(compiler);
-    if (devOptions.noBrowser) setupNoBrowserBannerOnFirstDone({
-        compiler,
-        browser: String(devOptions.browser || 'chromium'),
-        manifestPath,
-        readyPath: metadata.readyPath,
-        distPath: primaryDistPath
-    });
     if (shouldWarnPortConflict(devOptions.port, port)) humanLine(portInUse(Number(devOptions.port), port));
     const serverConfig = {
         host: devServerHost,
         allowedHosts: 'all',
         static: {
-            directory: __rspack_external_node_path_c5b9b54f.join(packageJsonDir, 'public'),
+            directory: publicFolderOrDefault(manifestPath, packageJsonDir),
             watch: false
         },
         compress: false,
@@ -1304,7 +1277,7 @@ async function dev_server_devServer(projectStructure, devOptions) {
         },
         watchFiles: {
             paths: [
-                __rspack_external_node_path_c5b9b54f.join(packageJsonDir, 'public', '**/*'),
+                __rspack_external_node_path_c5b9b54f.join(publicFolderOrDefault(manifestPath, packageJsonDir), '**/*'),
                 ...isUsingJSFramework(packageJsonDir) ? [] : [
                     __rspack_external_node_path_c5b9b54f.join(packageJsonDir, '**/*.html')
                 ]
@@ -1328,34 +1301,127 @@ async function dev_server_devServer(projectStructure, devOptions) {
         hot: true,
         liveReload: true
     };
-    const devServer = new RspackDevServer(serverConfig, compiler);
-    if ('function' == typeof devServer.stop) {
-        const originalDevServerStop = devServer.stop.bind(devServer);
-        devServer.stop = async ()=>{
-            try {
-                await originalDevServerStop();
-            } finally{
-                uninstallManifestGuard();
-                releaseOutputFsGuard();
-            }
+    const START_TIMEOUT_MS = parseInt(String(process.env.EXTENSION_START_TIMEOUT_MS || '30000'), 10);
+    async function createCompilerAndServer(opts) {
+        const baseConfig = webpackConfig(projectStructure, webpackConfigOptions);
+        const customWebpackConfig = await loadCustomConfig(packageJsonDir);
+        const compilerConfig = merge(customWebpackConfig(baseConfig), {});
+        const compiler = rspack(compilerConfig);
+        const uninstallManifestGuard = installManifestDiskWriteGuard(manifestOutputPath);
+        const releaseOutputFsGuard = suppressManifestOutputWrites(compiler, manifestOutputPath);
+        if (!extendedOptions.browsersPlugin && compiler?.hooks?.watchRun) {
+            const changedSources = createChangedSourcesTracker(compiler);
+            let isFirstBridgeCompile = true;
+            compiler.hooks.done.tapPromise('extjs-no-browser-reload', async (stats)=>{
+                const compilation = stats.compilation;
+                if (compilation.errors && compilation.errors.length > 0) return;
+                if (isFirstBridgeCompile) {
+                    isFirstBridgeCompile = false;
+                    return;
+                }
+                const outputPath = String(compilation.options?.output?.path || '');
+                const contextDir = String(compilation.options?.context || '');
+                const { forcedFull, changedSources: sources } = changedSources.snapshot();
+                const instruction = classifyReloadFromSources({
+                    changedSources: sources,
+                    forcedFull,
+                    getContentScriptCount: ()=>readContentScriptCount(compilation, outputPath),
+                    getSourceFeatureIndex: ()=>buildSourceFeatureIndex(compilation, contextDir),
+                    outputPath
+                });
+                await dispatchReload(instruction, {
+                    broker: bridgeBroker
+                });
+            });
+        }
+        attachLifecycleStream(compiler, lifecycle);
+        setupCompilerLifecycleHooks(compiler);
+        if (!opts.isRestart && devOptions.noBrowser) setupNoBrowserBannerOnFirstDone({
+            compiler,
+            browser: String(devOptions.browser || 'chromium'),
+            manifestPath,
+            readyPath: metadata.readyPath,
+            distPath: primaryDistPath
+        });
+        const firstCompile = new Promise((resolve)=>{
+            let settled = false;
+            const finish = (stats)=>{
+                if (settled) return;
+                settled = true;
+                resolve(stats);
+            };
+            if (!compiler.hooks?.done?.tap) return void finish(null);
+            compiler.hooks.done.tap('extjs-session-restart-first-done', (stats)=>{
+                finish(stats);
+            });
+            compiler.hooks.failed?.tap?.('extjs-session-restart-first-failed', ()=>{
+                finish(null);
+            });
+        });
+        const server = new RspackDevServer(serverConfig, compiler);
+        if ('function' == typeof server.stop) {
+            const originalDevServerStop = server.stop.bind(server);
+            server.stop = async ()=>{
+                try {
+                    await originalDevServerStop();
+                } finally{
+                    uninstallManifestGuard();
+                    releaseOutputFsGuard();
+                }
+            };
+        }
+        return {
+            compiler,
+            server,
+            firstCompile
         };
     }
-    const START_TIMEOUT_MS = parseInt(String(process.env.EXTENSION_START_TIMEOUT_MS || '30000'), 10);
-    let startTimeout;
-    try {
-        startTimeout = setTimeout(()=>{
-            console.error(devServerStartTimeout(START_TIMEOUT_MS));
-        }, START_TIMEOUT_MS);
-        await devServer.start();
-        if (startTimeout) clearTimeout(startTimeout);
-    } catch (error) {
-        if (startTimeout) clearTimeout(startTimeout);
-        metadata.writeError('dev_server_start_failed', error instanceof Error ? error.message : String(error));
-        lifecycle.failed(error instanceof Error ? error.message : String(error));
-        humanLine(extensionJsRunnerError(error));
-        process.exit(1);
+    async function startBundler(server) {
+        let startTimeout;
+        try {
+            startTimeout = setTimeout(()=>{
+                console.error(devServerStartTimeout(START_TIMEOUT_MS));
+            }, START_TIMEOUT_MS);
+            await server.start();
+            if (startTimeout) clearTimeout(startTimeout);
+        } catch (error) {
+            if (startTimeout) clearTimeout(startTimeout);
+            metadata.writeError('dev_server_start_failed', error instanceof Error ? error.message : String(error));
+            lifecycle.failed(error instanceof Error ? error.message : String(error));
+            humanLine(extensionJsRunnerError(error));
+            process.exit(1);
+        }
     }
+    const firstBundle = await createCompilerAndServer({
+        isRestart: false
+    });
+    let currentServer = firstBundle.server;
+    await startBundler(firstBundle.server);
+    const sessionRestart = new DevSessionRestartScheduler();
+    sessionRestart.setHandler(async (request)=>{
+        humanLine(devServerRestarting(request));
+        const nextBundle = await createCompilerAndServer({
+            isRestart: true
+        });
+        const previous = currentServer;
+        currentServer = null;
+        if (previous && 'function' == typeof previous.stop) await previous.stop();
+        currentServer = nextBundle.server;
+        await startBundler(nextBundle.server);
+        const stats = await nextBundle.firstCompile;
+        if (stats && 'function' == typeof stats.hasErrors && stats.hasErrors()) return;
+        await dispatchReload({
+            type: 'full',
+            label: 'extension'
+        }, {
+            broker: bridgeBroker
+        });
+    });
+    bindDevSessionRestart(sessionRestart);
+    process.once('exit', ()=>{
+        sessionRestart.dispose();
+    });
     lifecycle.watchBrowserExit();
-    setupCleanupHandlers(devServer, portManager);
+    setupCleanupHandlers(()=>currentServer, portManager);
 }
 export { dev_server_devServer as devServer };