qunitx-cli 0.5.0 → 0.5.2

package/README.md

@@ -1,6 +1,7 @@
 # qunitx-cli
 
 [![CI](https://github.com/izelnakri/qunitx-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/izelnakri/qunitx-cli/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/izelnakri/qunitx-cli/branch/main/graph/badge.svg)](https://codecov.io/gh/izelnakri/qunitx-cli)
 [![npm](https://img.shields.io/npm/v/qunitx-cli)](https://www.npmjs.com/package/qunitx-cli)
 [![npm downloads](https://img.shields.io/npm/dm/qunitx-cli)](https://www.npmjs.com/package/qunitx-cli)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
@@ -8,7 +9,7 @@
 Browser-based test runner for [QUnitX](https://github.com/izelnakri/qunitx) — bundles your JS/TS tests
 with esbuild, runs them in headless Chrome, and streams TAP output to the terminal.
 
-![qunitx-cli demo](demo/demo.gif)
+![qunitx-cli demo](docs/demo.gif)
 
 ## Features
 
@@ -154,7 +155,7 @@ Options:
 npm install
 make check                 # lint + test (run before every commit)
 make test                  # run tests only
-make demo                  # regenerate demo output
+make demo                  # regenerate docs/demo.gif
 make release LEVEL=patch   # bump version, update changelog, tag, push
 ```
 

package/cli.js

@@ -19,7 +19,7 @@ process.title = 'qunitx';
     return await initializeProject();
   }
 
-  let config = await setupConfig();
+  const config = await setupConfig();
 
   return await run(config);
 })();

package/deno.json

@@ -0,0 +1,7 @@
+{
+  "lint": {
+    "rules": {
+      "exclude": ["no-process-global", "no-node-globals", "no-window"]
+    }
+  }
+}

package/docs/demo-math-test.failing.js

@@ -0,0 +1,59 @@
+import { module, test } from 'qunitx';
+
+module('Math', (hooks) => {
+  hooks.beforeEach(function () {
+    this.numbers = [1, 2, 3];
+  });
+
+  test('equal and notEqual', (assert) => {
+    assert.equal(1 + 1, 2, 'addition');
+    assert.notEqual(1 + 1, 3);
+  });
+
+  test('strictEqual', (assert) => {
+    assert.strictEqual('hello', 'hello');
+    assert.notStrictEqual(1, '1', '1 !== "1" (type-strict)');
+  });
+
+  test('deepEqual — user profile sync', (assert) => {
+    const response = { user: { name: 'Alice', scores: [95, 88, 92] }, active: true };
+    const expected = { user: { name: 'Alice', scores: [95, 88, 92] }, active: true };
+    assert.deepEqual(response, expected, 'API response matches expected shape');
+  });
+
+  test('hooks: beforeEach resets state per test', function (assert) {
+    assert.deepEqual(this.numbers, [1, 2, 3]);
+    this.numbers.push(4);
+    assert.equal(this.numbers.length, 4);
+  });
+
+  module('Async', () => {
+    test('async/await', async (assert) => {
+      const data = await Promise.resolve({ id: 1, name: 'Alice' });
+      console.log(data.name, 'resolved in Chrome');
+      assert.propContains(data, { name: 'Alice' });
+    });
+
+    test('assert.rejects', async (assert) => {
+      await assert.rejects(Promise.reject(new TypeError('invalid')), TypeError);
+    });
+  });
+});
+
+module('Assertions', () => {
+  test('throws — match by constructor', (assert) => {
+    assert.throws(() => { throw new RangeError('out of bounds'); }, RangeError);
+  });
+
+  test('step/verifySteps — execution order', (assert) => {
+    assert.step('init');
+    assert.step('process');
+    assert.step('done');
+    assert.verifySteps(['init', 'process', 'done']);
+  });
+
+  test('propContains — partial object match', (assert) => {
+    const user = { id: 1, name: 'Alice', role: 'admin', active: true };
+    assert.propContains(user, { role: 'admin', active: true });
+  });
+});

package/docs/demo-math-test.js

@@ -0,0 +1,59 @@
+import { module, test } from 'qunitx';
+
+module('Math', (hooks) => {
+  hooks.beforeEach(function () {
+    this.numbers = [1, 2, 3];
+  });
+
+  test('equal and notEqual', (assert) => {
+    assert.equal(1 + 1, 2, 'addition');
+    assert.notEqual(1 + 1, 3);
+  });
+
+  test('strictEqual', (assert) => {
+    assert.strictEqual('hello', 'hello');
+    assert.notStrictEqual(1, '1', '1 !== "1" (type-strict)');
+  });
+
+  test('deepEqual — user profile sync', (assert) => {
+    const response = { user: { name: 'Alice', scores: [95, 88, 92] }, active: true };
+    const expected = { user: { name: 'Alice', scores: [95, 88, 92] }, active: true };
+    assert.deepEqual(response, expected, 'API response matches expected shape');
+  });
+
+  test('hooks: beforeEach resets state per test', function (assert) {
+    assert.deepEqual(this.numbers, [1, 2, 3]);
+    this.numbers.push(4);
+    assert.equal(this.numbers.length, 4);
+  });
+
+  module('Async', () => {
+    test('async/await', async (assert) => {
+      const data = await Promise.resolve({ id: 1, name: 'Alice' });
+      console.log(data.name, 'resolved in Chrome');
+      assert.propContains(data, { name: 'Alice' });
+    });
+
+    test('assert.rejects', async (assert) => {
+      await assert.rejects(Promise.reject(new TypeError('invalid')), TypeError);
+    });
+  });
+});
+
+module('Assertions', () => {
+  test('throws — match by constructor', (assert) => {
+    assert.throws(() => { throw new RangeError('out of bounds'); }, RangeError);
+  });
+
+  test('step/verifySteps — execution order', (assert) => {
+    assert.step('init');
+    assert.step('process');
+    assert.step('done');
+    assert.verifySteps(['init', 'process', 'done']);
+  });
+
+  test('propContains — partial object match', (assert) => {
+    const user = { id: 1, name: 'Alice', role: 'admin', active: true };
+    assert.propContains(user, { role: 'admin', active: true });
+  });
+});

package/docs/demo.tape

@@ -0,0 +1,92 @@
+# QUnitX demo — terminal portion of the composite GIF
+# Run: nix run nixpkgs#vhs -- docs/demo.tape
+# Output: docs/terminal.gif  (composited into docs/demo.gif by make-demo-gif.sh)
+
+Output docs/terminal.gif
+
+Set Shell "zsh"
+Set FontSize 14
+Set Width 700
+Set Height 680
+Set Theme "Dracula"
+Set Padding 20
+Set TypingSpeed 55ms
+Set PlaybackSpeed 0.85
+
+Hide
+Type "setopt interactive_comments"
+Enter
+Type "alias qunitx=$(pwd)/cli.js"
+Enter
+Sleep 200ms
+# Create failing version: copy demo-math-test.js with the score bug (88 → 87)
+Type "cp docs/demo-math-test.js docs/demo-math-test.failing.js && sed -i '/const response/s/88/87/' docs/demo-math-test.failing.js"
+Enter
+Sleep 400ms
+Show
+
+# ── 1. Show the test file ─────────────────────────────────────────────────────
+Type "bat --paging=never docs/demo-math-test.js"
+Enter
+Sleep 4000ms
+
+Hide
+Type "clear"
+Enter
+Show
+
+# ── 2. qunitx --debug: headless Chrome, TAP output, browser console ───────────
+Type "# qunitx: headless Chrome, streams TAP, pipes browser console"
+Enter
+Sleep 400ms
+Type "qunitx docs/demo-math-test.failing.js --debug"
+Enter
+Sleep 9500ms
+
+Hide
+Type "clear"
+Enter
+Show
+
+# ── 3. --failFast: stop immediately on the first failure ──────────────────────
+Type "# --failFast: stop on the first failure"
+Enter
+Sleep 400ms
+Type "qunitx docs/demo-math-test.failing.js --failFast"
+Enter
+Sleep 6000ms
+
+Hide
+Type "clear"
+Enter
+# Background: 'fix' the file 9 seconds from now — fires during the watch run
+Type "(sleep 9 && cp docs/demo-math-test.js docs/demo-math-test.failing.js) &"
+Enter
+Sleep 200ms
+Show
+
+# ── 4. --watch: live fail → fix → pass cycle ──────────────────────────────────
+Type "# --watch: re-runs on every file save"
+Enter
+Sleep 400ms
+Type "qunitx docs/demo-math-test.failing.js --watch"
+Enter
+Sleep 4500ms
+# Background fires ~9s after the hidden job was queued, ~5.2s after qunitx started.
+# Initial failing run is done; file is replaced; watch detects change and re-runs.
+Sleep 5500ms
+Ctrl+C
+Sleep 800ms
+
+Hide
+Type "clear"
+Enter
+Show
+
+# ── 5. node --test: same file, same results ───────────────────────────────────
+Type "# Same file in Node.js — zero extra config"
+Enter
+Sleep 400ms
+Type "node --test docs/demo-math-test.js"
+Enter
+Sleep 5500ms

package/docs/make-demo-gif.sh

@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+# Regenerates docs/demo.gif — the combined terminal + browser demo GIF.
+#
+# Prerequisites (available in the nix devShell):
+#   nix run nixpkgs#vhs        — terminal recorder
+#   CHROME_BIN                 — path to Chromium binary
+#   ffmpeg, gifsicle           — compositing and optimisation
+#
+# Usage:
+#   export CHROME_BIN=/nix/store/<hash>-chromium-<ver>/bin/chromium
+#   bash docs/make-demo-gif.sh
+#
+# Outputs:
+#   docs/terminal.gif           — terminal-only animation (VHS)
+#   docs/browser-*.png          — browser screenshots (puppeteer)
+#   docs/demo.gif               — final composite (1000×500, ~500 KB)
+
+set -euo pipefail
+cd "$(dirname "$0")/.."
+DOCS=docs
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+
+# ── 1. Terminal GIF via VHS ────────────────────────────────────────────────────
+echo "==> Recording terminal animation (VHS)..."
+nix run nixpkgs#vhs -- "$DOCS/demo.tape"
+echo "    terminal.gif: $(du -h "$DOCS/terminal.gif" | cut -f1)"
+
+# ── 2. Browser screenshots via puppeteer ──────────────────────────────────────
+echo "==> Taking browser screenshots..."
+if [[ -z "${CHROME_BIN:-}" ]]; then
+  CHROME_BIN=$(nix eval --raw nixpkgs#chromium.outPath)/bin/chromium
+fi
+CHROME_BIN="$CHROME_BIN" node "$DOCS/take-browser-screenshots.js"
+
+# ── 3. Get terminal duration ───────────────────────────────────────────────────
+DURATION=$(ffprobe -v error -show_entries format=duration \
+  -of default=noprint_wrappers=1:nokey=1 "$DOCS/terminal.gif")
+DURATION=${DURATION%.*}
+
+# ── 4. Terminal: scale to 500×500, per-module palette, optimise ───────────────
+echo "==> Scaling terminal to 500×500..."
+ffmpeg -y -i "$DOCS/terminal.gif" \
+  -vf "fps=8,scale=500:500:flags=lanczos,pad=500:500:(ow-iw)/2:(oh-ih)/2,split[a][b];[a]palettegen=max_colors=200[p];[b][p]paletteuse" \
+  -t "$DURATION" -loop 0 "$TMP/terminal_small.gif" 2>/dev/null
+nix run nixpkgs#gifsicle -- -O3 --lossy=80 "$TMP/terminal_small.gif" -o "$TMP/terminal_opt.gif" 2>/dev/null
+
+# ── 5. Browser slideshow: scale to 500×500, 2fps ──────────────────────────────
+# Frame timing:
+#   1. Failing tests + deepEqual diff  — 14s (give viewers time to read the diff)
+#   2. All passing (simulated refresh) —  8s (quick "it's fixed!")
+#   3. Filtered to Async module        —  8s (shareable URL demo)
+#   4. deepEqual test expanded         — remainder
+D1=14
+D2=8
+D3=8
+D4=$(( DURATION - D1 - D2 - D3 ))
+echo "==> Building browser slideshow (${D1}s / ${D2}s / ${D3}s / ${D4}s)..."
+cat > "$TMP/browser_list.txt" << EOF
+file '$(realpath $DOCS/browser-1-failing.png)'
+duration $D1
+file '$(realpath $DOCS/browser-2-all-passed.png)'
+duration $D2
+file '$(realpath $DOCS/browser-3-filtered.png)'
+duration $D3
+file '$(realpath $DOCS/browser-4-expanded.png)'
+duration $D4
+file '$(realpath $DOCS/browser-4-expanded.png)'
+EOF
+
+ffmpeg -y -f concat -safe 0 -i "$TMP/browser_list.txt" \
+  -vf "fps=2,scale=500:500:flags=lanczos,pad=500:500:(ow-iw)/2:(oh-ih)/2,split[a][b];[a]palettegen=max_colors=200[p];[b][p]paletteuse" \
+  -t "$DURATION" -loop 0 "$TMP/browser_small.gif" 2>/dev/null
+nix run nixpkgs#gifsicle -- -O3 --lossy=80 "$TMP/browser_small.gif" -o "$TMP/browser_opt.gif" 2>/dev/null
+
+# ── 6. Composite: hstack with shared palette ──────────────────────────────────
+echo "==> Compositing side-by-side..."
+ffmpeg -y -i "$TMP/terminal_opt.gif" -i "$TMP/browser_opt.gif" \
+  -filter_complex \
+  "[0:v][1:v]hstack=inputs=2,split[a][b]; \
+   [a]palettegen=max_colors=128[p];[b][p]paletteuse=dither=bayer:bayer_scale=5" \
+  -t "$DURATION" -loop 0 "$TMP/combined.gif" 2>/dev/null
+
+# ── 7. Final optimise ─────────────────────────────────────────────────────────
+echo "==> Optimising with gifsicle..."
+nix run nixpkgs#gifsicle -- -O3 --lossy=100 "$TMP/combined.gif" -o "$DOCS/demo.gif" 2>/dev/null
+
+echo "==> Done: $DOCS/demo.gif ($(du -h "$DOCS/demo.gif" | cut -f1))"

package/docs/take-browser-screenshots.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+// Serves QUnit test pages and captures screenshots for the demo GIF.
+// Usage: CHROME_BIN=... node docs/take-browser-screenshots.js
+// Output: docs/browser-{1-failing,2-all-passed,3-filtered,4-expanded}.png
+
+import http from 'node:http';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import puppeteer from 'puppeteer';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+const CHROME =
+  process.env.CHROME_BIN ||
+  `${process.env.HOME}/.cache/puppeteer/chrome/linux-146.0.7680.66/chrome-linux64/chrome`;
+
+const qunitJS = await fs.readFile(path.join(ROOT, 'vendor/qunit.js'), 'utf8');
+const qunitCSS = await fs.readFile(path.join(ROOT, 'vendor/qunit.css'), 'utf8');
+
+// ── Shared test suite ────────────────────────────────────────────────────────
+// Bug is in deepEqual: scores[1] is 87 in "actual" but 88 in "expected".
+// Swap BUGGY_VALUE → FIXED_VALUE to simulate saving the fix.
+const BUGGY_VALUE = '87';
+const FIXED_VALUE = '88';
+
+const makeSuite = (scoreValue) => `
+QUnit.module('Assertions', (hooks) => {
+  QUnit.test('ok / notOk', (assert) => {
+    assert.ok(1, 'truthy value passes');
+    assert.notOk(0, 'falsy value passes');
+  });
+
+  QUnit.test('equal / strictEqual', (assert) => {
+    assert.equal(2 + 2, 4, 'addition');
+    assert.strictEqual('hello', 'hello');
+  });
+
+  QUnit.test('deepEqual – user profile sync', (assert) => {
+    const response = { user: { name: 'Alice', scores: [95, ${scoreValue}, 92] }, active: true };
+    const expected = { user: { name: 'Alice', scores: [95, 88, 92] }, active: true };
+    assert.deepEqual(response, expected, 'API response matches expected shape');
+  });
+
+  QUnit.test('throws – match by constructor', (assert) => {
+    assert.throws(() => { throw new TypeError('bad input'); }, TypeError);
+  });
+
+  QUnit.test('propContains – partial object match', (assert) => {
+    assert.propContains({ id: 1, name: 'Alice', role: 'admin' }, { role: 'admin' });
+  });
+});
+
+QUnit.module('Async', (hooks) => {
+  QUnit.test('async/await', async (assert) => {
+    const result = await Promise.resolve(42);
+    assert.strictEqual(result, 42, 'resolved to 42');
+  });
+
+  QUnit.test('assert.async() – callback style', (assert) => {
+    const done = assert.async();
+    setTimeout(() => {
+      assert.ok(true, 'callback fired');
+      done();
+    }, 10);
+  });
+
+  QUnit.test('rejects – async error handling', async (assert) => {
+    await assert.rejects(Promise.reject(new RangeError('out of bounds')), RangeError);
+  });
+});
+
+QUnit.module('Hooks', (hooks) => {
+  hooks.beforeEach(function () {
+    this.user = { name: 'Alice', loggedIn: false };
+  });
+
+  QUnit.test('beforeEach sets up fresh state', function (assert) {
+    assert.strictEqual(this.user.name, 'Alice');
+    assert.false(this.user.loggedIn, 'starts logged out');
+  });
+
+  QUnit.test('mutations do not leak between tests', function (assert) {
+    this.user.loggedIn = true;
+    assert.true(this.user.loggedIn, 'mutated in this test only');
+  });
+
+  QUnit.module('Nested Hooks', (innerHooks) => {
+    innerHooks.beforeEach(function () {
+      this.role = 'admin';
+    });
+
+    QUnit.test('inner beforeEach stacks on outer', function (assert) {
+      assert.strictEqual(this.user.name, 'Alice', 'outer beforeEach ran');
+      assert.strictEqual(this.role, 'admin', 'inner beforeEach also ran');
+    });
+  });
+});
+`;
+
+const makeHTML = (tests) => `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+    <title>QUnitX Demo Tests</title>
+    <style>${qunitCSS}</style>
+    <style>
+      body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; }
+      #qunit-header { background: #1c1c1e; }
+    </style>
+  </head>
+  <body>
+    <div id="qunit"></div>
+    <div id="qunit-fixture"></div>
+    <script>${qunitJS}</script>
+    <script>${tests}</script>
+  </body>
+</html>`;
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function createServer(html) {
+  const server = http.createServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.end(html);
+  });
+  return new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve(server)));
+}
+
+async function waitForResults(page, timeout = 15000) {
+  await page.waitForFunction(
+    () => {
+      const banner = document.getElementById('qunit-banner');
+      return (
+        banner &&
+        (banner.classList.contains('qunit-pass') || banner.classList.contains('qunit-fail'))
+      );
+    },
+    { timeout },
+  );
+}
+
+// ── Puppeteer ────────────────────────────────────────────────────────────────
+const browser = await puppeteer.launch({
+  executablePath: CHROME,
+  headless: true,
+  args: ['--no-sandbox', '--disable-gpu', '--window-size=1200,860'],
+});
+
+const page = await browser.newPage();
+await page.setViewport({ width: 700, height: 680, deviceScaleFactor: 1 });
+
+// ── Screenshot 1: Failing tests — deepEqual diff visible ─────────────────────
+const failingServer = await createServer(makeHTML(makeSuite(BUGGY_VALUE)));
+const failingURL = `http://127.0.0.1:${failingServer.address().port}/`;
+console.log(`Serving failing tests at ${failingURL}`);
+
+await page.goto(failingURL, { waitUntil: 'networkidle0' });
+await waitForResults(page);
+
+// Expand the failing test so the deepEqual diff is in view
+const failingItem = await page.$('#qunit-tests > li.fail');
+if (failingItem) {
+  const toggle = await failingItem.$('strong');
+  if (toggle) {
+    await toggle.click();
+    await new Promise((r) => setTimeout(r, 600));
+  }
+  // Scroll the failing test to the top so diff is fully visible
+  await page.evaluate((el) => el.scrollIntoView({ block: 'start' }), failingItem);
+  await new Promise((r) => setTimeout(r, 300));
+}
+
+await page.screenshot({ path: path.join(__dirname, 'browser-1-failing.png') });
+console.log('Screenshot 1: failing (deepEqual diff) ✓');
+failingServer.close();
+
+// ── Screenshot 2: All passing — simulates browser refresh after fixing the bug ──
+const passingServer = await createServer(makeHTML(makeSuite(FIXED_VALUE)));
+const passingURL = `http://127.0.0.1:${passingServer.address().port}/`;
+console.log(`Serving passing tests at ${passingURL}`);
+
+await page.goto(passingURL, { waitUntil: 'networkidle0' });
+await waitForResults(page);
+await page.evaluate(() => window.scrollTo(0, 0));
+await page.screenshot({ path: path.join(__dirname, 'browser-2-all-passed.png') });
+console.log('Screenshot 2: all passed ✓');
+
+// ── Screenshot 3: Filtered to "Async" module — shareable URL demo ────────────
+const asyncModuleId = await page.evaluate(() => {
+  if (typeof QUnit !== 'undefined' && QUnit.config && QUnit.config.modules) {
+    const m = QUnit.config.modules.find((m) => m.name === 'Async');
+    return m ? m.moduleId : null;
+  }
+  return null;
+});
+
+if (asyncModuleId) {
+  await page.goto(`${passingURL}?moduleId=${asyncModuleId}`, { waitUntil: 'networkidle0' });
+  await waitForResults(page);
+}
+await page.evaluate(() => window.scrollTo(0, 0));
+await page.screenshot({ path: path.join(__dirname, 'browser-3-filtered.png') });
+console.log('Screenshot 3: filtered (Async module) ✓');
+
+// ── Screenshot 4: Back to all tests, deepEqual test expanded ─────────────────
+await page.goto(passingURL, { waitUntil: 'networkidle0' });
+await waitForResults(page);
+
+// Expand the deepEqual test (3rd test in Assertions) to show passing assertion detail
+const deepEqualItem = await page.$('#qunit-tests > li:nth-child(3)');
+if (deepEqualItem) {
+  const toggle = await deepEqualItem.$('strong');
+  if (toggle) {
+    await toggle.click();
+    await new Promise((r) => setTimeout(r, 400));
+  }
+  await page.evaluate((el) => el.scrollIntoView({ block: 'start' }), deepEqualItem);
+  await new Promise((r) => setTimeout(r, 200));
+}
+await page.screenshot({ path: path.join(__dirname, 'browser-4-expanded.png') });
+console.log('Screenshot 4: deepEqual expanded (passing) ✓');
+
+passingServer.close();
+await browser.close();
+console.log('Done. Screenshots saved to docs/');

package/lib/boilerplates/test.js

@@ -1,6 +1,6 @@
 import { module, test } from 'qunitx';
 
-module('{{moduleName}}', function (hooks) {
+module('{{moduleName}}', function (_hooks) {
   test('assert true works', function (assert) {
     assert.expect(3);
     assert.ok(true);
@@ -11,11 +11,11 @@ module('{{moduleName}}', function (hooks) {
   test('async test finishes', async function (assert) {
     assert.expect(3);
 
-    let wait = () =>
-      new Promise((resolve, reject) => {
+    const wait = () =>
+      new Promise((resolve) => {
         setTimeout(() => resolve(true), 50);
       });
-    let result = await wait();
+    const result = await wait();
 
     assert.ok(true);
     assert.equal(true, result);

package/lib/commands/generate.js

@@ -8,9 +8,9 @@ import pathExists from '../utils/path-exists.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 export default async function () {
-  let projectRoot = await findProjectRoot();
-  let moduleName = process.argv[3]; // TODO: classify this maybe in future
-  let path =
+  const projectRoot = await findProjectRoot();
+  const moduleName = process.argv[3]; // TODO: classify this maybe in future
+  const path =
     process.argv[3].endsWith('.js') || process.argv[3].endsWith('.ts')
       ? `${projectRoot}/${process.argv[3]}`
       : `${projectRoot}/${process.argv[3]}.js`;
@@ -19,8 +19,8 @@ export default async function () {
     return console.log(`${path} already exists!`);
   }
 
-  let testJSContent = await fs.readFile(`${__dirname}/../boilerplates/test.js`);
-  let targetFolderPaths = path.split('/');
+  const testJSContent = await fs.readFile(`${__dirname}/../boilerplates/test.js`);
+  const targetFolderPaths = path.split('/');
 
   targetFolderPaths.pop();