@vixoniccom/module-packager 2.10.2-test.7 → 2.10.3-dev.0

package/dist/electron.js

@@ -4,7 +4,6 @@ import remoteMain from '@electron/remote/main/index.js';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import commandLineArgs from 'command-line-args';
-import fs from 'fs';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const optionDefinitions = [
@@ -16,14 +15,12 @@ const optionDefinitions = [
     { name: 'mode', type: String, defaultValue: 'run' }
 ];
 const options = commandLineArgs(optionDefinitions);
-console.log('🚀 [ELECTRON] options:', options);
 if (options.mode === 'watch') {
     (await import('electron-debug')).default({ showDevTools: true });
 }
 remoteMain.initialize();
 let mainWindow = null;
 function createWindow() {
-    console.log('[ELECTRON] Creating BrowserWindow…');
     mainWindow = new BrowserWindow({
         show: false,
         x: 100,
@@ -31,7 +28,6 @@ function createWindow() {
         width: 1024,
         height: 768,
         webPreferences: {
-            preload: path.join(__dirname, 'preload.js'),
             nodeIntegrationInSubFrames: true,
             nodeIntegration: true,
             contextIsolation: false,
@@ -40,21 +36,22 @@ function createWindow() {
         }
     });
     remoteMain.enable(mainWindow.webContents);
-    const devUrl = `http://localhost:${options.port}/index.html`;
-    const fileUrl = `file://${path.join(options.build, 'index.html')}`;
-    console.log('[ELECTRON] build dir:', options.build);
-    console.log('[ELECTRON] index.html exists?', fs.existsSync(path.join(options.build, 'index.html')));
-    const url = options.mode === 'watch' ? devUrl : fileUrl;
-    console.log('[ELECTRON] Loading URL:', url);
-    console.log('[ELECTRON] Loading URL:', url);
-    mainWindow.loadURL(url);
+    const launcherPath = path.join(__dirname, 'launcher.html');
+    const launcherURL = `file://${launcherPath}`;
+    // const devUrl = `http://localhost:${options.port}/index.html`;
+    // const fileUrl = `file://${path.join(options.build, 'index.html')}`;
+    console.log('🚀  cargando launcher:', launcherURL);
+    mainWindow.loadURL(launcherURL);
+    // const url = options.mode === 'watch' ? devUrl : fileUrl;
+    // console.log("🚀 ~ createWindow ~ url:", url)
+    mainWindow.webContents.openDevTools({ mode: 'detach' });
+    // mainWindow.loadURL(url);
     mainWindow.webContents.once('did-finish-load', () => {
         console.log('[ELECTRON] did-finish-load → show()');
         mainWindow?.show();
         mainWindow?.webContents.send('init', options);
     });
     mainWindow.on('closed', () => (mainWindow = null));
-    // mainWindow.webContents.openDevTools({ mode: 'detach' });
 }
 app.whenReady().then(() => {
     console.log('[ELECTRON] App is ready');

package/dist/launcher.html

@@ -0,0 +1,98 @@
+<!DOCTYPE html>
+<html 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 {
+      ModuleController = require('@vixoniccom/module-controller');
+      console.log('[WEBVIEW] ModuleController cargado OK');
+    } 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) => {
+      console.log('[WEBVIEW] init', options)
+
+      const webview = document.getElementById('webview')
+      const win = remote.getCurrentWindow()
+
+      webview.setAttribute('nodeintegration', '')
+      webview.setAttribute('webpreferences', 'contextIsolation=no, nodeIntegration=yes')
+
+      webview.addEventListener('dom-ready', () => {
+        webview.openDevTools() // opcional
+      })
+
+      webview.addEventListener('did-finish-load', () => {
+        console.log('[WEBVIEW] did-finish-load fired')
+        win.show()
+        win.focus()
+      })
+
+      webview.addEventListener('did-fail-load', (e) => {
+        console.error('[WEBVIEW] did-fail-load', e)
+      })
+
+      const resolvedSrc = options.mode === 'watch'
+        ? `http://localhost:${options.port}/index.html`
+        : `file://${path.join(options.build, 'index.html')}`
+
+      console.log('[WEBVIEW] Resolved src:', resolvedSrc)
+
+      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')
+        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()
+
+      console.log('[WEBVIEW] Data entregada a ModuleController:', data)
+      console.log('[WEBVIEW] Schema entregado a ModuleController:', schema)
+
+      ModuleController.init(win, webview, data, schema, options.mode === 'watch')
+    })
+  </script>
+</body>
+
+</html>

package/dist/main.js

@@ -80,9 +80,11 @@ function runElectron() {
     });
 }
 async function pack(callback) {
+    console.log(path.resolve(__dirname, './dist', options.config));
     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) {
@@ -144,6 +146,8 @@ function installExternals(callback) {
 }
 function zip() {
     console.log(clc.blue('Archiving...'));
+    console.log(clc.blue('Cleaning build...'));
+    console.log("[DEBUG] Cleaning build folder", path.resolve(options.build, '../', 'build.zip'));
     let output = fs.createWriteStream(path.resolve(options.build, '../', 'build.zip'));
     let archive = archiver('zip');
     archive.pipe(output);
@@ -159,11 +163,16 @@ function zip() {
 }
 async function watch() {
     console.log('[VMP] ▸ starting dev-server & electron in watch mode…');
-    const cfgPath = path.resolve(__dirname, '..', 'webpack.config.js');
+    const cfgPath = path.resolve(__dirname, '..', 'dist/webpack.config.js');
     const webpackConfigFactory = (await import(cfgPath)).default;
-    console.log("🚀 ~ watch ~ webpackConfigFactory:", webpackConfigFactory);
+    console.log('[VMP] ▸ webpack config loaded from', cfgPath);
     const compiler = webpack(webpackConfigFactory(options));
-    const server = new WebpackDevServer({ static: path.join(__dirname, options.src, '..'), port: options.port }, compiler);
+    const server = new WebpackDevServer({
+        static: false,
+        port: options.port,
+        devMiddleware: { publicPath: '/' },
+        historyApiFallback: true
+    }, compiler);
     await server.start();
     console.log(`[VMP] ▸ dev-server listening on http://localhost:${options.port}`);
     const cmd = [
@@ -216,11 +225,11 @@ 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 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 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');

package/dist/webpack.config.js

@@ -1,12 +1,15 @@
 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);
+// const __dirname = path.dirname(__filename)
 export default (env = {}, argv = {}) => {
+    const require = createRequire(import.meta.url);
     const options = {
         src: env.src ?? './src',
         build: env.build ?? './build',
@@ -29,6 +32,7 @@ export default (env = {}, argv = {}) => {
             publicPath: '/'
         },
         externals: {
+            electron: 'commonjs electron',
             '@vixoniccom/module-controller': 'commonjs @vixoniccom/module-controller',
             webpack: 'commonjs webpack',
             'terser-webpack-plugin': 'commonjs terser-webpack-plugin',
@@ -40,10 +44,11 @@ export default (env = {}, argv = {}) => {
             extensions: ['.tsx', '.ts', '.js', '.jsx', '.mjs'],
             mainFields: ['module', 'browser', 'main'],
             fullySpecified: false,
-            modules: [
-                'node_modules',
-                path.resolve(__dirname, '../../node_modules')
-            ]
+            fallback: {
+                process: require.resolve('process/browser.js'),
+                global: require.resolve('global')
+            },
+            modules: ['node_modules']
         },
         module: {
             rules: [
@@ -91,10 +96,26 @@ export default (env = {}, argv = {}) => {
                             sources: false,
                         }
                     }
+                },
+                {
+                    test: /\.(ts|tsx)$/,
+                    exclude: /node_modules/,
+                    use: {
+                        loader: 'ts-loader',
+                        options: {
+                            transpileOnly: true
+                        }
+                    }
                 }
             ]
         },
         plugins: [
+            new webpack.DefinePlugin({
+                global: 'globalThis'
+            }),
+            new webpack.ProvidePlugin({
+                process: 'process/browser.js'
+            }),
             new CleanWebpackPlugin(),
             new HtmlWebpackPlugin({
                 template: controllerHtmlPath,
@@ -123,11 +144,9 @@ export default (env = {}, argv = {}) => {
                 })
             ]
         },
-        devtool: isDev ? 'source-map' : false,
+        devtool: isDev ? 'eval' : false,
         devServer: isDev ? {
-            static: {
-                directory: path.resolve(options.src)
-            },
+            static: false,
             open: false,
             client: {
                 overlay: true

package/package.json

@@ -56,7 +56,7 @@
   ],
   "dependencies": {
     "@electron/remote": "^2.1.2",
-    "@vixoniccom/module-controller": "1.3.0-dev.5",
+    "@vixoniccom/module-controller": "2.0.0-dev.0",
     "@vixoniccom/modules": "^2.20.0",
     "archiver": "^5.3.0",
     "clean-webpack-plugin": "^4.0.0",
@@ -66,9 +66,11 @@
     "electron": "^36.1.0",
     "electron-debug": "^3.2.0",
     "file-loader": "^0.9.0",
+    "global": "^4.4.0",
     "html-loader": "^0.4.5",
     "html-webpack-plugin": "^4.5.2",
     "lodash": "^4.17.21",
+    "process": "^0.11.10",
     "raw-loader": "^0.5.1",
     "ts-loader": "^9.5.0",
     "ts-node": "^10.9.1",
@@ -93,19 +95,18 @@
   "readme": "ERROR: No README data found!",
   "scripts": {
     "start": "electron dist/electron.js --mode run --build ./dist/build",
-    "build:renderer": "webpack ./webpack.config.js --mode production --env src=./ --env build=./dist/build",
-    "build:main": "tsc -p tsconfig.json",
-    "build": "npm-run-all -p build:renderer build:main",
-    "dev:renderer": "webpack serve ./webpack.config.js --mode development --env src=./src --env build=./dist/build --env port=8080",
-    "dev:electron": "wait-on http://localhost:8080/index.html && electron dist/electron.js --mode watch --port 8080 --build ./dist/build",
-    "dev": "npm-run-all -p dev:renderer dev:electron",
+    "clean": "rimraf dist",
+    "build:main": "tsc -p tsconfig.json --outDir dist",
+    "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",
     "prerelease-dev": "standard-version --prerelease dev",
     "prerelease-rc": "standard-version --prerelease rc",
     "prerelease-test": "standard-version --prerelease test",
     "release": "standard-version"
   },
   "type": "module",
-  "version": "2.10.2-test.7",
+  "version": "2.10.3-dev.0",
   "license": "ISC",
   "devDependencies": {
     "@types/archiver": "^6.0.3",