@vixoniccom/module-packager 2.12.0-dev.0 → 2.12.0-dev.1

package/dist/electron.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { app, BrowserWindow } from 'electron';
+import remoteMain from '@electron/remote/main/index.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import commandLineArgs from 'command-line-args';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const optionDefinitions = [
+    { name: 'externals', type: String, defaultValue: [], multiple: true },
+    { name: 'src', type: String, defaultValue: path.join(__dirname, 'src') },
+    { name: 'build', type: String, defaultValue: path.join(__dirname, 'build') },
+    { name: 'config', type: String, defaultValue: './webpack.config.js' },
+    { name: 'port', type: Number, defaultValue: 8080 },
+    { name: 'mode', type: String, defaultValue: 'run' }
+];
+const options = commandLineArgs(optionDefinitions);
+if (options.mode === 'watch') {
+    (await import('electron-debug')).default({ showDevTools: true });
+}
+remoteMain.initialize();
+let mainWindow = null;
+function createWindow() {
+    mainWindow = new BrowserWindow({
+        show: false,
+        x: 100,
+        y: 100,
+        width: 1024,
+        height: 768,
+        webPreferences: {
+            nodeIntegrationInSubFrames: true,
+            allowRunningInsecureContent: true,
+            nodeIntegration: true,
+            contextIsolation: false,
+            webSecurity: false,
+            webviewTag: true
+        }
+    });
+    remoteMain.enable(mainWindow.webContents);
+    const launcherPath = path.join(__dirname, 'launcher.html');
+    const launcherURL = `file://${launcherPath}`;
+    mainWindow.loadURL(launcherURL);
+    // mainWindow.webContents.openDevTools({ mode: 'detach' })
+    mainWindow.webContents.once('did-finish-load', () => {
+        mainWindow?.show();
+        mainWindow?.webContents.send('init', options);
+    });
+    mainWindow.on('closed', () => (mainWindow = null));
+}
+app.whenReady().then(() => {
+    createWindow();
+    app.on('activate', () => {
+        if (BrowserWindow.getAllWindows().length === 0) {
+            createWindow();
+        }
+    });
+});
+app.on('window-all-closed', () => app.quit());

package/dist/launcher.html

@@ -0,0 +1,86 @@
+<!DOCTYPE html>
+<html lang="en" xml:lang="en" style="width: 100%; height: 100%; margin: 0; padding: 0;">
+
+<head>
+  <meta charset="UTF-8" />
+  <title></title>
+</head>
+
+<body style="width: 100%; height: 100%; margin: 0; padding: 0;">
+  <webview id="webview" style="width: 100%; height: 100%;" partition="persist:webview"></webview>
+
+  <script>
+    const path = require('path')
+    let ModuleController;
+    try {
+      const moduleControllerModule = require('@vixoniccom/module-controller');
+      ModuleController = moduleControllerModule.default;     
+     } catch (err) {
+      console.error('[WEBVIEW] NO se pudo cargar ModuleController', err);
+    }
+    const { ipcRenderer } = require('electron')
+    const remote = require('@electron/remote')
+
+    ipcRenderer.on('init', (event, options) => {
+      const webview = document.getElementById('webview')
+      const win = remote.getCurrentWindow()
+
+      webview.setAttribute('nodeintegration', '')
+      webview.setAttribute('webpreferences', 'webSecurity=false, allowRunningInsecureContent=true, nodeIntegration=yes, contextIsolation=no')
+
+      webview.addEventListener('did-finish-load', () => {
+        win.show()
+        win.focus()
+      })
+
+      const resolvedSrc = options.mode === 'watch'
+        ? `http://localhost:${options.port}/index.html`
+        : `file://${path.join(options.build, 'index.html')}`
+
+      webview.src = resolvedSrc
+
+      function getData() {
+        const data = {}
+
+        try {
+          data.parameters = require(path.join(options.src, '/test/parameters.json')).parameters
+        } catch (err) {
+          console.log('No parameters:', err.message)
+        }
+
+        let escaped = path.join(options.mode === 'watch' ? options.src : options.build, 'test', 'downloads')
+
+        // Add file:// to watch because in this mode the app will be in a localhost hosted environment.
+        if (options.mode === 'watch') escaped = `file://${escaped}`
+        escaped = escaped.replace(/\\/g, '/')
+
+        data.downloadsPath = escaped
+
+
+        try {
+          data.services = require(path.join(options.src, '/test/services.json')).services
+        } catch (err) {
+          console.log('No services:', err.message)
+        }
+
+        return data
+      }
+
+      function getSchema() {
+        try {
+          return require(path.join(options.src, '../configuration.json')).schema
+        } catch (err) {
+          console.log('No schema:', err.message)
+          return {}
+        }
+      }
+
+      const data = getData()
+      const schema = getSchema()
+
+      ModuleController.init(win, webview, data, schema, options.mode === 'watch')
+    })
+  </script>
+</body>
+
+</html>

package/dist/main.js

@@ -4,18 +4,19 @@ import commandLineArgs from 'command-line-args';
 import path from 'path';
 import webpack from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
-import { spawn, exec } from 'child_process';
+import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
 import archiver from 'archiver';
 import clc from 'cli-color';
 import { Configuration } from '@vixoniccom/modules';
 import tsNode from 'ts-node';
+import { createRequire } from 'module';
+import which from 'which';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const electronPath = path.join(__dirname, 'electron.js');
-// import pjson from '../package.json' assert { type: 'json' }
-// console.log(`VIXONIC PACKAGER: Version ${pjson.version}`)
+const npxPath = which.sync('npx');
 const optionDefinitions = [
     { name: 'externals', type: String, defaultValue: [], multiple: true },
     { name: 'target', type: String, defaultValue: 'web' },
@@ -29,9 +30,92 @@ const optionDefinitions = [
     { name: 'tsOverride', type: Boolean }
 ];
 const options = commandLineArgs(optionDefinitions);
-if (options.target !== 'electron-renderer' && options.externals.length > 0) {
-    throw new Error(`Can't use external dependencies if target is not electron-renderer.`);
+// Validación de entrada mejorada
+function validateOptions(options) {
+    if (options.target !== 'electron-renderer' && options.externals.length > 0) {
+        throw new Error(`Can't use external dependencies if target is not electron-renderer.`);
+    }
+    // Validar puerto
+    if (options.port < 1 || options.port > 65535) {
+        throw new Error('Port must be between 1 and 65535');
+    }
+    // Validar modo
+    const validModes = ['build', 'watch', 'run', 'generate-configuration', 'validate-configuration'];
+    if (!validModes.includes(options.mode)) {
+        throw new Error(`Invalid mode. Must be one of: ${validModes.join(', ')}`);
+    }
+}
+// Función para sanitizar rutas
+function sanitizePath(inputPath) {
+    // Prevenir path traversal
+    if (inputPath.includes('..') || inputPath.includes('~')) {
+        throw new Error('Invalid path: path traversal detected');
+    }
+    return path.resolve(inputPath);
+}
+// Función centralizada para crear argumentos de Electron
+function createElectronArgs(mode) {
+    return [
+        electronPath,
+        '--src', sanitizePath(options.src),
+        '--build', sanitizePath(options.build),
+        '--port', String(options.port),
+        '--mode', mode,
+        '--config', options.config,
+        '--externals', Array.isArray(options.externals) ? options.externals.join(',') : ''
+    ];
+}
+// Función centralizada para manejar procesos Electron
+function spawnElectronProcess(mode) {
+    const args = createElectronArgs(mode);
+    const nodeEnv = mode === 'run' ? 'production' : 'development';
+    const child = spawn(npxPath, ['electron', ...args], {
+        cwd: __dirname,
+        env: {
+            ...process.env,
+            NODE_ENV: nodeEnv,
+            ELECTRON_DISABLE_SECURITY_WARNINGS: 'true',
+            NODE_NO_WARNINGS: '1'
+        },
+        stdio: 'inherit'
+    });
+    // Manejo centralizado de logs
+    setupChildProcessLogging(child);
+    return child;
 }
+// Función para manejar logging de procesos hijo
+function setupChildProcessLogging(child) {
+    child.stdout?.on('data', (data) => {
+        const output = data.toString();
+        if (!shouldFilterLog(output)) {
+            process.stdout.write(output);
+        }
+    });
+    child.stderr?.on('data', (data) => {
+        const output = data.toString();
+        if (!shouldFilterLog(output)) {
+            process.stderr.write(output);
+        }
+    });
+}
+// Función centralizada para compilar webpack
+async function compileWebpack() {
+    // CORREGIDO: Usar __dirname para el webpack.config.js del module-packager
+    const cfgPath = path.resolve(__dirname, 'webpack.config.js');
+    const webpackConfigFactory = (await import(cfgPath)).default;
+    const compiler = webpack(webpackConfigFactory(options));
+    return new Promise((resolve, reject) => {
+        compiler.run((err, stats) => {
+            if (err)
+                return reject(err);
+            if (stats?.hasErrors()) {
+                return reject(new Error(stats.toString({ all: false, errors: true, colors: true })));
+            }
+            compiler.close(closeErr => (closeErr ? reject(closeErr) : resolve()));
+        });
+    });
+}
+validateOptions(options);
 if (options.mode === 'build') {
     pack(() => {
         if (options.target === 'electron-renderer') {
@@ -45,75 +129,59 @@ if (options.mode === 'build') {
     });
 }
 else if (options.mode === 'watch') {
-    console.log('[DEBUG] Entrando a watch()');
     watch();
 }
 else if (options.mode === 'run') {
     run();
 }
 else if (options.mode === 'generate-configuration') {
-    generateConfiguration();
+    await generateConfiguration();
 }
 else if (options.mode === 'validate-configuration') {
     validateConfiguration();
 }
-function runElectron() {
-    const electronProcess = spawn('npx', [
-        'electron',
-        electronPath,
-        '--src', path.resolve(options.src),
-        '--build', path.resolve(options.build),
-        '--port', `${options.port}`,
-        '--mode', options.mode,
-        '--config', options.config,
-        '--externals', options.externals.join(',')
-    ], {
-        cwd: __dirname,
-        env: { ...process.env, NODE_ENV: 'development' },
-        stdio: 'inherit'
-    });
-    electronProcess.on('close', (code) => {
-        console.log(`Electron process exited with code ${code}`);
-        if (code !== 0) {
-            console.error('Electron process exited with an error.');
-        }
-    });
-}
 async function pack(callback) {
     console.log(clc.blue('Building module...'));
     validateConfiguration();
-    const configPath = path.resolve(__dirname, '../', options.config);
+    const configPath = path.resolve(__dirname, options.config);
+    console.log("🚀 ~ pack ~ configPath:", configPath);
     try {
         const webpackConfig = (await import(configPath)).default(options);
-        webpack(webpackConfig, function (err, stats) {
-            if (err) {
-                console.error('Build error:', err);
-                if (err.details) {
-                    console.error('Details:', err.details);
-                }
-                if (err.errors) {
-                    console.error('TS Errors:', JSON.stringify(err.errors, null, 2));
-                }
-                throw err;
+        function handleWebpackError(err) {
+            console.error('Build error:', err);
+            if (err.details) {
+                console.error('Details:', err.details);
             }
-            else {
-                if (stats.hasErrors()) {
-                    const info = stats.toJson('errors-only');
-                    console.error(clc.red('Webpack errors:'));
-                    if (info.errors && info.errors.length) {
-                        info.errors.forEach((e) => {
-                            console.error(clc.red(typeof e === 'object' ? JSON.stringify(e, null, 2) : e));
-                        });
-                    }
-                    else {
-                        console.error(clc.red(JSON.stringify(info, null, 2)));
-                    }
-                    callback && callback(stats);
+            if (err.errors) {
+                console.error('TS Errors:', JSON.stringify(err.errors, null, 2));
+            }
+            throw err;
+        }
+        function handleWebpackStats(stats, callback) {
+            if (stats.hasErrors()) {
+                const info = stats.toJson('errors-only');
+                console.error(clc.red('Webpack errors:'));
+                if (info.errors?.length) {
+                    info.errors.forEach((e) => {
+                        console.error(clc.red(typeof e === 'object' ? JSON.stringify(e, null, 2) : e));
+                    });
                 }
                 else {
-                    console.log(clc.green('Build OK.'));
-                    callback && callback(null);
+                    console.error(clc.red(JSON.stringify(info, null, 2)));
                 }
+                callback?.(stats);
+            }
+            else {
+                console.log(clc.green('Build OK.'));
+                callback?.(null);
+            }
+        }
+        webpack(webpackConfig, function (err, stats) {
+            if (err) {
+                handleWebpackError(err);
+            }
+            else {
+                handleWebpackStats(stats, callback);
             }
         });
     }
@@ -124,30 +192,42 @@ async function pack(callback) {
 }
 function installExternals(callback) {
     let externals = options.externals.map((x) => {
-        return `${x}@${JSON.parse(fs.readFileSync(path.resolve(options.src, '..', 'node_modules', x, 'package.json'), 'utf8')).version}`;
+        // Validar nombre del paquete
+        if (!/^[@a-z0-9-_./]+$/i.test(x)) {
+            throw new Error(`Invalid package name: ${x}`);
+        }
+        const packageJsonPath = sanitizePath(path.resolve(options.src, '..', 'node_modules', x, 'package.json'));
+        return `${x}@${JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).version}`;
     });
     if (externals.length) {
-        externals = externals.join(' ');
-        console.log(clc.blue(`Installing externals ${externals}...`));
-        exec(`npm install --prefix ./ --production ${externals}`, {
-            cwd: options.build
-        }, (err, _stdout) => {
-            if (err)
-                throw err;
+        console.log(clc.blue(`Installing externals ${externals.join(', ')}...`));
+        const npmPath = which.sync('npm');
+        const child = spawn(npmPath, ['install', '--prefix', './', '--production', ...externals], { cwd: sanitizePath(options.build), stdio: 'inherit' });
+        child.on('exit', (code) => {
+            if (code !== 0) {
+                return callback?.(new Error(`npm install failed with code ${code}`));
+            }
             console.log(clc.green('Externals installed.'));
-            callback && callback(null);
+            callback?.(null);
+        });
+        child.on('error', (err) => {
+            callback?.(err);
         });
     }
     else {
-        callback && callback(null);
+        callback?.(null);
     }
 }
 function zip() {
     console.log(clc.blue('Archiving...'));
-    let output = fs.createWriteStream(path.resolve(options.build, '../', 'build.zip'));
+    console.log(clc.blue('Cleaning build...'));
+    const buildPath = sanitizePath(options.build);
+    const zipPath = path.resolve(buildPath, '../', 'build.zip');
+    console.log("[DEBUG] Cleaning build folder", zipPath);
+    let output = fs.createWriteStream(zipPath);
     let archive = archiver('zip');
     archive.pipe(output);
-    archive.directory(path.resolve(options.build), './');
+    archive.directory(buildPath, './');
     archive.finalize();
     output.on('close', function () {
         console.log(clc.green('Generated build.zip.'));
@@ -158,10 +238,9 @@ function zip() {
     clc.move(-2, 0);
 }
 async function watch() {
-    console.log('[VMP] ▸ starting dev-server & electron in watch mode…');
-    const cfgPath = path.resolve(__dirname, '..', 'dist/webpack.config.js');
+    // CORREGIDO: Usar __dirname para el webpack.config.js del module-packager
+    const cfgPath = path.resolve(__dirname, 'webpack.config.js');
     const webpackConfigFactory = (await import(cfgPath)).default;
-    console.log('[VMP] ▸ webpack config loaded from', cfgPath);
     const compiler = webpack(webpackConfigFactory(options));
     const server = new WebpackDevServer({
         static: false,
@@ -170,32 +249,15 @@ async function watch() {
         historyApiFallback: true
     }, compiler);
     await server.start();
-    console.log(`[VMP] ▸ dev-server listening on http://localhost:${options.port}`);
-    const cmd = [
-        'npx', 'electron', electronPath,
-        '--src', path.resolve(options.src),
-        '--build', path.resolve(options.build),
-        '--port', String(options.port),
-        '--mode', 'watch',
-        '--config', options.config,
-        '--externals', options.externals.join(',')
-    ].join(' ');
-    console.log(`[VMP] ▸ ${cmd}`);
-    const child = exec(cmd, { cwd: __dirname, env: { ...process.env, NODE_ENV: 'development' } });
-    child.stdout?.pipe(process.stdout);
-    child.stderr?.pipe(process.stderr);
-}
-function run() {
-    pack((err) => {
-        if (err) {
-            throw err;
-        }
-        else {
-            runElectron();
-        }
-    });
+    spawnElectronProcess('watch');
+}
+async function run() {
+    await new Promise((resolve) => pack((err) => (err ? console.log(err) : resolve())));
+    await compileWebpack();
+    spawnElectronProcess('run');
 }
-function loadConfiguration() {
+async function loadConfiguration() {
+    const require = createRequire(import.meta.url);
     tsNode.register({
         compilerOptions: {
             moduleResolution: 'node',
@@ -204,13 +266,15 @@ function loadConfiguration() {
             checkJs: false
         }
     });
-    return require(path.resolve(options.confDefinition, 'index.ts')).configuration;
+    const configPath = sanitizePath(path.resolve(options.confDefinition, 'index.ts'));
+    return require(configPath).configuration;
 }
-function generateConfiguration() {
+async function generateConfiguration() {
     try {
-        let configuration = loadConfiguration();
-        fs.writeFileSync(path.resolve(options.src, 'parameters.d.ts'), configuration.declarationFileString);
-        fs.writeFileSync(path.resolve(options.src, '..', 'configuration.json'), JSON.stringify(configuration, undefined, 2));
+        let configuration = await loadConfiguration();
+        const srcPath = sanitizePath(options.src);
+        fs.writeFileSync(path.resolve(srcPath, 'parameters.d.ts'), configuration.declarationFileString);
+        fs.writeFileSync(path.resolve(srcPath, '..', 'configuration.json'), JSON.stringify(configuration, undefined, 2));
         console.log(clc.green(`Configuration generated`));
     }
     catch (e) {
@@ -220,12 +284,13 @@ function generateConfiguration() {
 }
 function validateConfiguration() {
     try {
-        const jsonPath = path.resolve(options.src, '../', 'configuration.json');
-        const json = JSON.parse(fs.readFileSync(jsonPath, 'utf8')); // Leer y parsear el archivo JSON
+        const srcPath = sanitizePath(options.src);
+        const jsonPath = path.resolve(srcPath, '../', 'configuration.json');
+        const json = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
         const conf = Configuration.fromJSON(json);
         if (conf.durationFormula) {
-            const valuesPath = path.resolve(options.src, 'test', 'parameters.json');
-            const values = JSON.parse(fs.readFileSync(valuesPath, 'utf8')); // Leer y parsear otro archivo JSON
+            const valuesPath = path.resolve(srcPath, 'test', 'parameters.json');
+            const values = JSON.parse(fs.readFileSync(valuesPath, 'utf8'));
             console.log('Validate duration');
             console.log('Duration on undefined:', conf.getDuration({}), 'seconds');
             console.log('Duration:', conf.getDuration(values.parameters), 'seconds');
@@ -237,3 +302,22 @@ function validateConfiguration() {
         throw e;
     }
 }
+function shouldFilterLog(output) {
+    const filtersToRemove = [
+        "'session.getAllExtensions' is deprecated",
+        "DeprecationWarning: Compilation.assets will be frozen",
+        "BREAKING CHANGE: No more changes should happen to Compilation.assets",
+        "[DEP_WEBPACK_COMPILATION_ASSETS] DeprecationWarning",
+        "Compilation.assets will be frozen in future",
+        "Request Autofill.enable failed",
+        "Request Autofill.setAddresses failed",
+        "Uncaught (in promise) SyntaxError",
+        "wasn't found",
+        "asset main.js",
+        "runtime modules",
+        "orphan modules",
+        "cacheable modules",
+        "webpack compiled successfully"
+    ];
+    return filtersToRemove.some(filter => output.includes(filter));
+}

package/dist/webpack.config.js

@@ -0,0 +1,153 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+import { CleanWebpackPlugin } from 'clean-webpack-plugin';
+import CopyWebpackPlugin from 'copy-webpack-plugin';
+import TerserPlugin from 'terser-webpack-plugin';
+import webpack from 'webpack';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+console.log("🚀 ~ __dirname:", __dirname);
+export default (env = {}, argv = {}) => {
+    const require = createRequire(import.meta.url);
+    const options = {
+        src: env.src ?? './src',
+        build: env.build ?? './build',
+        port: env.port ?? 8080,
+        mode: argv.mode ?? 'production',
+    };
+    const isDev = options.mode === 'watch';
+    const buildPath = path.resolve(options.build);
+    const controllerHtmlPath = path.resolve(options.src, 'index.html');
+    const controllerStaticPath = path.resolve(path.dirname(controllerHtmlPath), '../static');
+    const controllerFontsPath = path.resolve(path.dirname(controllerHtmlPath), '../fonts');
+    return {
+        mode: isDev ? 'development' : 'production',
+        target: 'electron-renderer',
+        entry: isDev ? [
+            `webpack-dev-server/client?http://localhost:${options.port}/`,
+            'webpack/hot/dev-server',
+            path.resolve(options.src, 'main.ts')
+        ] : path.resolve(options.src, 'main.ts'),
+        output: {
+            path: buildPath,
+            filename: '[name].js',
+            publicPath: isDev ? '/' : './'
+        },
+        externals: {
+            electron: 'commonjs electron',
+            '@vixoniccom/module-controller': 'commonjs @vixoniccom/module-controller',
+            webpack: 'commonjs webpack',
+            'terser-webpack-plugin': 'commonjs terser-webpack-plugin',
+            esbuild: 'commonjs esbuild',
+            '@swc/core': 'commonjs @swc/core',
+            '@swc/wasm': 'commonjs @swc/wasm'
+        },
+        resolve: {
+            extensions: ['.tsx', '.ts', '.js', '.jsx', '.mjs'],
+            mainFields: ['module', 'browser', 'main'],
+            fullySpecified: false,
+            fallback: {
+                process: require.resolve('process/browser.js'),
+                global: require.resolve('global')
+            },
+            modules: ['node_modules', 'src', 'static']
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.(ts|tsx|js|jsx)$/,
+                    exclude: /node_modules/,
+                    use: {
+                        loader: 'ts-loader',
+                        options: {
+                            transpileOnly: true
+                        }
+                    }
+                },
+                {
+                    test: /\.s[ac]ss$/,
+                    use: ['style-loader', 'css-loader', 'sass-loader']
+                },
+                {
+                    test: /\.css$/,
+                    use: ['style-loader', 'css-loader'],
+                    exclude: /node_modules/
+                },
+                {
+                    test: /\.(png|jpe?g|gif|svg|woff|woff2|ttf|eot|mp4)$/,
+                    type: 'asset/resource',
+                    generator: {
+                        filename: '[name][ext]'
+                    }
+                },
+                {
+                    test: /\.html$/,
+                    use: {
+                        loader: 'html-loader',
+                        options: {
+                            sources: false,
+                        }
+                    }
+                }
+            ]
+        },
+        plugins: [
+            new webpack.DefinePlugin({
+                global: 'globalThis'
+            }),
+            new webpack.ProvidePlugin({
+                process: 'process/browser.js'
+            }),
+            new CleanWebpackPlugin(),
+            new HtmlWebpackPlugin({
+                template: controllerHtmlPath,
+                filename: 'index.html',
+                inject: 'body',
+                chunks: ['main']
+            }),
+            new CopyWebpackPlugin({
+                patterns: [
+                    { from: controllerStaticPath, to: 'static', noErrorOnMissing: true },
+                    { from: controllerFontsPath, to: 'fonts', noErrorOnMissing: true }
+                ]
+            })
+        ],
+        optimization: isDev ? undefined : {
+            minimize: false,
+            minimizer: [
+                new TerserPlugin({
+                    minify: TerserPlugin.terserMinify,
+                    terserOptions: {
+                        ecma: 2020,
+                        compress: true,
+                        mangle: true,
+                        format: { comments: false }
+                    }
+                })
+            ]
+        },
+        devtool: isDev ? 'source-map' : false,
+        devServer: isDev ? {
+            static: [
+                {
+                    directory: path.resolve(options.src, 'test'),
+                    publicPath: '/test',
+                    watch: true,
+                }
+            ],
+            open: false,
+            client: {
+                overlay: true
+            },
+            port: options.port || 8080,
+            hot: true,
+            historyApiFallback: true,
+            devMiddleware: {
+                publicPath: '/',
+                writeToDisk: false
+            }
+        } : undefined
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vixoniccom/module-packager",
-  "version": "2.12.0-dev.0",
+  "version": "2.12.0-dev.1",
   "type": "module",
   "license": "ISC",
   "bin": {
@@ -17,9 +17,6 @@
     "build:renderer": "webpack --config webpack.config.js --env src=./ --env build=./dist/build --mode production",
     "copy:launcher": "cp launcher.html dist/launcher.html",
     "build": "npm run clean && npm-run-all -p build:renderer build:main && npm run copy:launcher",
-    "watch:renderer": "webpack --config webpack.config.js --env src=./ --env build=./dist/build --mode=development --watch",
-    "watch:main": "tsc -p tsconfig.json --outDir dist --watch",
-    "dev:watch": "npm run clean && npm-run-all -p watch:renderer watch:main",
     "prerelease-dev": "standard-version --prerelease dev",
     "prerelease-rc": "standard-version --prerelease rc",
     "prerelease-test": "standard-version --prerelease test",