qunitx-cli 0.9.4 → 0.9.7

package/lib/commands/help.ts

@@ -1,37 +0,0 @@
-import { blue, magenta } from '../utils/color.ts';
-import pkg from '../../package.json' with { type: 'json' };
-
-const highlight = (text) => magenta().bold(text);
-const color = (text) => blue(text);
-
-/** Prints qunitx-cli usage information to stdout. */
-export default function displayHelpOutput() {
-  const config = pkg;
-
-  console.log(`${highlight('[qunitx v' + config.version + '] Usage:')} qunitx ${color('[targets] --$flags')}
-
-${highlight('Input options:')}
-- File: $ ${color('qunitx test/foo.js')}
-- Folder: $ ${color('qunitx test/login')}
-- Globs: $ ${color('qunitx test/**/*-test.js')}
-- Combination: $ ${color('qunitx test/foo.js test/bar.js test/*-test.js test/logout')}
-
-${highlight('Optional flags:')}
-${color('--debug')} : print console output when tests run in browser
-${color('--watch')} : run the target file or folders, watch them for continuous run and expose http server under localhost
-${color('--timeout')} : change default timeout per test case
-${color('--output')} : folder to distribute built qunitx html and js that a webservers can run[default: tmp]
-${color('--failFast')} : run the target file or folders with immediate abort if a single test fails
-${color('--port')} : HTTP server port (auto-selects a free port if the given port is taken)[default: 1234]
-${color('--extensions')} : comma-separated file extensions to track for discovery and watch-mode rebuilds[default: js,ts]
-${color('--browser')} : browser engine to run tests in: chromium, firefox, webkit[default: chromium]
-${color('--before')} : run a script before the tests(i.e start a new web server before tests)
-${color('--after')} : run a script after the tests(i.e save test results to a file)
-
-${highlight('Example:')} $ ${color('qunitx test/foo.ts app/e2e --debug --watch --before=scripts/start-new-webserver.js --after=scripts/write-test-results.js')}
-
-${highlight('Commands:')}
-${color('$ qunitx init')}               # Bootstraps qunitx base html and add qunitx config to package.json if needed
-${color('$ qunitx new $testFileName')}  # Creates a qunitx test file
-`);
-}

package/lib/commands/init.ts

@@ -1,77 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import findProjectRoot from '../utils/find-project-root.ts';
-import pathExists from '../utils/path-exists.ts';
-import defaultProjectConfigValues from '../setup/default-project-config-values.ts';
-import readBoilerplate from '../utils/read-boilerplate.ts';
-
-/** Bootstraps a new qunitx project: writes the test HTML template, updates package.json, and optionally writes tsconfig.json. */
-export default async function initializeProject() {
-  const projectRoot = await findProjectRoot();
-  const oldPackageJSON = JSON.parse(await fs.readFile(`${projectRoot}/package.json`));
-  const existingQunitx = oldPackageJSON.qunitx || {};
-  const cliHtmlPaths = process.argv.slice(2).filter((arg) => arg.endsWith('.html'));
-  const config = Object.assign({}, defaultProjectConfigValues, existingQunitx, {
-    htmlPaths:
-      cliHtmlPaths.length > 0 ? cliHtmlPaths : existingQunitx.htmlPaths || ['test/tests.html'],
-  });
-
-  await Promise.all([
-    writeTestsHTML(projectRoot, config, oldPackageJSON),
-    rewritePackageJSON(projectRoot, config, oldPackageJSON),
-    writeTSConfigIfNeeded(projectRoot),
-  ]);
-}
-
-async function writeTestsHTML(
-  projectRoot: string,
-  config: { htmlPaths: string[]; output: string },
-  oldPackageJSON: Record<string, unknown>,
-): Promise<unknown[]> {
-  const testHTMLTemplateBuffer = await readBoilerplate('setup/tests.hbs');
-
-  return await Promise.all(
-    config.htmlPaths.map(async (htmlPath) => {
-      const targetPath = `${projectRoot}/${htmlPath}`;
-      if (await pathExists(targetPath)) {
-        return console.log(`${htmlPath} already exists`);
-      } else {
-        const targetDirectory = path.dirname(targetPath);
-        const _targetOutputPath = path.relative(
-          targetDirectory,
-          `${projectRoot}/${config.output}/tests.js`,
-        );
-        const testHTMLTemplate = testHTMLTemplateBuffer.replace(
-          '{{applicationName}}',
-          oldPackageJSON.name,
-        );
-
-        await fs.mkdir(targetDirectory, { recursive: true });
-        await fs.writeFile(targetPath, testHTMLTemplate);
-
-        console.log(`${targetPath} written`);
-      }
-    }),
-  );
-}
-
-async function rewritePackageJSON(
-  projectRoot: string,
-  config: unknown,
-  oldPackageJSON: Record<string, unknown>,
-): Promise<void> {
-  const newPackageJSON = Object.assign(oldPackageJSON, { qunitx: config });
-
-  await fs.writeFile(`${projectRoot}/package.json`, JSON.stringify(newPackageJSON, null, 2));
-}
-
-async function writeTSConfigIfNeeded(projectRoot: string): Promise<void> {
-  const targetPath = `${projectRoot}/tsconfig.json`;
-  if (!(await pathExists(targetPath))) {
-    const tsConfigTemplate = await readBoilerplate('setup/tsconfig.json');
-
-    await fs.writeFile(targetPath, tsConfigTemplate);
-
-    console.log(`${targetPath} written`);
-  }
-}

package/lib/commands/run/tests-in-browser.ts

@@ -1,221 +0,0 @@
-import fs from 'node:fs/promises';
-import { blue } from '../../utils/color.ts';
-import esbuild from 'esbuild';
-import timeCounter from '../../utils/time-counter.ts';
-import runUserModule from '../../utils/run-user-module.ts';
-import TAPDisplayFinalResult from '../../tap/display-final-result.ts';
-import type { Config, CachedContent, Connections } from '../../types.ts';
-import type HTTPServer from '../../servers/http.ts';
-
-class BundleError extends Error {
-  constructor(message: unknown) {
-    super(message);
-    this.name = 'BundleError';
-    this.message = `esbuild Bundle Error: ${message}`.split('\n').join('\n# ');
-  }
-}
-
-/**
- * Pre-builds the esbuild bundle for all test files and caches the result in `cachedContent`.
- * @returns {Promise<void>}
- */
-export async function buildTestBundle(config: Config, cachedContent: CachedContent): Promise<void> {
-  const { projectRoot, output } = config;
-  const allTestFilePaths = Object.keys(config.fsTree);
-
-  await Promise.all([
-    esbuild.build({
-      stdin: {
-        contents: allTestFilePaths.map((f) => `import "${f}";`).join(''),
-        resolveDir: process.cwd(),
-      },
-      bundle: true,
-      logLevel: 'error',
-      outfile: `${projectRoot}/${output}/tests.js`,
-      keepNames: true,
-      sourcemap: config.debug || config.watch ? 'inline' : false,
-    }),
-    Promise.all(
-      cachedContent.htmlPathsToRunTests.map(async (htmlPath) => {
-        const targetPath = `${config.projectRoot}/${config.output}${htmlPath}`;
-        if (htmlPath !== '/') {
-          await fs.rm(targetPath, { force: true, recursive: true });
-          await fs.mkdir(targetPath.split('/').slice(0, -1).join('/'), { recursive: true });
-        }
-      }),
-    ),
-  ]);
-
-  cachedContent.allTestCode = await fs.readFile(`${projectRoot}/${output}/tests.js`);
-}
-
-/**
- * Runs the esbuild-bundled tests inside a Playwright-controlled browser page and streams TAP output.
- * @returns {Promise<object>}
- */
-export default async function runTestsInBrowser(
-  config: Config,
-  cachedContent: CachedContent = {} as CachedContent,
-  connections: Connections,
-  targetTestFilesToFilter?: string[],
-): Promise<Connections | undefined> {
-  const { projectRoot, output } = config;
-  const allTestFilePaths = Object.keys(config.fsTree);
-  const runHasFilter = !!targetTestFilesToFilter;
-
-  // In group mode the COUNTER is shared across all groups and managed by run.js.
-  if (!config._groupMode) {
-    config.COUNTER = { testCount: 0, failCount: 0, skipCount: 0, passCount: 0, errorCount: 0 };
-  }
-  config.lastRanTestFiles = targetTestFilesToFilter || allTestFilePaths;
-
-  try {
-    // Skip bundle build if run.js already pre-built it (group mode optimization).
-    if (!cachedContent.allTestCode) {
-      await buildTestBundle(config, cachedContent);
-    }
-
-    if (runHasFilter) {
-      const outputPath = `${projectRoot}/${output}/filtered-tests.js`;
-      await buildFilteredTests(targetTestFilesToFilter, outputPath, config);
-      cachedContent.filteredTestCode = (await fs.readFile(outputPath)).toString();
-    }
-
-    const TIME_COUNTER = timeCounter();
-
-    if (runHasFilter) {
-      await runTestInsideHTMLFile('/qunitx.html', connections, config);
-    } else {
-      await Promise.all(
-        cachedContent.htmlPathsToRunTests.map((htmlPath) =>
-          runTestInsideHTMLFile(htmlPath, connections, config),
-        ),
-      );
-    }
-
-    const TIME_TAKEN = TIME_COUNTER.stop();
-
-    // In group mode the parent orchestrator handles the final summary, after hook, and exit.
-    if (!config._groupMode) {
-      TAPDisplayFinalResult(config.COUNTER, TIME_TAKEN);
-
-      if (config.after) {
-        await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, 'after');
-      }
-
-      if (!config.watch) {
-        await Promise.all([
-          connections.server && connections.server.close(),
-          connections.browser && connections.browser.close(),
-        ]);
-        return process.exit(config.COUNTER.failCount > 0 ? 1 : 0);
-      }
-    }
-  } catch (error) {
-    config.lastFailedTestFiles = config.lastRanTestFiles;
-    console.log(error);
-    const exception = new BundleError(error);
-
-    if (config.watch) {
-      console.log(`# ${exception}`);
-    } else {
-      throw exception;
-    }
-  }
-
-  return connections;
-}
-
-function buildFilteredTests(
-  filteredTests: string[],
-  outputPath: string,
-  config: Config,
-): Promise<esbuild.BuildResult> {
-  return esbuild.build({
-    stdin: {
-      contents: filteredTests.map((f) => `import "${f}";`).join(''),
-      resolveDir: process.cwd(),
-    },
-    bundle: true,
-    logLevel: 'error',
-    outfile: outputPath,
-    sourcemap: config.debug || config.watch ? 'inline' : false,
-  });
-}
-
-async function runTestInsideHTMLFile(
-  filePath: string,
-  { page, server, browser }: Connections,
-  config: Config,
-): Promise<void> {
-  let QUNIT_RESULT;
-  let targetError;
-  let timeoutHandle;
-  try {
-    console.log('#', blue(`QUnitX running: http://localhost:${config.port}${filePath}`));
-
-    // Single promise driven by the WS handler:
-    //   config._testRunDone()      → tests finished normally
-    //   config._resetTestTimeout() → reset idle timer; fires as timeout if silent for config.timeout ms
-    // This replaces waitForFunction (CDP polling), which raced against WS testEnd messages
-    // under load: CDP could win and trigger cleanup before Node.js processed the pending messages.
-    const testRaceResult = new Promise((resolve) => {
-      config._testRunDone = () => resolve(false);
-      config._resetTestTimeout = () => {
-        clearTimeout(timeoutHandle);
-        timeoutHandle = setTimeout(() => resolve(true), config.timeout);
-      };
-    });
-
-    await page.goto(`http://localhost:${config.port}${filePath}`, {
-      timeout: config.timeout + 10000,
-    });
-
-    config._resetTestTimeout(); // start idle countdown once the page is loaded
-
-    await testRaceResult;
-
-    QUNIT_RESULT = await page.evaluate(() => window.QUNIT_RESULT);
-  } catch (error) {
-    targetError = error;
-    console.log(error);
-    console.error(error);
-  } finally {
-    clearTimeout(timeoutHandle);
-    config._resetTestTimeout = null;
-  }
-
-  if (!QUNIT_RESULT || QUNIT_RESULT.totalTests === 0) {
-    console.log(targetError);
-    console.log('BROWSER: runtime error thrown during executing tests');
-    console.error('BROWSER: runtime error thrown during executing tests');
-    await failOnNonWatchMode(config.watch, { server, browser }, config._groupMode);
-  } else if (QUNIT_RESULT.totalTests > QUNIT_RESULT.finishedTests) {
-    console.log(targetError);
-    console.log(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
-    console.error(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
-    await failOnNonWatchMode(config.watch, { server, browser }, config._groupMode);
-  } else if (QUNIT_RESULT.failedTests > config.COUNTER.failCount) {
-    // Safety net: browser tracked failures that WebSocket events never delivered to Node.js
-    // (e.g. WS connection dropped mid-run). Reconcile so the exit code is always correct.
-    config.COUNTER.failCount = QUNIT_RESULT.failedTests;
-  }
-}
-
-async function failOnNonWatchMode(
-  watchMode: boolean = false,
-  connections: { server?: HTTPServer; browser?: { close(): Promise<void> } } = {},
-  groupMode: boolean = false,
-): Promise<void> {
-  if (!watchMode) {
-    if (groupMode) {
-      // Parent orchestrator handles cleanup and exit; signal failure via throw.
-      throw new Error('Browser test run failed');
-    }
-    await Promise.all([
-      connections.server && connections.server.close(),
-      connections.browser && connections.browser.close(),
-    ]);
-    process.exit(1);
-  }
-}

package/lib/commands/run.ts

@@ -1,279 +0,0 @@
-import setupBrowser, { launchBrowser } from '../setup/browser.ts';
-import fs from 'node:fs/promises';
-import { normalize } from 'node:path';
-import { availableParallelism } from 'node:os';
-import { blue, yellow } from '../utils/color.ts';
-import runTestsInBrowser, { buildTestBundle } from './run/tests-in-browser.ts';
-import fileWatcher from '../setup/file-watcher.ts';
-import findInternalAssetsFromHTML from '../utils/find-internal-assets-from-html.ts';
-import runUserModule from '../utils/run-user-module.ts';
-import setupKeyboardEvents from '../setup/keyboard-events.ts';
-import writeOutputStaticFiles from '../setup/write-output-static-files.ts';
-import timeCounter from '../utils/time-counter.ts';
-import TAPDisplayFinalResult from '../tap/display-final-result.ts';
-import readBoilerplate from '../utils/read-boilerplate.ts';
-import type { Config, CachedContent } from '../types.ts';
-
-/**
- * Runs qunitx tests in headless Chrome, either in watch mode or concurrent batch mode.
- * @returns {Promise<void>}
- */
-export default async function run(config: Config): Promise<void> {
-  const cachedContent = await buildCachedContent(config, config.htmlPaths);
-
-  if (config.watch) {
-    // WATCH MODE: single browser, all test files bundled together.
-    // The HTTP server stays alive so the user can browse http://localhost:PORT
-    // and see all tests running in a single QUnit view.
-    const [connections] = await Promise.all([
-      setupBrowser(config, cachedContent),
-      writeOutputStaticFiles(config, cachedContent),
-    ]);
-    config.expressApp = connections.server;
-    setupKeyboardEvents(config, cachedContent, connections);
-
-    if (config.before) {
-      await runUserModule(`${process.cwd()}/${config.before}`, config, 'before');
-    }
-
-    try {
-      await runTestsInBrowser(config, cachedContent, connections);
-    } catch (error) {
-      await Promise.all([
-        connections.server && connections.server.close(),
-        connections.browser && connections.browser.close(),
-      ]);
-      throw error;
-    }
-
-    logWatcherAndKeyboardShortcutInfo(config, connections.server);
-
-    await fileWatcher(
-      config.testFileLookupPaths,
-      config,
-      async (event, file) => {
-        if (event === 'addDir') return;
-        if (['unlink', 'unlinkDir'].includes(event)) {
-          return await runTestsInBrowser(config, cachedContent, connections);
-        }
-        await runTestsInBrowser(config, cachedContent, connections, [file]);
-      },
-      (_path, _event) => connections.server.publish('refresh', 'refresh'),
-    );
-  } else {
-    // CONCURRENT MODE: split test files across N groups = availableParallelism().
-    // All group bundles are built while Chrome is starting up, so esbuild time
-    // is hidden behind the ~1.2s Chrome launch. Each group then gets its own
-    // HTTP server and Playwright page inside one shared browser instance.
-    const allFiles = Object.keys(config.fsTree);
-    const groupCount = Math.min(allFiles.length, availableParallelism());
-    const groups = splitIntoGroups(allFiles, groupCount);
-
-    // Shared COUNTER so TAP test numbers are globally sequential across all groups.
-    config.COUNTER = { testCount: 0, failCount: 0, skipCount: 0, passCount: 0, errorCount: 0 };
-    config.lastRanTestFiles = allFiles;
-
-    const groupConfigs = groups.map((groupFiles, i) => ({
-      ...config,
-      fsTree: Object.fromEntries(groupFiles.map((f) => [f, config.fsTree[f]])),
-      // Single group keeps the root output dir for backward-compatible file paths.
-      output: groupCount === 1 ? config.output : `${config.output}/group-${i}`,
-      _groupMode: true,
-    }));
-    const groupCachedContents = groups.map(() => ({ ...cachedContent }));
-
-    console.log('TAP version 13');
-
-    // Build all group bundles and write static files while the browser is starting up.
-    const [browser] = await Promise.all([
-      launchBrowser(config),
-      Promise.all(
-        groupConfigs.map((groupConfig, i) =>
-          Promise.all([
-            buildTestBundle(groupConfig, groupCachedContents[i]),
-            writeOutputStaticFiles(groupConfig, groupCachedContents[i]),
-          ]),
-        ),
-      ),
-    ]);
-    const TIME_COUNTER = timeCounter();
-
-    // 3-minute per-group deadline. Firefox/WebKit can hang indefinitely in any Playwright
-    // operation (browser.newPage, page.evaluate, page.close) when overwhelmed by concurrent
-    // pages. Without this outer timeout, one stuck group freezes Promise.allSettled forever.
-    // After all groups settle, browser.close() (below) terminates the browser and unblocks
-    // any still-pending Playwright calls in background async fns.
-    const GROUP_TIMEOUT_MS = 3 * 60 * 1000;
-
-    // Keep the event loop alive during Promise.allSettled. The Chrome child process and its
-    // stderr pipe are unref'd (pre-launch-chrome.js). If Chrome crashes during group cleanup,
-    // all active handles close and the event loop would drain — exiting silently before
-    // allSettled resolves or results are printed. This interval holds the loop open so that
-    // unref'd group/page-close timers can still fire normally.
-    const keepAlive = setInterval(() => {}, 1000);
-
-    const groupResults = await Promise.allSettled(
-      groupConfigs.map((groupConfig, i) => {
-        const groupTimeout = new Promise((_, reject) => {
-          const t = setTimeout(
-            () => reject(new Error(`Group ${i} timed out after ${GROUP_TIMEOUT_MS}ms`)),
-            GROUP_TIMEOUT_MS,
-          );
-          t.unref();
-        });
-
-        return Promise.race([
-          (async () => {
-            const connections = await setupBrowser(groupConfig, groupCachedContents[i], browser);
-            groupConfig.expressApp = connections.server;
-
-            if (config.before) {
-              await runUserModule(`${process.cwd()}/${config.before}`, groupConfig, 'before');
-            }
-
-            try {
-              await runTestsInBrowser(groupConfig, groupCachedContents[i], connections);
-            } finally {
-              await Promise.all([
-                connections.server && connections.server.close(),
-                connections.page &&
-                  // Unref'd: the keepAlive interval above holds the event loop open, so this
-                  // timer still fires if page.close() hangs, without preventing process exit later.
-                  Promise.race([
-                    connections.page.close(),
-                    new Promise((resolve) => {
-                      const t = setTimeout(resolve, 10000);
-                      t.unref();
-                    }),
-                  ]).catch(() => {}),
-              ]);
-            }
-          })(),
-          groupTimeout,
-        ]);
-      }),
-    );
-
-    const exitCode = groupResults.reduce(
-      (code, { status, reason }) => {
-        if (status !== 'rejected') return code;
-        console.error(reason);
-        return 1;
-      },
-      config.COUNTER.failCount > 0 ? 1 : 0,
-    );
-
-    process.exitCode = exitCode;
-
-    TAPDisplayFinalResult(config.COUNTER, TIME_COUNTER.stop());
-
-    if (config.after) {
-      await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, 'after');
-    }
-
-    // Flush stdout then exit. keepAlive holds the event loop open until this callback fires,
-    // at which point process.exit() takes over — so clearInterval happens here, not earlier.
-    // If the write callback never fires (theoretical), the unref'd exitTimer is the fallback.
-    const exitTimer = setTimeout(() => process.exit(exitCode), 5000);
-    exitTimer.unref();
-    process.stdout.write('\n', () => {
-      clearTimeout(exitTimer);
-      clearInterval(keepAlive);
-      // Close browser after stdout is flushed; fire-and-forget since process.exit follows.
-      browser.close().catch(() => {});
-      process.exit(exitCode);
-    });
-  }
-}
-
-async function buildCachedContent(config: Config, htmlPaths: string[]): Promise<CachedContent> {
-  const htmlBuffers = await Promise.all(config.htmlPaths.map((htmlPath) => fs.readFile(htmlPath)));
-  const cachedContent = htmlPaths.reduce(
-    (result, _htmlPath, index) => {
-      const filePath = config.htmlPaths[index];
-      const html = htmlBuffers[index].toString();
-
-      if (html.includes('{{content}}')) {
-        result.dynamicContentHTMLs[filePath] = html;
-        result.htmlPathsToRunTests.push(filePath.replace(config.projectRoot, ''));
-      } else {
-        console.log(
-          '#',
-          yellow(
-            `WARNING: Static html file with no {{content}} detected. Therefore ignoring ${filePath}`,
-          ),
-        );
-        result.staticHTMLs[filePath] = html;
-      }
-
-      findInternalAssetsFromHTML(html).forEach((key) => {
-        result.assets.add(normalizeInternalAssetPathFromHTML(config.projectRoot, key, filePath));
-      });
-
-      return result;
-    },
-    {
-      allTestCode: null,
-      assets: new Set(),
-      htmlPathsToRunTests: [],
-      mainHTML: { filePath: null, html: null },
-      staticHTMLs: {},
-      dynamicContentHTMLs: {},
-    },
-  );
-
-  if (cachedContent.htmlPathsToRunTests.length === 0) {
-    cachedContent.htmlPathsToRunTests = ['/'];
-  }
-
-  return addCachedContentMainHTML(config.projectRoot, cachedContent);
-}
-
-async function addCachedContentMainHTML(
-  projectRoot: string,
-  cachedContent: CachedContent,
-): Promise<CachedContent> {
-  const mainHTMLPath = Object.keys(cachedContent.dynamicContentHTMLs)[0];
-  if (mainHTMLPath) {
-    cachedContent.mainHTML = {
-      filePath: mainHTMLPath,
-      html: cachedContent.dynamicContentHTMLs[mainHTMLPath],
-    };
-  } else {
-    const html = await readBoilerplate('setup/tests.hbs');
-    cachedContent.mainHTML = { filePath: `${projectRoot}/test/tests.html`, html };
-    cachedContent.assets.add(`${projectRoot}/node_modules/qunitx/vendor/qunit.css`);
-  }
-
-  return cachedContent;
-}
-
-function splitIntoGroups(files: string[], groupCount: number): string[][] {
-  const groups = Array.from({ length: groupCount }, () => []);
-  files.forEach((file, i) => groups[i % groupCount].push(file));
-  return groups.filter((g) => g.length > 0);
-}
-
-function logWatcherAndKeyboardShortcutInfo(config: Config, _server: unknown): void {
-  console.log(
-    '#',
-    blue(`Watching files... You can browse the tests on http://localhost:${config.port} ...`),
-  );
-  console.log(
-    '#',
-    blue(
-      `Shortcuts: Press "qq" to abort running tests, "qa" to run all the tests, "qf" to run last failing test, "ql" to repeat last test`,
-    ),
-  );
-}
-
-function normalizeInternalAssetPathFromHTML(
-  projectRoot: string,
-  assetPath: string,
-  htmlPath: string,
-): string {
-  const currentDirectory = htmlPath ? htmlPath.split('/').slice(0, -1).join('/') : projectRoot;
-  return assetPath.startsWith('./')
-    ? normalize(`${currentDirectory}/${assetPath.slice(2)}`)
-    : normalize(`${currentDirectory}/${assetPath}`);
-}