@nutin/cli 1.3.1 → 2.0.0

package/templates/base/tools/builder/core/html-templates/merge-templates.js.hbs

@@ -0,0 +1,152 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getFilesRecursive, print, pascalCased, capitalized } from '../../../utils/index.js';
+import { PATHS } from '../app/paths.js';
+import { minifyHTML } from './minify-html.js';
+
+const PLACEHOLDER = '__TEMPLATE_PLACEHOLDER__';
+const TARGET_EXTENSIONS = ['.ts', '.js'];
+const TEMPLATE_REGEX = /const\s+(?:template|templateFn)\s*=?\s*(?:\(.*?\)\s*=>\s*)?`([\s\S]*?)`/;
+
+// A component/view's template can live inline in its .ts/.js file or in a
+// colocated .html sibling merged in via `__TEMPLATE_PLACEHOLDER__` — resolved
+// automatically per file rather than through a global config flag:
+//   external + placeholder -> merge external in
+//   external + real inline markup -> conflict, fail
+//   no external + real inline markup -> minify inline
+//   no external + still the placeholder -> nothing to use, fail
+export async function resolveTemplates() {
+  const htmlFiles = await getFilesRecursive(PATHS.tempApp, 'html');
+  const resolvedPaths = new Set();
+  const failures = [];
+
+  for (const htmlPath of htmlFiles) {
+    await resolveExternalTemplate(htmlPath, resolvedPaths, failures);
+  }
+
+  await resolveRemainingTemplates(resolvedPaths, failures);
+
+  if (failures.length) {
+    throw new Error(`Failed to resolve ${failures.length} template(s).`);
+  }
+}
+
+// Normally a view/component has exactly one sibling here — `.js` in dev (tsc
+// output), `.ts` in prod (esbuild bundles straight from source, tsc runs
+// --noEmit there). Checking whichever exist(s) rather than assuming one, so
+// this can't silently regress again if that dev/prod split ever changes.
+async function resolveExternalTemplate(htmlPath, resolvedPaths, failures) {
+  const htmlFilename = path.basename(htmlPath);
+
+  let htmlContent;
+  try {
+    htmlContent = await fs.readFile(htmlPath, 'utf-8');
+  } catch (err) {
+    print.warn(`Failed to read "${htmlFilename}". ${err.message}`);
+    failures.push(htmlFilename);
+    return;
+  }
+
+  const minifiedHtml = await minifyHTML(htmlContent);
+  let mergedCount = 0;
+  let conflictCount = 0;
+
+  for (const extension of TARGET_EXTENSIONS) {
+    const codePath = htmlPath.replace(/\.html$/, extension);
+
+    let content;
+    try {
+      content = await fs.readFile(codePath, 'utf-8');
+    } catch (err) {
+      if (err.code === 'ENOENT') continue;
+      print.warn(`Cannot update "${path.basename(codePath)}". ${err.message}`);
+      failures.push(path.basename(codePath));
+      resolvedPaths.add(codePath);
+      continue;
+    }
+
+    resolvedPaths.add(codePath);
+
+    if (content.includes(PLACEHOLDER)) {
+      await fs.writeFile(codePath, content.replace(PLACEHOLDER, minifiedHtml));
+      mergedCount++;
+      continue;
+    }
+
+    print.warn(describeConflict(codePath));
+    failures.push(path.basename(codePath));
+    conflictCount++;
+  }
+
+  if (mergedCount > 0) {
+    await fs.unlink(htmlPath);
+  } else if (mergedCount + conflictCount === 0) {
+    print.warn(describeOrphanHtml(htmlPath));
+    failures.push(htmlFilename);
+  }
+}
+
+async function resolveRemainingTemplates(resolvedPaths, failures) {
+  const codeFiles = await getFilesRecursive(PATHS.tempApp, TARGET_EXTENSIONS);
+
+  for (const codePath of codeFiles) {
+    if (resolvedPaths.has(codePath)) continue;
+
+    const content = await fs.readFile(codePath, 'utf-8');
+    const match = content.match(TEMPLATE_REGEX);
+    if (!match) continue;
+
+    const [full, body] = match;
+
+    if (body === PLACEHOLDER) {
+      print.warn(describeMissingTemplate(codePath));
+      failures.push(path.basename(codePath));
+      continue;
+    }
+
+    const minified = await minifyHTML(body);
+    await fs.writeFile(codePath, content.replace(full, full.replace(body, minified)));
+  }
+}
+
+function describeCodeFile(codePath) {
+  const filename = path.basename(codePath);
+  const basename = filename.replace(/\.(ts|js)$/, '');
+  const lastDot = basename.lastIndexOf('.');
+  const namePart = lastDot === -1 ? basename : basename.slice(0, lastDot);
+  const suffix = lastDot === -1 ? '' : basename.slice(lastDot + 1);
+  const kind = suffix ? capitalized(suffix) : 'Component';
+  const className = `${pascalCased(namePart)}${kind}`;
+
+  return { filename, basename, kind, className };
+}
+
+function describeConflict(codePath) {
+  const { filename, basename, kind, className } = describeCodeFile(codePath);
+
+  return `${kind} "${className}" has both an inline template and an external template.
+
+Use either:
+  ${filename}
+or:
+  ${filename} (template placeholder) + ${basename}.html
+Remove one of the template definitions.`;
+}
+
+function describeMissingTemplate(codePath) {
+  const { filename, basename, kind, className } = describeCodeFile(codePath);
+
+  return `${kind} "${className}" has a template placeholder but no external template.
+
+Expected:
+  ${filename} (template placeholder) + ${basename}.html
+Add ${basename}.html, or replace the placeholder in ${filename} with inline markup.`;
+}
+
+function describeOrphanHtml(htmlPath) {
+  const htmlFilename = path.basename(htmlPath);
+  const basename = htmlFilename.replace(/\.html$/, '');
+
+  return `"${htmlFilename}" has no matching component or view (expected ${basename}.ts or ${basename}.js).
+Remove ${htmlFilename}, or add ${basename}.ts with a template placeholder to merge it into.`;
+}

package/templates/base/tools/builder/core/html-templates/minify-html.js.hbs

@@ -0,0 +1,15 @@
+import { minify } from 'html-minifier-terser';
+
+export async function minifyHTML(html) {
+  return minify(html, {
+    collapseWhitespace: true,
+    removeComments: true,
+    removeRedundantAttributes: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    useShortDoctype: true,
+    keepClosingSlash: true,
+    minifyCSS: true,
+    minifyJS: true,
+  });
+}

package/templates/base/tools/builder/core/html-templates/process-html-templates.js.hbs

@@ -0,0 +1,8 @@
+import { errorExit } from '../../../utils/index.js';
+import { resolveTemplates } from './merge-templates.js';
+
+try {
+  await resolveTemplates();
+} catch (err) {
+  errorExit(err);
+}

package/templates/{features/i18n/tools/builder/core → base/tools/builder/core/i18n}/build-i18n.js.hbs

@@ -1,8 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { exit } from 'process';
-import { getFilesRecursive, print, isVerbose } from '../../utils/index.js';
-import { PATHS } from './paths.js';
+import { getFilesRecursive, print, errorExit } from '../../../utils/index.js';
+import { PATHS } from '../app/paths.js';
 
 const destDir = path.join(PATHS.tempSource, 'locales');
 
@@ -50,7 +49,7 @@ async function removeJsonFiles(directory) {
   try {
     await fs.promises.access(directory);
   } catch {
-    print.info(`Directory ${directory} does not exist, skipping cleanup`);
+    print.grayError(`Directory ${directory} does not exist, skipping cleanup`);
     return;
   }
   
@@ -60,19 +59,13 @@ async function removeJsonFiles(directory) {
     if (file.includes(`${path.sep}locales${path.sep}`)) {
       try {
         await fs.promises.unlink(file);
-        if (isVerbose) print.info(`Deleted locale JSON file: ${file}`);
       } catch (err) {
         print.error(`Failed to remove ${file}: ${err.message}`);
       }
-    } 
-    else if (isVerbose) {
-      print.info(`Skipping non-locale JSON file: ${file}`);
     }
   }
 
   await removeEmptyDirectories(directory);
-
-  if (isVerbose) print.boldInfo(`JSON files cleanup complete.`);
 }
 
 async function removeEmptyDirectories(directory) {
@@ -102,10 +95,9 @@ async function removeEmptyDirectories(directory) {
       const updatedItems = await fs.promises.readdir(directory);
       if (updatedItems.length === 0) {
         await fs.promises.rmdir(directory, { recursive: false });
-        if (isVerbose) print.info(`📁 Removed empty directory: ${directory}`);
       }
     } catch (err) {
-      print.error(`Failed to remove empty directory ${directory}: ${err.message}`);
+      print.grayError(`Failed to remove empty directory ${directory}: ${err.message}`);
     }
   }
 }
@@ -114,19 +106,16 @@ async function mergeJson() {
   if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
 
   const localeFilesMap = findLocaleFiles();
-
   for (const [locale, files] of Object.entries(localeFilesMap)) {
     const combined = combineJsonFiles(files);
     fs.writeFileSync(
       `${destDir}/${locale}.json`,
       JSON.stringify(combined, null, 2)
     );
-    if (isVerbose) print.boldInfo(`Json files for locale ${locale} merged successfully`);
   }
-  removeJsonFiles(PATHS.tempApp);
+  await removeJsonFiles(PATHS.tempApp);
 }
 
 mergeJson().catch((err) => {
-  print.boldError(`Unexpected error: ${err.message}`);
-  exit(1);
+  errorExit(err)
 });

package/templates/base/tools/builder/core/prod-bundle/compress-files.js.hbs

@@ -0,0 +1,37 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { gzipSync, brotliCompressSync, constants } from 'zlib';
+import { print, getFilesRecursive, errorExit } from '../../../utils/index.js';
+import { PATHS } from '../app/paths.js';
+
+function compressStaticAssets() {
+  const files = getFilesRecursive(
+    PATHS.tempSource,
+    ['.js', '.css', '.json', '.svg', '.ttf', '.otf', '.eot']
+  );
+  
+  for (const file of files) {
+    const content = readFileSync(file);
+
+    const gzipped = gzipSync(content, {
+      level: 9,
+      memLevel: 9,
+      windowBits: 15
+    });
+    writeFileSync(`${file}.gz`, gzipped);
+    
+    const brotlied = brotliCompressSync(content, {
+      params: {
+        [constants.BROTLI_PARAM_QUALITY]: 11,
+        [constants.BROTLI_PARAM_MODE]: constants.BROTLI_MODE_GENERIC,
+        [constants.BROTLI_PARAM_SIZE_HINT]: content.length
+      }
+    });
+    writeFileSync(`${file}.br`, brotlied);
+  };
+}
+
+try {
+  compressStaticAssets()
+} catch(err) {
+  errorExit(err, 'compress-files');
+}

package/templates/base/tools/builder/core/prod-bundle/esbuild.js.hbs

@@ -0,0 +1,30 @@
+import esbuild from 'esbuild';
+import path from 'path';
+import { print, errorExit } from '../../../utils/index.js';
+import { PATHS } from '../app/paths.js';
+import { builderConfig } from '../../builder.config.js';
+
+const ENTRY_FILE = path.join(PATHS.tempApp, 'main.ts');
+const OUT_FILE = path.join(PATHS.tempSource, 'bundle.js');
+
+async function build() {
+  await esbuild.build({
+    ...builderConfig.esbuild,
+    platform: 'browser',
+    format: 'esm',
+    legalComments: 'none',
+    loader: {
+      '.json': 'json',
+    },
+    define: {
+      'process.env.NODE_ENV': '"production"',
+    },
+    entryPoints: [ENTRY_FILE],
+    outfile: OUT_FILE,
+    keepNames: false,
+  });
+}
+
+build().catch((err) => {
+  errorExit(err, 'esbuild');
+});

package/templates/base/tools/builder/core/{hash-files.js.hbs → prod-bundle/hash-files.js.hbs}

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
-import { PATHS } from './paths.js';
-import { print, isVerbose, getFilesRecursive } from '../../utils/index.js';
+import { PATHS } from '../app/paths.js';
+import { print, getFilesRecursive, errorExit } from '../../../utils/index.js';
 
 function addHashToFiles(distDir) {
   const files = getFilesRecursive(distDir, ['.js', '.css']);
@@ -24,10 +24,6 @@ function addHashToFiles(distDir) {
     const newRel = path.relative(distDir, newPath).replace(/\\/g, '/');
 
     fileMap[oldRel] = newRel;
-
-    if (isVerbose) {
-      print.info(`Renamed: ${oldRel} → ${newRel}`);
-    }
   });
 
   updateHtmlReferences(path.join(distDir, 'index.html'), fileMap);
@@ -38,15 +34,22 @@ function hashFile(filePath) {
   return crypto.createHash('sha256').update(content).digest('hex').substring(0, 8);
 }
 
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 function updateHtmlReferences(htmlPath, fileMap) {
   let html = fs.readFileSync(htmlPath, 'utf8');
-  
+
   Object.entries(fileMap).forEach(([oldName, newName]) => {
-    html = html.replace(new RegExp(oldName, 'g'), newName);
+    html = html.replace(new RegExp(escapeRegExp(oldName), 'g'), newName);
   });
-  
+
   fs.writeFileSync(htmlPath, html);
-  if (isVerbose) print.info('Updated index.html references');
 }
 
-addHashToFiles(PATHS.tempSource);
+try {
+  addHashToFiles(PATHS.tempSource)
+} catch(err) {
+  errorExit(err, 'hash-files');
+}

package/templates/base/tools/builder/core/seo/generate-robots-txt.js.hbs

@@ -0,0 +1,51 @@
+import fs from 'fs';
+import path from 'path';
+import { PATHS } from '../app/paths.js';
+import { print } from '../../../utils/index.js';
+
+export function generateRobotsTxt() {
+  const seoConfigPath = path.join(PATHS.temp, 'config', 'seo.json');
+  const seoConfig = JSON.parse(fs.readFileSync(seoConfigPath, 'utf-8'));
+  const baseUrl = seoConfig.baseUrl.replace(/\/$/, '');
+  const routes = seoConfig.routes ?? [];
+  const disallowBots = seoConfig.disallowBots ?? [];
+
+  // Paths disallowed for all bots (disallow: true)
+  const globalDisallows = routes
+    .filter(r => r.disallow === true)
+    .map(r => `Disallow: ${r.path}`);
+
+  // Paths disallowed per named bot: { botName -> [path, ...] }
+  const perBotDisallows = {};
+  for (const r of routes) {
+    if (!Array.isArray(r.disallow)) continue;
+    for (const bot of r.disallow) {
+      (perBotDisallows[bot] ??= []).push(r.path);
+    }
+  }
+  // Bots that are fully blocked contribute an empty-path disallow
+  for (const bot of disallowBots) {
+    perBotDisallows[bot] ??= [];
+  }
+
+  const lines = [
+    'User-agent: *',
+    'Allow: /',
+    ...globalDisallows,
+  ];
+
+  for (const [bot, paths] of Object.entries(perBotDisallows)) {
+    lines.push('');
+    lines.push(`User-agent: ${bot}`);
+    if (paths.length > 0) {
+      for (const p of paths) lines.push(`Disallow: ${p}`);
+    } else {
+      lines.push('Disallow: /');
+    }
+  }
+
+  lines.push('', `Sitemap: ${baseUrl}/sitemap.xml`);
+
+  const outputPath = path.join(PATHS.tempSource, 'robots.txt');
+  fs.writeFileSync(outputPath, lines.join('\n') + '\n', 'utf-8');
+}

package/templates/base/tools/builder/core/seo/generate-seo-files.js.hbs

@@ -0,0 +1,16 @@
+import { print, errorExit } from '../../../utils/index.js';
+import { generateSeoHtml } from './generate-seo-html.js';
+import { generateRobotsTxt } from './generate-robots-txt.js';
+import { generateSitemapXml } from './generate-sitemap-xml.js';
+
+async function generateSeoFiles() {
+  await generateSeoHtml();
+  generateRobotsTxt();
+  generateSitemapXml();
+}
+
+try {
+  await generateSeoFiles();
+} catch (err) {
+  errorExit(err, 'generate-seo-files');
+}

package/templates/base/tools/builder/core/seo/generate-seo-html.js.hbs

@@ -0,0 +1,128 @@
+import fs from 'fs';
+import path from 'path';
+import { PATHS } from '../app/paths.js';
+import { print, errorExit } from '../../../utils/index.js';
+import { buildSsrBundle, cleanupSsrBundle } from './ssr/ssr-bundle.js';
+import { renderRoute } from './ssr/ssr-render.js';
+import { builderConfig } from '../../builder.config.js';
+import { resolveLocaleValue, valueForLangWithFallback, collectI18nSeoIssues } from './i18n-resolution.js';
+import { segmentsOf, validateMockParams, writeRouteHtml, warnForRoutesMissingSeoConfig } from './route-output.js';
+
+async function processRoute(template, baseUrl, defaultLanguage, languages, route, bundleUrl) {
+  validateMockParams(route);
+
+  const routeSuffix = route.path === '/' ? '' : route.path;
+
+  if (builderConfig.i18n) {
+    for (const lang of languages) {
+      const title = valueForLangWithFallback(route.title, lang, defaultLanguage);
+      const description = valueForLangWithFallback(route.description, lang, defaultLanguage);
+      const ogImage = valueForLangWithFallback(route.ogImage, lang, defaultLanguage);
+
+      const pageUrl = `${baseUrl}/${lang}${routeSuffix}`;
+      const body = await renderRoute({
+        bundleUrl,
+        appRoutesKey: route.path,
+        mockParams: route.mockParams,
+        mockFetch: route.mockFetch,
+        lang,
+        pageUrl,
+        i18nEnabled: builderConfig.i18n,
+      });
+
+      await writeRouteHtml({
+        template, lang, title, description, pageUrl, ogImage, body,
+        outputSegments: [lang, ...segmentsOf(routeSuffix)],
+        routePath: route.path,
+      });
+    }
+  } else {
+    const title = resolveLocaleValue(route.title, defaultLanguage);
+    const description = resolveLocaleValue(route.description, defaultLanguage);
+    const ogImage = resolveLocaleValue(route.ogImage, defaultLanguage);
+
+    if (!title || !description) {
+      errorExit(`Missing title or description for route "${route.path}" in seo.json`, 'generate-seo-html');
+    }
+
+    const pageUrl = `${baseUrl}${routeSuffix}`;
+    const body = await renderRoute({
+      bundleUrl,
+      appRoutesKey: route.path,
+      mockParams: route.mockParams,
+      mockFetch: route.mockFetch,
+      lang: defaultLanguage,
+      pageUrl,
+      i18nEnabled: builderConfig.i18n,
+    });
+
+    await writeRouteHtml({
+      template, lang: defaultLanguage, title, description, pageUrl, ogImage, body,
+      outputSegments: segmentsOf(routeSuffix),
+      routePath: route.path,
+    });
+  }
+}
+
+export async function generateSeoHtml() {
+  const templatePath = path.join(PATHS.tempSource, 'index.html');
+  const template = fs.readFileSync(templatePath, 'utf-8');
+
+  if (!template.includes('</head>')) {
+    errorExit('index.html is missing a </head> tag — cannot inject SEO tags', 'generate-seo-html');
+  }
+
+  const seoConfigPath = path.join(PATHS.temp, 'config', 'seo.json');
+  const seoConfig = JSON.parse(fs.readFileSync(seoConfigPath, 'utf-8'));
+  const baseUrl = seoConfig.baseUrl.replace(/\/$/, '');
+
+  const languagesConfigPath = path.join(PATHS.temp, 'config', 'languages.json');
+  const { languages, defaultLanguage } = JSON.parse(fs.readFileSync(languagesConfigPath, 'utf-8'));
+
+  if (builderConfig.i18n) {
+    const { fallbacks, missing, noLocalization } = collectI18nSeoIssues(seoConfig.routes, languages, defaultLanguage);
+
+    if (noLocalization.length > 0) {
+      const lines = noLocalization
+        .map(({ path, field }) => `  - route "${path}": "${field}"`)
+        .join('\n');
+      print.warn(
+        `[generate-seo-html] i18n is enabled, but these routes have no language values in seo.json:\n${lines}\n\n` +
+        `Add per-language objects (e.g. { "en": ..., "fr": ... }) under the matching route's ` +
+        `"title"/"description" in config/seo.json to localize this content, or ignore this ` +
+        `warning if sharing the same content across every language is intentional.`
+      );
+    }
+
+    if (fallbacks.length > 0) {
+      const lines = fallbacks
+        .map(({ path, field, lang, sourceLang }) => `  - route "${path}": "${field}.${lang}" not set — using "${field}.${sourceLang}"`)
+        .join('\n');
+      print.error(`[generate-seo-html] Using defaultLanguage fallback for missing i18n content:\n${lines}`);
+    }
+
+    if (missing.length > 0) {
+      const lines = missing
+        .map(({ path, field, lang }) => `  - route "${path}": missing "${field}.${lang}" (no language has a value for this field)`)
+        .join('\n');
+
+      errorExit(
+        `config/seo.json is missing required content:\n${lines}\n\n` +
+        `Add these keys under the matching route's "title"/"description" in config/seo.json. ` +
+        `Configured languages (config/languages.json): ${languages.join(', ')}.`
+        , 'generate-seo-html'
+      );
+    }
+  }
+
+  try {
+    const bundleUrl = await buildSsrBundle();
+    await warnForRoutesMissingSeoConfig(bundleUrl, seoConfig.routes, defaultLanguage, baseUrl);
+
+    for (const route of seoConfig.routes) {
+      await processRoute(template, baseUrl, defaultLanguage, languages, route, bundleUrl);
+    }
+  } finally {
+    cleanupSsrBundle();
+  }
+}

package/templates/base/tools/builder/core/seo/generate-sitemap-xml.js.hbs

@@ -0,0 +1,43 @@
+import fs from 'fs';
+import path from 'path';
+import { PATHS } from '../app/paths.js';
+import { print } from '../../../utils/index.js';
+import { builderConfig } from '../../builder.config.js';
+
+function collectUrls(baseUrl, routes, languages) {
+  const urls = [];
+
+  for (const route of routes) {
+    const routeSuffix = route.path === '/' ? '' : route.path;
+
+    if (builderConfig.i18n) {
+      for (const lang of languages) {
+        urls.push(`${baseUrl}/${lang}${routeSuffix}/`);
+      }
+    } else {
+      urls.push(`${baseUrl}${routeSuffix}/`);
+    }
+  }
+
+  return urls;
+}
+
+function buildSitemapXml(urls) {
+  const urlEntries = urls.map(loc => `  <url>\n    <loc>${loc}</loc>\n  </url>`).join('\n');
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${urlEntries}\n</urlset>\n`;
+}
+
+export function generateSitemapXml() {
+  const seoConfigPath = path.join(PATHS.temp, 'config', 'seo.json');
+  const seoConfig = JSON.parse(fs.readFileSync(seoConfigPath, 'utf-8'));
+  const baseUrl = seoConfig.baseUrl.replace(/\/$/, '');
+
+  const languagesConfigPath = path.join(PATHS.temp, 'config', 'languages.json');
+  const { languages } = JSON.parse(fs.readFileSync(languagesConfigPath, 'utf-8'));
+
+  const urls = collectUrls(baseUrl, seoConfig.routes, languages);
+  const xml = buildSitemapXml(urls);
+
+  const outputPath = path.join(PATHS.tempSource, 'sitemap.xml');
+  fs.writeFileSync(outputPath, xml, 'utf-8');
+}