qunitx-cli 0.0.2 → 0.1.0

package/lib/setup/fs-tree.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs/promises';
+import picomatch from 'picomatch';
+import recursiveLookup from 'recursive-lookup';
+
+export default async function buildFSTree(fileAbsolutePaths, config = {}) {
+  let targetExtensions = ['js', 'ts'];
+  let fsTree = {};
+
+  await Promise.all(fileAbsolutePaths.map(async (fileAbsolutePath) => {
+    let glob = picomatch.scan(fileAbsolutePath);
+
+    // TODO: maybe allow absolute path references
+
+    try {
+      if (glob.isGlob) {
+        let fileNames = await recursiveLookup(glob.base, (path) => {
+          return targetExtensions.some((extension) => path.endsWith(extension));
+        });
+
+        fileNames.forEach((fileName) => {
+          if (picomatch.isMatch(fileName, fileAbsolutePath, { bash: true })) {
+            fsTree[fileName] = null;
+          }
+        });
+      } else {
+        let entry = await fs.stat(fileAbsolutePath);
+
+        if (entry.isFile()) {
+          fsTree[fileAbsolutePath] = null;
+        } else if (entry.isDirectory()) {
+          let fileNames = await recursiveLookup(glob.base, (path) => {
+            return targetExtensions.some((extension) => path.endsWith(extension));
+          });
+
+          fileNames.forEach((fileName) => {
+            fsTree[fileName] = null;
+          });
+        }
+      }
+    } catch (error) {
+      console.error(error);
+
+      return process.exit(1);
+    }
+  }));
+
+  return fsTree;
+}

package/lib/setup/keyboard-events.js

@@ -0,0 +1,34 @@
+import kleur from 'kleur';
+import listenToKeyboardKey from '../utils/listen-to-keyboard-key.js';
+import runTestsInBrowser from '../commands/run/tests-in-browser.js';
+
+export default function setupKeyboardEvents(config, cachedContent, connections) {
+  listenToKeyboardKey('qq', () => abortBrowserQUnit(config, connections));
+  listenToKeyboardKey('qa', () => {
+    abortBrowserQUnit(config, connections);
+    runTestsInBrowser(config, cachedContent, connections)
+  });
+  listenToKeyboardKey('qf', () => {
+    abortBrowserQUnit(config, connections);
+
+    if (!config.lastFailedTestFiles) {
+      console.log('#', kleur.blue(`QUnitX: No tests failed so far, so repeating the last test run`));
+      return runTestsInBrowser(config, cachedContent, connections, config.lastRanTestFiles);
+    }
+
+    runTestsInBrowser(config, cachedContent, connections, config.lastFailedTestFiles)
+  });
+  listenToKeyboardKey('ql', () => {
+    abortBrowserQUnit(config, connections);
+    runTestsInBrowser(config, cachedContent, connections, config.lastRanTestFiles)
+  });
+}
+
+function abortBrowserQUnit(config, connections) {
+  connections.server.publish('abort', 'abort');
+}
+
+function abortNodejsQUnit(config) {
+  window.QUnit.config.queue.length = 0;
+  config.aborted = true;
+}

package/lib/setup/test-file-paths.js

@@ -0,0 +1,79 @@
+import picomatch from 'picomatch';
+
+export default function setupTestFilePaths(projectRoot, inputs) { // NOTE: very complex algorithm, order is very important
+  let [folders, filesWithGlob, filesWithoutGlob] = inputs.reduce((result, input) => {
+    let isGlob = picomatch.scan(input).isGlob;
+
+    if (!pathIsFile(input)) {
+      result[0].push({
+        input,
+        isFile: false,
+        isGlob
+      });
+    } else {
+      result[isGlob ? 1 : 2].push({
+        input,
+        isFile: true,
+        isGlob
+      });
+    }
+
+    return result;
+  }, [[], [], []]);
+
+  let result = folders.reduce((folderResult, folder) => {
+    if (!pathIsIncludedInPaths(folders, folder)) {
+      folderResult.push(folder);
+    }
+
+    return folderResult;
+  }, []);
+
+  filesWithGlob.forEach((file) => {
+    if (
+      !pathIsIncludedInPaths(result, file) &&
+      !pathIsIncludedInPaths(filesWithGlob, file)
+    ) {
+      result.push(file);
+    }
+  });
+  filesWithoutGlob.forEach((file) => {
+    if (!pathIsIncludedInPaths(result, file)) {
+      result.push(file);
+    }
+  });
+
+  return result.map((metaItem) => metaItem.input);
+}
+
+function pathIsFile(path) {
+  let inputs = path.split('/');
+
+  return inputs[inputs.length - 1].includes('.');
+}
+
+function pathIsIncludedInPaths(paths, targetPath) {
+  return paths.some((path) => {
+    if (path === targetPath) {
+      return false;
+    }
+
+    let globFormat = buildGlobFormat(path);
+
+    return picomatch.isMatch(targetPath.input, globFormat, { bash: true });
+  });
+}
+
+function buildGlobFormat(path) {
+  if (!path.isFile) {
+    if (!path.isGlob) {
+      return `${path.input}/*`;
+    } else if (path.input.endsWith('*')) { // NOTE: could be problematic in future, investigate if I should check endsWith /*
+      return path.input;
+    }
+
+    return `${path.input}/*`;
+  }
+
+  return path.input;
+}

package/lib/setup/web-server.js

@@ -0,0 +1,241 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import findInternalAssetsFromHTML from '../utils/find-internal-assets-from-html.js';
+import TAPDisplayTestResult from '../tap/display-test-result.js';
+import pathExists from '../utils/path-exists.js';
+import HTTPServer, { MIME_TYPES } from '../servers/http.js';
+
+const fsPromise = fs.promises;
+
+export default async function setupWebServer(config = {
+  port: 1234, debug: false, watch: false, timeout: 10000
+}, cachedContent) {
+  let STATIC_FILES_PATH = path.join(config.projectRoot, config.output);
+  let server = new HTTPServer();
+
+  server.wss.on('connection', function connection(socket) {
+    socket.on('message', function message(data) {
+      const { event, details, abort } = JSON.parse(data);
+
+      if (event === "connection") {
+        console.log('TAP version 13');
+      } else if ((event === 'testEnd') && !abort) {
+        if (details.status === 'failed') {
+          config.lastFailedTestFiles = config.lastRanTestFiles;
+        }
+
+        TAPDisplayTestResult(config.COUNTER, details)
+      }
+    });
+  });
+
+  server.get('/', async (req, res) => {
+    let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+    let htmlContent = escapeAndInjectTestsToHTML(
+      replaceAssetPaths(cachedContent.mainHTML.html, cachedContent.mainHTML.filePath, config.projectRoot),
+      TEST_RUNTIME_TO_INJECT,
+      cachedContent.allTestCode
+    );
+
+    res.write(htmlContent);
+    res.end();
+
+    return await fsPromise.writeFile(`${config.projectRoot}/${config.output}/index.html`, htmlContent);
+  });
+
+  server.get('/qunitx.html', async (req, res) => {
+    let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+    let htmlContent = escapeAndInjectTestsToHTML(
+      replaceAssetPaths(cachedContent.mainHTML.html, cachedContent.mainHTML.filePath, config.projectRoot),
+      TEST_RUNTIME_TO_INJECT,
+      cachedContent.filteredTestCode
+    );
+
+    res.write(htmlContent);
+    res.end();
+
+    return await fsPromise.writeFile(`${config.projectRoot}/${config.output}/qunitx.html`, htmlContent);
+  });
+
+  server.get('/*', async (req, res) => {
+    let possibleDynamicHTML = cachedContent.dynamicContentHTMLs[`${config.projectRoot}${req.path}`];
+    if (possibleDynamicHTML) {
+      let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+      let htmlContent = escapeAndInjectTestsToHTML(
+        possibleDynamicHTML,
+        TEST_RUNTIME_TO_INJECT,
+        cachedContent.allTestCode
+      );
+
+      res.write(htmlContent);
+      res.end();
+
+      return await fsPromise.writeFile(`${config.projectRoot}/${config.output}${req.path}`, htmlContent);
+    }
+
+    let url = req.url;
+    let requestStartedAt = new Date();
+    let filePath = (url.endsWith("/") ? [STATIC_FILES_PATH, url, "index.html"] : [STATIC_FILES_PATH, url]).join('');
+    let statusCode = await pathExists(filePath) ? 200 : 404;
+
+    res.writeHead(statusCode, {
+      "Content-Type": req.headers.accept?.includes('text/html')
+        ? MIME_TYPES.html
+        : MIME_TYPES[path.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html
+    });
+
+    if (statusCode === 404) {
+      res.end();
+    } else {
+      fs.createReadStream(filePath)
+        .pipe(res);
+    }
+
+    console.log(`# [HTTPServer] GET ${url} ${statusCode} - ${new Date() - requestStartedAt}ms`);
+  });
+
+  return server;
+}
+
+function replaceAssetPaths(html, htmlPath, projectRoot) {
+  let assetPaths = findInternalAssetsFromHTML(html);
+  let htmlDirectory = htmlPath.split('/').slice(0, -1).join('/')
+
+  return assetPaths.reduce((result, assetPath) => {
+    let normalizedFullAbsolutePath = path.normalize(`${htmlDirectory}/${assetPath}`);
+
+    return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, '.'));
+  }, html);
+}
+
+function testRuntimeToInject(port, config) {
+  return `<script>
+    window.testTimeout = 0;
+    setInterval(() => {
+      window.testTimeout = window.testTimeout + 1000;
+    }, 1000);
+
+    (function() {
+      function setupWebsocket() {
+        window.socket = new WebSocket('ws://localhost:${port}');
+        window.socket.addEventListener('message', function(messageEvent) {
+          if (!window.IS_PUPPETEER && messageEvent.data === 'refresh') {
+            window.location.reload(true);
+          } else if (window.IS_PUPPETEER && messageEvent.data === 'abort') {
+            window.abortQUnit = true;
+            window.QUnit.config.queue.length = 0;
+            window.socket.send(JSON.stringify({ event: 'abort' }))
+          }
+        });
+      }
+
+      function trySetupWebsocket() {
+        try {
+          setupWebsocket();
+        } catch(error) {
+          console.log(error);
+          window.setTimeout(() => trySetupWebsocket(), 10);
+        }
+      }
+
+      trySetupWebsocket();
+    })();
+
+    {{allTestCode}}
+
+    function getCircularReplacer() {
+      const ancestors = [];
+      return function (key, value) {
+        if (typeof value !== "object" || value === null) {
+          return value;
+        }
+        while (ancestors.length > 0 && ancestors.at(-1) !== this) {
+          ancestors.pop();
+        }
+        if (ancestors.includes(value)) {
+          return "[Circular]";
+        }
+        ancestors.push(value);
+        return value;
+      };
+    }
+
+    function setupQUnit() {
+      window.QUNIT_RESULT = { totalTests: 0, finishedTests: 0, currentTest: '' };
+
+      if (!window.socket ) {
+        return window.setTimeout(() => setupQUnit(), 10);
+      } else if (!window.QUnit || !window.QUnit.moduleStart || window.QUnit.config.queue === 0) {
+        if (socket.readyState == 0) {
+          return window.setTimeout(() => setupQUnit(), 10);
+        }
+
+        window.testTimeout = ${config.timeout};
+        return;
+      }
+
+      window.QUnit.begin(() => { // NOTE: might be useful in future for hanged module tracking
+        if (window.IS_PUPPETEER) {
+          window.socket.send(JSON.stringify({ event: 'connection' }));
+        }
+      });
+      window.QUnit.moduleStart((details) => { // NOTE: might be useful in future for hanged module tracking
+        if (window.IS_PUPPETEER) {
+          window.socket.send(JSON.stringify({ event: 'moduleStart', details: details }, getCircularReplacer()));
+        }
+      });
+      window.QUnit.on('testStart', (details) => {
+        window.QUNIT_RESULT.totalTests++;
+        window.QUNIT_RESULT.currentTest = details.fullName.join(' | ');
+      });
+      window.QUnit.on('testEnd', (details) => { // NOTE: https://github.com/qunitjs/qunit/blob/master/src/html-reporter/diff.js
+        window.testTimeout = 0;
+        window.QUNIT_RESULT.finishedTests++;
+        window.QUNIT_RESULT.currentTest = null;
+        if (window.IS_PUPPETEER) {
+          window.socket.send(JSON.stringify({ event: 'testEnd', details: details, abort: window.abortQUnit }, getCircularReplacer()));
+
+          if (${config.failFast} && details.status === 'failed') {
+            window.QUnit.config.queue.length = 0;
+          }
+        }
+      });
+      window.QUnit.done((details) => {
+        if (window.IS_PUPPETEER) {
+          window.setTimeout(() => {
+            window.socket.send(JSON.stringify({ event: 'done', details: details, abort: window.abortQUnit }, getCircularReplacer()))
+          }, 50);
+        }
+        window.setTimeout(() => {
+          window.testTimeout = ${config.timeout};
+        }, 75);
+      });
+
+      if ([1, 3].includes(window.socket.readyState)) {
+        return window.setTimeout(() => window.QUnit.start(), 25);
+      } else {
+        let connectionTrialCount = 0;
+        let connectionInterval = window.setInterval(() => {
+          if ([1, 3].includes(window.socket.readyState) || connectionTrialCount > 25) {
+            window.clearInterval(connectionInterval);
+
+            return window.setTimeout(() => window.QUnit.start(), 25);
+          }
+
+          connectionTrialCount = connectionTrialCount + 1;
+        }, 10);
+      }
+    }
+
+    setupQUnit();
+  </script>`;
+}
+
+function escapeAndInjectTestsToHTML(html, testRuntimeCode, testContentCode) {
+  return html
+    .replace('{{content}}',
+      testRuntimeCode
+        .replace('{{allTestCode}}', testContentCode)
+        .replace('</script>', '<\/script>') // NOTE: remove this when simple-html-tokenizer PR gets merged
+    );
+}

package/lib/setup/write-output-static-files.js

@@ -0,0 +1,22 @@
+import fs from 'node:fs/promises';
+
+export default async function writeOutputStaticFiles({ projectRoot, output }, cachedContent) {
+  let staticHTMLPromises = Object.keys(cachedContent.staticHTMLs).map(async (staticHTMLKey) => {
+    let htmlRelativePath = staticHTMLKey.replace(`${projectRoot}/`, '');
+
+    await ensureFolderExists(`${projectRoot}/${output}/${htmlRelativePath}`);
+    await fs.writeFile(`${projectRoot}/${output}/${htmlRelativePath}`, cachedContent.staticHTMLs[staticHTMLKey]);
+  });
+  let assetPromises = Array.from(cachedContent.assets).map(async (assetAbsolutePath) => {
+    let assetRelativePath = assetAbsolutePath.replace(`${projectRoot}/`, '');
+
+    await ensureFolderExists(`${projectRoot}/${output}/${assetRelativePath}`);
+    await fs.copyFile(assetAbsolutePath, `${projectRoot}/${output}/${assetRelativePath}`);
+  });
+
+  await Promise.all(staticHTMLPromises.concat(assetPromises));
+}
+
+async function ensureFolderExists(assetPath) {
+  await fs.mkdir(assetPath.split('/').slice(0, -1).join('/'), { recursive: true });
+}

package/lib/tap/display-final-result.js

@@ -0,0 +1,15 @@
+export default function({ testCount, passCount, skipCount, failCount }, timeTaken) {
+  console.log('');
+  console.log(`1..${testCount}`);
+  console.log(`# tests ${testCount}`);
+  console.log(`# pass ${passCount}`);
+  console.log(`# skip ${skipCount}`);
+  console.log(`# fail ${failCount}`);
+
+  // let seconds = timeTaken > 1000 ? Math.floor(timeTaken / 1000) : 0;
+  // let milliseconds = timeTaken % 100;
+
+  console.log(`# duration ${timeTaken}`);
+  console.log('');
+}
+  // console.log(details.timeTaken); // runtime

package/lib/tap/display-test-result.js

@@ -0,0 +1,73 @@
+import yaml from 'js-yaml'
+import indentString from '../utils/indent-string.js';
+
+// tape TAP output: ['operator', 'stack', 'at', 'expected', 'actual']
+// ava TAP output: ['message', 'name', 'at', 'assertion', 'values'] // Assertion #5, message
+export default function(COUNTER, details) { // NOTE: https://github.com/qunitjs/qunit/blob/master/src/html-reporter/diff.js
+  COUNTER.testCount++;
+
+  if (details.status === 'skipped') {
+    COUNTER.skipCount++;
+    console.log(`ok ${COUNTER.testCount}`, details.fullName.join(' | '), '# skip');
+  } else if (details.status === 'todo') {
+    console.log(`not ok ${COUNTER.testCount}`, details.fullName.join(' | '), '# skip');
+  } else if (details.status === 'failed') {
+    COUNTER.failCount++;
+    console.log(`not ok ${COUNTER.testCount}`, details.fullName.join(' | '), `# (${details.runtime.toFixed(0)} ms)`);
+    details.assertions.reduce((errorCount, assertion, index) => {
+      if (!assertion.passed && assertion.todo === false) {
+        COUNTER.errorCount++;
+        let stack = assertion.stack?.match(/\(.+\)/g);
+
+        console.log('  ---');
+        console.log(indentString(yaml.dump({
+          name: `Assertion #${index + 1}`, // TODO: check what happens on runtime errors
+          actual: assertion.actual ? JSON.parse(JSON.stringify(assertion.actual, getCircularReplacer())) : assertion.actual,
+          expected: assertion.expected ? JSON.parse(JSON.stringify(assertion.expected, getCircularReplacer())) : assertion.expected,
+          message: assertion.message || null,
+          stack: assertion.stack || null,
+          at: stack ? stack[0].replace('(file://', '').replace(')', '') : null
+        }), 4));
+        console.log('  ...');
+      }
+
+      return errorCount;
+    }, 0);
+  } else if (details.status === 'passed') {
+    COUNTER.passCount++;
+    console.log(`ok ${COUNTER.testCount}`, details.fullName.join(' | '), `# (${details.runtime.toFixed(0)} ms)`);
+  }
+}
+
+function getCircularReplacer() {
+  const ancestors = [];
+  return function (key, value) {
+    if (typeof value !== "object" || value === null) {
+      return value;
+    }
+    while (ancestors.length > 0 && ancestors.at(-1) !== this) {
+      ancestors.pop();
+    }
+    if (ancestors.includes(value)) {
+      return "[Circular]";
+    }
+    ancestors.push(value);
+    return value;
+  };
+}
+
+// not ok 10 test exited without ending: deepEqual true works
+//   ---
+//     operator: fail
+//     at: process.<anonymous> (/home/izelnakri/ava-test/node_modules/tape/index.js:85:19)
+//     stack: |-
+//       Error: test exited without ending: deepEqual true works
+//           at Test.assert [as _assert] (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:269:54)
+//           at Test.bound [as _assert] (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:90:32)
+//           at Test.fail (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:363:10)
+//           at Test.bound [as fail] (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:90:32)
+//           at Test._exit (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:226:14)
+//           at Test.bound [as _exit] (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:90:32)
+//           at process.<anonymous> (/home/izelnakri/ava-test/node_modules/tape/index.js:85:19)
+//           at process.emit (node:events:376:20)
+//   ...

package/lib/utils/find-internal-assets-from-html.js

@@ -0,0 +1,16 @@
+import cheerio from 'cheerio';
+
+const ABSOLUTE_URL_REGEX = new RegExp('^(?:[a-z]+:)?//', 'i');
+
+export default function findInternalAssetsFromHTML(htmlContent) {
+  const $ = cheerio.load(htmlContent);
+  const internalJSFiles = $('script[src]').toArray()
+    .map((scriptNode) => $(scriptNode).attr('src'))
+    .filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
+  const internalCSSFiles = $('link[href]').toArray()
+    .map((scriptNode) => $(scriptNode).attr('href'))
+    .filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
+
+  return internalCSSFiles.concat(internalJSFiles);
+    // TODO: maybe needs normalization ? .map((fileReferencePath) => fileReferencePath.replace('/assets', `${projectRoot}/tmp/assets`));
+}

package/lib/utils/find-project-root.js

@@ -0,0 +1,17 @@
+import process from 'node:process';
+import searchInParentDirectories from './search-in-parent-directories.js';
+
+export default async function() {
+  try {
+    let absolutePath = await searchInParentDirectories('.', 'package.json');
+    if (!absolutePath.includes('package.json')) {
+      throw new Error('package.json mising');
+    }
+
+    return absolutePath.replace('/package.json', '');
+  } catch (error) {
+    console.log('couldnt find projects package.json, did you run $ npm init ??');
+    process.exit(1);
+  }
+}
+

package/lib/utils/indent-string.js

@@ -0,0 +1,11 @@
+export default function indentString(string, count = 1, options = {}) {
+	const { indent = ' ', includeEmptyLines = false } = options;
+
+	if (count <= 0) {
+		return string;
+	}
+
+	const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+
+	return string.replace(regex, indent.repeat(count));
+}

package/lib/utils/listen-to-keyboard-key.js

@@ -0,0 +1,44 @@
+import process from 'node:process';
+
+let stdin = process.stdin;
+let targetInputs = {};
+let inputs = [];
+let listenerAdded = false;
+
+export default function listenToKeyboardKey(inputString, closure, options = { caseSensitive: false }) {
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding('utf8');
+  if (!listenerAdded) {
+    stdin.on('data', function(key){
+      if (key === '\u0003') {
+        process.exit(); // so node process doesnt trap Control-C
+      }
+
+      inputs.shift();
+      inputs.push(key);
+
+      let inputString = inputs.join('');
+      let targetListener = targetInputs[inputString.toUpperCase()];
+      if (targetListener && targetListenerConformsToCase(targetListener, inputString)) {
+        targetListener.closure(inputString);
+        inputs.fill(undefined);
+      }
+    });
+    listenerAdded = true;
+  }
+
+  if (inputString.length > inputs.length) {
+    inputs.length = inputString.length;
+  }
+
+  targetInputs[inputString.toUpperCase()] = Object.assign(options, { closure });
+}
+
+function targetListenerConformsToCase(targetListener, inputString) {
+  if (targetListener.caseSensitive) {
+    return inputString === inputString.toUpperCase();
+  }
+
+  return true;
+}

package/lib/utils/parse-cli-flags.js

@@ -0,0 +1,57 @@
+// { inputs: [], debug: true, watch: true, failFast: true, htmlPaths: [], output }
+export default async function(projectRoot) {
+  const providedFlags = process.argv.slice(2).reduce((result, arg) => {
+    if (arg.startsWith('--debug')) {
+      return Object.assign(result, { debug: parseBoolean(arg.split('=')[1]) });
+    } else if (arg.startsWith('--watch')) {
+      return Object.assign(result, { watch: parseBoolean(arg.split('=')[1]) });
+    } else if (arg.startsWith('--failfast') || arg.startsWith('--failFast')) {
+      return Object.assign(result, { failFast: parseBoolean(arg.split('=')[1]) });
+    } else if (arg.startsWith('--timeout')) {
+      return Object.assign(result, { timeout: arg.split('=')[1] || 10000 });
+    } else if (arg.startsWith('--output')) {
+      return Object.assign(result, { output: arg.split('=')[1] });
+    } else if (arg.endsWith('.html')) {
+      if (result.htmlPaths) {
+        result.htmlPaths.push(arg);
+      } else {
+        result.htmlPaths = [arg];
+      }
+
+      return result;
+    } else if (arg.startsWith('--port')) {
+      return Object.assign(result, { port: Number(arg.split('=')[1]) });
+    } else if (arg.startsWith('--before')) {
+      return Object.assign(result, { before: parseModule(arg.split('=')[1]) });
+    } else if (arg.startsWith('--after')) {
+      return Object.assign(result, { after: parseModule(arg.split('=')[1]) });
+    }
+
+    // maybe set watch depth via micromatch(so incl metadata)
+    result.inputs.add(arg.startsWith(projectRoot) ? arg : `${process.cwd()}/${arg}`);
+
+    return result;
+  }, { inputs: new Set([]) });
+
+  providedFlags.inputs = Array.from(providedFlags.inputs);
+
+  return providedFlags;
+}
+
+function parseBoolean(result, defaultValue=true) {
+  if (result === 'true') {
+    return true;
+  } else if (result === 'false') {
+    return false;
+  }
+
+  return defaultValue;
+}
+
+function parseModule(value) {
+  if (['false', "'false'", '"false"', ''].includes(value)) {
+    return false;
+  }
+
+  return value;
+}

package/lib/utils/path-exists.js

@@ -0,0 +1,11 @@
+import fs from 'node:fs/promises';
+
+export default async function pathExists(path) {
+  try {
+    await fs.access(path);
+
+    return true;
+  } catch {
+    return false;
+  }
+}