@nutin/cli 1.3.0 → 2.0.0

package/templates/base/tools/testin-nutin/mocks/create-mock-method.test.js.hbs

@@ -0,0 +1,64 @@
+import { createMockMethod } from './create-mock-method.js';
+
+describe('createMockMethod', () => {
+  it('records every call', () => {
+    const fn = createMockMethod();
+    fn(1, 2);
+    fn('a');
+
+    expect(fn.calls).toEqual([[1, 2], ['a']]);
+  });
+
+  it('returns undefined by default', () => {
+    const fn = createMockMethod();
+    expect(fn()).toBe(undefined);
+  });
+
+  it('mockReturnValue makes every call return a fixed value', () => {
+    const fn = createMockMethod();
+    fn.mockReturnValue(42);
+
+    expect(fn()).toBe(42);
+    expect(fn('ignored arg')).toBe(42);
+  });
+
+  it('mockImplementation delegates to the given function', () => {
+    const fn = createMockMethod();
+    fn.mockImplementation((a, b) => a + b);
+
+    expect(fn(2, 3)).toBe(5);
+  });
+
+  it('mockReset clears recorded calls and configured behavior', () => {
+    const fn = createMockMethod();
+    fn.mockReturnValue(42);
+    fn(1);
+
+    fn.mockReset();
+
+    expect(fn.calls).toEqual([]);
+    expect(fn()).toBe(undefined);
+  });
+
+  it('falls back to the given default implementation', () => {
+    const fn = createMockMethod((a, b) => a + b);
+
+    expect(fn(2, 3)).toBe(5);
+  });
+
+  it('mockImplementation overrides the default implementation', () => {
+    const fn = createMockMethod(() => 'default');
+    fn.mockImplementation(() => 'overridden');
+
+    expect(fn()).toBe('overridden');
+  });
+
+  it('mockReset restores the default implementation', () => {
+    const fn = createMockMethod(() => 'default');
+    fn.mockImplementation(() => 'overridden');
+
+    fn.mockReset();
+
+    expect(fn()).toBe('default');
+  });
+});

package/templates/{features/testinNutin → base/tools}/testin-nutin/mocks/mock-event-bus.js.hbs

@@ -24,10 +24,10 @@ export class MockEventBus {
     this.off.calls = [];
     this.off.mockReset = () => { this.off.calls = []; };
 
-    this.on = (event, callback) => {
+    this.on = createMockMethod((event, callback) => {
       if (!this.handlers[event]) this.handlers[event] = [];
       this.handlers[event].push(callback);
-    };
+    });
 
     this.onDestroy = createMockMethod();
     this.reset = this.reset.bind(this);
@@ -37,6 +37,7 @@ export class MockEventBus {
     this.subscribe.mockReset();
     this.emit.mockReset();
     this.off.mockReset();
+    this.on.mockReset();
     this.onDestroy.mockReset();
     this.handlers = {};
   }

package/templates/base/tools/testin-nutin/mocks/mock-event-bus.test.js.hbs

@@ -0,0 +1,66 @@
+import { MockEventBus } from './mock-event-bus.js';
+
+describe('MockEventBus', () => {
+  it('on() + emit() dispatches the event data to the registered handler', () => {
+    const bus = new MockEventBus();
+    let received;
+    bus.on('greet', (data) => { received = data; });
+
+    bus.emit('greet', 'hello');
+
+    expect(received).toBe('hello');
+    expect(bus.emit.calls).toEqual([['greet', 'hello']]);
+  });
+
+  it('on() is a trackable mock', () => {
+    const bus = new MockEventBus();
+    const handler = () => {};
+    bus.on('greet', handler);
+
+    expect(bus.on).toHaveBeenCalled();
+    expect(bus.on).toHaveBeenCalledWith('greet', handler);
+  });
+
+  it('off() removes a previously registered handler', () => {
+    const bus = new MockEventBus();
+    let callCount = 0;
+    const handler = () => { callCount++; };
+    bus.on('greet', handler);
+    bus.off('greet', handler);
+
+    bus.emit('greet', 'hello');
+
+    expect(callCount).toBe(0);
+  });
+
+  it('subscribe() is a bare mock and does not actually register a handler', () => {
+    const bus = new MockEventBus();
+    let called = false;
+    const handler = () => { called = true; };
+    bus.subscribe('greet', handler);
+
+    bus.emit('greet', 'hello');
+
+    expect(called).toBeFalsy();
+    expect(bus.subscribe.calls.length).toBe(1);
+    expect(bus.subscribe.calls[0][0]).toBe('greet');
+    expect(bus.subscribe.calls[0][1]).toBe(handler);
+  });
+
+  it('reset() clears handlers and call logs', () => {
+    const bus = new MockEventBus();
+    let callCount = 0;
+    bus.on('greet', () => { callCount++; });
+    bus.emit('greet', 'x');
+    bus.subscribe('greet', () => {});
+
+    bus.reset();
+
+    expect(bus.emit.calls).toEqual([]);
+    expect(bus.subscribe.calls).toEqual([]);
+    expect(bus.on.calls).toEqual([]);
+
+    bus.emit('greet', 'y');
+    expect(callCount).toBe(1); // only the pre-reset emit reached the handler
+  });
+});

package/templates/base/tools/testin-nutin/mocks/mock-http-client.test.js.hbs

@@ -0,0 +1,26 @@
+import { MockHttpClient } from './mock-http-client.js';
+
+describe('MockHttpClient', () => {
+  it('exposes get/post/put/patch/delete as independent bare mocks', () => {
+    const client = new MockHttpClient();
+    client.get.mockReturnValue('get-result');
+    client.post('/widgets', { name: 'a' });
+
+    expect(client.get()).toBe('get-result');
+    expect(client.post.calls).toEqual([['/widgets', { name: 'a' }]]);
+    expect(client.put.calls).toEqual([]);
+  });
+
+  it('reset() clears calls and configured return values on every method', () => {
+    const client = new MockHttpClient();
+    client.get.mockReturnValue('cached');
+    client.get();
+    client.delete('/widgets/1');
+
+    client.reset();
+
+    expect(client.get.calls).toEqual([]);
+    expect(client.delete.calls).toEqual([]);
+    expect(client.get()).toBe(undefined);
+  });
+});

package/templates/base/tools/testin-nutin/mocks/mock-i18n.test.js.hbs

@@ -0,0 +1,61 @@
+import { MockI18n } from './mock-i18n.js';
+
+describe('MockI18n', () => {
+  it('exposes the constructor defaults via currentLanguage', () => {
+    const i18n = new MockI18n('fr', ['en', 'fr']);
+    expect(i18n.currentLanguage).toBe('fr');
+  });
+
+  it('translate/getBrowserLanguage run their built-in default implementation without needing .mockImplementation', () => {
+    const i18n = new MockI18n();
+
+    // No translations set — translate() falls back to returning the key itself.
+    expect(i18n.translate('some.key')).toBe('some.key');
+    expect(i18n.getBrowserLanguage()).toBe('en');
+  });
+
+  it('loadTranslations/initTranslations run their default implementation and update currentLanguage', async () => {
+    const i18n = new MockI18n('en', ['en', 'fr']);
+
+    await i18n.loadTranslations('fr');
+    expect(i18n.currentLanguage).toBe('fr');
+  });
+
+  it('translate is still trackable as a mock alongside its default implementation', () => {
+    const i18n = new MockI18n();
+    i18n.translate('some.key');
+
+    expect(i18n.translate).toHaveBeenCalledWith('some.key');
+  });
+
+  it('translate can be given real interpolation behavior via .mockImplementation', () => {
+    const i18n = new MockI18n();
+    i18n.setTranslations({ greeting: 'Hello {name}' });
+    i18n.translate.mockImplementation((key, params) => {
+      const value = i18n._translations[key] || key;
+      if (!params) return value;
+      return Object.entries(params).reduce((acc, [k, v]) => acc.replace(`{${k}}`, v), value);
+    });
+
+    expect(i18n.translate('greeting', { name: 'Ada' })).toBe('Hello Ada');
+  });
+
+  it('setTranslations/setDefaultTranslations seed real, readable state', () => {
+    const i18n = new MockI18n();
+    i18n.setTranslations({ a: '1' });
+    i18n.setDefaultTranslations({ b: '2' });
+
+    expect(i18n._translations).toEqual({ a: '1' });
+    expect(i18n._defaultTranslations).toEqual({ b: '2' });
+  });
+
+  it('reset() restores the constructor default language and clears translations', () => {
+    const i18n = new MockI18n('en');
+    i18n.setTranslations({ a: '1' });
+
+    i18n.reset();
+
+    expect(i18n._translations).toEqual({});
+    expect(i18n.currentLanguage).toBe('en');
+  });
+});

package/templates/base/tools/testin-nutin/mocks/mock-router.test.js.hbs

@@ -0,0 +1,29 @@
+import { MockRouter } from './mock-router.js';
+
+describe('MockRouter', () => {
+  it('stores the routes passed to the constructor', () => {
+    const routes = { '/home': {} };
+    const router = new MockRouter(routes);
+
+    expect(router.routes).toBe(routes);
+  });
+
+  it('navigate/handlePopState/handleNotFound/handleGuards/initializeEventListeners are independent bare mocks', () => {
+    const router = new MockRouter();
+    router.navigate('/about');
+
+    expect(router.navigate.calls).toEqual([['/about']]);
+    expect(router.handlePopState.calls).toEqual([]);
+  });
+
+  it('reset() clears every mock method and _currentView', () => {
+    const router = new MockRouter();
+    router.navigate('/about');
+    router._currentView = 'about-view';
+
+    router.reset();
+
+    expect(router.navigate.calls).toEqual([]);
+    expect(router._currentView).toBe(null);
+  });
+});

package/templates/base/tools/testin-nutin/runner.js.hbs

@@ -0,0 +1,100 @@
+import path from 'path';
+import {
+  registerTestGlobals, getTestFiles, runQueuedTests, setCurrentTestFile, print,
+  startCoverage, stopCoverage, buildCoverageReport, printCoverageReport, maybeWriteUncoveredReport,
+  writeSummaryReport, setupJsdom, teardownJsdom,
+} from './core/index.js';
+import config from '#root/nutin.config.js';
+
+const args = process.argv.slice(2);
+const coverageEnabled = args.includes('--coverage') || Boolean(config.testinNutin.coverage?.enabled);
+const verboseEnabled = args.includes('--verbose');
+const fileFilters = args.filter(arg => arg !== '--coverage' && arg !== '--verbose');
+
+// Tests import and run the compiled build output (dist/src/)
+// and has no sourcemap back to the .ts sources
+const origins = [];
+const coverageDirs = [];
+
+if (config.testinNutin.includeFramework) {
+  const frameworkDir = path.join('src', 'core');
+  origins.push(frameworkDir);
+  if (coverageEnabled) coverageDirs.push(path.join('dist', frameworkDir));
+}
+
+if (config.testinNutin.includeApp) {
+  const appDir = path.join('src', 'app');
+  origins.push(appDir);
+  if (coverageEnabled) coverageDirs.push(path.join('dist', appDir));
+}
+
+if (config.testinNutin.includeTools) origins.push('tools');
+
+registerTestGlobals();
+
+let testFiles = origins.flatMap(
+  origin => getTestFiles(path.join('..', origin))
+);
+
+if (fileFilters.length) {
+  testFiles = testFiles.filter(file => fileFilters.some(f => file.includes(f)));
+}
+
+async function loadTestFile(file) {
+  setupJsdom();
+  setCurrentTestFile(file);
+  await import(file);
+  teardownJsdom();
+}
+
+async function runCoverage(testResults) {
+  let scopedResults = await stopCoverage(coverageDirs);
+  if (fileFilters.length) {
+    scopedResults = scopedResults.filter(({ filePath }) => fileFilters.some(f => filePath.includes(f)));
+  }
+  const report = buildCoverageReport(scopedResults);
+  const globals = printCoverageReport(report);
+  writeSummaryReport(report, globals, testResults);
+  await maybeWriteUncoveredReport(report);
+
+  const threshold = config.testinNutin.coverage?.threshold;
+  if (typeof threshold === 'number') {
+    const misses = Object.entries({
+      lines: globals.globalLinesPct,
+      functions: globals.globalFunctionsPct,
+      branches: globals.globalBranchesPct,
+    }).filter(([, pct]) => pct < threshold);
+
+    if (misses.length) {
+      print.boldError(`\n✗ Coverage below threshold (${threshold}%): ${misses.map(([k, pct]) => `${k} ${pct.toFixed(1)}%`).join(', ')}\n`);
+      process.exit(1);
+    }
+  }
+}
+
+async function runTests() {
+  if (verboseEnabled) print.head('Test suites :');
+
+  if (coverageEnabled) await startCoverage();
+
+  for (const file of testFiles) {
+    try {
+      await loadTestFile(file);
+    } catch (error) {
+      print.boldError(`✗ ${file} failed to load:`);
+      print.grayError(error.stack);
+    }
+  }
+
+  const testResults = await runQueuedTests();
+
+  if (testResults.failed > 0) process.exitCode = 1;
+
+  if (coverageEnabled) await runCoverage(testResults);
+}
+
+runTests().catch((err) => {
+  print.boldError(`Unexpected error: ${err.message}`);
+  print.grayError(err.stack);
+  process.exitCode = 1;
+});

package/templates/base/tools/testin-nutin/watch-tests.js.hbs

@@ -0,0 +1,37 @@
+import chokidar from 'chokidar';
+import { exec } from 'child_process';
+import path from 'path';
+import { print } from './core/index.js'
+
+const watcher = chokidar.watch(['src', 'test', 'unit', 'e2e'], {
+  ignored: /(^|[/\\])\../,
+  persistent: true,
+});
+
+print.boldHead('Watching for test changes...')
+
+watcher.on('error', (err) => {
+  print.boldError(`\nWatcher error: ${err.message}`);
+});
+
+let isRunning = false;
+let runTimeout = null;
+
+watcher.on('change', (filePath) => {
+  if (runTimeout) clearTimeout(runTimeout);
+
+  runTimeout = setTimeout(() => {
+    if (isRunning) return;
+    isRunning = true;
+
+    console.clear();
+    print.boldInfo(`\n🔄 File changed: ${path.relative(process.cwd(), filePath)}\n`);
+
+    exec('node --experimental-modules testin-nutin/runner.js', { maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+      if (stdout) process.stdout.write(stdout);
+      if (stderr) process.stderr.write(stderr);
+      if (err) print.boldError(`\nTest run failed: ${err.message}`);
+      isRunning = false;
+    });
+  }, 100);
+});

package/templates/base/tools/utils/error-exit.js.hbs

@@ -0,0 +1,8 @@
+import { exit } from 'process';
+import { print } from './print.js';
+
+export function errorExit(err, origin = '') {
+  print.boldError(`\n${origin} - Error: ${ err.message || err }`);
+  if (err.stack) print.grayError(err.stack)
+  exit(1);
+}

package/templates/base/tools/utils/format.js.hbs

@@ -5,20 +5,20 @@ export function getLastWord(input) {
 }
 
 export function capitalized(input) {
-	const formatted = input.replace(
+  const formatted = input.replace(
     /\w*/g,
     function(txt) {
       return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
     }) 
-	return formatted.replace(/,/g, '');
+  return formatted.replace(/,/g, '');
 }
 
 export function kebabCased(input) {
-	return input.replace(/[A-Z][a-z]*/g, str => str.toLowerCase() + ' ').trim().replace(/ /g, '-').replace(/,/g, '');
+  return input.replace(/[A-Z][a-z]*/g, str => str.toLowerCase() + ' ').trim().replace(/ /g, '-').replace(/,/g, '');
 }
 
 export function camelCased(input) {
-	return input
+  return input
     .split('-')
     .map((word, index) => 
       index === 0 
@@ -36,10 +36,10 @@ export function pascalCased(input) {
 }
 
 export function allFormats(input) {
-	return {
-		kebab: kebabCased(input),
-		pascal: pascalCased(input),
-		camel: camelCased(input),
-		capitalized: capitalized(input)
-	}
+  return {
+    kebab: kebabCased(input),
+    pascal: pascalCased(input),
+    camel: camelCased(input),
+    capitalized: capitalized(input)
+  }
 }

package/templates/base/tools/utils/format.test.js.hbs

@@ -0,0 +1,45 @@
+import { getLastWord, capitalized, kebabCased, camelCased, pascalCased, allFormats } from './format.js';
+
+describe('format', () => {
+  it('getLastWord returns the last non-empty path segment', () => {
+    expect(getLastWord('a/b/c')).toBe('c');
+    expect(getLastWord('a/b/c/')).toBe('c');
+    expect(getLastWord('single')).toBe('single');
+  });
+
+  it('getLastWord returns an empty string for non-string input', () => {
+    expect(getLastWord(123)).toBe('');
+    expect(getLastWord(undefined)).toBe('');
+  });
+
+  it('capitalized title-cases each word and strips commas', () => {
+    expect(capitalized('hello world')).toBe('Hello World');
+    expect(capitalized('HELLO, WORLd')).toBe('Hello World');
+  });
+
+  it('kebabCased splits on capital letters', () => {
+    expect(kebabCased('HelloWorld')).toBe('hello-world');
+    // leading lowercase run isn't matched by the [A-Z][a-z]* regex, so it
+    // sticks to the next captured word instead of being split off on its own
+    expect(kebabCased('myComponentName')).toBe('mycomponent-name');
+  });
+
+  it('camelCased joins kebab-case segments with an initial lowercase', () => {
+    expect(camelCased('my-component-name')).toBe('myComponentName');
+    expect(camelCased('single')).toBe('single');
+  });
+
+  it('pascalCased joins kebab-case segments with every segment capitalized', () => {
+    expect(pascalCased('my-component-name')).toBe('MyComponentName');
+    expect(pascalCased('single')).toBe('Single');
+  });
+
+  it('allFormats returns all four casings for the same input', () => {
+    expect(allFormats('my-component')).toEqual({
+      kebab: 'my-component',
+      pascal: 'MyComponent',
+      camel: 'myComponent',
+      capitalized: 'My-Component',
+    });
+  });
+});

package/templates/base/tools/utils/get-files-recursive.js.hbs

@@ -16,7 +16,12 @@ export function getFilesRecursive(dir, extension) {
 
   function findFilesRecursively(currentDir) {
     const files = [];
-    const items = fs.readdirSync(currentDir, { withFileTypes: true });
+    let items;
+    try {
+      items = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch (err) {
+      throw new Error(`Failed to read directory "${currentDir}": ${err.message}`, { cause: err });
+    }
 
     for (const item of items) {
       const fullPath = path.join(currentDir, item.name);

package/templates/base/tools/utils/get-files-recursive.test.js.hbs

@@ -0,0 +1,49 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { getFilesRecursive } from './get-files-recursive.js';
+
+describe('getFilesRecursive', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nutin-get-files-recursive-'));
+    fs.mkdirSync(path.join(tmpDir, 'nested'), { recursive: true });
+    fs.writeFileSync(path.join(tmpDir, 'a.js'), '');
+    fs.writeFileSync(path.join(tmpDir, 'b.css'), '');
+    fs.writeFileSync(path.join(tmpDir, 'nested', 'c.js'), '');
+    fs.writeFileSync(path.join(tmpDir, 'nested', 'd.txt'), '');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('recursively collects files matching a single extension', () => {
+    const files = getFilesRecursive(tmpDir, '.js').sort();
+    expect(files).toEqual([
+      path.join(tmpDir, 'a.js'),
+      path.join(tmpDir, 'nested', 'c.js'),
+    ].sort());
+  });
+
+  it('accepts an extension without a leading dot', () => {
+    const files = getFilesRecursive(tmpDir, 'js').sort();
+    expect(files).toEqual([
+      path.join(tmpDir, 'a.js'),
+      path.join(tmpDir, 'nested', 'c.js'),
+    ].sort());
+  });
+
+  it('accepts an array of extensions', () => {
+    const files = getFilesRecursive(tmpDir, ['.css', '.txt']).sort();
+    expect(files).toEqual([
+      path.join(tmpDir, 'b.css'),
+      path.join(tmpDir, 'nested', 'd.txt'),
+    ].sort());
+  });
+
+  it('returns an empty array when the directory does not exist', () => {
+    expect(getFilesRecursive(path.join(tmpDir, 'does-not-exist'), '.js')).toEqual([]);
+  });
+});

package/templates/base/tools/utils/get-rel-to-core.test.js.hbs

@@ -0,0 +1,18 @@
+import path from 'path';
+import { getRelToCore } from './get-rel-to-core.js';
+
+describe('getRelToCore', () => {
+  it('adds one "../" per path segment before core/index.js', () => {
+    const targetPath = ['src', 'app', 'components', 'widget'].join(path.sep);
+    expect(getRelToCore(targetPath)).toBe('../../../core/index.js');
+  });
+
+  it('adds no "../" for a single-segment path', () => {
+    expect(getRelToCore('widget')).toBe('core/index.js');
+  });
+
+  it('scales with the number of segments', () => {
+    const targetPath = ['a', 'b'].join(path.sep);
+    expect(getRelToCore(targetPath)).toBe('../core/index.js');
+  });
+});

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

@@ -3,8 +3,6 @@ export * from './format.js';
 export * from './get-files-recursive.js';
 export * from './run-command.js';
 export * from './run-script.js';
-export * from './export-flags.js';
 export * from './prompt-boolean.js';
-{{#if i18n}}
 export * from './languages.js';
-{{/if}}
+export * from './error-exit.js';

package/templates/base/tools/utils/languages.js.hbs

@@ -0,0 +1,15 @@
+import fs from 'fs';
+import path from 'path';
+import { errorExit } from './error-exit.js';
+
+const langsPath = path.join(process.cwd(), 'config', 'languages.json');
+
+let langs;
+try {
+  langs = JSON.parse(fs.readFileSync(langsPath, 'utf-8'));
+} catch (err) {
+  errorExit(new Error(`config/languages.json is missing or malformed: ${err.message}`), 'languages');
+}
+
+export const LANGUAGES = langs.languages;
+export const DEFAULT_LANGUAGE = langs.defaultLanguage;

package/templates/base/tools/utils/languages.test.js.hbs

@@ -0,0 +1,16 @@
+import { LANGUAGES, DEFAULT_LANGUAGE } from './languages.js';
+
+describe('languages', () => {
+  it('reads LANGUAGES from config/languages.json', () => {
+    expect(Array.isArray(LANGUAGES)).toBeTruthy();
+    expect(LANGUAGES.length).toBeGreaterThan(0);
+  });
+
+  it('reads DEFAULT_LANGUAGE from config/languages.json', () => {
+    expect(typeof DEFAULT_LANGUAGE).toBe('string');
+  });
+
+  it('includes the default language among the supported languages', () => {
+    expect(LANGUAGES).toContain(DEFAULT_LANGUAGE);
+  });
+});