@jsenv/test 3.6.6 → 3.6.8

package/dist/jsenv_test_node_modules.js

@@ -0,0 +1,295 @@
+import process from "node:process";
+import os from "node:os";
+import tty from "node:tty";
+
+// From: https://github.com/sindresorhus/has-flag/blob/main/index.js
+/// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) {
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process.argv) {
+	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf('--');
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+
+const {env} = process;
+
+let flagForceColor;
+if (
+	hasFlag('no-color')
+	|| hasFlag('no-colors')
+	|| hasFlag('color=false')
+	|| hasFlag('color=never')
+) {
+	flagForceColor = 0;
+} else if (
+	hasFlag('color')
+	|| hasFlag('colors')
+	|| hasFlag('color=true')
+	|| hasFlag('color=always')
+) {
+	flagForceColor = 1;
+}
+
+function envForceColor() {
+	if (!('FORCE_COLOR' in env)) {
+		return;
+	}
+
+	if (env.FORCE_COLOR === 'true') {
+		return 1;
+	}
+
+	if (env.FORCE_COLOR === 'false') {
+		return 0;
+	}
+
+	if (env.FORCE_COLOR.length === 0) {
+		return 1;
+	}
+
+	const level = Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+
+	if (![0, 1, 2, 3].includes(level)) {
+		return;
+	}
+
+	return level;
+}
+
+function translateLevel(level) {
+	if (level === 0) {
+		return false;
+	}
+
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3,
+	};
+}
+
+function _supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== undefined) {
+		flagForceColor = noFlagForceColor;
+	}
+
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+
+	if (forceColor === 0) {
+		return 0;
+	}
+
+	if (sniffFlags) {
+		if (hasFlag('color=16m')
+			|| hasFlag('color=full')
+			|| hasFlag('color=truecolor')) {
+			return 3;
+		}
+
+		if (hasFlag('color=256')) {
+			return 2;
+		}
+	}
+
+	// Check for Azure DevOps pipelines.
+	// Has to be above the `!streamIsTTY` check.
+	if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
+		return 1;
+	}
+
+	if (haveStream && !streamIsTTY && forceColor === undefined) {
+		return 0;
+	}
+
+	const min = forceColor || 0;
+
+	if (env.TERM === 'dumb') {
+		return min;
+	}
+
+	if (process.platform === 'win32') {
+		// Windows 10 build 10586 is the first Windows release that supports 256 colors.
+		// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+		const osRelease = os.release().split('.');
+		if (
+			Number(osRelease[0]) >= 10
+			&& Number(osRelease[2]) >= 10_586
+		) {
+			return Number(osRelease[2]) >= 14_931 ? 3 : 2;
+		}
+
+		return 1;
+	}
+
+	if ('CI' in env) {
+		if (['GITHUB_ACTIONS', 'GITEA_ACTIONS', 'CIRCLECI'].some(key => key in env)) {
+			return 3;
+		}
+
+		if (['TRAVIS', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+			return 1;
+		}
+
+		return min;
+	}
+
+	if ('TEAMCITY_VERSION' in env) {
+		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	}
+
+	if (env.COLORTERM === 'truecolor') {
+		return 3;
+	}
+
+	if (env.TERM === 'xterm-kitty') {
+		return 3;
+	}
+
+	if ('TERM_PROGRAM' in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+		switch (env.TERM_PROGRAM) {
+			case 'iTerm.app': {
+				return version >= 3 ? 3 : 2;
+			}
+
+			case 'Apple_Terminal': {
+				return 2;
+			}
+			// No default
+		}
+	}
+
+	if (/-256(color)?$/i.test(env.TERM)) {
+		return 2;
+	}
+
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+		return 1;
+	}
+
+	if ('COLORTERM' in env) {
+		return 1;
+	}
+
+	return min;
+}
+
+function createSupportsColor(stream, options = {}) {
+	const level = _supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options,
+	});
+
+	return translateLevel(level);
+}
+
+({
+	stdout: createSupportsColor({isTTY: tty.isatty(1)}),
+	stderr: createSupportsColor({isTTY: tty.isatty(2)}),
+});
+
+function isUnicodeSupported() {
+	const {env} = process;
+	const {TERM, TERM_PROGRAM} = env;
+
+	if (process.platform !== 'win32') {
+		return TERM !== 'linux'; // Linux console (kernel)
+	}
+
+	return Boolean(env.WT_SESSION) // Windows Terminal
+		|| Boolean(env.TERMINUS_SUBLIME) // Terminus (<0.2.27)
+		|| env.ConEmuTask === '{cmd::Cmder}' // ConEmu and cmder
+		|| TERM_PROGRAM === 'Terminus-Sublime'
+		|| TERM_PROGRAM === 'vscode'
+		|| TERM === 'xterm-256color'
+		|| TERM === 'alacritty'
+		|| TERM === 'rxvt-unicode'
+		|| TERM === 'rxvt-unicode-256color'
+		|| env.TERMINAL_EMULATOR === 'JetBrains-JediTerm';
+}
+
+/* globals WorkerGlobalScope, DedicatedWorkerGlobalScope, SharedWorkerGlobalScope, ServiceWorkerGlobalScope */
+
+const isBrowser = globalThis.window?.document !== undefined;
+
+globalThis.process?.versions?.node !== undefined;
+
+globalThis.process?.versions?.bun !== undefined;
+
+globalThis.Deno?.version?.deno !== undefined;
+
+globalThis.process?.versions?.electron !== undefined;
+
+globalThis.navigator?.userAgent?.includes('jsdom') === true;
+
+typeof WorkerGlobalScope !== 'undefined' && globalThis instanceof WorkerGlobalScope;
+
+typeof DedicatedWorkerGlobalScope !== 'undefined' && globalThis instanceof DedicatedWorkerGlobalScope;
+
+typeof SharedWorkerGlobalScope !== 'undefined' && globalThis instanceof SharedWorkerGlobalScope;
+
+typeof ServiceWorkerGlobalScope !== 'undefined' && globalThis instanceof ServiceWorkerGlobalScope;
+
+// Note: I'm intentionally not DRYing up the other variables to keep them "lazy".
+const platform = globalThis.navigator?.userAgentData?.platform;
+
+platform === 'macOS'
+	|| globalThis.navigator?.platform === 'MacIntel' // Even on Apple silicon Macs.
+	|| globalThis.navigator?.userAgent?.includes(' Mac ') === true
+	|| globalThis.process?.platform === 'darwin';
+
+platform === 'Windows'
+	|| globalThis.navigator?.platform === 'Win32'
+	|| globalThis.process?.platform === 'win32';
+
+platform === 'Linux'
+	|| globalThis.navigator?.platform?.startsWith('Linux') === true
+	|| globalThis.navigator?.userAgent?.includes(' Linux ') === true
+	|| globalThis.process?.platform === 'linux';
+
+platform === 'Android'
+	|| globalThis.navigator?.platform === 'Android'
+	|| globalThis.navigator?.userAgent?.includes(' Android ') === true
+	|| globalThis.process?.platform === 'android';
+
+const ESC = '\u001B[';
+
+!isBrowser && process.env.TERM_PROGRAM === 'Apple_Terminal';
+const isWindows = !isBrowser && process.platform === 'win32';
+
+isBrowser ? () => {
+	throw new Error('`process.cwd()` only works in Node.js, not the browser.');
+} : process.cwd;
+
+const cursorUp = (count = 1) => ESC + count + 'A';
+
+const cursorLeft = ESC + 'G';
+
+const eraseLines = count => {
+	let clear = '';
+
+	for (let i = 0; i < count; i++) {
+		clear += eraseLine + (i < count - 1 ? cursorUp() : '');
+	}
+
+	if (count) {
+		clear += cursorLeft;
+	}
+
+	return clear;
+};
+const eraseLine = ESC + '2K';
+const eraseScreen = ESC + '2J';
+
+const clearTerminal = isWindows
+	? `${eraseScreen}${ESC}0f`
+	// 1. Erases the screen (Only done in case `2` is not supported)
+	// 2. Erases the whole screen including scrollback buffer
+	// 3. Moves cursor to the top-left position
+	// More info: https://www.real-world-systems.com/docs/ANSIcode.html
+	:	`${eraseScreen}${ESC}3J${ESC}H`;
+
+export { clearTerminal, createSupportsColor, eraseLines, isUnicodeSupported };

package/dist/v8_coverage/v8_coverage.js

@@ -336,9 +336,19 @@ const applyPatternMatching = ({ url, pattern }) => {
   return applyPattern({ url, pattern });
 };
 
-const resolveAssociations = (associations, baseUrl) => {
-  if (baseUrl && typeof baseUrl.href === "string") baseUrl = baseUrl.href;
-  assertUrlLike(baseUrl, "baseUrl");
+const resolveAssociations = (associations, resolver) => {
+  let resolve = () => {};
+  if (typeof resolver === "function") {
+    resolve = resolver;
+  } else if (typeof resolver === "string") {
+    const baseUrl = resolver;
+    assertUrlLike(baseUrl, "baseUrl");
+    resolve = (pattern) => new URL(pattern, baseUrl).href;
+  } else if (resolver && typeof resolver.href === "string") {
+    const baseUrl = resolver.href;
+    assertUrlLike(baseUrl, "baseUrl");
+    resolve = (pattern) => new URL(pattern, baseUrl).href;
+  }
 
   const associationsResolved = {};
   for (const key of Object.keys(associations)) {
@@ -349,12 +359,11 @@ const resolveAssociations = (associations, baseUrl) => {
         const valueAssociated = value[pattern];
         let patternResolved;
         try {
-          patternResolved = String(new URL(pattern, baseUrl));
+          patternResolved = resolve(pattern);
         } catch {
           // it's not really an url, no need to perform url resolution nor encoding
           patternResolved = pattern;
         }
-
         valueMapResolved[patternResolved] = valueAssociated;
       }
       associationsResolved[key] = valueMapResolved;
@@ -477,34 +486,29 @@ const urlChildMayMatch = ({ url, associations, predicate }) => {
 };
 
 const applyAliases = ({ url, aliases }) => {
-  let aliasFullMatchResult;
-  const aliasMatchingKey = Object.keys(aliases).find((key) => {
-    const aliasMatchResult = applyPatternMatching({
+  for (const key of Object.keys(aliases)) {
+    const matchResult = applyPatternMatching({
       pattern: key,
       url,
     });
-    if (aliasMatchResult.matched) {
-      aliasFullMatchResult = aliasMatchResult;
-      return true;
+    if (!matchResult.matched) {
+      continue;
     }
-    return false;
-  });
-  if (!aliasMatchingKey) {
-    return url;
-  }
-  const { matchGroups } = aliasFullMatchResult;
-  const alias = aliases[aliasMatchingKey];
-  const parts = alias.split("*");
-  let newUrl = "";
-  let index = 0;
-  for (const part of parts) {
-    newUrl += `${part}`;
-    if (index < parts.length - 1) {
-      newUrl += matchGroups[index];
+    const { matchGroups } = matchResult;
+    const alias = aliases[key];
+    const parts = alias.split("*");
+    let newUrl = "";
+    let index = 0;
+    for (const part of parts) {
+      newUrl += `${part}`;
+      if (index < parts.length - 1) {
+        newUrl += matchGroups[index];
+      }
+      index++;
     }
-    index++;
+    return newUrl;
   }
-  return newUrl;
+  return url;
 };
 
 const matches = (url, patterns) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/test",
-  "version": "3.6.6",
+  "version": "3.6.8",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -41,17 +41,17 @@
   "dependencies": {
     "@c88/v8-coverage": "0.1.1",
     "@jsenv/abort": "4.3.1",
-    "@jsenv/ast": "6.6.6",
-    "@jsenv/exception": "1.1.6",
-    "@jsenv/filesystem": "4.14.4",
-    "@jsenv/github-check-run": "0.2.19",
-    "@jsenv/node-esm-resolution": "1.1.0",
-    "@jsenv/humanize": "1.3.1",
-    "@jsenv/plugin-supervisor": "1.6.11",
-    "@jsenv/sourcemap": "1.3.3",
-    "@jsenv/url-meta": "8.5.5",
-    "@jsenv/urls": "2.7.0",
-    "@jsenv/utils": "2.2.1",
+    "@jsenv/ast": "6.6.7",
+    "@jsenv/exception": "1.1.7",
+    "@jsenv/filesystem": "4.14.6",
+    "@jsenv/github-check-run": "0.2.21",
+    "@jsenv/node-esm-resolution": "1.2.0",
+    "@jsenv/humanize": "1.4.0",
+    "@jsenv/plugin-supervisor": "1.6.12",
+    "@jsenv/sourcemap": "1.3.4",
+    "@jsenv/url-meta": "8.5.6",
+    "@jsenv/urls": "2.7.1",
+    "@jsenv/utils": "2.3.0",
     "he": "1.2.0",
     "istanbul-lib-coverage": "3.2.2",
     "istanbul-lib-instrument": "6.0.3",

package/src/execution/execute_test_plan.js

@@ -12,24 +12,26 @@ import {
   readGitHubWorkflowEnv,
   startGithubCheckRun,
 } from "@jsenv/github-check-run";
-import { createDetailedMessage, createLogger, UNICODE } from "@jsenv/humanize";
+import {
+  createCallOrderer,
+  createDetailedMessage,
+  createLogger,
+  UNICODE,
+} from "@jsenv/humanize";
 import { applyNodeEsmResolution } from "@jsenv/node-esm-resolution";
+import {
+  countAvailableCpus,
+  getAvailableMemory,
+  getOsVersion,
+  startMonitoringCpuUsage,
+  startMonitoringMemoryUsage,
+} from "@jsenv/os-metrics";
 import { URL_META } from "@jsenv/url-meta";
 import { urlIsInsideOf } from "@jsenv/urls";
 import { existsSync } from "node:fs";
-import {
-  availableParallelism,
-  cpus,
-  freemem,
-  release,
-  totalmem,
-} from "node:os";
-import { memoryUsage } from "node:process";
 import { takeCoverage } from "node:v8";
 import stripAnsi from "strip-ansi";
 import { generateCoverage } from "../coverage/generate_coverage.js";
-import { createCallOrderer } from "../helpers/call_orderer.js";
-import { startMeasuringTotalCpuUsage } from "../helpers/cpu_usage.js";
 import { githubAnnotationFromError } from "./github_annotation_from_error.js";
 import { createIsInsideFragment } from "./is_inside_fragment.js";
 import { renderOutroContent, reporterList } from "./reporters/reporter_list.js";
@@ -159,22 +161,12 @@ export const executeTestPlan = async ({
     });
   }
 
-  const cpuUsage = startMeasuringTotalCpuUsage();
-  operation.addEndCallback(cpuUsage.stop);
-  const processCpuUsageMonitoring = startMonitoringMetric(() => {
-    return cpuUsage.thisProcess.active;
-  });
-  const osCpuUsageMonitoring = startMonitoringMetric(() => {
-    return cpuUsage.overall.active;
-  });
-  const processMemoryUsageMonitoring = startMonitoringMetric(() => {
-    return memoryUsage().rss;
-  });
-  const osMemoryUsageMonitoring = startMonitoringMetric(() => {
-    const total = totalmem();
-    const free = freemem();
-    return total - free;
-  });
+  const cpuMonitoring = startMonitoringCpuUsage();
+  operation.addEndCallback(cpuMonitoring.stop);
+  const [processCpuUsageMonitoring, osCpuUsageMonitoring] = cpuMonitoring;
+  const memoryMonitoring = startMonitoringMemoryUsage();
+  const [processMemoryUsageMonitoring, osMemoryUsageMonitoring] =
+    memoryMonitoring;
 
   const timingsOrigin = Date.now();
   const takeTiming = () => {
@@ -190,9 +182,9 @@ export const executeTestPlan = async ({
             : process.platform === "linux"
               ? "linux"
               : "other",
-      version: release(),
+      version: getOsVersion(),
       availableCpu: countAvailableCpus(),
-      availableMemory: totalmem(),
+      availableMemory: getAvailableMemory(),
     },
     runtime: {
       name: "node",
@@ -1160,59 +1152,6 @@ To fix this warning:
   return testPlanResult;
 };
 
-const startMonitoringMetric = (measure) => {
-  const metrics = [];
-  const takeMeasure = () => {
-    const value = measure();
-    metrics.push(value);
-    return value;
-  };
-
-  const info = {
-    start: takeMeasure(),
-    min: null,
-    max: null,
-    median: null,
-    end: null,
-  };
-  return {
-    info,
-    measure: takeMeasure,
-    end: () => {
-      info.end = takeMeasure();
-      metrics.sort((a, b) => a - b);
-      info.min = metrics[0];
-      info.max = metrics[metrics.length - 1];
-      info.median = medianFromSortedArray(metrics);
-      metrics.length = 0;
-    },
-  };
-};
-
-const medianFromSortedArray = (array) => {
-  const length = array.length;
-  const isOdd = length % 2 === 1;
-  if (isOdd) {
-    const medianNumberIndex = (length - 1) / 2;
-    const medianNumber = array[medianNumberIndex];
-    return medianNumber;
-  }
-  const rightMiddleNumberIndex = length / 2;
-  const leftMiddleNumberIndex = rightMiddleNumberIndex - 1;
-  const leftMiddleNumber = array[leftMiddleNumberIndex];
-  const rightMiddleNumber = array[rightMiddleNumberIndex];
-  const medianNumber = (leftMiddleNumber + rightMiddleNumber) / 2;
-  return medianNumber;
-};
-
-const countAvailableCpus = () => {
-  if (typeof availableParallelism === "function") {
-    return availableParallelism();
-  }
-  const cpuArray = cpus();
-  return cpuArray.length || 1;
-};
-
 const mutateCountersBeforeExecutionStarts = (counters) => {
   counters.executing++;
   counters.waiting--;

package/src/execution/reporters/reporter_list.js

@@ -4,6 +4,9 @@ import {
   createDynamicLog,
   humanizeDuration,
   humanizeMemory,
+  renderBigSection,
+  renderDetails,
+  renderSection,
   UNICODE,
 } from "@jsenv/humanize";
 import { urlToFileSystemPath } from "@jsenv/urls";
@@ -949,76 +952,3 @@ const renderStatusRepartition = (counters, { showProgression } = {}) => {
   }
   return `${parts.join(", ")}`;
 };
-
-const renderBigSection = (params) => {
-  return renderSection({
-    width: 45,
-    ...params,
-  });
-};
-
-const renderSection = ({
-  title,
-  content,
-  dashColor = ANSI.GREY,
-  width = 38,
-  bottomSeparator = true,
-}) => {
-  let section = "";
-
-  if (title) {
-    const titleWidth = stripAnsi(title).length;
-    const minWidthRequired = `--- … ---`.length;
-    const needsTruncate = titleWidth + minWidthRequired >= width;
-    if (needsTruncate) {
-      const titleTruncated = title.slice(0, width - minWidthRequired);
-      const leftDashes = ANSI.color("---", dashColor);
-      const rightDashes = ANSI.color("---", dashColor);
-      section += `${leftDashes} ${titleTruncated}… ${rightDashes}`;
-    } else {
-      const remainingWidth = width - titleWidth - 2; // 2 for spaces around the title
-      const dashLeftCount = Math.floor(remainingWidth / 2);
-      const dashRightCount = remainingWidth - dashLeftCount;
-      const leftDashes = ANSI.color("-".repeat(dashLeftCount), dashColor);
-      const rightDashes = ANSI.color("-".repeat(dashRightCount), dashColor);
-      section += `${leftDashes} ${title} ${rightDashes}`;
-    }
-    section += "\n";
-  } else {
-    const topDashes = ANSI.color(`-`.repeat(width), dashColor);
-    section += topDashes;
-    section += "\n";
-  }
-  section += `${content}`;
-  if (bottomSeparator) {
-    section += "\n";
-    const bottomDashes = ANSI.color(`-`.repeat(width), dashColor);
-    section += bottomDashes;
-  }
-  return section;
-};
-
-const renderDetails = (data) => {
-  const details = [];
-  for (const key of Object.keys(data)) {
-    const value = data[key];
-    let valueString = "";
-    valueString += ANSI.color(`${key}:`, ANSI.GREY);
-    const useNonGreyAnsiColor =
-      typeof value === "string" && value.includes("\x1b");
-    valueString += " ";
-    valueString += useNonGreyAnsiColor
-      ? value
-      : ANSI.color(String(value), ANSI.GREY);
-    details.push(valueString);
-  }
-  if (details.length === 0) {
-    return "";
-  }
-
-  let string = "";
-  string += ` ${ANSI.color("(", ANSI.GREY)}`;
-  string += details.join(ANSI.color(", ", ANSI.GREY));
-  string += ANSI.color(")", ANSI.GREY);
-  return string;
-};

package/src/helpers/call_orderer.js

@@ -1,39 +0,0 @@
-export const createCallOrderer = () => {
-  const queue = [];
-  const callWhenPreviousExecutionAreDone = (executionIndex, callback) => {
-    if (queue[executionIndex]) {
-      throw new Error(`${executionIndex} already used`);
-    }
-
-    let allBeforeAreDone = true;
-    if (executionIndex > 0) {
-      let beforeIndex = executionIndex - 1;
-      do {
-        const value = queue[beforeIndex];
-        if (!value) {
-          allBeforeAreDone = false;
-          break;
-        }
-      } while (beforeIndex--);
-    }
-    if (!allBeforeAreDone) {
-      queue[executionIndex] = callback;
-      return;
-    }
-    queue[executionIndex] = true;
-    callback();
-    let afterIndex = executionIndex + 1;
-    while (afterIndex < queue.length) {
-      const value = queue[afterIndex];
-      if (value === undefined) {
-        break;
-      }
-      if (typeof value === "function") {
-        queue[afterIndex] = true;
-        value();
-      }
-      afterIndex++;
-    }
-  };
-  return callWhenPreviousExecutionAreDone;
-};