@vixoniccom/module-packager 2.11.0-dev.9 → 2.11.0-just4dev.1

package/dist/main.js

@@ -1,323 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-import commandLineArgs from 'command-line-args';
-import path from 'path';
-import webpack from 'webpack';
-import WebpackDevServer from 'webpack-dev-server';
-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');
-const npxPath = which.sync('npx');
-const optionDefinitions = [
-    { name: 'externals', type: String, defaultValue: [], multiple: true },
-    { name: 'target', type: String, defaultValue: 'web' },
-    { name: 'src', type: String, defaultValue: './src' },
-    { name: 'build', type: String, defaultValue: './build' },
-    { name: 'confDefinition', type: String, defaultValue: './configuration' },
-    { name: 'config', type: String, defaultValue: './webpack.config.js' },
-    { name: 'port', type: Number, defaultValue: 8080 },
-    { name: 'mode', type: String, defaultValue: 'build' },
-    { name: 'transpileOnly', type: Boolean },
-    { name: 'tsOverride', type: Boolean }
-];
-const options = commandLineArgs(optionDefinitions);
-// 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') {
-            installExternals(() => {
-                zip();
-            });
-        }
-        else {
-            zip();
-        }
-    });
-}
-else if (options.mode === 'watch') {
-    watch();
-}
-else if (options.mode === 'run') {
-    run();
-}
-else if (options.mode === 'generate-configuration') {
-    await generateConfiguration();
-}
-else if (options.mode === 'validate-configuration') {
-    validateConfiguration();
-}
-async function pack(callback) {
-    console.log(clc.blue('Building module...'));
-    validateConfiguration();
-    const configPath = path.resolve(__dirname, options.config);
-    console.log("🚀 ~ pack ~ configPath:", configPath);
-    try {
-        const webpackConfig = (await import(configPath)).default(options);
-        function handleWebpackError(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 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.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);
-            }
-        });
-    }
-    catch (e) {
-        console.error(clc.red('Failed to load webpack config'));
-        throw e;
-    }
-}
-function installExternals(callback) {
-    let externals = options.externals.map((x) => {
-        // 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) {
-        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?.(null);
-        });
-        child.on('error', (err) => {
-            callback?.(err);
-        });
-    }
-    else {
-        callback?.(null);
-    }
-}
-function zip() {
-    console.log(clc.blue('Archiving...'));
-    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(buildPath, './');
-    archive.finalize();
-    output.on('close', function () {
-        console.log(clc.green('Generated build.zip.'));
-    });
-    archive.on('error', function (err) {
-        throw err;
-    });
-    clc.move(-2, 0);
-}
-async function watch() {
-    // 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));
-    const server = new WebpackDevServer({
-        static: false,
-        port: options.port,
-        devMiddleware: { publicPath: '/' },
-        historyApiFallback: true
-    }, compiler);
-    await server.start();
-    spawnElectronProcess('watch');
-}
-async function run() {
-    await new Promise((resolve) => pack((err) => (err ? console.log(err) : resolve())));
-    await compileWebpack();
-    spawnElectronProcess('run');
-}
-async function loadConfiguration() {
-    const require = createRequire(import.meta.url);
-    tsNode.register({
-        compilerOptions: {
-            moduleResolution: 'node',
-            module: 'commonjs',
-            target: 'es2015',
-            checkJs: false
-        }
-    });
-    const configPath = sanitizePath(path.resolve(options.confDefinition, 'index.ts'));
-    return require(configPath).configuration;
-}
-async function generateConfiguration() {
-    try {
-        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) {
-        console.log(clc.red('Configuration generation failed'));
-        throw e;
-    }
-}
-function validateConfiguration() {
-    try {
-        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(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');
-        }
-        console.log(clc.green('Valid configuration'));
-    }
-    catch (e) {
-        console.log(clc.red('Invalid configuration'));
-        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

@@ -1,153 +0,0 @@
-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
-    };
-};