@nutin/cli 1.3.0 → 2.0.0

package/templates/base/tools/builder/builder.js.hbs

@@ -1,38 +1,36 @@
 #!/usr/bin/env node
 
 import path from 'path';
-import { print, isProd, runScript } from '../utils/index.js';
+import { print, runScript } from '../utils/index.js';
+import { builderConfig } from './builder.config.js';
 
 const scriptsDir = path.join(process.cwd(), 'tools', 'builder', 'core');
 
-if (!isProd) print.boldInfo('For production, use build:prod.\n');
-print.boldHead(`Starting build...\n`);
-
-runScript(path.join(scriptsDir, 'copy-static.js'), 'Copying files...');
-
-if(!isProd) runScript(path.join(scriptsDir, 'tsc.js'), 'Running TypeScript compiler...');
-
-{{#if template}}
-runScript(path.join(scriptsDir, 'merge-templates.js'), 'Merging HTML templates in temp files...');
-{{else}}
-runScript(path.join(scriptsDir, 'minify-html.js'), 'Minifying inline templates...');
-{{/if}}
-{{#if i18n}}
-runScript(path.join(scriptsDir, 'build-i18n.js'), 'Combining locales for production...');
-{{/if}}
-runScript(path.join(scriptsDir, 'sass.js'), 'Compiling styles from main.scss...');
-runScript(path.join(scriptsDir, 'validate-html.js'), 'Adding and validating tags in index.html...');
-
-if (isProd) {
-	runScript(path.join(scriptsDir, 'esbuild.js'), 'Running esbuild...');
-	runScript(path.join(scriptsDir, 'hash-files.js'), 'Hashing files...');
-{{#if deployHelper}}
-	runScript(path.join(scriptsDir, 'compress-files.js'), 'Compressing files...');
-{{/if}}
+print.boldHead(`\nStarting build...`);
+
+runScript(path.join(scriptsDir, 'app', 'copy-static.js'), 'Copying files...');
+
+runScript(path.join(scriptsDir, 'html-index', 'validate-html.js'), 'Processing index.html...');
+runScript(path.join(scriptsDir, 'app', 'validate-routes.js'), 'Validating app routes...');
+
+runScript(path.join(scriptsDir, 'app', 'compile-ts.js'), 'Compiling TypeScript...');
+
+runScript(path.join(scriptsDir, 'html-templates', 'process-html-templates.js'), 'Processing HTML templates...');
+
+runScript(path.join(scriptsDir, 'styles', 'sass.js'), 'Compiling styles...');
+if (builderConfig.tailwind) runScript(path.join(scriptsDir, 'styles', 'tailwind.js'), 'Compiling Tailwind CSS...');
+
+if (builderConfig.i18n) runScript(path.join(scriptsDir, 'i18n', 'build-i18n.js'), 'Combining locales...');
+
+if (builderConfig.isProd) {
+	runScript(path.join(scriptsDir, 'prod-bundle', 'esbuild.js'), 'Running esbuild...');
+	runScript(path.join(scriptsDir, 'prod-bundle', 'hash-files.js'), 'Hashing files...');
+	runScript(path.join(scriptsDir, 'prod-bundle', 'compress-files.js'), 'Compressing files...');
+	if (builderConfig.generateSEO) runScript(path.join(scriptsDir, 'seo', 'generate-seo-files.js'), 'Generating SEO Files...');
 }
 
 runScript(path.join(scriptsDir, 'finalize-build.js'), 'Finalizing build...')
 
 print.boldSuccess(`\nBuild successful!\n`);
 
-if (!isProd) print.boldInfo('For production, use build:prod.');
+if (!builderConfig.isProd) print.info('For production, use "{{packageManager}} run build:prod"');

package/templates/base/tools/builder/core/app/binary-extensions.test.js.hbs

@@ -0,0 +1,16 @@
+import { BINARY_EXTENSIONS } from './binary-extensions.js';
+
+describe('BINARY_EXTENSIONS', () => {
+  it('is a Set containing common binary asset extensions', () => {
+    expect(BINARY_EXTENSIONS).toBeInstanceOf(Set);
+    expect(BINARY_EXTENSIONS.has('.png')).toBeTruthy();
+    expect(BINARY_EXTENSIONS.has('.woff2')).toBeTruthy();
+    expect(BINARY_EXTENSIONS.has('.gz')).toBeTruthy();
+  });
+
+  it('does not treat text/source extensions as binary', () => {
+    expect(BINARY_EXTENSIONS.has('.js')).toBeFalsy();
+    expect(BINARY_EXTENSIONS.has('.css')).toBeFalsy();
+    expect(BINARY_EXTENSIONS.has('.html')).toBeFalsy();
+  });
+});

package/templates/base/tools/builder/core/app/compile-ts.js.hbs

@@ -0,0 +1,16 @@
+import { runCommand, print, errorExit } from "../../../utils/index.js";
+import { builderConfig } from '../../builder.config.js';
+
+async function compileTS() {
+  // Prod bundles straight from .ts source (see prod-bundle/esbuild.js), so tsc only
+  // needs to type-check there, not emit — emitting would leave a stale, unmerged .js
+  // sibling next to each merged .ts view/component's source.
+  const args = ['--project', 'tsconfig.json'];
+  if (builderConfig.isProd) args.push('--noEmit');
+
+  await runCommand('tsc', args);
+}
+
+compileTS().catch((err) => {
+  errorExit(err, 'compile-ts');
+});

package/templates/base/tools/builder/core/{copy-static.js.hbs → app/copy-static.js.hbs}

@@ -1,22 +1,23 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { exit } from 'process';
-import { getFilesRecursive, print, isVerbose, isProd } from '../../utils/index.js';
-import { BINARY_EXTENSIONS } from '../variables/binary-extensions.js';
+import { getFilesRecursive, print, errorExit } from '../../../utils/index.js';
+import { BINARY_EXTENSIONS } from './binary-extensions.js';
 import { PATHS } from './paths.js';
+import { builderConfig } from '../../builder.config.js';
 
 async function copyStatic() {
-  const extensions = [...BINARY_EXTENSIONS, 'html'];
-  if (isProd) extensions.push('.ts');
-
-  if (isVerbose) print.info(`File types that will be copied: ${Array.from(extensions)}`);
-
+  const extensions = [...BINARY_EXTENSIONS, '.html'];
+  if (builderConfig.isProd) extensions.push('.ts');
+
+  // Every build starts from a clean dist-build: a failed/interrupted prior
+  // build never gets renamed away by finalize-build.js, so a stale sibling
+  // (already merged, placeholder gone) can otherwise sit next to the next
+  // run's fresh output and trip merge-templates.js's per-sibling check.
+  await fs.rm(PATHS.temp, { recursive: true, force: true });
   await ensureDir(PATHS.tempSource);
 
   await copyFavicon();
-  {{#if i18n}}
   await copyConfig();
-  {{/if}}
 
   for (const extension of extensions) {
     const files = await getFilesRecursive(PATHS.source, extension);
@@ -27,17 +28,13 @@ async function copyStatic() {
 
       try {
         await copyFile(file, dest);
-        if (isVerbose) print.info(`✅ Copied: ${file} → ${dest}`);
       } catch (err) {
-        print.error(`❌ Failed to copy: ${file}. ${err.message}`);
-        exit(1);
+        throw new Error(`Failed to copy: ${file}. ${err.message}`, { cause: err });
       }
     }
   }
 
-  if (isProd) await copyJsonFiles(PATHS.source, PATHS.tempSource);
-
-  if (isVerbose) print.boldInfo(`Copy complete.\n`);
+  if (builderConfig.isProd) await copyJsonFiles(PATHS.source, PATHS.tempSource);
 }
 
 async function ensureDir(dir) {
@@ -55,33 +52,31 @@ async function copyFavicon() {
 
   try {
     await copyFile(srcPath, destPath);
-    if (isVerbose) print.info('Copied: favicon.ico');
-  } catch {
-    print.boldError('⚠️  No favicon found at public/favicon.ico');
+  } catch (err) {
+    if (err.code === 'ENOENT') print.warn('No favicon found at public/favicon.ico');
+    else errorExit(err, 'copy-static');
   }
 }
 
-{{#if i18n}}
 async function copyConfig() {
   const srcPath = path.resolve(path.join('config'));
-  const temp = isProd ? PATHS.temp : PATHS.tempSource;
+  const temp = builderConfig.isProd ? PATHS.temp : PATHS.tempSource;
   const destPath = path.join(temp, 'config');
   try {
     await copyJsonFiles(srcPath, destPath);
-{{#if testinNutin}}
-    // for tests to run
-    if (!isProd) await copyJsonFiles(srcPath, path.join(PATHS.temp, 'config'))
-{{/if}}
-    if (isVerbose) print.info('Config files copied');
-  } catch {
-    print.boldError('Issue when copying config files.');
-    exit(1);
+    await copyFile(path.resolve('nutin.config.js'), path.join(temp, 'nutin.config.js'));
+
+    // for testin-nutin tests to run
+    if (!builderConfig.isProd) {
+      await copyJsonFiles(srcPath, path.join(PATHS.temp, 'config'));
+      await copyFile(path.resolve('nutin.config.js'), path.join(PATHS.temp, 'nutin.config.js'));
+    }
+  } catch (err) {
+    errorExit(err, 'copy-static');
   }
 }
 
-{{/if}}
 async function copyJsonFiles(sourceDir, destDir) {
-  
   const items = await fs.readdir(sourceDir, { withFileTypes: true });
 
   for (const item of items) {
@@ -93,12 +88,10 @@ async function copyJsonFiles(sourceDir, destDir) {
     } else if (item.isFile() && path.extname(item.name) === '.json') {
       await fs.mkdir(path.dirname(destPath), { recursive: true });
       await fs.copyFile(sourcePath, destPath);
-      if (isVerbose) print.info(`Copied JSON: ${sourcePath} -> ${destPath}`);
     }
   }
 }
 
 copyStatic().catch((err) => {
-  print.boldError(`Unexpected error: ${err.message}`);
-  exit(1);
+  errorExit(err, 'copy-static');
 });

package/templates/base/tools/builder/core/app/validate-routes.js.hbs

@@ -0,0 +1,77 @@
+import { readFileSync } from 'fs';
+import path from 'path';
+import ts from 'typescript';
+import { print, errorExit } from '../../../utils/index.js';
+import { PATHS } from './paths.js';
+
+const ROUTES_FILE = path.join(PATHS.sourceApp, 'routes.ts');
+
+function findAppRoutesObjectLiteral(sourceFile) {
+  let objectLiteral;
+
+  ts.forEachChild(sourceFile, function visit(node) {
+    if (
+      ts.isVariableDeclaration(node) &&
+      ts.isIdentifier(node.name) &&
+      node.name.text === 'appRoutes' &&
+      node.initializer &&
+      ts.isObjectLiteralExpression(node.initializer)
+    ) {
+      objectLiteral = node.initializer;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  });
+
+  return objectLiteral;
+}
+
+function getRouteKeys(objectLiteral) {
+  return objectLiteral.properties
+    .filter((prop) => ts.isPropertyAssignment(prop) && ts.isStringLiteralLike(prop.name))
+    .map((prop) => prop.name.text);
+}
+
+function findDuplicates(keys) {
+  const seen = new Set();
+  const duplicates = new Set();
+
+  for (const key of keys) {
+    if (seen.has(key)) duplicates.add(key);
+    seen.add(key);
+  }
+
+  return [...duplicates];
+}
+
+function validateRoutes() {
+  let source;
+  try {
+    source = readFileSync(ROUTES_FILE, 'utf-8');
+  } catch {
+    errorExit(`Failed to read ${ROUTES_FILE}`);
+  }
+
+  const sourceFile = ts.createSourceFile(ROUTES_FILE, source, ts.ScriptTarget.Latest, true);
+  const objectLiteral = findAppRoutesObjectLiteral(sourceFile);
+
+  if (!objectLiteral) {
+    errorExit(`Could not find an "appRoutes" object literal in ${ROUTES_FILE}`);
+  }
+
+  const duplicates = findDuplicates(getRouteKeys(objectLiteral));
+
+  if (duplicates.length > 0) {
+    const list = duplicates.map((key) => `"${key}"`).join(', ');
+    errorExit(
+      `Duplicate route key(s) in ${ROUTES_FILE}: ${list} — an earlier route with this path is silently unreachable.`
+    );
+  }
+
+}
+
+try {
+  validateRoutes();
+} catch(err) {
+  errorExit(err, 'validate-routes');
+}

package/templates/base/tools/builder/core/finalize-build.js.hbs

@@ -1,19 +1,24 @@
-import { print, isProd, isVerbose } from "../../utils/index.js";
 import fs from 'fs';
 import path from 'path';
-import { PATHS } from "./paths.js";
+import { PATHS } from "./app/paths.js";
+import { builderConfig } from '../builder.config.js';
+import { print, errorExit } from "../../utils/index.js";
 
 function finalizeBuild() {
-  if (isProd) removeFoldersAfterBundle();
+  if (builderConfig.isProd) removeFoldersAfterBundle();
+  if (builderConfig.isProd) removeNutinConfig();
   replaceDir(PATHS.temp, PATHS.build);
-  if (isVerbose) print.boldInfo('Build finalized.\n');
 }
 
 function removeFoldersAfterBundle() {
-  const foldersToRemove = ['core', 'libs', 'app'];
+  const foldersToRemove = [ 'core', 'app', path.join('..', 'config') ];
   const pathToFolder = (folder) => path.join(PATHS.tempSource, folder);
 
-  foldersToRemove.forEach(folder => fs.rmSync(pathToFolder(folder), { recursive : true }));
+  foldersToRemove.forEach(folder => fs.rmSync(pathToFolder(folder), { recursive: true, force: true }));
+}
+
+function removeNutinConfig() {
+  fs.rmSync(path.join(PATHS.temp, 'nutin.config.js'));
 }
 
 function replaceDir(src, dest) {
@@ -21,4 +26,8 @@ function replaceDir(src, dest) {
   fs.renameSync(src, dest);
 }
 
-finalizeBuild();
+try {
+  finalizeBuild();
+} catch(err) {
+  errorExit(err, 'finalize-build')
+}

package/templates/base/tools/builder/core/{add-tags.js.hbs → html-index/add-tags.js.hbs}

@@ -1,8 +1,8 @@
-import { print, isProd } from '../../utils/index.js';
 import { writeFile } from 'fs/promises';
+import { builderConfig } from '../../builder.config.js';
 
 export async function addTags(htmlContent, filePath) {
-  const scriptSrc = isProd ? "bundle.js" : "app/main.js";
+  const scriptSrc = builderConfig.isProd ? "bundle.js" : "app/main.js";
   
   const tags = [
     { type: 'stylesheet', href: 'main.css', position: 'head' },

package/templates/base/tools/builder/core/html-index/add-tags.test.js.hbs

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { addTags } from './add-tags.js';
+
+describe('addTags', () => {
+  let tmpDir;
+  let filePath;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nutin-add-tags-'));
+    filePath = path.join(tmpDir, 'index.html');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('inserts the stylesheet before </head> and the script before </body>', async () => {
+    const html = '<html><head><title>T</title></head><body></body></html>';
+
+    const result = await addTags(html, filePath);
+
+    expect(result).toBe(
+      '<html><head><title>T</title><link rel="stylesheet" href="/main.css"></head><body><script type="module" src="/app/main.js"></script></body></html>'
+    );
+  });
+
+  it('falls back to inserting the stylesheet before <title> when there is no </head>', async () => {
+    const html = '<html><title>T</title><body></body></html>';
+
+    const result = await addTags(html, filePath);
+
+    expect(result).toBe(
+      '<html><link rel="stylesheet" href="/main.css"><title>T</title><body><script type="module" src="/app/main.js"></script></body></html>'
+    );
+  });
+
+  it('appends both tags to the end when neither anchor is present', async () => {
+    const html = '<html></html>';
+
+    const result = await addTags(html, filePath);
+
+    expect(result).toBe(
+      '<html></html><link rel="stylesheet" href="/main.css"><script type="module" src="/app/main.js"></script>'
+    );
+  });
+
+  it('writes the modified html to filePath', async () => {
+    const html = '<html><head></head><body></body></html>';
+
+    const result = await addTags(html, filePath);
+
+    expect(fs.readFileSync(filePath, 'utf8')).toBe(result);
+  });
+});

package/templates/base/tools/builder/core/{validate-html.js.hbs → html-index/validate-html.js.hbs}

@@ -1,8 +1,7 @@
 import { readFile } from 'fs/promises';
-import { exit } from 'process';
-import { print, isVerbose } from '../../utils/index.js';
-import { PATHS } from './paths.js';
 import path from 'path';
+import { print, errorExit } from '../../../utils/index.js';
+import { PATHS } from '../app/paths.js';
 import { addTags } from './add-tags.js';
 
 async function validateHtml() {
@@ -27,13 +26,8 @@ async function validateHtml() {
   if (!/<link[^>]*rel=["']stylesheet["']/.test(htmlContent)) {
     errorExit('No stylesheet found in HTML');
   }
-
-  if (isVerbose) print.boldInfo('HTML validation passed\n');
-}
-
-function errorExit(message) {
-  print.boldError(`[ERROR] ${message}`);
-  exit(1);
 }
 
-validateHtml();
+validateHtml().catch((err) => {
+  errorExit(err, 'validate-html');
+});

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);
+}