@nutin/cli 1.3.1 → 2.0.0

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

@@ -1,32 +1,40 @@
 #!/usr/bin/env node
 
+import { spawn } from 'child_process';
 import { print, runCommand } from '../utils/index.js';
 
 async function startDev() {
-  try {
-    console.clear();
-    print.boldHead('🚀 Starting Dev Environment...');
-
-    await runCommand('{{packageManager}}', ['run', 'build']);
-
-    const { serve, watcher } = await Promise.all([
-      runCommand('{{packageManager}}', ['run', 'serve:only']),
-      runCommand('node', ['tools/dev/watcher.js'])
-    ]);
+  console.clear();
+  print.blue('🚀 Starting Dev Environment...\n');
 
-    serve.on('close', (code) => {
-      print.error(`live-server exited with code ${code}`);
-      process.exit(code);
-    });
-    watcher.on('close', (code) => {
-      print.error(`watcher exited with code ${code}`);
-    });
+  try {
+    await runCommand('{{packageManager}}', ['run', 'build', '--silent']);
   } catch (err) {
     print.boldError(`Dev startup failed: ${err.message}`);
+    process.exit(1);
   }
+
+  const serve = spawn(['{{packageManager}}', 'run', 'serve:only', '--silent'].join(' '), { stdio: 'inherit', shell: true });
+  const watcher = spawn(['node', 'tools/dev/watcher.js', '--silent'].join(' '), { stdio: 'inherit', shell: true });
+
+  serve.on('error', (err) => {
+    print.boldError(`live-server failed to start: ${err.message}`);
+    process.exit(1);
+  });
+  serve.on('close', (code) => {
+    print.error(`live-server exited with code ${code}`);
+    process.exit(code ?? 1);
+  });
+  watcher.on('error', (err) => {
+    print.boldError(`watcher failed to start: ${err.message}`);
+    process.exit(1);
+  });
+  watcher.on('close', (code) => {
+    print.error(`watcher exited with code ${code}`);
+  });
 }
 
 startDev().catch((err) => {
   print.boldError(`Unexpected error: ${err.message}`);
-  exit(1);
+  process.exit(1);
 });

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

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import liveServer from 'live-server';
+import { print } from '../utils/index.js';
 
 const params = {
   port: 9090,
@@ -20,4 +21,13 @@ const params = {
   ]
 };
 
-liveServer.start(params);
+try {
+  liveServer.start(params);
+} catch (err) {
+  if (err.code === 'EADDRINUSE') {
+    print.boldError(`Port ${params.port} is already in use — stop the process using it or change the dev port.`);
+  } else {
+    print.boldError(`live-server failed to start: ${err.message}`);
+  }
+  process.exit(1);
+}

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

@@ -11,6 +11,10 @@ const watcher = chokidar.watch(['src'], {
 let isBuilding = false;
 let buildTimeout = null;
 
+watcher.on('error', (err) => {
+  print.boldError(`\nWatcher error: ${err.message}`);
+});
+
 watcher.on('change', (filePath) => {
   if (buildTimeout) {
     clearTimeout(buildTimeout);
@@ -24,15 +28,19 @@ watcher.on('change', (filePath) => {
     print.boldInfo(`\n🔄 File changed: ${path.relative(process.cwd(), filePath)}\n`);
     print.info('\nRebuilding...');
 
-    const command = '{{packageManager}} run build';
-    
-    exec(command, (err, stdout, stderr) => {
+    const command = '{{packageManager}} run build --silent';
+
+    exec(command, { maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (stdout) process.stdout.write(stdout);
       if (stderr) process.stderr.write(stderr);
       if (err) {
-        print.error(`\n❌ Build failed: ${err.message}`);
+        if (err.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+          print.boldError(`\nBuild output exceeded the buffer size — raise maxBuffer in tools/dev/watcher.js.`);
+        } else {
+          print.boldError(`\nBuild failed: ${err.message}`);
+        }
       } else {
-        print.boldHead('Watching for changes...');
+        print.boldBlue('Watching for changes...');
       }
       isBuilding = false;
     });
@@ -40,5 +48,5 @@ watcher.on('change', (filePath) => {
 });
 
 watcher.on('ready', () => {
-  print.boldHead('\nWatching for changes...\n');
+  print.boldBlue('Watching for changes...');
 });

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

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 
 import path from "path";
-import { allFormats, getLastWord, print{{#if stylinNutin}}, promptBoolean{{/if}} } from "../utils/index.js";
-import { generateFile, appendToIndex{{#if i18n}}, generateJson{{/if}}{{#if stylinNutin}}, generateStylesheet{{/if}} } from "./handle-file.js";
-import { serviceTemplate, componentTemplate, viewTemplate{{#if template}}, htmlTemplate{{/if}} } from "./templates/index.js";
+import { allFormats, getLastWord, print, promptBoolean, errorExit } from "../utils/index.js";
+import { generateFile, appendToIndex, generateLocalesJson } from "./handle-file.js";
+import { serviceTemplate, componentTemplate, viewTemplate, htmlTemplate, scssTemplate, testTemplate } from "./templates/index.js";
+import nutinConfig from "../../nutin.config.js";
 
 // Constants and Setup
 const [, , rawType, rawFullPath] = process.argv;
 
 if (!rawType || !rawFullPath) {
   showUsageAndExit("Missing arguments.");
+  process.exit(1);
 }
 
 const type = allFormats(rawType);
@@ -19,55 +21,43 @@ const targetPath = path.join('src', 'app', `${type.kebab}s/${fullPath.kebab}`);
 
 // Creator Mapping
 const creators = {
-  service: (name, targetPath) => {
-    print.section(`Creating service: ${name.capitalized}`);
+  service: async (name, targetPath) => {
+    const suffix = 'service';
+    print.section(`Generating service: ${name.capitalized}`);
     try {
-      generateFile({ name, targetPath, templateFn: serviceTemplate, suffix: 'service' });
-      appendToIndex({ name, targetPath, suffix: 'service' });
+      generateFile({ name, targetPath, templateFn: serviceTemplate, suffix: suffix });
+      appendToIndex({ name, targetPath, suffix: suffix });
+      if (nutinConfig.generator.generateTest) await generateTest({ name, targetPath, suffix: suffix });
     } catch (err) {
       handleError("Failed to generate service", err);
     }
   },
-  component: {{#if stylinNutin}}async {{/if}}(name, targetPath) => {
-    print.section(`Creating component: ${name.capitalized}`);
-    {{#if stylinNutin}}
-    const doCreateStylesheet = await promptBoolean('Create component\'s stylesheet in styles/components ?');
-    {{/if}}
+  component: async (name, targetPath) => {
+    const suffix = 'component';
+    print.section(`Generating component: ${name.capitalized}`);
 
     try {
-      generateFile({ name, targetPath, templateFn: componentTemplate, suffix: 'component' });
-      {{#if template}}
-      generateFile({ name, targetPath, templateFn: htmlTemplate, suffix: 'component', extension: 'html' });
-      {{/if}}
-      {{#if i18n}}
-      generateJson({ targetPath, name });
-      {{/if}}
-      {{#if stylinNutin}}
-      if (doCreateStylesheet) generateStylesheet({ name, suffix: 'component' });
-      {{/if}}
-      appendToIndex({ name, targetPath, suffix: 'component' });
+      generateFile({ name, targetPath, templateFn: componentTemplate, suffix: suffix });
+      generateFile({ name, targetPath, templateFn: htmlTemplate, suffix: suffix, extension: 'html' });
+      if (nutinConfig.generator.generateStylesheet) generateFile({ name, targetPath, templateFn: scssTemplate, suffix: suffix, extension: 'scss' });
+      if (nutinConfig.generator.generateLocales) await generateLocales({ targetPath, name });
+      appendToIndex({ name, targetPath, suffix: suffix });
+      if (nutinConfig.generator.generateTest) await generateTest({ name, targetPath, suffix });
     } catch (err) {
       handleError("Failed to generate component", err);
     }
   },
-  view: {{#if stylinNutin}}async {{/if}}(name, targetPath) => {
-    print.section(`Creating view: ${name.capitalized}`);
-    {{#if stylinNutin}}
-    const doCreateStylesheet = await promptBoolean('Create component\'s stylesheet in styles/components ?');
-    {{/if}}
+  view: async (name, targetPath) => {
+    const suffix = 'view';
+    print.section(`Generating view: ${name.capitalized}`);
 
     try {
-      generateFile({ name, targetPath, templateFn: viewTemplate, suffix: 'view' });
-      {{#if template}}
-      generateFile({ name, targetPath, templateFn: htmlTemplate, suffix: 'view', extension: 'html' });
-      {{/if}}
-      {{#if i18n}}
-      generateJson({ targetPath, name });
-      {{/if}}
-      {{#if stylinNutin}}
-      if (doCreateStylesheet) generateStylesheet({ name, suffix: 'view' });
-      {{/if}}
-      appendToIndex({name, targetPath, suffix: 'view' });
+      generateFile({ name, targetPath, templateFn: viewTemplate, suffix: suffix });
+      generateFile({ name, targetPath, templateFn: htmlTemplate, suffix: suffix, extension: 'html' });
+      if (nutinConfig.generator.generateStylesheet) generateFile({ name, targetPath, templateFn: scssTemplate, suffix: suffix, extension: 'scss' });
+      if (nutinConfig.generator.generateLocales) await generateLocales({ targetPath, name });
+      appendToIndex({ name, targetPath, suffix: suffix });
+      if (nutinConfig.generator.generateTest) await generateTest({ name, targetPath, suffix });
     } catch (err) {
       handleError("Failed to generate view", err);
     }
@@ -78,22 +68,49 @@ const creators = {
 const create = creators[type.kebab];
 
 if (create) {
-  {{#if stylinNutin}}await {{/if}}create(name, targetPath);
-  print.boldSuccess(`\n${type.capitalized} ${name.capitalized} has been generated.\n`)
+  await create(name, targetPath);
+  print.boldSuccess(`\n${type.capitalized} ${name.capitalized} generated in ${targetPath}.\n`)
 } else {
   showUsageAndExit(`Unsupported type: '${type.kebab}'`);
+  process.exit(1);
 }
 
 // Helper Functions
+async function generateTest({ targetPath, name, suffix }) {
+  let isGenerate = true;
+  if (!nutinConfig.testinNutin.includeApp) {
+    print.warn('⚠️ Enable includeApp in nutin.config.js testinNutin object to use test files.');
+    if (!process.stdin.isTTY) {
+      print.warn('Non-interactive shell detected — skipping test file generation.');
+      isGenerate = false;
+    } else {
+      isGenerate = await promptBoolean('Do you want to generate the test file anyway ?');
+    }
+  }
+  if (isGenerate) generateFile({ targetPath, name, templateFn: testTemplate, extension: 'test.js', suffix: suffix });
+}
+
+async function generateLocales({ targetPath, name }) {
+  let isGenerate = true;
+  if (!nutinConfig.i18n) {
+    print.warn('⚠️ Enable i18n in nutin.config.js to use json-based content per language.');
+    if (!process.stdin.isTTY) {
+      print.warn('Non-interactive shell detected — skipping locales file generation.');
+      isGenerate = false;
+    } else {
+      isGenerate = await promptBoolean('Do you want to generate the locales file(s) anyway ?');
+    }
+  }
+  if (isGenerate) generateLocalesJson({ targetPath, name });
+}
+
 function showUsageAndExit(message) {
-  print.boldError(`\n❌ ${message}`);
-  print.boldError("Usage: npm run generate <type> <path>");
-  print.boldError(`Supported types: ${Object.keys(creators).join(", ")}`);
+  print.boldError(`\n${message}`);
+  print.warn("Usage: {{packageManager}} run generate <type> <path>");
+  print.warn(`Supported types: ${Object.keys(creators).join(", ")}`);
   process.exit(1);
 }
 
 function handleError(context, error) {
-  print.boldError(`\n❌ ${context}`);
-  print.boldError(error instanceof Error ? error.message : error);
-  process.exit(1);
+  errorExit(error, context);
 }

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

@@ -1,12 +1,7 @@
 import fs from 'fs';
 import path from 'path';
-import { print{{#if i18n}}, LANGUAGES{{/if}} } from '../utils/index.js';
-{{#if i18n}}
-import { jsonTemplate } from './templates/index.js';
-{{/if}}
-{{#if stylinNutin}}
-import { scssTemplate } from './templates/index.js';
-{{/if}}
+import { print, LANGUAGES } from '../utils/index.js';
+import { localeTemplate } from './templates/index.js';
 
 export function generateFile({
   name,
@@ -16,7 +11,7 @@ export function generateFile({
   extension = 'ts',
 }) {
   fs.mkdirSync(targetPath, { recursive: true });
-  const template = templateFn(name, targetPath);
+  const template = templateFn(name, targetPath, suffix);
   const filePath = `${targetPath}/${name.kebab}.${suffix}.${extension}`;
 
   if (fs.existsSync(filePath)) {
@@ -42,51 +37,29 @@ export function appendToIndex({ name, targetPath, suffix }) {
 
   try {
     fs.appendFileSync(indexFilePath, lineToAppend, 'utf8');
-    print.info(`${suffix}s/index.ts updated.`);
+    print.gray(`${suffix}s/index.ts updated.`);
   } catch (err) {
-    print.error(`Error appending line: ${err}`);
+    throw new Error(`Failed to update ${indexFilePath}: ${err.message}`, { cause: err });
   }
 }
 
-{{#if i18n}}
-export function generateJson({ targetPath, name }) {
+export function generateLocalesJson({ targetPath, name }) {
   const localesDir = `${targetPath}/locales`;
   fs.mkdirSync(localesDir, { recursive: true });
 
-  const template = targetPath.includes('view') ? jsonTemplate(name) : `{ "default": "${name.pascal} works !"}`;
+  const template = localeTemplate(name);
 
-// include "meta" keys for views, empty JSON for components
-  LANGUAGES.forEach((lang) => {
-    fs.writeFileSync(`${localesDir}/${lang}.json`, template);
-  });
-}
-
-{{/if}}
-{{#if stylinNutin}}
-export function generateStylesheet({ name, suffix }) {
-  const template = scssTemplate();
-  const stylesPath = path.join('src', 'styles', `${suffix}s`);
-  const filePath = path.join(stylesPath, `_${name.kebab}.${suffix}.scss`);
-  const indexPath = path.join(stylesPath, `_index.scss`);
-  
-  if (!fs.existsSync(stylesPath) || !fs.existsSync(indexPath)) {
-    print.boldError('Non existing path');
-    process.exit(1);
-  }
-  if (fs.existsSync(filePath)) {
-    print.boldError('A file with this name already exists');
-    process.exit(1);
+  const failedLangs = [];
+  for (const lang of LANGUAGES) {
+    try {
+      fs.writeFileSync(`${localesDir}/${lang}.json`, template);
+    } catch (err) {
+      print.error(`Failed to write locale file for "${lang}": ${err.message}`);
+      failedLangs.push(lang);
+    }
   }
 
-  fs.writeFileSync(filePath, template);
-
-  const lineToAppend = `@forward "${name.kebab}.${suffix}";\n`;
-
-  try {
-    fs.appendFileSync(indexPath, lineToAppend, 'utf8');
-  } catch (err) {
-    print.error(`Error appending line: ${err}`);
+  if (failedLangs.length) {
+    throw new Error(`Failed to generate locale file(s) for: ${failedLangs.join(', ')}`);
   }
 }
-
-{{/if}}

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

@@ -0,0 +1,72 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { generateFile, appendToIndex } from './handle-file.js';
+
+describe('handle-file', () => {
+  let tmpDir;
+  let originalCwd;
+  let exitSpy;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nutin-handle-file-'));
+    originalCwd = process.cwd();
+    exitSpy = spyOn(process, 'exit').andCallFake(() => {});
+  });
+
+  afterEach(() => {
+    exitSpy.restore();
+    process.chdir(originalCwd);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('generateFile writes the template output to <targetPath>/<name>.<suffix>.<extension>', () => {
+    const targetPath = path.join(tmpDir, 'components', 'widget');
+    const name = { kebab: 'widget', pascal: 'Widget', camel: 'widget', capitalized: 'Widget' };
+
+    generateFile({ name, targetPath, templateFn: (n) => `content for ${n.kebab}`, suffix: 'component' });
+
+    const filePath = path.join(targetPath, 'widget.component.ts');
+    expect(fs.existsSync(filePath)).toBeTruthy();
+    expect(fs.readFileSync(filePath, 'utf8')).toBe('content for widget');
+    expect(exitSpy.callCount).toBe(0);
+  });
+
+  it('generateFile respects a custom extension', () => {
+    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' });
+
+    expect(fs.existsSync(path.join(targetPath, 'widget.service.js'))).toBeTruthy();
+  });
+
+  it('generateFile calls process.exit(1) instead of overwriting an existing file', () => {
+    const targetPath = path.join(tmpDir, 'components', 'widget');
+    const name = { kebab: 'widget', pascal: 'Widget', camel: 'widget', capitalized: 'Widget' };
+    const templateFn = () => 'fixed content';
+
+    generateFile({ name, targetPath, templateFn, suffix: 'component' });
+    // the second call hits the already-exists guard, which prints via console.error
+    silenceConsole('error', () => generateFile({ name, targetPath, templateFn, suffix: 'component' }));
+
+    expect(exitSpy.callCount).toBe(1);
+    expect(exitSpy.lastCall).toEqual([1]);
+  });
+
+  it('appendToIndex appends an export line to the barrel three segments up from targetPath', () => {
+    process.chdir(tmpDir);
+    const basePath = path.join('src', 'app', 'components');
+    fs.mkdirSync(basePath, { recursive: true });
+    fs.writeFileSync(path.join(basePath, 'index.ts'), "export * from './existing.js';\n");
+
+    const targetPath = path.join('src', 'app', 'components', 'widget');
+    const name = { kebab: 'widget', pascal: 'Widget', camel: 'widget', capitalized: 'Widget' };
+
+    // appendToIndex prints a "index.ts updated" log via console.info
+    silenceConsole('info', () => appendToIndex({ name, targetPath, suffix: 'component' }));
+
+    const indexContent = fs.readFileSync(path.join(basePath, 'index.ts'), 'utf8');
+    expect(indexContent).toBe("export * from './existing.js';\nexport * from './widget/widget.component.js';\n");
+  });
+});

package/templates/base/tools/generator/templates/{component.template.js.hbs → component/component.template.js.hbs}

@@ -1,11 +1,12 @@
-import { getRelToCore } from "../../utils/get-rel-to-core.js";
+import { getRelToCore } from "../../../utils/get-rel-to-core.js";
 
 export const componentTemplate = (name, targetPath) => {
   const relToCore = getRelToCore(targetPath);
+  const htmlTemplate = '__TEMPLATE_PLACEHOLDER__';
 
   return `import { Component } from '${relToCore}';
 
-const templateFn = () => {{#if template}}\`__TEMPLATE_PLACEHOLDER__\`{{else}}\`<div>${name.pascal} works !</div>\`{{/if}};
+const templateFn = () => \`${htmlTemplate}\`;
 
 export class ${name.pascal}Component extends Component {
   constructor(mountTarget: HTMLElement) {

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

@@ -0,0 +1,23 @@
+import { componentTemplate } from './component.template.js';
+
+describe('componentTemplate', () => {
+  it('renders a component class importing Component via the relative core path', () => {
+    const name = { pascal: 'Widget' };
+    const targetPath = 'src/app/components/widget';
+
+    // 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';
+
+const templateFn = () => \`__TEMPLATE_PLACEHOLDER__\`;
+
+export class WidgetComponent extends Component {
+  constructor(mountTarget: HTMLElement) {
+    super({templateFn, mountTarget});
+  }
+}
+`
+    );
+  });
+});

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

@@ -0,0 +1,2 @@
+export const htmlTemplate = (name) => `<div>${name.pascal} works !</div>
+`;

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

@@ -0,0 +1,7 @@
+import { htmlTemplate } from './html.template.js';
+
+describe('htmlTemplate', () => {
+  it('renders a placeholder div with the component/view name', () => {
+    expect(htmlTemplate({ pascal: 'Widget' })).toBe('<div>Widget works !</div>\n');
+  });
+});

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

@@ -1,12 +1,7 @@
-export * from './component.template.js';
-export * from './view.template.js';
-export * from './service.template.js';
-{{#if template}}
-export * from './html.template.js';
-{{/if}}
-{{#if i18n}}
-export * from './json.template.js';
-{{/if}}
-{{#if stylinNutin}}
-export * from './scss.template.js';
-{{/if}}
+export * from './component/component.template.js';
+export * from './view/view.template.js';
+export * from './service/service.template.js';
+export * from './locale/locale.template.js';
+export * from './scss/scss.template.js';
+export * from './html/html.template.js';
+export * from './test/test.template.js';

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

@@ -0,0 +1,4 @@
+export const localeTemplate = (name) => `{
+  "default": "${name.pascal} works !"
+}
+`;

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

@@ -0,0 +1,7 @@
+import { localeTemplate } from './locale.template.js';
+
+describe('localeTemplate', () => {
+  it('renders a locale JSON stub with a "default" key', () => {
+    expect(localeTemplate({ pascal: 'Widget' })).toBe('{\n  "default": "Widget works !"\n}\n');
+  });
+});

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

@@ -0,0 +1 @@
+export const scssTemplate = () => `\n`;

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

@@ -0,0 +1,7 @@
+import { scssTemplate } from './scss.template.js';
+
+describe('scssTemplate', () => {
+  it('renders an empty stylesheet placeholder', () => {
+    expect(scssTemplate()).toBe('\n');
+  });
+});

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

@@ -0,0 +1,17 @@
+import { getRelToCore } from "../../../utils/get-rel-to-core.js";
+
+export const serviceTemplate = (name, targetPath) => {
+  const relToCore = getRelToCore(targetPath);
+
+  return `import { Service } from '${relToCore}';
+
+export class ${name.pascal}Service extends Service<${name.pascal}Service> {  
+  constructor() {
+    super();
+  }
+
+}
+
+export const ${name.camel}Service = ${name.pascal}Service.getInstance();
+`;
+}

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

@@ -0,0 +1,22 @@
+import { serviceTemplate } from './service.template.js';
+
+describe('serviceTemplate', () => {
+  it('renders a Service subclass with a singleton export, importing Service via the relative core path', () => {
+    const name = { pascal: 'Widget', camel: 'widget' };
+    const targetPath = 'src/app/components/widget';
+
+    expect(serviceTemplate(name, targetPath)).toBe(
+      `import { Service } from '../../../core/index.js';
+
+export class WidgetService extends Service<WidgetService> {  
+  constructor() {
+    super();
+  }
+
+}
+
+export const widgetService = WidgetService.getInstance();
+`
+    );
+  });
+});

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

@@ -0,0 +1,10 @@
+export const testTemplate = (name, targetPath, suffix) => {
+  const type = suffix.charAt(0).toUpperCase() + suffix.slice(1);
+
+  return `import { ${name.pascal}${type} } from '#root/dist/${targetPath}/${name.kebab}.${suffix}.js';
+
+describe('${name.pascal}${type}', () => {
+  it.todo('Write tests for ${name.pascal}${type}');
+});
+`;
+}

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

@@ -0,0 +1,27 @@
+import { testTemplate } from './test.template.js';
+
+describe('testTemplate', () => {
+  it('renders an it.todo stub importing the built output via #root/dist', () => {
+    const name = { pascal: 'Widget', kebab: 'widget' };
+    const targetPath = 'src/app/components/widget';
+
+    expect(testTemplate(name, targetPath, 'component')).toBe(
+      `import { WidgetComponent } from '#root/dist/src/app/components/widget/widget.component.js';
+
+describe('WidgetComponent', () => {
+  it.todo('Write tests for WidgetComponent');
+});
+`
+    );
+  });
+
+  it('capitalizes only the first letter of the suffix for the "Type" suffix on the class name', () => {
+    const name = { pascal: 'Home', kebab: 'home' };
+    const targetPath = 'src/app/views/home';
+
+    const result = testTemplate(name, targetPath, 'view');
+
+    expect(result).toContain('HomeView');
+    expect(result).toContain("it.todo('Write tests for HomeView');");
+  });
+});

package/templates/base/tools/generator/templates/{view.template.js.hbs → view/view.template.js.hbs}

@@ -1,11 +1,12 @@
-import { getRelToCore } from "../../utils/get-rel-to-core.js";
+import { getRelToCore } from "../../../utils/get-rel-to-core.js";
 
 export const viewTemplate = (name, targetPath) => {
   const relToCore = getRelToCore(targetPath);
+  const htmlTemplate = '__TEMPLATE_PLACEHOLDER__';
 
   return `import { View } from '${relToCore}';
 
-const template = {{#if template}}\`__TEMPLATE_PLACEHOLDER__\`{{else}}\`<div>${name.pascal} works !</div>\`{{/if}};
+const template = \`${htmlTemplate}\`;
 
 export class ${name.pascal}View extends View {
   constructor() {