@nutin/cli 2.1.1 → 3.0.0

package/templates/base/tools/builder/core/styles/tailwind.js.hbs

@@ -1,77 +1,37 @@
 import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import path from 'path';
-import { print, runCommand, promptBoolean, errorExit } from '../../../utils/index.js';
+import { ensureDeps, errorExit } from '../../../utils/index.js';
 import { PATHS } from '../app/paths.js';
 import { builderConfig } from '../../builder.config.js';
 
-const REQUIRED_DEPS = [
-  { name: 'tailwindcss', version: '^4.3.0' },
-  { name: '@tailwindcss/cli', version: '^4.3.0' },
-];
-
-const isInstalled = (depName) => fs.existsSync(path.join(process.cwd(), 'node_modules', depName, 'package.json'));
-
-const getPackageManager = () => {
-  if (fs.existsSync(path.join(process.cwd(), 'pnpm-lock.yaml'))) return 'pnpm';
-  if (fs.existsSync(path.join(process.cwd(), 'yarn.lock'))) return 'yarn';
-  if (fs.existsSync(path.join(process.cwd(), 'bun.lock')) || fs.existsSync(path.join(process.cwd(), 'bun.lockb'))) return 'bun';
-  return 'npm';
-};
-
-const getInstallCommand = (packageManager, deps) => {
-  const pkgList = deps.map(dep => `${dep.name}@${dep.version}`).join(' ');
-  switch (packageManager) {
-    case 'yarn': return `yarn add -D ${pkgList}`;
-    case 'pnpm': return `pnpm add -D ${pkgList}`;
-    case 'bun': return `bun add -D ${pkgList}`;
-    default: return `npm install -D ${pkgList}`;
-  }
-};
-
-const missingDeps = REQUIRED_DEPS.filter(dep => !isInstalled(dep.name));
-
-if (missingDeps.length) {
-  if (builderConfig.isProd) {
-    errorExit('Tailwind CSS is enabled (tailwind: true) but its dependencies are missing.\nRun "npm install" before rebuilding');
-  }
-  const packageManager = getPackageManager();
-  const installCommand = getInstallCommand(packageManager, missingDeps);
-
-  print.warn('Tailwind CSS is enabled (tailwind: true) but its dependencies are missing.');
-  print.gray('Required packages:');
-  missingDeps.forEach(dep => print.gray(`  - ${dep.name}@${dep.version}`));
-
-  let shouldInstall = true;
-  if (process.stdin.isTTY) {
-    shouldInstall = await promptBoolean('Install them now?');
-  } else {
-    print.gray(`Non-interactive shell detected. Installing automatically: ${installCommand}`);
-  }
-
-  if (!shouldInstall) {
-    print.boldError(`Aborting. Run manually: ${installCommand}`);
-    process.exit(1);
-  }
-
-  const [command, ...args] = installCommand.split(' ');
-  try {
-    await runCommand(command, args);
-  } catch (err) {
-    errorExit(err, 'tailwind-install');
-  }
+await ensureDeps({
+  feature: 'Tailwind CSS (tailwind: true)',
+  deps: [
+    { name: 'tailwindcss', version: '^4.3.0' },
+    { name: '@tailwindcss/cli', version: '^4.3.0' },
+  ],
+  isProd: builderConfig.isProd,
+  origin: 'tailwind',
+});
+
+// Run the CLI's JS entry with node rather than node_modules/.bin/tailwindcss, which is a
+// .cmd shim on Windows that execFileSync can't launch without a shell.
+function tailwindEntry() {
+  const cliDir = path.join(process.cwd(), 'node_modules', '@tailwindcss', 'cli');
+  const { bin } = JSON.parse(fs.readFileSync(path.join(cliDir, 'package.json'), 'utf-8'));
+  return path.join(cliDir, typeof bin === 'string' ? bin : bin.tailwindcss);
 }
 
-const twBin = path.join(process.cwd(), 'node_modules', '.bin', 'tailwindcss');
 const input = path.join(PATHS.source, 'styles', 'tailwind.css');
 const output = path.join(PATHS.tempSource, 'tw-out.css');
 const mainCss = path.join(PATHS.tempSource, 'main.css');
 
-const args = ['-i', input, '-o', output, '--silent'];
+const args = [tailwindEntry(), '-i', input, '-o', output, '--silent'];
 if (builderConfig.isProd) args.push('--minify');
 
 try {
-  execFileSync(twBin, args, { stdio: 'inherit' });
+  execFileSync(process.execPath, args, { stdio: 'inherit' });
 } catch (err) {
   errorExit(err, 'tailwind');
 }

package/templates/base/tools/dev/dev-serve.js.hbs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { spawn, spawnSync } from 'child_process';
-import { print, runCommand } from '../utils/index.js';
+import { print, resolvePort, runCommand } from '../utils/index.js';
 
 const isWindows = process.platform === 'win32';
 
@@ -9,6 +9,14 @@ async function startDev() {
   console.clear();
   print.blue('🚀 Starting Dev Environment...\n');
 
+  let port;
+  try {
+    port = resolvePort();
+  } catch (err) {
+    print.boldError(err.message);
+    process.exit(1);
+  }
+
   try {
     await runCommand('{{packageManager}}', ['run', 'build', '--silent']);
   } catch (err) {
@@ -25,8 +33,23 @@ async function startDev() {
   // Not on Windows: there, detached children leave the console, so Ctrl-C would no
   // longer reach them, and negative-pid group kills aren't supported — taskkill /T
   // walks the process tree instead.
-  const serve = spawn(['{{packageManager}}', 'run', 'serve:only', '--silent'].join(' '), { stdio: 'inherit', shell: true, detached: !isWindows });
-  const watcher = spawn(['node', 'tools/dev/watcher.js', '--silent'].join(' '), { stdio: 'inherit', shell: true, detached: !isWindows });
+  // Hand serve.js the already-resolved port via PORT; npm_config_port is dropped so it
+  // can't take precedence over it in the child.
+  const { npm_config_port, ...serveEnv } = process.env;
+  serveEnv.PORT = String(port);
+  // Both run node directly (no shell/npm layer) with an IPC channel, used as a relay:
+  // serve.js reports the URL it listens on (watcher.js reprints it after every rebuild),
+  // and watcher.js reports each successful rebuild (serve.js reloads open pages).
+  const stdio = ['inherit', 'inherit', 'inherit', 'ipc'];
+  const serve = spawn(process.execPath, ['tools/dev/serve.js'], { stdio, detached: !isWindows, env: serveEnv });
+  const watcher = spawn(process.execPath, ['tools/dev/watcher.js'], { stdio, detached: !isWindows });
+
+  serve.on('message', (msg) => {
+    if (msg?.type === 'server-url' && watcher.connected) watcher.send(msg);
+  });
+  watcher.on('message', (msg) => {
+    if (msg?.type === 'reload' && serve.connected) serve.send(msg);
+  });
 
   const children = [serve, watcher];
   let shuttingDown = false;
@@ -53,14 +76,16 @@ async function startDev() {
 
   process.on('SIGINT', () => shutdown('SIGINT'));
   process.on('SIGTERM', () => shutdown('SIGTERM'));
+  // Closing the terminal tab/window sends SIGHUP; the detached children don't get it.
+  process.on('SIGHUP', () => shutdown('SIGTERM'));
 
   serve.on('error', (err) => {
-    print.boldError(`live-server failed to start: ${err.message}`);
+    print.boldError(`dev server failed to start: ${err.message}`);
     process.exit(1);
   });
   serve.on('close', (code) => {
     if (shuttingDown) return;
-    print.error(`live-server exited with code ${code}`);
+    print.error(`dev server exited with code ${code}`);
     shutdown('SIGTERM', code ?? 1);
   });
   watcher.on('error', (err) => {

package/templates/base/tools/dev/serve.js.hbs

@@ -1,33 +1,163 @@
 #!/usr/bin/env node
 
-import liveServer from 'live-server';
-import { print } from '../utils/index.js';
-
-const params = {
-  port: 9090,
-  root: 'dist/src',
-  open: false, // set to true to open a new window in browser
-  logLevel: 0, // 0 = errors only, 1 = some info, 2 = verbose
-  entryFile: 'index.html',
-  wait: 100, // debounce reloads
-  middleware: [
-    function(req, res, next) {
-      if (req.url.includes('.') && !req.url.endsWith('/')) {
-        return next();
-      }
-      req.url = '/index.html';
-      next();
-    }
-  ]
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { print, resolvePort } from '../utils/index.js';
+
+const ROOT = path.resolve('dist', 'src');
+const RELOAD_EVENTS = '/__nutin/reload';
+const RELOAD_SCRIPT = '/__nutin/reload.js';
+const RELOAD_TAG = `<script src="${RELOAD_SCRIPT}"></script>`;
+// External rather than inline, so a page CSP without 'unsafe-inline' doesn't block it.
+const RELOAD_CLIENT = `new EventSource('${RELOAD_EVENTS}').addEventListener('reload', () => location.reload());\n`;
+
+const MIME_TYPES = {
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.mjs': 'text/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.map': 'application/json; charset=utf-8',
+  '.txt': 'text/plain; charset=utf-8',
+  '.xml': 'application/xml; charset=utf-8',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.avif': 'image/avif',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+  '.pdf': 'application/pdf',
 };
 
+let port;
 try {
-  liveServer.start(params);
+  port = resolvePort(); // --port <n> or PORT env, defaults to 9090
 } catch (err) {
+  print.boldError(err.message);
+  process.exit(1);
+}
+
+// Live reload only when started by dev-serve.js (IPC channel present): watcher.js
+// reports each successful rebuild, relayed here as { type: 'reload' }.
+const liveReload = Boolean(process.send);
+const reloadClients = new Set();
+
+function isFile(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// Exact file, then a directory's index.html (prerendered SEO pages), else nothing.
+function resolveFile(pathname) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+    return null;
+  }
+  const candidate = path.join(ROOT, decoded);
+  if (candidate !== ROOT && !candidate.startsWith(ROOT + path.sep)) return null;
+  if (isFile(candidate)) return candidate;
+  const index = path.join(candidate, 'index.html');
+  return isFile(index) ? index : null;
+}
+
+// Browsers send Accept: text/html for page navigations — those get the SPA shell when no
+// file matches (whatever the URL looks like, dots included); a missing asset gets a 404.
+function wantsHtml(req) {
+  return (req.headers.accept ?? '').includes('text/html');
+}
+
+function send(res, status, body, headers = {}) {
+  res.writeHead(status, { 'Cache-Control': 'no-store', ...headers });
+  res.end(body);
+}
+
+function serveFile(req, res, filePath) {
+  const type = MIME_TYPES[path.extname(filePath).toLowerCase()] ?? 'application/octet-stream';
+  let body = fs.readFileSync(filePath);
+
+  if (liveReload && type.startsWith('text/html')) {
+    const html = body.toString('utf-8');
+    body = html.includes('</body>') ? html.replace('</body>', () => `${RELOAD_TAG}</body>`) : html + RELOAD_TAG;
+  }
+
+  send(res, 200, req.method === 'HEAD' ? undefined : body, { 'Content-Type': type });
+}
+
+function openReloadStream(req, res) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-store',
+    Connection: 'keep-alive',
+  });
+  res.write(': connected\n\n');
+  reloadClients.add(res);
+  req.on('close', () => reloadClients.delete(res));
+}
+
+const server = http.createServer((req, res) => {
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    return send(res, 405, 'Method Not Allowed', { Allow: 'GET, HEAD' });
+  }
+
+  const { pathname } = new URL(req.url, 'http://localhost');
+
+  if (liveReload && pathname === RELOAD_EVENTS) return openReloadStream(req, res);
+  if (liveReload && pathname === RELOAD_SCRIPT) {
+    return send(res, 200, RELOAD_CLIENT, { 'Content-Type': MIME_TYPES['.js'] });
+  }
+
+  const filePath = resolveFile(pathname) ?? (wantsHtml(req) ? resolveFile('/index.html') : null);
+  if (!filePath) return send(res, 404, 'Not Found', { 'Content-Type': MIME_TYPES['.txt'] });
+
+  serveFile(req, res, filePath);
+});
+
+server.on('error', (err) => {
   if (err.code === 'EADDRINUSE') {
-    print.boldError(`Port ${params.port} is already in use — stop the process using it or change the dev port.`);
+    print.boldError(`Port ${port} is already in use. Pass another one with --port <n> (or PORT=<n>).`);
   } else {
-    print.boldError(`live-server failed to start: ${err.message}`);
+    print.boldError(`Dev server failed to start: ${err.message}`);
   }
   process.exit(1);
+});
+
+// Loopback only, like the URL printed below: the dev server isn't exposed to the network.
+server.listen(port, '127.0.0.1', () => {
+  const url = `http://127.0.0.1:${port}`;
+  print.boldInfo(`Serving at ${url}`);
+  // Started by dev-serve.js: report the URL so watcher.js can reprint it after rebuilds.
+  if (process.send) process.send({ type: 'server-url', url });
+});
+
+if (liveReload) {
+  process.on('message', (msg) => {
+    if (msg?.type !== 'reload') return;
+    for (const client of reloadClients) client.write('event: reload\ndata: {}\n\n');
+  });
+
+  // Keeps idle event streams from being closed by proxies/browsers.
+  setInterval(() => {
+    for (const client of reloadClients) client.write(': ping\n\n');
+  }, 30_000).unref();
+
+  // Started by dev-serve.js: exit with it even if it dies without cleaning up (kill -9, crash).
+  process.on('disconnect', () => process.exit(0));
 }

package/templates/base/tools/dev/watcher.js.hbs

@@ -2,16 +2,43 @@ import chokidar from 'chokidar';
 import { exec } from 'child_process';
 import path from 'path';
 import { print } from '../utils/index.js'
+{{#if markdown}}
+import nutinConfig from '../../nutin.config.js';
+{{/if}}
 
-const watcher = chokidar.watch(['src'], {
+// config/, nutin.config.js and public/ are copied into the build too.
+const watcher = chokidar.watch(['src', 'config', 'public', 'nutin.config.js'], {
   ignored: /(^|[/\\])\../,
   persistent: true,
+  ignoreInitial: true,
 });
+{{#if markdown}}
+
+// Markdown folders live outside src/ but still feed the build.
+watcher.add(
+  (nutinConfig.markdownSources?.sourceFolders ?? [])
+    .map((entry) => (typeof entry === 'string' ? entry : entry?.folder))
+    .filter(Boolean)
+);
+{{/if}}
 
 let isBuilding = false;
 let pendingRebuild = false;
 let buildTimeout = null;
 let lastChangedPath = null;
+let serverUrl = null;
+
+function printWatching() {
+  if (serverUrl) print.boldInfo(`Serving at ${serverUrl}`);
+  print.boldBlue('Watching for changes...');
+}
+
+// Sent by dev-serve.js (relayed from serve.js) once the server is listening.
+process.on('message', (msg) => {
+  if (msg?.type === 'server-url') serverUrl = msg.url;
+});
+// Exit with dev-serve.js even if it dies without cleaning up (kill -9, crash).
+if (process.send) process.on('disconnect', () => process.exit(0));
 
 function runBuild() {
   isBuilding = true;
@@ -33,7 +60,9 @@ function runBuild() {
         print.boldError(`\nBuild failed: ${err.message}`);
       }
     } else {
-      print.boldBlue('Watching for changes...');
+      printWatching();
+      // Relayed by dev-serve.js to serve.js, which tells open pages to reload.
+      if (process.send && process.connected) process.send({ type: 'reload' });
     }
     isBuilding = false;
 
@@ -48,7 +77,9 @@ watcher.on('error', (err) => {
   print.boldError(`\nWatcher error: ${err.message}`);
 });
 
-watcher.on('change', (filePath) => {
+// New files (e.g. from `{{packageManager}} run generate`) and deletions need a rebuild too.
+watcher.on('all', (event, filePath) => {
+  if (!['add', 'change', 'unlink'].includes(event)) return;
   lastChangedPath = filePath;
 
   if (isBuilding) {

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import path from "path";
-import { allFormats, getLastWord, print, promptBoolean, errorExit } from "../utils/index.js";
+import { allFormats, getLastWord, print, errorExit } from "../utils/index.js";
 import fs from "fs";
 import { generateFile, generateLocalesJson } from "./handle-file.js";
 import { serviceTemplate, componentTemplate, viewTemplate, htmlTemplate, scssTemplate, testTemplate } from "./templates/index.js";

package/templates/base/tools/generator/handle-file.js.hbs

@@ -1,5 +1,7 @@
 import fs from 'fs';
-import { print, LANGUAGES } from '../utils/index.js';
+import { print } from '../utils/index.js';
+// Imported directly, not via the utils barrel: it reads config/languages.json on load.
+import { LANGUAGES } from '../utils/languages.js';
 import { localeTemplate } from './templates/index.js';
 
 export function generateFile({
@@ -7,7 +9,7 @@ export function generateFile({
   targetPath,
   templateFn,
   suffix,
-  extension = 'ts',
+  extension = '{{#if (eq lang "js")}}js{{else}}ts{{/if}}',
 }) {
   fs.mkdirSync(targetPath, { recursive: true });
   const template = templateFn(name, targetPath, suffix);

package/templates/base/tools/generator/handle-file.test.js.hbs

@@ -23,7 +23,7 @@ describe('handle-file', () => {
 
     generateFile({ name, targetPath, templateFn: (n) => `content for ${n.kebab}`, suffix: 'component' });
 
-    const filePath = path.join(targetPath, 'widget.component.ts');
+    const filePath = path.join(targetPath, 'widget.component.{{#if (eq lang "js")}}js{{else}}ts{{/if}}');
     expect(fs.existsSync(filePath)).toBeTruthy();
     expect(fs.readFileSync(filePath, 'utf8')).toBe('content for widget');
     expect(exitSpy.callCount).toBe(0);
@@ -33,9 +33,9 @@ describe('handle-file', () => {
     const targetPath = path.join(tmpDir, 'services', 'widget');
     const name = { kebab: 'widget', pascal: 'Widget', camel: 'widget', capitalized: 'Widget' };
 
-    generateFile({ name, targetPath, templateFn: () => 'x', suffix: 'service', extension: 'js' });
+    generateFile({ name, targetPath, templateFn: () => 'x', suffix: 'service', extension: 'scss' });
 
-    expect(fs.existsSync(path.join(targetPath, 'widget.service.js'))).toBeTruthy();
+    expect(fs.existsSync(path.join(targetPath, 'widget.service.scss'))).toBeTruthy();
   });
 
   it('generateFile calls process.exit(1) instead of overwriting an existing file', () => {

package/templates/base/tools/generator/templates/component/component.template.js.hbs

@@ -4,12 +4,12 @@ export const componentTemplate = (name, targetPath) => {
   const relToCore = getRelToCore(targetPath);
   const htmlTemplate = '__TEMPLATE_PLACEHOLDER__';
 
-  return `import { Component } from '${relToCore}';
+  return `import { Component, html } from '${relToCore}';
 
-const templateFn = () => \`${htmlTemplate}\`;
+const templateFn = () => html\`${htmlTemplate}\`;
 
 export class ${name.pascal}Component extends Component {
-  constructor(mountTarget: HTMLElement) {
+  constructor({{#if (eq lang "js")}}mountTarget{{else}}mountTarget: HTMLElement{{/if}}) {
     super({templateFn, mountTarget});
   }
 }

package/templates/base/tools/generator/templates/component/component.template.test.js.hbs

@@ -8,12 +8,12 @@ describe('componentTemplate', () => {
     // The generator always leaves the html body as a placeholder — the builder
     // swaps in the .html sibling's content at build time.
     expect(componentTemplate(name, targetPath)).toBe(
-      `import { Component } from '../../../core/index.js';
+      `import { Component, html } from '../../../core/index.js';
 
-const templateFn = () => \`__TEMPLATE_PLACEHOLDER__\`;
+const templateFn = () => html\`__TEMPLATE_PLACEHOLDER__\`;
 
 export class WidgetComponent extends Component {
-  constructor(mountTarget: HTMLElement) {
+  constructor({{#if (eq lang "js")}}mountTarget{{else}}mountTarget: HTMLElement{{/if}}) {
     super({templateFn, mountTarget});
   }
 }

package/templates/base/tools/generator/templates/service/service.template.js.hbs

@@ -5,7 +5,7 @@ export const serviceTemplate = (name, targetPath) => {
 
   return `import { Service } from '${relToCore}';
 
-export class ${name.pascal}Service extends Service<${name.pascal}Service> {  
+export class ${name.pascal}Service extends Service{{#unless (eq lang "js")}}<${name.pascal}Service>{{/unless}} {  
   constructor() {
     super();
   }

package/templates/base/tools/generator/templates/service/service.template.test.js.hbs

@@ -8,7 +8,7 @@ describe('serviceTemplate', () => {
     expect(serviceTemplate(name, targetPath)).toBe(
       `import { Service } from '../../../core/index.js';
 
-export class WidgetService extends Service<WidgetService> {  
+export class WidgetService extends Service{{#unless (eq lang "js")}}<WidgetService>{{/unless}} {  
   constructor() {
     super();
   }

package/templates/base/tools/generator/templates/view/view.template.js.hbs

@@ -4,9 +4,9 @@ export const viewTemplate = (name, targetPath) => {
   const relToCore = getRelToCore(targetPath);
   const htmlTemplate = '__TEMPLATE_PLACEHOLDER__';
 
-  return `import { View } from '${relToCore}';
+  return `import { View, html } from '${relToCore}';
 
-const template = \`${htmlTemplate}\`;
+const template = html\`${htmlTemplate}\`;
 
 export class ${name.pascal}View extends View {
   constructor() {

package/templates/base/tools/generator/templates/view/view.template.test.js.hbs

@@ -8,9 +8,9 @@ describe('viewTemplate', () => {
     // The generator always leaves the html body as a placeholder — the builder
     // swaps in the .html sibling's content at build time.
     expect(viewTemplate(name, targetPath)).toBe(
-      `import { View } from '../../../core/index.js';
+      `import { View, html } from '../../../core/index.js';
 
-const template = \`__TEMPLATE_PLACEHOLDER__\`;
+const template = html\`__TEMPLATE_PLACEHOLDER__\`;
 
 export class WidgetView extends View {
   constructor() {

package/templates/base/tools/testin-nutin/core/coverage/write-uncovered-report.js.hbs

@@ -13,7 +13,7 @@ export async function maybeWriteUncoveredReport(report) {
     return;
   }
 
-  if (!config.testinNutin.coverage.reportUncovered) return;
+  if (!config.testinNutin.coverage?.reportUncovered) return;
 
   try {
     fs.mkdirSync(path.dirname(REPORT_PATH), { recursive: true });

package/templates/base/tools/testin-nutin/core/globals/assertion-lib.js.hbs

@@ -101,12 +101,12 @@ global.expect = (actual) => {
       }
     },
     toBeLessThan(expected) {
-      if (actual > expected) {
+      if (!(actual < expected)) {
         throw new AssertionError(`Expected ${actual} to be less than ${expected}`)
       }
     },
     toBeGreaterThan(expected) {
-      if (actual < expected) {
+      if (!(actual > expected)) {
         throw new AssertionError(`Expected ${actual} to be greater than ${expected}`)
       }
     },

package/templates/base/tools/testin-nutin/core/{tests/assertions.test.js.hbs → globals/assertion-lib.test.js.hbs}

@@ -94,4 +94,10 @@ describe('assertions', () => {
     }
     expect(caught).toBeInstanceOf(TypeError);
   });
+  it('toBeLessThan / toBeGreaterThan are strict comparisons', () => {
+    expect(1).toBeLessThan(2);
+    expect(2).toBeGreaterThan(1);
+    expect(2).not.toBeLessThan(2);
+    expect(2).not.toBeGreaterThan(2);
+  });
 });

package/templates/base/tools/testin-nutin/core/globals/register-test-globals.js.hbs

@@ -23,15 +23,14 @@ export function registerTestGlobals() {
     fn();
   };
 
+  // The suite's hooks object is shared by reference (read when the queue runs), so a hook
+  // registered after some it() calls in the same describe() still applies to them.
   global.it = (name, fn) => {
-    addTest({ 
-      suiteName: currentSuite, 
-      testName: name, 
+    addTest({
+      suiteName: currentSuite,
+      testName: name,
       testFn: fn,
-      beforeEach: currentSuiteHooks.beforeEach,
-      beforeAll: currentSuiteHooks.beforeAll,
-      afterEach: currentSuiteHooks.afterEach,
-      afterAll: currentSuiteHooks.afterAll
+      hooks: currentSuiteHooks,
     });
   };
   global.it.todo = (s) => {

package/templates/base/tools/testin-nutin/core/{tests/globals-each-all.test.js.hbs → globals/register-test-globals.test.js.hbs}

@@ -26,3 +26,15 @@ describe('globals beforeEach/All and afterEach/All', () => {
     expect(afterEachCount).toEqual(1);
   });
 })
+
+describe('Hooks registered after it()', () => {
+  let beforeEachCount = 0;
+
+  it('still get the beforeEach declared further down', () => {
+    expect(beforeEachCount).toBe(1);
+  });
+
+  beforeEach(() => {
+    beforeEachCount++;
+  });
+});

package/templates/base/tools/testin-nutin/core/printer.js.hbs

@@ -39,8 +39,9 @@ export function printStart() {
 
 export function printCoverageReport(report) {
   if (!report.length) {
-    print.warn('No app source files were covered.');
-    return { globalLinesPct: 100, globalFunctionsPct: 100, globalBranchesPct: 100 };
+    // 0, not 100: an empty report must not pass a coverage threshold by default.
+    print.warn('No source files were covered.');
+    return { globalLinesPct: 0, globalFunctionsPct: 0, globalBranchesPct: 0 };
   }
 
   print.boldBlue('\nCoverage Summary');
@@ -77,9 +78,14 @@ export function printCoverageReport(report) {
 
 export function toTsPath(input) {
   return input
-    .split('/')
+    .split(/[\\/]/)
     .slice(1)
+{{#if (eq lang "js")}}
+    .join('/');
+{{else}}
     .join('/')
-    .replace(/\.js$/, '.ts');
+    // Test files stay .test.js in TypeScript projects too.
+    .replace(/(?<!\.test)\.js$/, '.ts');
+{{/if}}
 }