underpost 2.7.7 → 2.7.9

package/src/client/ssr/pages/offline.js

@@ -0,0 +1,21 @@
+import { htmls, loggerFactory } from '../common/SsrCore.js';
+import { Alert } from '../common/Alert.js';
+import { Translate } from '../common/Translate.js';
+import { Worker } from '../common/Worker.js';
+/*imports*/
+
+const logger = loggerFactory({ url: location.toString() });
+
+window.onload = () =>
+  Worker.instance({
+    render: async () => {
+      window.ononline = async () => {
+        location.href = location.pathname.split('/')[1] ? `/${location.pathname.split('/')[1].split('.')[0]}` : '/';
+      };
+      window.onoffline = async () => {
+        htmls(`.page-render`, html`${await Alert.noInternet({ Translate })}`);
+      };
+      if (navigator.onLine && !location.hostname.match('localhost')) window.ononline();
+      else window.onoffline();
+    },
+  });

package/src/client/sw/default.sw.js

@@ -37,6 +37,8 @@ even while offline, can asynchronously save files and many other things)
 
 const logger = loggerFactory(import.meta);
 
+const PROXY_PATH = '/';
+
 self.addEventListener('install', (event) => {
   // Activate right away
   self.skipWaiting();
@@ -179,15 +181,17 @@ self.addEventListener('fetch', (event) => {
           }
 
           logger.error('Fetch failed; returning offline page instead.', { error, path });
-
-          // const cache = await caches.open(CACHE_NAME);
-          // const cachedResponse = await cache.match(OFFLINE_URL);
-          // return cachedResponse;
-
-          const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
-          // response.status = 200;
-          response.headers.set('Content-Type', 'application/json');
-          return response;
+          try {
+            const cache = await caches.open(`${PROXY_PATH}offline.html`);
+            const cachedResponse = await cache.match(`${PROXY_PATH}offline.html`);
+            return cachedResponse;
+          } catch (error) {
+            logger.error('Error opening cache for offline page', { error, path });
+            const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
+            // response.status = 200;
+            response.headers.set('Content-Type', 'application/json');
+            return response;
+          }
         }
       })(),
     );

package/src/db/DataBaseProvider.js

@@ -18,7 +18,18 @@ const DataBaseProvider = {
         case 'mongoose':
           {
             const conn = await MongooseDB.connect(db.host, db.name);
-            this.instance[`${host}${path}`][db.provider] = await MongooseDB.loadModels({ conn, apis });
+            this.instance[`${host}${path}`][db.provider] = {
+              models: await MongooseDB.loadModels({ conn, apis }),
+              connection: conn,
+              close: async () => {
+                return await new Promise((resolve) => {
+                  DataBaseProvider.instance[`${host}${path}`][db.provider].connection.close().then(() => {
+                    // logger.info('Mongoose connection is disconnected', db);
+                    return resolve();
+                  });
+                });
+              },
+            };
           }
           break;
         default:

package/src/db/mongo/MongooseDB.js

@@ -1,5 +1,4 @@
 import mongoose from 'mongoose';
-import cron from 'node-cron';
 import { loggerFactory } from '../../server/logger.js';
 import { getCapVariableName } from '../../client/components/core/CommonJs.js';
 import { shellCd, shellExec } from '../../server/process.js';

package/src/mailer/EmailRender.js

@@ -59,7 +59,7 @@ const EmailRender = {
     for (const templateKey of Object.keys(options.templates)) {
       const ssrEmailComponent = options.templates[templateKey];
       let SrrComponent;
-      eval(await srcFormatted(fs.readFileSync(`./src/client/ssr/email-components/${ssrEmailComponent}.js`, 'utf8')));
+      eval(await srcFormatted(fs.readFileSync(`./src/client/ssr/components/email/${ssrEmailComponent}.js`, 'utf8')));
       templates[templateKey] = SrrComponent(this, options);
     }
     return templates;

package/src/server/backup.js

@@ -9,100 +9,112 @@ dotenv.config();
 const logger = loggerFactory(import.meta);
 
 const BackUpManagement = {
-  repoUrl: `https://${process.env.GITHUB_BACKUP_TOKEN}@github.com/${process.env.GITHUB_BACKUP_USERNAME}/${process.env.GITHUB_BACKUP_REPO}.git`,
-  Init: async function () {
-    await this.Callback();
-    return this.Callback;
-  },
-  Callback: async function () {
-    const privateCronConfPath = `./engine-private/conf/${process.argv[2]}/conf.cron.json`;
+  repoUrl: `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_BACKUP_REPO}.git`,
+  Init: async function ({ deployId }) {
+    const Callback = async function () {
+      const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
 
-    const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+      const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
 
-    const { backups } = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
+      const { backups } = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
 
-    if (!backups) return;
+      if (!backups) return;
 
-    const currentDate = new Date().getTime();
+      logger.info('init backups callback');
+      await logger.setUpInfo();
 
-    if (!fs.existsSync('./engine-private/cron-backups'))
-      fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
+      const currentDate = new Date().getTime();
 
-    for (const deployGroupData of backups) {
-      const { deployGroupId } = deployGroupData;
-      const dataDeploy = getDataDeploy({ deployGroupId });
+      if (!fs.existsSync('./engine-private/cron-backups'))
+        fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
 
-      for (const deployObj of dataDeploy) {
-        const { deployId, replicaHost } = deployObj;
+      for (const deployGroupData of backups) {
+        const { deployGroupId } = deployGroupData;
+        const dataDeploy = getDataDeploy({ deployGroupId });
 
-        if (replicaHost) continue;
+        for (const deployObj of dataDeploy) {
+          const { deployId, replicaHost } = deployObj;
 
-        const confServer = JSON.parse(
-          fs.existsSync(`./engine-private/replica/${deployId}/conf.server.json`)
-            ? fs.readFileSync(`./engine-private/replica/${deployId}/conf.server.json`, 'utf8')
-            : fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'),
-        );
+          if (replicaHost) continue;
 
-        for (const host of Object.keys(confServer))
-          for (const path of Object.keys(confServer[host])) {
-            // retention policy
-            let { db, backupFrequency, maxBackupRetention, singleReplica, wp, git, directory } = confServer[host][path];
+          const confServer = JSON.parse(
+            fs.existsSync(`./engine-private/replica/${deployId}/conf.server.json`)
+              ? fs.readFileSync(`./engine-private/replica/${deployId}/conf.server.json`, 'utf8')
+              : fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'),
+          );
 
-            if (!db || singleReplica) continue;
+          for (const host of Object.keys(confServer))
+            for (const path of Object.keys(confServer[host])) {
+              // retention policy
+              let { db, backupFrequency, maxBackupRetention, singleReplica, wp, git, directory } =
+                confServer[host][path];
 
-            if (!backupFrequency) backupFrequency = 'daily';
-            if (!maxBackupRetention) maxBackupRetention = 5;
+              if (!db || singleReplica) continue;
 
-            const backUpPath = `${process.cwd()}/engine-private/cron-backups/${getCronBackUpFolder(host, path)}`;
-            if (!fs.existsSync(backUpPath)) fs.mkdirSync(`${backUpPath}`, { recursive: true });
-            // .isDirectory()
-            const files = await fs.readdir(backUpPath, { withFileTypes: true });
+              if (!backupFrequency) backupFrequency = 'daily';
+              if (!maxBackupRetention) maxBackupRetention = 5;
 
-            const currentBackupsDirs = files
-              .map((fileObj) => parseInt(fileObj.name))
-              .sort((a, b) => a - b)
-              .reverse();
+              const backUpPath = `${process.cwd()}/engine-private/cron-backups/${getCronBackUpFolder(host, path)}`;
+              if (!fs.existsSync(backUpPath)) fs.mkdirSync(`${backUpPath}`, { recursive: true });
+              // .isDirectory()
+              const files = await fs.readdir(backUpPath, { withFileTypes: true });
 
-            switch (backupFrequency) {
-              case 'daily':
+              const currentBackupsDirs = files
+                .map((fileObj) => parseInt(fileObj.name))
+                .sort((a, b) => a - b)
+                .reverse();
 
-              default:
-                // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
-                break;
-            }
+              switch (backupFrequency) {
+                case 'daily':
 
-            for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
-              const removePathRetention = `${backUpPath}/${retentionPath}`;
-              logger.info('Remove backup folder', removePathRetention);
-              fs.removeSync(removePathRetention);
-            }
+                default:
+                  // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
+                  break;
+              }
+
+              for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
+                const removePathRetention = `${backUpPath}/${retentionPath}`;
+                logger.info('Remove backup folder', removePathRetention);
+                fs.removeSync(removePathRetention);
+              }
 
-            fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
+              fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
 
-            shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
+              shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
 
-            if (wp) {
-              const repoUrl = `https://${process.env.GITHUB_BACKUP_TOKEN}@github.com/${
-                process.env.GITHUB_BACKUP_USERNAME
-              }/${git.split('/').pop()}.git`;
+              if (wp) {
+                const repoUrl = `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${git
+                  .split('/')
+                  .pop()}.git`;
 
-              shellExec(
-                `cd ${directory}` +
-                  ` && git pull ${repoUrl}` +
-                  ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-                  ` && git push ${repoUrl}`,
-              );
+                shellExec(
+                  `cd ${directory}` +
+                    ` && git pull ${repoUrl}` +
+                    ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
+                    ` && git push ${repoUrl}`,
+                  {
+                    disableLog: true,
+                  },
+                );
+              }
             }
-          }
+        }
       }
-    }
-    shellExec(
-      `cd ./engine-private/cron-backups` +
-        ` && git pull ${BackUpManagement.repoUrl}` +
-        ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-        ` && git push ${BackUpManagement.repoUrl}`,
-    );
+      shellExec(
+        `cd ./engine-private/cron-backups` +
+          ` && git pull ${BackUpManagement.repoUrl}` +
+          ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
+          ` && git push ${BackUpManagement.repoUrl}`,
+        {
+          disableLog: true,
+        },
+      );
+    };
+    await Callback();
+    BackUpManagement.Callback = Callback;
+    return Callback;
   },
+  Callback: async function (params) {},
 };
 
 export { BackUpManagement };

package/src/server/client-build-live.js

@@ -71,6 +71,12 @@ const clientLiveBuild = async () => {
       } else if (srcPath.split('src')[1].startsWith(`\\client\\sw`)) {
         const publicBuildPath = `./public/${baseHost}/sw.js`;
         liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+      } else if (
+        srcPath.split('src')[1].startsWith(`\\client\\offline`) &&
+        srcPath.split('src')[1].startsWith(`index.js`)
+      ) {
+        const publicBuildPath = `./public/${baseHost}/offline.js`;
+        liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
       } else if (srcPath.split('src')[1].startsWith(`\\client`) && srcPath.slice(-9) === '.index.js') {
         for (const view of views) {
           const publicBuildPath = `./public/${baseHost}${view.path === '/' ? '' : view.path}/${clientId}.index.js`;

package/src/server/client-build.js

@@ -1,7 +1,7 @@
 'use strict';
 
 import fs from 'fs-extra';
-import { srcFormatted, componentFormatted, viewFormatted } from './client-formatted.js';
+import { srcFormatted, componentFormatted, viewFormatted, ssrFactory } from './client-formatted.js';
 import { loggerFactory } from './logger.js';
 import { cap, newInstance, orderArrayFromAttrInt, titleFormatted } from '../client/components/core/CommonJs.js';
 import UglifyJS from 'uglify-js';
@@ -52,7 +52,7 @@ const fullBuild = async ({
       if (!fs.existsSync(defaultBaseIconPath))
         await buildTextImg(metadata.title, { debugFilename: defaultBaseIconPath });
 
-      if (path === '/' && !fs.existsSync(`./src/client/public/${publicClientId}/site.webmanifest`))
+      if (!fs.existsSync(`./src/client/public/${publicClientId}/site.webmanifest`))
         await buildIcons({ publicClientId, metadata });
     }
     fs.copySync(
@@ -112,6 +112,16 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
   const enableLiveRebuild =
     options && options.liveClientBuildPaths && options.liveClientBuildPaths.length > 0 ? true : false;
 
+  // common ssr components
+  let jsSsrCommonComponents = '';
+  {
+    const files = await fs.readdir(`./src/client/ssr/common`);
+    for (const relativePath of files)
+      jsSsrCommonComponents += await srcFormatted(
+        fs.readFileSync(`./src/client/ssr/common/${relativePath}`, 'utf8').split('export')[0],
+      );
+  }
+
   let currentPort = parseInt(process.env.PORT) + 1;
   for (const host of Object.keys(confServer)) {
     const paths = orderArrayFromAttrInt(Object.keys(confServer[host]), 'length', 'asc');
@@ -178,7 +188,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
           iconsBuild,
           metadata,
         });
-        if (apis)
+        if (apis && false)
           for (const apiBuildScript of apis) {
             const scriptPath = `src/api/${apiBuildScript}/${apiBuildScript}.build.js`;
             if (fs.existsSync(`./${scriptPath}`)) {
@@ -238,8 +248,13 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                   'const getBaseHost = () => location.host;',
                   `const getBaseHost = () => '${apiBaseHost}';`,
                 );
-              if (apiBaseProxyPath)
+              if (apiBaseProxyPath) {
                 jsSrc = jsSrc.replace('${getProxyPath()}api/', `${apiBaseProxyPath}${process.env.BASE_API}/`);
+                jsSrc = jsSrc.replace(
+                  "const getWsBasePath = () => (getProxyPath() !== '/' ? `${getProxyPath()}socket.io/` : undefined);",
+                  `const getWsBasePath = () => '${apiBaseProxyPath}socket.io/';`,
+                );
+              }
             }
             fs.writeFileSync(
               jsPublicPath,
@@ -274,26 +289,61 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
 
       const buildId = `${client}.index`;
       const siteMapLinks = [];
+      let Render = () => '';
+      eval(await srcFormatted(fs.readFileSync(`./src/client/ssr/Render.js`, 'utf8')));
 
       if (views) {
-        // build service worker
-        if (path === '/') {
-          const jsSrcPath = fs.existsSync(`./src/client/sw/${publicClientId}.sw.js`)
-            ? `./src/client/sw/${publicClientId}.sw.js`
-            : `./src/client/sw/default.sw.js`;
-
-          const jsPublicPath = `${rootClientPath}/sw.js`;
-
+        const buildJsSrcPage = async (jsSrcPath, jsPublicPath, filter) => {
           if (!(enableLiveRebuild && !options.liveClientBuildPaths.find((p) => p.srcBuildPath === jsSrcPath))) {
-            const jsSrc = viewFormatted(await srcFormatted(fs.readFileSync(jsSrcPath, 'utf8')), dists, path, baseHost);
-
+            let jsSrc = viewFormatted(await srcFormatted(fs.readFileSync(jsSrcPath, 'utf8')), dists, path, baseHost);
+            if (jsSrc.split('/*imports*/')[1]) jsSrc = jsSrc.split('/*imports*/')[1];
+            if (filter) jsSrc = await filter(jsSrc);
             fs.writeFileSync(
               jsPublicPath,
               minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
               'utf8',
             );
           }
+        };
+
+        // service woker
+        await buildJsSrcPage(
+          fs.existsSync(`./src/client/sw/${publicClientId}.sw.js`)
+            ? `./src/client/sw/${publicClientId}.sw.js`
+            : `./src/client/sw/default.sw.js`,
+          `${rootClientPath}/sw.js`,
+          path !== '/'
+            ? (jsSrc) => jsSrc.replaceAll(`const PROXY_PATH = '/';`, `const PROXY_PATH = '${path}/';`)
+            : undefined,
+        );
+
+        // ssr pages
+        for (const page of await fs.readdir('./src/client/ssr/pages')) {
+          await buildJsSrcPage(`./src/client/ssr/pages/${page}`, `${rootClientPath}/${page}`);
+
+          const htmlSrc = Render({
+            title: metadata?.title ? metadata.title : cap(client),
+            ssrPath: '/',
+            ssrHeadComponents: '',
+            ssrBodyComponents: '',
+            baseSsrLib: jsSsrCommonComponents + fs.readFileSync(`${rootClientPath}/${page}`, 'utf8'),
+          });
+
+          fs.writeFileSync(
+            `${rootClientPath}/${page.slice(0, -3)}.html`,
+            minifyBuild || process.env.NODE_ENV === 'production'
+              ? await minify(htmlSrc, {
+                  minifyCSS: true,
+                  minifyJS: true,
+                  collapseBooleanAttributes: true,
+                  collapseInlineTagWhitespace: true,
+                  collapseWhitespace: true,
+                })
+              : htmlSrc,
+            'utf8',
+          );
         }
+
         if (
           !(
             enableLiveRebuild &&
@@ -345,11 +395,9 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                 confSSR[view.ssr].head.unshift('Production');
 
               for (const ssrHeadComponent of confSSR[view.ssr].head) {
-                let SrrComponent;
-                eval(
-                  await srcFormatted(
-                    fs.readFileSync(`./src/client/ssr/head-components/${ssrHeadComponent}.js`, 'utf8'),
-                  ),
+                const SrrComponent = await ssrFactory(
+                  `./src/client/ssr/components/head/${ssrHeadComponent}.js`,
+                  jsSsrCommonComponents,
                 );
 
                 switch (ssrHeadComponent) {
@@ -359,7 +407,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                       fs.existsSync(`./src/client/public/${publicClientId}/browserconfig.xml`) &&
                       fs.existsSync(`./src/client/public/${publicClientId}/site.webmanifest`);
 
-                    if (view.path === '/' && validPwaBuild) {
+                    if (validPwaBuild) {
                       // build webmanifest
                       const webmanifestJson = JSON.parse(
                         fs.readFileSync(`./src/client/public/${publicClientId}/site.webmanifest`, 'utf8'),
@@ -431,11 +479,9 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
               }
 
               for (const ssrBodyComponent of confSSR[view.ssr].body) {
-                let SrrComponent;
-                eval(
-                  await srcFormatted(
-                    fs.readFileSync(`./src/client/ssr/body-components/${ssrBodyComponent}.js`, 'utf8'),
-                  ),
+                const SrrComponent = await ssrFactory(
+                  `./src/client/ssr/components/body/${ssrBodyComponent}.js`,
+                  jsSsrCommonComponents,
                 );
                 switch (ssrBodyComponent) {
                   case 'UnderpostDefaultSplashScreen':
@@ -448,7 +494,10 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                           .readFileSync(backgroundImage)
                           .toString('base64')}`,
                       });
+                      break;
                     } else {
+                      ssrHeadComponents += SrrComponent({ metadata });
+                      break;
                       const bufferBackgroundImage = await getBufferPngText({
                         text: ' ',
                         textColor: metadata?.themeColor ? metadata.themeColor : '#ececec',
@@ -459,7 +508,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                         base64BackgroundImage: `data:image/png;base64,${bufferBackgroundImage.toString('base64')}`,
                       });
                     }
-                    break;
 
                   case 'CyberiaSplashScreenLore': {
                     ssrBodyComponents += SrrComponent({
@@ -467,48 +515,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                       host,
                       path,
                       ttiLoadTimeLimit,
-                      storage: {
-                        // 'space-background': fs.readFileSync('./src/client/public/cyberia/space-background', 'utf8'),
-                        lore0: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore0.jpeg')
-                          .toString('base64')}`,
-                        lore1: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore1.jpeg')
-                          .toString('base64')}`,
-                        lore2: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore2.jpeg')
-                          .toString('base64')}`,
-                        lore3: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore3.jpeg')
-                          .toString('base64')}`,
-                        lore4: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore4.jpeg')
-                          .toString('base64')}`,
-                        lore5: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore5.jpeg')
-                          .toString('base64')}`,
-                        lore6: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore6.jpeg')
-                          .toString('base64')}`,
-                        lore7: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore7.jpeg')
-                          .toString('base64')}`,
-                        lore8: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore8.jpeg')
-                          .toString('base64')}`,
-                        ['arrow-left']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/ui-icons/arrow-left.png')
-                          .toString('base64')}`,
-                        ['arrow-right']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/ui-icons/arrow-right.png')
-                          .toString('base64')}`,
-                        ['fullscreen']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/ui-icons/fullscreen.png')
-                          .toString('base64')}`,
-                        ['cyberia-logo']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/util/cyberia-retro-banner.png')
-                          .toString('base64')}`,
-                      },
                     });
                     break;
                   }
@@ -519,16 +525,13 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                 }
               }
             }
-
-            let Render = () => '';
-            eval(await srcFormatted(fs.readFileSync(`./src/client/ssr/Render.js`, 'utf8')));
-
             const htmlSrc = Render({
               title,
               buildId,
               ssrPath,
               ssrHeadComponents,
               ssrBodyComponents,
+              baseSsrLib: jsSsrCommonComponents,
             });
 
             /** @type {import('sitemap').SitemapItem} */
@@ -616,7 +619,7 @@ Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
         fs.copySync(`./coverage`, coverageBuildPath);
 
         // uml
-        shellExec(`node bin/deploy uml ${host} ${path}`);
+        // shellExec(`node bin/deploy uml ${host} ${path}`);
 
         // https://swagger-autogen.github.io/docs/
 

package/src/server/client-formatted.js

@@ -1,5 +1,7 @@
 'use strict';
 
+import fs from 'fs-extra';
+
 const srcFormatted = (src) =>
   src
     .replaceAll(' html`', '`')
@@ -45,4 +47,12 @@ const viewFormatted = (src, dists, proxyPath, baseHost = '') => {
   return src.replaceAll(`from './`, componentFromFormatted).replaceAll(`from '../`, componentFromFormatted);
 };
 
-export { srcFormatted, JSONweb, componentFormatted, viewFormatted };
+const ssrFactory = async (componentPath = '', jsSsrCommonComponents) => {
+  let SrrComponent = () => {};
+  let render = await srcFormatted(fs.readFileSync(componentPath, 'utf8'));
+  if (render.split('/*imports*/')[1]) render = render.split('/*imports*/')[1];
+  eval(jsSsrCommonComponents + render);
+  return SrrComponent;
+};
+
+export { srcFormatted, JSONweb, componentFormatted, viewFormatted, ssrFactory };

package/src/server/client-icons.js

@@ -140,7 +140,7 @@ const buildIcons = async ({
     for (const file of response.files)
       fs.writeFileSync(`./src/client/public/${publicClientId}/${file.name}`, file.contents, 'utf8');
 
-    const ssrPath = `./src/client/ssr/head-components/Pwa${getCapVariableName(publicClientId)}.js`;
+    const ssrPath = `./src/client/ssr/components/head/Pwa${getCapVariableName(publicClientId)}.js`;
     if (!fs.existsSync(ssrPath))
       fs.writeFileSync(ssrPath, 'SrrComponent = () => html`' + response.html.join(`\n`) + '`;', 'utf8');
   } catch (error) {