@nutin/cli 1.3.1 → 2.0.0

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

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

@@ -12,20 +12,26 @@ export const chalk = {
   boldYellow: (s) => `\x1b[1;33m${s}\x1b[0m`,
   boldCyan: (s) => `\x1b[1;36m${s}\x1b[0m`,
   boldPurple: (s) => `\x1b[1;35m${s}\x1b[0m`,
+  boldGray: (s) => `\x1b[1;90m${s}\x1b[0m`,
 };
 
 export const print = {
-	head: (s) => console.log(`${chalk.purple(s)}`),  
-	boldHead : (s) => console.log(`${chalk.boldPurple(s)}`),
-	section: (s) => console.log(`${chalk.yellow(s)}`),
-	boldSection: (s) => console.log(`${chalk.boldYellow(s)}`),
-	info: (s) => console.log(`${chalk.green(s)}`),
-  boldInfo: (s) => console.log(`${chalk.boldGreen(s)}`),
-	success: (s) => console.log(`${chalk.cyan(s)}`),
-	boldSuccess: (s) => console.log(`${chalk.boldCyan(s)}`),
-	error: (s) => console.error(`${chalk.red(s)}`),
-	boldError: (s) => console.error(`${chalk.boldRed(s)}`),
-  grayError: (s) => console.error(`${chalk.gray(s)}`),
-  blue: (s) => console.log(`${chalk.blue(s)}`),
-  boldBlue: (s) => console.log(`${chalk.boldBlue(s)}`),
+  head: (s) => console.info(`${chalk.purple(s)}`),  
+  boldHead : (s) => console.info(`${chalk.boldPurple(s)}`),
+  section: (s) => console.info(`${chalk.yellow(s)}`),
+  boldSection: (s) => console.info(`${chalk.boldYellow(s)}`),
+  info: (s) => console.info(`${chalk.green(s)}`),
+  boldInfo: (s) => console.info(`${chalk.boldGreen(s)}`),
+  success: (s) => console.log(`${chalk.cyan(s)}`),
+  boldSuccess: (s) => console.log(`${chalk.boldCyan(s)}`),
+  gray: (s) => console.info(`${chalk.gray(s)}`),
+  boldGray: (s) => console.info(`${chalk.boldGray(s)}`),
+  blue: (s) => console.info(`${chalk.blue(s)}`),
+  boldBlue: (s) => console.info(`${chalk.boldBlue(s)}`),
+  error: (s) => console.error(`${chalk.red(s)}`),
+  boldError: (s) => console.error(`${chalk.boldRed(s)}`),
+  grayError: (s) => console.error(`${chalk.boldGray(s)}`),
+  warn: (s) => console.warn(`${chalk.yellow(s)}`),
+  boldWarn: (s) => console.warn(`${chalk.yellow(s)}`),
+  debug: (s) => console.debug(`${chalk.gray(s)}`),
 }

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

@@ -0,0 +1,60 @@
+import { print, chalk } from './print.js';
+
+describe('print', () => {
+  let infoSpy;
+  let logSpy;
+  let errorSpy;
+  let warnSpy;
+  let debugSpy;
+
+  beforeEach(() => {
+    infoSpy = spyOn(console, 'info').andCallFake(() => {});
+    logSpy = spyOn(console, 'log').andCallFake(() => {});
+    errorSpy = spyOn(console, 'error').andCallFake(() => {});
+    warnSpy = spyOn(console, 'warn').andCallFake(() => {});
+    debugSpy = spyOn(console, 'debug').andCallFake(() => {});
+  });
+
+  afterEach(() => {
+    infoSpy.restore();
+    logSpy.restore();
+    errorSpy.restore();
+    warnSpy.restore();
+    debugSpy.restore();
+  });
+
+  it('info() writes to console.info, colorized green', () => {
+    print.info('hello');
+    expect(infoSpy.callCount).toBe(1);
+    expect(infoSpy.lastCall).toEqual([chalk.green('hello')]);
+  });
+
+  it('success() writes to console.log, colorized cyan', () => {
+    print.success('done');
+    expect(logSpy.callCount).toBe(1);
+    expect(logSpy.lastCall).toEqual([chalk.cyan('done')]);
+  });
+
+  it('error() writes to console.error, colorized red', () => {
+    print.error('oops');
+    expect(errorSpy.callCount).toBe(1);
+    expect(errorSpy.lastCall).toEqual([chalk.red('oops')]);
+  });
+
+  it('warn() writes to console.warn, colorized yellow', () => {
+    print.warn('careful');
+    expect(warnSpy.callCount).toBe(1);
+    expect(warnSpy.lastCall).toEqual([chalk.yellow('careful')]);
+  });
+
+  it('debug() writes to console.debug, colorized gray', () => {
+    print.debug('trace');
+    expect(debugSpy.callCount).toBe(1);
+    expect(debugSpy.lastCall).toEqual([chalk.gray('trace')]);
+  });
+
+  it('chalk wraps text in the matching ANSI escape codes', () => {
+    expect(chalk.red('x')).toBe('\x1b[31mx\x1b[0m');
+    expect(chalk.boldGreen('x')).toBe('\x1b[1;32mx\x1b[0m');
+  });
+});

package/templates/base/tools/utils/prompt-boolean.js.hbs

@@ -7,9 +7,16 @@ export const promptBoolean = (question) => {
   });
 
   return new Promise((resolve) => {
+    let answered = false;
+
     rl.question(`${question} (y/n): `, (answer) => {
+      answered = true;
       rl.close();
       resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
     });
+
+    rl.on('close', () => {
+      if (!answered) resolve(false);
+    });
   });
 };

package/templates/base/tools/utils/prompt-boolean.test.js.hbs

@@ -0,0 +1,54 @@
+import readline from 'readline';
+import { promptBoolean } from './prompt-boolean.js';
+
+describe('promptBoolean', () => {
+  let createInterfaceSpy;
+  let answer;
+
+  beforeEach(() => {
+    createInterfaceSpy = spyOn(readline, 'createInterface').andCallFake(() => ({
+      question: (_question, callback) => callback(answer),
+      close: () => {},
+      on: () => {},
+    }));
+  });
+
+  afterEach(() => {
+    createInterfaceSpy.restore();
+  });
+
+  it('resolves true for "y"', async () => {
+    answer = 'y';
+    expect(await promptBoolean('continue?')).toBe(true);
+  });
+
+  it('resolves true for "yes", case-insensitively', async () => {
+    answer = 'YES';
+    expect(await promptBoolean('continue?')).toBe(true);
+  });
+
+  it('resolves false for "n"', async () => {
+    answer = 'n';
+    expect(await promptBoolean('continue?')).toBe(false);
+  });
+
+  it('resolves false for anything else', async () => {
+    answer = 'maybe';
+    expect(await promptBoolean('continue?')).toBe(false);
+  });
+
+  it('resolves false instead of hanging if stdin closes before an answer', async () => {
+    createInterfaceSpy.restore();
+    let closeHandler;
+    createInterfaceSpy = spyOn(readline, 'createInterface').andCallFake(() => ({
+      question: () => {},
+      close: () => {},
+      on: (event, handler) => { if (event === 'close') closeHandler = handler; },
+    }));
+
+    const resultPromise = promptBoolean('continue?');
+    closeHandler();
+
+    expect(await resultPromise).toBe(false);
+  });
+});

package/templates/base/tools/utils/run-command.js.hbs

@@ -1,8 +1,10 @@
 import { spawn } from 'child_process';
 
-export function runCommand(command, args = []) {
+export function runCommand(command, args = [], options = {}) {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: 'inherit', shell: true });
+    const child = spawn([command, ...args].join(' '), { stdio: 'inherit', shell: true, ...options });
+
+    child.on('error', (err) => reject(err));
 
     child.on('close', (code) => {
       if (code === 0) resolve();

package/templates/base/tools/utils/run-command.test.js.hbs

@@ -0,0 +1,19 @@
+import { runCommand } from './run-command.js';
+
+describe('runCommand', () => {
+  it('resolves when the child process exits with code 0', async () => {
+    const result = await runCommand('node', ['-e', 'process.exitCode=0']);
+    expect(result).toBe(undefined);
+  });
+
+  it('rejects with the exit code when the child process exits non-zero', async () => {
+    let error;
+    try {
+      await runCommand('node', ['-e', 'process.exitCode=7']);
+    } catch (err) {
+      error = err;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toContain('7');
+  });
+});

package/templates/base/tools/utils/run-script.js.hbs

@@ -4,17 +4,28 @@ import process from 'process';
 import { print } from './index.js';
 
 export function runScript(path, message) {
-  print.boldSection(message);
+  if (!message) print.boldSection(`Running ${path}...`);
+  else print.boldSection(`${message}`);
 
-  const args = [resolve(path)];
+  const args = [resolve(path), '--silent'];
 
-  const result = spawnSync('node', args, 
+  const result = spawnSync('node', args,
     { 
       stdio: 'inherit',
       env: { ...process.env }, 
     }
   );
 
+  if (result.error) {
+    print.boldError(`\nScript ${path} could not be started: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  if (result.signal) {
+    print.boldError(`\nScript ${path} was terminated by signal ${result.signal}.`);
+    process.exit(1);
+  }
+
   if (result.status !== 0) {
     print.boldError(`\nScript ${path} failed.`);
     process.exit(result.status ?? 1);

package/templates/base/tools/utils/run-script.test.js.hbs

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { runScript } from './run-script.js';
+
+describe('runScript', () => {
+  let tmpDir;
+  let exitSpy;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nutin-run-script-'));
+    exitSpy = spyOn(process, 'exit').andCallFake(() => {});
+  });
+
+  afterEach(() => {
+    exitSpy.restore();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('does not call process.exit when the script exits 0', () => {
+    const scriptPath = path.join(tmpDir, 'ok.js');
+    fs.writeFileSync(scriptPath, '// no-op, exits 0 by default\n');
+
+    // runScript prints its status message via console.info as part of its real behavior
+    silenceConsole('info', () => runScript(scriptPath, 'running ok script'));
+
+    expect(exitSpy.callCount).toBe(0);
+  });
+
+  it('calls process.exit with the script status when it exits non-zero', () => {
+    const scriptPath = path.join(tmpDir, 'fail.js');
+    fs.writeFileSync(scriptPath, 'process.exitCode = 3;\n');
+
+    // runScript prints its status message and a failure message via console.info/console.error
+    silenceConsole(['info', 'error'], () => runScript(scriptPath, 'running failing script'));
+
+    expect(exitSpy.callCount).toBe(1);
+    expect(exitSpy.lastCall).toEqual([3]);
+  });
+});

package/templates/features/{deployHelper → docker}/.dockerignore.hbs

@@ -8,13 +8,13 @@ dist-build
 *.md
 .env
 *.txt
-{{#if testinNutin}}
 *.test.js
-testin-nutin
-{{/if}}
 *.log
 
-npm-debug.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
 .nyc_output
 coverage
 .DS_Store