@ozdao/martyrs 0.2.477 → 0.2.479

package/src/builder/modes/ssr.rspack.dev.js

@@ -1,44 +1,28 @@
-const path = require("path");
-const { rspack } = require("@rspack/core");
-// const readline = require("readline");
+import path from "path";
+import chalk from "chalk";
 
-const devMiddleware = require("webpack-dev-middleware"); 
-// const hotMiddleware = require("webpack-hot-middleware"); // Replace if uncommented; test HMR without it first
+import { rspack, ProgressPlugin } from "@rspack/core";
+import { fork } from "child_process";
 
-const { createHtmlRenderer } = require("../ssr/ssr-render-html.js");
-const { transformDevStats } = require("../ssr/ssr-transform-webpack-stats.js");
+import devMiddleware from "webpack-dev-middleware";
 
-module.exports = function createSsrDevServer(projectRoot, { clientConfig, serverConfig, ssrConfig, createServerPath }) {
+import { createHtmlRenderer } from "../ssr/ssr-render-html.js";
+import { transformDevStats } from "../ssr/ssr-transform-webpack-stats.js";
+
+export default function createSsrDevServer(projectRoot, { clientConfig, apiConfig, ssrConfig }) {
   const clientCompiler = rspack(clientConfig); 
-  const serverCompiler = rspack(serverConfig);
   const ssrCompiler = rspack(ssrConfig);
+  const serverCompiler = rspack(apiConfig);
 
   const createDevRenderer = (onUpdate) => {
     const createHotReloadingServerRenderer = (config) => {
-      // Native ANSI escape codes for colors
-      const colors = {
-        reset: "\x1b[0m",
-        green: "\x1b[32m",
-        greenBright: "\x1b[92;1m",
-        blue: "\x1b[34m",
-        blueBright: "\x1b[94m",
-        yellow: "\x1b[33m",
-        red: "\x1b[31m",
-      };
+      const progressPlugin = new ProgressPlugin((percentage, message, ...args) => {
 
-      const progressPlugin = new rspack.ProgressPlugin((percentage, message, ...args) => {
-        // readline.clearLine(process.stdout, 0);
-        // readline.cursorTo(process.stdout, 0);
-
-        process.stdout.write(
-          colors.greenBright +
-            `${(percentage * 100).toFixed(2)}% ` +
-            colors.reset +
-            colors.blueBright +
-            message +
-            colors.reset +
-            " " +
-            args.map((arg) => colors.yellow + arg + colors.reset).join(" ")
+        console.log(
+          chalk.greenBright(`${(percentage * 100).toFixed(2)}% `) +
+          chalk.blueBright(message) +
+          " " +
+          args.map((arg) => chalk.yellow(arg)).join(" ")
         );
       });
 
@@ -46,25 +30,25 @@ module.exports = function createSsrDevServer(projectRoot, { clientConfig, server
       config.plugins.push(progressPlugin);
       
       let renderApp = null;
+
       let setCompilationDone = null;
-      let ssrCompilation = new Promise((resolve) => {
-        setCompilationDone = resolve;
-      });
+      let ssrCompilation = new Promise((resolve) => { setCompilationDone = resolve });
 
       ssrCompiler.watch(
         {
           "info-verbosity": "none",
         },
-        (error, stats) => {
+        async (error, stats) => {
           if (error) {
-            console.error(colors.red + "Server critical error" + colors.reset);
+            console.error(chalk.red("Server critical error"));
             console.error(JSON.stringify(error, null, 2));
             throw error;
-            return;
           }
+
           const jsonStats = stats.toJson();
+
           if (stats.hasErrors()) {
-            console.error(colors.red + "Client compilation error" + colors.reset);
+            console.error(chalk.red("Client compilation error"));
             jsonStats.errors.forEach((err) => {
               if (err.details) {
                 console.error(err.details);
@@ -72,25 +56,27 @@ module.exports = function createSsrDevServer(projectRoot, { clientConfig, server
                 try {
                   console.error(JSON.stringify(err, null, 2));
                 } catch (e) {
-                  console.error(e)
+                  console.error(e);
                 }
               } else {
-                console.error(colors.red + err.slice() + colors.reset);
+                console.error(chalk.red(err.slice()));
               }
             });
             return;
           }
           const { entrypoints, outputPath } = jsonStats;
           const { main: { assets: [mainChunkPath] } } = entrypoints;
-          const { render } = require(path.resolve(outputPath, mainChunkPath.name));
-          renderApp = render;
+          const mainModulePath = path.resolve(outputPath, mainChunkPath.name);
+          
+          // Dynamic import for ESM compatibility
+          const module = await import(mainModulePath);
+          renderApp = module.render;
           setCompilationDone();
         }
       );
       
       return async (stuff) => {
         await ssrCompilation;
-
         const result = await renderApp(stuff);
         return result;
       };
@@ -120,6 +106,36 @@ module.exports = function createSsrDevServer(projectRoot, { clientConfig, server
   let serverInstance;
   let rendererInstance;
 
+  let serverModule;
+
+  serverCompiler.watch({}, async (err, stats) => {
+    if (err) {
+      console.error(err);
+      return;
+    }
+    
+    console.log(stats.toString(apiConfig.stats));
+    
+    try {
+      // Получаем путь к скомпилированному файлу
+      const { outputPath } = stats.toJson();
+      const entryName = Object.keys(stats.toJson().entrypoints)[0];
+      const assetName = stats.toJson().entrypoints[entryName].assets[0].name;
+      
+      // Импортируем с уникальным параметром для сброса кэша
+      serverModule = await import(`file://${path.resolve(outputPath, assetName)}?t=${Date.now()}`);
+      
+      if (typeof serverModule.createServer !== 'function') {
+        throw new Error("Экспорт createServer не найден");
+      }
+      
+      console.log("Сервер скомпилирован, перезапуск...");
+      await startServer();
+    } catch (error) {
+      console.error("Ошибка при загрузке серверного модуля:", error);
+    }
+  });
+
   const clientDevMiddleware = devMiddleware(clientCompiler, {
     publicPath: clientConfig.output.publicPath,
     serverSideRender: true,
@@ -128,11 +144,6 @@ module.exports = function createSsrDevServer(projectRoot, { clientConfig, server
     },
   });
 
-  // const clientHotMiddleware = hotMiddleware(clientCompiler, {
-  //   heartbeat: 5000,
-  //   log: false,
-  // });
-
   const port = process.env.PORT || 8080;
 
   // Function to start the server
@@ -141,20 +152,24 @@ module.exports = function createSsrDevServer(projectRoot, { clientConfig, server
       serverInstance.close();
     }
 
-    const { createServer } = createServerPath;
+     // Проверяем, что серверный модуль загружен
+    if (!serverModule) {
+      console.error("Серверный модуль еще не скомпилирован");
+      return;
+    }
 
-    let { app, server, env } = await createServer();
+
+    let { app, server, env } = await serverModule.createServer();
 
     app.use(clientDevMiddleware);
-    // app.use(clientHotMiddleware);
 
     // SSR client-side compilation
     if (!rendererInstance) {
       rendererInstance = createDevRenderer(() => {
         clientCompiler.hooks.done.tap("reload", () => {
           setTimeout(() => {
-            // HMR reload logic (adjust if using rspack-hot-middleware)
-            // require("webpack-hot-middleware/client")?.reload();
+            // const client = await import("webpack-hot-middleware/client");
+            // client?.reload();
           }, 500);
         });
       });
@@ -187,16 +202,5 @@ module.exports = function createSsrDevServer(projectRoot, { clientConfig, server
     }
   };
 
-  // Watch for server changes
-  // serverCompiler.watch({}, async (err, stats) => {
-  //   if (err) {
-  //     console.error(err);
-  //     return;
-  //   }
-  //   console.log(stats.toString(serverConfig.stats));
-  //   console.log("Server.js has changed, updating...");
-  //   await startServer();
-  // });
-
   return startServer;
-};
+}

package/src/builder/modes/ssr.vite.dev.js

@@ -1,33 +1,26 @@
-const path = require("path");
-const { createServer: createViteServer } = require("vite");
-const compression = require('compression');
-const readline = require('readline');
-const fs = require('fs');
-
-const { createHtmlRenderer } = require("../ssr/ssr-render-html.js");
-
+import compression from 'compression';
+import fs from 'fs';
+import path from 'path';
+import { createServer as createViteServer } from 'vite';
+import { createHtmlRenderer } from '../ssr/ssr-render-html.js';
 // Цвета для консоли
 const colors = {
-  reset: "\x1b[0m",
-  green: "\x1b[32m",
-  greenBright: "\x1b[92;1m",
-  blue: "\x1b[34m",
-  blueBright: "\x1b[94m",
-  yellow: "\x1b[33m",
-  red: "\x1b[31m"
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  greenBright: '\x1b[92;1m',
+  blue: '\x1b[34m',
+  blueBright: '\x1b[94m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
 };
-
-module.exports = function createSsrDevServer(projectRoot, { clientConfig, serverConfig, ssrConfig, createServerPath }) {
+export default (function createSsrDevServer(projectRoot, { clientConfig, apiConfig, ssrConfig, createServer }) {
   let serverInstance;
   let viteDevServer;
   let rendererInstance;
-  
   const port = process.env.PORT || 8080;
-
   // Создаем рендерер для SSR
-  const createDevRenderer = (onUpdate) => {
+  const createDevRenderer = onUpdate => {
     const renderHtml = createHtmlRenderer(onUpdate);
-    
     return async (stuff, vite) => {
       // Динамически импортируем входную точку SSR
       let ssrEntry;
@@ -35,60 +28,51 @@ module.exports = function createSsrDevServer(projectRoot, { clientConfig, server
         // Используем Vite для трансформации и загрузки SSR-скрипта
         ssrEntry = await vite.ssrLoadModule(ssrConfig.entry);
       } catch (error) {
-        console.error(colors.red + "SSR compilation error" + colors.reset);
+        console.error(colors.red + 'SSR compilation error' + colors.reset);
         console.error(error);
-        return { 
-          html: `<pre>${error.stack}</pre>`, 
-          statusCode: 500 
+        return {
+          html: `<pre>${error.stack}</pre>`,
+          statusCode: 500,
         };
       }
-      
       // Рендерим приложение с помощью SSR
       try {
         const { html, meta, state, statusCode } = await ssrEntry.render(stuff);
-        
         // Получаем скрипты и стили клиентской части для вставки в HTML
         const headTags = [];
         const bodyTags = [];
-        
         // Добавляем основной скрипт клиентской части
         bodyTags.push(`<script type="module" src="/@vite/client"></script>`);
         bodyTags.push(`<script type="module" src="${clientConfig.entry}"></script>`);
-        
         const initialState = JSON.stringify(state);
-        
         // Рендерим финальный HTML
         const completeHtml = await renderHtml({
           appHtml: html,
           meta,
-          head: headTags.join("\n"),
-          body: bodyTags.join("\n"),
-          initialState
+          head: headTags.join('\n'),
+          body: bodyTags.join('\n'),
+          initialState,
         });
-        
         return { html: completeHtml, statusCode };
       } catch (error) {
-        console.error(colors.red + "Render error" + colors.reset);
+        console.error(colors.red + 'Render error' + colors.reset);
         console.error(error.stack);
-        return { 
-          html: `<pre>${error.stack}</pre>`, 
-          statusCode: 500 
+        return {
+          html: `<pre>${error.stack}</pre>`,
+          statusCode: 500,
         };
       }
     };
   };
-
   // Функция для запуска сервера
   const startServer = async () => {
     if (serverInstance) {
       serverInstance.close();
     }
-    
     // Очистка кэша модулей
-    Object.keys(require.cache).forEach((id) => {
+    Object.keys(require.cache).forEach(id => {
       delete require.cache[id];
     });
-    
     try {
       // Создаем Vite Dev Server
       if (!viteDevServer) {
@@ -99,75 +83,65 @@ module.exports = function createSsrDevServer(projectRoot, { clientConfig, server
             hmr: true,
             watch: {
               usePolling: true,
-              interval: 100
-            }
+              interval: 100,
+            },
           },
           appType: 'custom',
           logLevel: 'info',
           // Используем настройки из клиентского конфига
-          ...clientConfig
+          ...clientConfig,
         });
       }
-      
       // Создаем рендерер, если его ещё нет
       if (!rendererInstance) {
         rendererInstance = createDevRenderer(() => {
-          console.log(colors.green + "Client updated, triggering reload..." + colors.reset);
+          console.log(colors.green + 'Client updated, triggering reload...' + colors.reset);
         });
       }
-      
-      // Импортируем и создаем сервер приложения
-      const { createServer } = require(createServerPath);
       let { app, server, env } = await createServer();
-      
       // Применяем Vite middleware
       app.use(viteDevServer.middlewares);
-      
       // Middleware для SSR
-      app.use("/*", async (req, res) => {
+      app.use('/*', async (req, res) => {
         try {
-          const result = await rendererInstance({
-            url: req.originalUrl,
-            cookies: req.cookies,
-            languages: req.acceptsLanguages()
-          }, viteDevServer);
-          
-          res.status(result.statusCode).header("Content-Type", "text/html; charset=utf-8").send(result.html);
+          const result = await rendererInstance(
+            {
+              url: req.originalUrl,
+              cookies: req.cookies,
+              languages: req.acceptsLanguages(),
+            },
+            viteDevServer
+          );
+          res.status(result.statusCode).header('Content-Type', 'text/html; charset=utf-8').send(result.html);
         } catch (error) {
-          console.error(colors.red + "SSR middleware error" + colors.reset);
+          console.error(colors.red + 'SSR middleware error' + colors.reset);
           console.error(error);
           viteDevServer.ssrFixStacktrace(error);
           res.status(500).send(`<pre>${error.stack}</pre>`);
         }
       });
-      
       app.use(compression());
-      
       serverInstance = server;
-      
       await server.listen(port);
       console.log(`${colors.greenBright}Server started at localhost:${port}${colors.reset}\n`);
-      
       // Настройка наблюдения за изменениями серверных файлов
-      const watcher = fs.watch(path.dirname(createServerPath), { recursive: true });
+      const watcher = fs.watch(path.dirname(createServer), { recursive: true });
       watcher.on('change', async (eventType, filename) => {
         if (filename && filename.endsWith('.js')) {
           console.log(`${colors.blue}Server file changed: ${filename}, updating...${colors.reset}`);
           try {
             await startServer();
           } catch (err) {
-            console.error(colors.red + "Server restart failed" + colors.reset);
+            console.error(colors.red + 'Server restart failed' + colors.reset);
             console.error(err);
           }
         }
       });
-      
     } catch (err) {
-      console.error(colors.red + "Server start failed" + colors.reset);
+      console.error(colors.red + 'Server start failed' + colors.reset);
       console.error(err);
       process.exit(1);
     }
   };
-  
   return startServer;
-};
+});

package/src/builder/rspack/index.js

@@ -1,13 +1,15 @@
-const baseConfig = require('./rspack.config.base');
-const clientConfig = require('./rspack.config.client');
-const serverConfig = require('./rspack.config.server');
-const spaConfig = require('./rspack.config.spa');
-const ssrConfig = require('./rspack.config.ssr');
+import baseConfig from './rspack.config.base.js';
 
-module.exports = {
+import clientConfig from './rspack.config.ssr.client.js';
+import ssrConfig from './rspack.config.ssr.server.js';
+import spaConfig from './rspack.config.spa.client.js';
+
+import apiConfig from './rspack.config.api.js';
+
+export default {
   baseConfig,
   clientConfig,
-  serverConfig,
+  apiConfig,
   spaConfig,
   ssrConfig,
-};
+};

package/src/builder/rspack/rspack.config.api.js

@@ -0,0 +1,59 @@
+import core from '@rspack/core';
+import path from 'path';
+import nodeExternals from 'webpack-node-externals';
+const { rspack } = core;
+
+export default projectRoot => {
+  return {
+    target: 'node',
+    mode: 'development',
+    entry: [path.resolve(projectRoot, 'src/server.js')],
+    output: {
+      filename: 'server.js',
+      path: path.resolve(projectRoot, 'builds/web/server'),
+      libraryTarget: 'module',
+      chunkFormat: 'module', 
+      module: true,
+      clean: true,
+    },
+    experiments: {
+      outputModule: true,
+    },
+    resolve: {
+      alias: {
+        '@martyrs': path.resolve(projectRoot, 'martyrs'),
+      },
+      fallback: {
+        path: false,
+      },
+    },
+    // Добавляем externals для node_modules
+    externals: [
+      nodeExternals({
+        // Явно указываем, чтобы uWebSockets.js был внешним модулем
+        allowlist: [] // Пустой список означает, что все модули будут внешними
+      }),
+      // Исключаем все .node файлы
+      function({ context, request }, callback) {
+        if (/\.node$/.test(request)) {
+          return callback(null, `commonjs ${request}`);
+        }
+        callback();
+      }
+    ],
+    plugins: [
+      // new rspack.HotModuleReplacementPlugin()
+    ],
+    // Добавляем правило, чтобы .node файлы не обрабатывались
+    module: {
+      rules: [
+        {
+          test: /\.node$/,
+          loader: 'node-loader',
+          // или просто исключаем их:
+          // use: 'null-loader', 
+        }
+      ]
+    }
+  };
+};

package/src/builder/rspack/rspack.config.base.js

@@ -1,14 +1,12 @@
-const path = require("path");
-const { rspack } = require('@rspack/core');
-const { VueLoaderPlugin } = require("vue-loader");
-const { CleanWebpackPlugin } = require("clean-webpack-plugin");
-const { RsdoctorRspackPlugin } = require('@rsdoctor/rspack-plugin');
+import path from "path";
+import { rspack } from '@rspack/core';
+import { VueLoaderPlugin } from "vue-loader";
+import { CleanWebpackPlugin } from "clean-webpack-plugin";
+import { RsdoctorRspackPlugin } from '@rsdoctor/rspack-plugin';
+import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer';
+import Dotenv from 'dotenv-webpack';
 
-const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
-
-const Dotenv = require('dotenv-webpack');
-
-module.exports = (projectRoot) => {
+export default (projectRoot) => {
   return {
     context: projectRoot,
     resolve: {
@@ -44,6 +42,26 @@ module.exports = (projectRoot) => {
           loader: 'vue-loader',
           options: {
             experimentalInlineMatchResource: true,
+            preprocessOptions: {
+              template: {
+                preprocess: (content, { filename }) => {
+                  const rewritten = content
+                    .replace(
+                      /<(\w+)\s+v-slot(:[\w\-]+)?=("|'){([^"'}]+)}("|')\s*>/g,
+                      (_match, tag, slotName, _q1, slotProps, _q2) => {
+                        const slotAttr = slotName || '';
+                        return `<template v-slot${slotAttr}="{${slotProps}}"><${tag}>`;
+                      }
+                    )
+                    .replace(
+                      /<\/(\w+)>\s*<!--\s*v-slot-close\s*-->/g,
+                      (_match, tag) => `</${tag}></template>`
+                    );
+
+                  return { code: rewritten };
+                }
+              }
+            }
           },
         },
         {
@@ -75,7 +93,6 @@ module.exports = (projectRoot) => {
           ],
           type: 'javascript/auto'
         },
-
         {
           test: /\.(?:ico|gif|png|jpg|jpeg|mp4|webp|webm|svg|woff2?|eot|ttf|otf)$/i,
           type: "asset/resource",

package/src/builder/rspack/{rspack.config.spa.js → rspack.config.spa.client.js}

@@ -1,28 +1,27 @@
-const path = require("path");
-const { rspack } = require('@rspack/core');
-const { VueLoaderPlugin } = require("vue-loader");
-const { StatsWriterPlugin } = require("webpack-stats-plugin");
-const { merge } = require("webpack-merge"); 
-const Mustache = require("mustache");
-const fs = require('fs').promises;
-
-const getClientConfig = require("./rspack.config.client");
-
-const isProd = process.env.NODE_ENV === "production";
-
-module.exports = (projectRoot) => {
+import core from '@rspack/core';
+import { promises } from 'fs';
+import Mustache from 'mustache';
+import path from 'path';
+import { merge } from 'webpack-merge';
+import { StatsWriterPlugin } from 'webpack-stats-plugin';
+import template from '../templates/page.js';
+import getClientConfig from './rspack.config.ssr.client.js';
+const { rspack } = core;
+const fs = { promises }.promises;
+const isProd = process.env.NODE_ENV === 'production';
+export default projectRoot => {
   const spaConfig = {
-    mode: !isProd ? "development" : "production",
-    devtool: "source-map",
+    mode: !isProd ? 'development' : 'production',
+    devtool: 'source-map',
     entry: {
-      main: path.resolve(projectRoot, "src/client.js"),
+      main: path.resolve(projectRoot, 'src/client.js'),
     },
     output: {
-      filename: "main.js",
-      path: path.resolve(projectRoot, "builds/web/spa"),
-      clean: true
+      filename: 'main.js',
+      path: path.resolve(projectRoot, 'builds/web/spa'),
+      clean: true,
     },
-    target: "web",
+    target: 'web',
     plugins: [
       // ...(!isProd ? [new rspack.HotModuleReplacementPlugin()] : []),
       new StatsWriterPlugin(),
@@ -31,8 +30,6 @@ module.exports = (projectRoot) => {
       }),
       new rspack.HtmlRspackPlugin({
         templateContent: async () => {
-          const template = require("../templates/page.js");
-
           const meta = {
             htmlAttrs: 'lang="en"',
             headAttrs: '',
@@ -45,7 +42,6 @@ module.exports = (projectRoot) => {
             googleMapApiKey: process.env.GOOGLE_MAPS_API_KEY,
             meta,
           };
-          
           return Mustache.render(template, data);
         },
         filename: 'index.html',
@@ -61,9 +57,8 @@ module.exports = (projectRoot) => {
       // new ServiceWorkerPlugin()
     ],
     optimization: {
-      minimizer: [new rspack.SwcJsMinimizerRspackPlugin(),, new rspack.LightningCssMinimizerRspackPlugin()],
+      minimizer: [new rspack.SwcJsMinimizerRspackPlugin(), , new rspack.LightningCssMinimizerRspackPlugin()],
     },
   };
-
   return merge(getClientConfig(projectRoot), spaConfig);
-};
+};