@unsetsoft/ryunix-presets 1.0.26-canary.4 → 1.0.26-canary.43

package/.generated/webpack/bin/compiler.js

@@ -0,0 +1,5 @@
+import webpack from 'webpack';
+import webpackConfig from '../webpack.config.js';
+webpackConfig.mode = 'production';
+const compiler = webpack(webpackConfig);
+export { compiler };

package/.generated/webpack/bin/dev.server.js

@@ -0,0 +1,115 @@
+import Webpack from 'webpack';
+import WebpackDevServer from 'webpack-dev-server';
+import webpackConfig from '../webpack.config.js';
+import { configFileExist } from '../utils/settingfile.cjs';
+import envPath from '../utils/envExist.cjs';
+import { getPackageVersion, resolveApp, cleanCacheDir } from '../utils/index.js';
+import logger from 'terminal-log';
+import chalk from 'chalk';
+import net from 'net'; // Para verificar si el puerto está disponible
+import boxen from 'boxen';
+import defaultSettings from '../utils/config.cjs';
+const checkPortInUse = (port) => {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(true); // Puerto en uso
+            }
+            else {
+                reject(err);
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve(false); // Puerto libre
+        });
+        server.listen(port);
+    });
+};
+const findAvailablePort = async (port) => {
+    let isPortInUse = await checkPortInUse(port);
+    while (isPortInUse) {
+        logger.warn(chalk.yellow(`Port ${port} is in use, trying port ${port + 1}...`));
+        port += 1;
+        isPortInUse = await checkPortInUse(port);
+    }
+    return port;
+};
+const StartServer = async (cliSettings) => {
+    const cacheDir = resolveApp(process.cwd(), `${defaultSettings.buildDir}/cache`);
+    const mode = cliSettings.production || defaultSettings.webpack.production ? true : false;
+    if (!mode) {
+        cleanCacheDir(cacheDir);
+    }
+    const configs = webpackConfig;
+    const clientConfig = Array.isArray(configs)
+        ? configs.find((c) => c.name === 'client') || configs[0]
+        : configs;
+    if (Array.isArray(configs)) {
+        configs.forEach((c) => {
+            c.mode = mode ? 'production' : 'development';
+        });
+    }
+    else {
+        configs.mode = mode ? 'production' : 'development';
+    }
+    const compiler = Array.isArray(configs)
+        ? Webpack(configs)
+        : Webpack(configs);
+    const clientDevServer = clientConfig.devServer;
+    let port = clientDevServer?.port || 3000;
+    // Encontrar un puerto disponible
+    port = await findAvailablePort(port);
+    // Modificamos el puerto en la configuración
+    if (clientDevServer) {
+        clientDevServer.port = port;
+    }
+    const devServerOptions = { ...(clientDevServer || {}), ...cliSettings };
+    const server = new WebpackDevServer(devServerOptions, compiler);
+    const devMode = Boolean(!mode);
+    const { version } = await getPackageVersion();
+    const startServer = async () => {
+        try {
+            await server.start(); // Iniciar el servidor con el nuevo puerto
+            const url = `http://localhost:${port}`;
+            const cfgStatus = configFileExist()
+                ? chalk.green('✔ Loaded')
+                : chalk.red('✘ Not found');
+            const envStatus = envPath()
+                ? chalk.green('✔ Loaded')
+                : chalk.yellow('✘ Not found');
+            const modeLabel = mode
+                ? chalk.bold(chalk.magenta('production'))
+                : chalk.bold(chalk.cyan('development'));
+            const { version } = await getPackageVersion();
+            const content = [
+                `${chalk.bold(chalk.cyanBright('<Ryunix/>'))} ${chalk.gray(`v${version}`)}`,
+                '',
+                `${chalk.white('Ready at:')} ${chalk.underline(chalk.cyan(url))}`,
+                `${chalk.white('Config:')}   ${cfgStatus}`,
+                `${chalk.white('Env:')}      ${envStatus}`,
+                `${chalk.white('Mode:')}     ${modeLabel}`,
+            ];
+            if (devMode) {
+                content.push('');
+                content.push(`${chalk.yellow('⚠️')}  ${chalk.yellow('Development mode active')}`);
+                content.push(chalk.gray('Build for production to optimize performance'));
+            }
+            console.log(boxen(content.join('\n'), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'round',
+                borderColor: 'cyan',
+                title: chalk.bold('Dev Server'),
+                titleAlignment: 'center',
+                minimumWidth: 50,
+            }));
+        }
+        catch (err) {
+            logger.error(`[error] ${err.message}`);
+        }
+    };
+    await startServer();
+};
+export { StartServer as StartDevServer };

package/.generated/webpack/bin/index.js

@@ -0,0 +1,195 @@
+#! /usr/bin/env node
+import yargs from 'yargs';
+const hideBin = (argv) => argv.slice(2);
+import { StartDevServer } from './dev.server.js';
+import { compiler } from './compiler.js';
+import logger from 'terminal-log';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import defaultSettings from '../utils/config.cjs';
+import Prerender from './prerender.js';
+import { resolveApp, getPackageVersion, } from '../utils/index.js';
+import { ESLint } from 'eslint';
+import eslintConfig from '../eslint.config.js';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import server from './prod.server.js';
+import config from '../utils/config.cjs';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const lint = {
+    command: 'lint',
+    describe: 'Lint code',
+    builder: {
+        fix: {
+            alias: 'f',
+            type: 'boolean',
+            default: false,
+            describe: 'Automatically fix problems',
+        },
+    },
+    handler: async (arg) => {
+        const classicConfig = eslintConfig[0];
+        const fix = arg.fix;
+        const eslint = new ESLint({
+            cwd: process.cwd(),
+            overrideConfigFile: true,
+            overrideConfig: classicConfig,
+            fix,
+        });
+        const results = await eslint.lintFiles(defaultSettings.eslint.files);
+        await ESLint.outputFixes(results);
+        const formatter = await eslint.loadFormatter('stylish');
+        const report = formatter.format(results);
+        console.log(report);
+    },
+};
+const dev = {
+    command: 'dev',
+    describe: 'Run server for developer mode.',
+    handler: async (arg) => {
+        process.env.RYUNIX_MODE = 'development';
+        const open = Boolean(arg.browser) || false;
+        const settings = {
+            open,
+        };
+        // add message to say the server is starting with chalk
+        console.log(chalk.cyan('Starting development server, please wait...'));
+        console.log(`${chalk.cyan('○')}  Compiler: ${chalk.bold(config.compiler.toUpperCase())}`);
+        try {
+            await StartDevServer(settings);
+        }
+        catch (error) {
+            logger.error(chalk.red('Error starting development server:'), error);
+            process.exit(1);
+        }
+    },
+};
+const prod = {
+    command: 'start',
+    describe: 'Run server for production mode. Requiere .ryunix/static',
+    handler: async (arg) => {
+        process.env.RYUNIX_MODE = 'production';
+        if (!fs.existsSync(join(process.cwd(), config.buildDir, 'static'))) {
+            logger.error('You need build first!');
+            return;
+        }
+        const { version } = await getPackageVersion();
+        server.listen(config.port, () => {
+            const content = [
+                `${chalk.bold(chalk.cyanBright('<Ryunix/>'))} ${chalk.gray(`v${version}`)}`,
+                '',
+                `${chalk.white('Ready at:')} ${chalk.underline(chalk.cyan(`http://localhost:${config.port}/`))}`,
+                `${chalk.white('Mode:')}     ${chalk.bold(chalk.magenta('production'))}`,
+            ];
+            console.log(boxen(content.join('\n'), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'round',
+                borderColor: 'magenta',
+                title: chalk.bold('Production Server'),
+                titleAlignment: 'center',
+                minimumWidth: 50,
+            }));
+        });
+    },
+};
+const build = {
+    command: 'build',
+    describe: 'Run builder',
+    handler: async (arg) => {
+        process.env.RYUNIX_MODE = 'production';
+        // ── Clean build output before each production build ───────────────────
+        // Clears static/ and server/ (except server/api/) but keeps cache/ intact.
+        const buildRoot = resolveApp(process.cwd(), defaultSettings.buildDir);
+        const clean = (dir) => {
+            if (fs.existsSync(dir)) {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+        };
+        clean(join(buildRoot, 'static'));
+        clean(join(buildRoot, 'server', 'app'));
+        clean(join(buildRoot, 'server', 'app-router-server.bundle.js'));
+        // Note: server/api/ is cleaned by ApiRouterPlugin on its own (incremental recompile)
+        console.log(`${chalk.cyan('○')}  Compiling using ${chalk.bold(config.compiler.toUpperCase())}...`);
+        const buildStart = Date.now();
+        compiler.run(async (err, stats) => {
+            if (err || stats.hasErrors()) {
+                logger.error(chalk.red('✘ Error during compilation:'));
+                if (err) {
+                    logger.error(err);
+                }
+                else {
+                    // MultiStats or Stats — toString works on both
+                    const output = stats.toString('errors-only');
+                    const lines = output.split('\n').filter(Boolean);
+                    lines.forEach((line) => logger.error(line));
+                }
+                compiler.close(() => process.exit(1));
+                return;
+            }
+            // ── Build time ─────────────────────────────────────────────────────────
+            const buildTimeMs = Date.now() - buildStart;
+            const minutes = Math.floor(buildTimeMs / 60000);
+            const seconds = ((buildTimeMs % 60000) / 1000).toFixed(1);
+            const formattedTime = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+            // ── SSG Prerender ──────────────────────────────────────────────────────
+            if (defaultSettings.webpack.production) {
+                await Prerender(defaultSettings.buildDir);
+            }
+            // ── API Routes log ─────────────────────────────────────────────────────
+            const apiOutputDir = join(buildRoot, 'server', 'api');
+            if (fs.existsSync(apiOutputDir)) {
+                const collectRoutes = (dir, base = '') => {
+                    const routes = [];
+                    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                        const fullPath = join(dir, entry.name);
+                        if (entry.isDirectory()) {
+                            routes.push(...collectRoutes(fullPath, `${base}/${entry.name}`));
+                        }
+                        else if (/^(route|router|endpoint)\.(mjs|js)$/.test(entry.name)) {
+                            routes.push(base || '/');
+                        }
+                    }
+                    return routes;
+                };
+                const apiRoutes = collectRoutes(apiOutputDir);
+                if (apiRoutes.length > 0) {
+                    console.log(`${chalk.cyan('○')}  API routes (${chalk.bold(apiRoutes.length)}):`);
+                    apiRoutes.forEach((r) => console.log(`   ${chalk.green('✔')} ${chalk.gray(`/api${r}`)}`));
+                    console.log('');
+                }
+            }
+            logger.info(`${chalk.green('✔')} ${chalk.bold('Compilation successful! 🎉')}`);
+            logger.info(`${chalk.gray('Done in')} ${chalk.bold(formattedTime)}`);
+            compiler.close((closeErr) => {
+                if (closeErr) {
+                    logger.error(chalk.red('Error closing the compiler:'), closeErr);
+                }
+                process.exit(0);
+            });
+        });
+    },
+};
+const extractHTML = {
+    command: 'customHtml',
+    describe: 'Extract HTML for customization',
+    handler: async (arg) => {
+        const runPath = process.cwd();
+        fs.copyFile(join(__dirname, '..', 'template/index.html'), join(runPath, 'public/index.html'), (err) => {
+            if (err) {
+                console.error('Error extracting HTML: ', err.message);
+                return;
+            }
+            console.log('File extracted successfully. Now you can enable the template with legacy.template inside ryunix.config.js');
+        });
+    },
+};
+yargs(hideBin(process.argv))
+    .command(dev)
+    .command(build)
+    .command(prod)
+    .command(lint)
+    .command(extractHTML)
+    .parse();

package/.generated/webpack/bin/prerender.js

@@ -0,0 +1,81 @@
+/**
+ * Automatic Prerender - reads routes from manifest
+ */
+import { buildSSG } from '../utils/ssg.js';
+import { configFileExist } from '../utils/settingfile.cjs';
+import defaultSettings from '../utils/config.cjs';
+import { resolveApp } from '../utils/index.js';
+import fs from 'fs';
+import path from 'path';
+const loadResolvedSSGRoutes = async (buildDirectory) => {
+    const serverBundleCandidates = [
+        path.join(buildDirectory, 'server', 'app-router-server.bundle.js'),
+        path.join(buildDirectory, 'server', 'app-router-server.bundle.mjs'),
+    ];
+    const serverBundlePath = serverBundleCandidates.find((candidate) => fs.existsSync(candidate));
+    if (!serverBundlePath)
+        return null;
+    try {
+        const serverModule = await import(`file://${serverBundlePath}?update=${Date.now()}`);
+        if (typeof serverModule.resolveSSGPaths === 'function') {
+            return await serverModule.resolveSSGPaths();
+        }
+    }
+    catch (error) {
+        console.warn('[SSG] Could not resolve dynamic routes from server bundle:', error.message);
+    }
+    return null;
+};
+const normalizeManifestRoutes = (routes) => routes
+    .filter((route) => route && route.path && !route.path.includes(':'))
+    .map((route) => ({
+    path: route.path,
+    meta: route.meta || {},
+}));
+const Prerender = async (directory) => {
+    const buildDirectory = resolveApp(process.cwd(), directory);
+    if (!configFileExist()) {
+        console.error('❌ No configuration file found.');
+        process.exit(1);
+    }
+    const manifestPath = path.join(process.cwd(), directory, 'cache/ssg', 'routes.json');
+    let routes = [];
+    if (fs.existsSync(manifestPath)) {
+        try {
+            routes = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        }
+        catch (error) {
+            console.error('[SSG] Error reading routes manifest:', error);
+        }
+    }
+    const resolvedRoutes = await loadResolvedSSGRoutes(buildDirectory);
+    if (resolvedRoutes) {
+        routes = resolvedRoutes;
+        if (defaultSettings.debug) {
+            console.log(`[SSG] Resolved ${routes.length} routes via generateStaticParams`);
+        }
+    }
+    else {
+        routes = normalizeManifestRoutes(routes);
+    }
+    const metaExist = routes.some((route) => route.meta);
+    if (metaExist &&
+        Object.keys(defaultSettings.legacy.seo.meta || {}).length > 0) {
+        console.error('[Ryunix Error] You are mixing static and dynamic meta tags; you can only use one of the two. Remove legacy.seo.meta from ryunix.config.js.');
+        process.exit(1);
+    }
+    if (routes.length === 0) {
+        const legacyRoutes = defaultSettings.legacy?.ssg?.prerender || [];
+        routes = legacyRoutes.map((route) => typeof route === 'string' ? { path: route, meta: {} } : route);
+        if (routes.length > 0) {
+            console.log(`[SSG] Using ${routes.length} routes from config`);
+        }
+    }
+    if (routes.length === 0) {
+        console.log('[SSG] No routes to prerender, skipping SSG generation.');
+        return;
+    }
+    await buildSSG(routes, defaultSettings, buildDirectory, defaultSettings.debug);
+    console.log('✅ SSG build complete');
+};
+export default Prerender;