@gjsify/unit 0.3.15 → 0.3.17

package/lib/esm/index.js

@@ -1,534 +1,8 @@
-import { spy } from "./spy.js";
-import "@girs/gjs";
-import nodeAssert from "node:assert";
-import { quitMainLoop } from "@gjsify/utils/main-loop";
-
-//#region src/index.ts
-const mainloop = globalThis?.imports?.mainloop;
-let countTestsOverall = 0;
-let countTestsFailed = 0;
-let countTestsIgnored = 0;
-let runtime = "";
-let runStartTime = 0;
-let currentSuite = "";
-let testErrors = [];
-const DEFAULT_TIMEOUT_CONFIG = {
-	testTimeout: 5e3,
-	suiteTimeout: 3e4,
-	runTimeout: 12e4
-};
-let timeoutConfig = { ...DEFAULT_TIMEOUT_CONFIG };
-var TimeoutError = class extends Error {
-	constructor(label, timeoutMs) {
-		super(`Timeout: "${label}" exceeded ${timeoutMs}ms`);
-		this.name = "TimeoutError";
-	}
-};
-async function withTimeout(fn, timeoutMs, label) {
-	if (timeoutMs <= 0) return fn();
-	let timeoutId;
-	const timeoutPromise = new Promise((_, reject) => {
-		timeoutId = setTimeout(() => reject(new TimeoutError(label, timeoutMs)), timeoutMs);
-	});
-	const fnPromise = Promise.resolve(fn());
-	fnPromise.catch(() => {});
-	try {
-		return await Promise.race([fnPromise, timeoutPromise]);
-	} finally {
-		clearTimeout(timeoutId);
-	}
-}
-const configure = (overrides) => {
-	timeoutConfig = {
-		...timeoutConfig,
-		...overrides
-	};
-};
-function applyEnvOverrides() {
-	try {
-		const env = globalThis.process?.env;
-		if (!env) return;
-		const t = parseInt(env.GJSIFY_TEST_TIMEOUT, 10);
-		if (!isNaN(t) && t >= 0) timeoutConfig.testTimeout = t;
-		const s = parseInt(env.GJSIFY_SUITE_TIMEOUT, 10);
-		if (!isNaN(s) && s >= 0) timeoutConfig.suiteTimeout = s;
-		const r = parseInt(env.GJSIFY_RUN_TIMEOUT, 10);
-		if (!isNaN(r) && r >= 0) timeoutConfig.runTimeout = r;
-	} catch (_e) {}
-}
-const RED = "\x1B[31m";
-const GREEN = "\x1B[32m";
-const BLUE = "\x1B[34m";
-const GRAY = "\x1B[90m";
-const RESET = "\x1B[39m";
-const now = () => globalThis.performance?.now?.() ?? Date.now();
-const formatDuration = (ms) => {
-	if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
-	if (ms >= 100) return `${Math.round(ms)}ms`;
-	return `${ms.toFixed(1)}ms`;
-};
-const _isGjsProcess = typeof globalThis.process?.versions?.gjs === "string";
-const print = !_isGjsProcess && typeof globalThis.document !== "undefined" ? console.log : globalThis.print || console.log;
-var MatcherFactory = class MatcherFactory {
-	not;
-	constructor(actualValue, positive, negated) {
-		this.actualValue = actualValue;
-		this.positive = positive;
-		if (negated) {
-			this.not = negated;
-		} else {
-			this.not = new MatcherFactory(actualValue, !positive, this);
-		}
-	}
-	triggerResult(success, msg) {
-		if (success && !this.positive || !success && this.positive) {
-			const error = new Error(msg);
-			error.__testFailureCounted = true;
-			++countTestsFailed;
-			throw error;
-		}
-	}
-	to(callback) {
-		this.triggerResult(callback(this.actualValue), `      Expected callback to validate`);
-	}
-	toBe(expectedValue) {
-		this.triggerResult(this.actualValue === expectedValue, `      Expected values to match using ===\n` + `      Expected: ${expectedValue} (${typeof expectedValue})\n` + `      Actual: ${this.actualValue} (${typeof this.actualValue})`);
-	}
-	toEqual(expectedValue) {
-		this.triggerResult(this.actualValue == expectedValue, `      Expected values to match using ==\n` + `      Expected: ${expectedValue} (${typeof expectedValue})\n` + `      Actual: ${this.actualValue} (${typeof this.actualValue})`);
-	}
-	toStrictEqual(expectedValue) {
-		let success = true;
-		let errorMessage = "";
-		try {
-			nodeAssert.deepStrictEqual(this.actualValue, expectedValue);
-		} catch (e) {
-			success = false;
-			errorMessage = e.message || "";
-		}
-		this.triggerResult(success, `      Expected values to be deeply strictly equal\n` + `      Expected: ${JSON.stringify(expectedValue)}\n` + `      Actual: ${JSON.stringify(this.actualValue)}` + (errorMessage ? `\n      ${errorMessage}` : ""));
-	}
-	toEqualArray(expectedValue) {
-		let success = Array.isArray(this.actualValue) && Array.isArray(expectedValue) && this.actualValue.length === expectedValue.length;
-		for (let i = 0; i < this.actualValue.length; i++) {
-			const actualVal = this.actualValue[i];
-			const expectedVal = expectedValue[i];
-			success = actualVal == expectedVal;
-			if (!success) break;
-		}
-		this.triggerResult(success, `      Expected array items to match using ==\n` + `      Expected: ${expectedValue} (${typeof expectedValue})\n` + `      Actual: ${this.actualValue} (${typeof this.actualValue})`);
-	}
-	toBeInstanceOf(expectedType) {
-		this.triggerResult(this.actualValue instanceof expectedType, `      Expected value to be instance of ${expectedType.name || expectedType}\n` + `      Actual: ${this.actualValue?.constructor?.name || typeof this.actualValue}`);
-	}
-	toHaveLength(expectedLength) {
-		const actualLength = this.actualValue?.length;
-		this.triggerResult(actualLength === expectedLength, `      Expected length: ${expectedLength}\n` + `      Actual length: ${actualLength}`);
-	}
-	toMatch(expectedValue) {
-		if (typeof this.actualValue.match !== "function") {
-			throw new Error(`You can not use toMatch on type ${typeof this.actualValue}`);
-		}
-		this.triggerResult(!!this.actualValue.match(expectedValue), "      Expected values to match using regular expression\n" + "      Expression: " + expectedValue + "\n" + "      Actual: " + this.actualValue);
-	}
-	toBeDefined() {
-		this.triggerResult(typeof this.actualValue !== "undefined", `      Expected value to be defined`);
-	}
-	toBeUndefined() {
-		this.triggerResult(typeof this.actualValue === "undefined", `      Expected value to be undefined`);
-	}
-	toBeNull() {
-		this.triggerResult(this.actualValue === null, `      Expected value to be null`);
-	}
-	toBeTruthy() {
-		this.triggerResult(this.actualValue, `      Expected value to be truthy`);
-	}
-	toBeFalsy() {
-		this.triggerResult(!this.actualValue, `      Expected value to be falsy`);
-	}
-	toContain(needle) {
-		const value = this.actualValue;
-		let contains;
-		if (typeof value === "string") {
-			contains = value.includes(String(needle));
-		} else if (value instanceof Array) {
-			contains = value.indexOf(needle) !== -1;
-		} else {
-			contains = false;
-		}
-		this.triggerResult(contains, `      Expected ` + value + ` to contain ` + needle);
-	}
-	toBeLessThan(greaterValue) {
-		this.triggerResult(this.actualValue < greaterValue, `      Expected ` + this.actualValue + ` to be less than ` + greaterValue);
-	}
-	toBeGreaterThan(smallerValue) {
-		this.triggerResult(this.actualValue > smallerValue, `      Expected ` + this.actualValue + ` to be greater than ` + smallerValue);
-	}
-	toBeGreaterThanOrEqual(value) {
-		this.triggerResult(this.actualValue >= value, `      Expected ${this.actualValue} to be greater than or equal to ${value}`);
-	}
-	toBeLessThanOrEqual(value) {
-		this.triggerResult(this.actualValue <= value, `      Expected ${this.actualValue} to be less than or equal to ${value}`);
-	}
-	toBeCloseTo(expectedValue, precision) {
-		const shiftHelper = Math.pow(10, precision);
-		this.triggerResult(Math.round(this.actualValue * shiftHelper) / shiftHelper === Math.round(expectedValue * shiftHelper) / shiftHelper, `      Expected ` + this.actualValue + ` with precision ` + precision + ` to be close to ` + expectedValue);
-	}
-	toThrow(expected) {
-		let errorMessage = "";
-		let didThrow = false;
-		let typeMatch = true;
-		let messageMatch = true;
-		try {
-			this.actualValue();
-			didThrow = false;
-		} catch (e) {
-			errorMessage = e.message || "";
-			didThrow = true;
-			if (typeof expected === "function") {
-				typeMatch = e instanceof expected;
-			} else if (typeof expected === "string") {
-				messageMatch = errorMessage.includes(expected);
-			} else if (expected instanceof RegExp) {
-				messageMatch = expected.test(errorMessage);
-			}
-		}
-		const functionName = this.actualValue.name || typeof this.actualValue === "function" ? "[anonymous function]" : this.actualValue.toString();
-		this.triggerResult(didThrow, `      Expected ${functionName} to ${this.positive ? "throw" : "not throw"} an exception ${!this.positive && errorMessage ? `, but an error with the message "${errorMessage}" was thrown` : ""}`);
-		if (typeof expected === "function") {
-			this.triggerResult(typeMatch, `      Expected Error type '${expected.name}', but the error is not an instance of it`);
-		} else if (expected !== undefined) {
-			this.triggerResult(messageMatch, `      Expected error message to match ${expected}\n` + `      Actual message: "${errorMessage}"`);
-		}
-	}
-	async toReject(expected) {
-		let didReject = false;
-		let errorMessage = "";
-		let typeMatch = true;
-		let messageMatch = true;
-		try {
-			await this.actualValue;
-			didReject = false;
-		} catch (e) {
-			didReject = true;
-			errorMessage = e?.message || String(e);
-			if (typeof expected === "function") {
-				typeMatch = e instanceof expected;
-			} else if (typeof expected === "string") {
-				messageMatch = errorMessage.includes(expected);
-			} else if (expected instanceof RegExp) {
-				messageMatch = expected.test(errorMessage);
-			}
-		}
-		this.triggerResult(didReject, `      Expected promise to ${this.positive ? "reject" : "resolve"}${!this.positive && errorMessage ? `, but it rejected with "${errorMessage}"` : ""}`);
-		if (didReject && typeof expected === "function") {
-			this.triggerResult(typeMatch, `      Expected rejection type '${expected.name}', but the error is not an instance of it`);
-		} else if (didReject && expected !== undefined) {
-			this.triggerResult(messageMatch, `      Expected rejection message to match ${expected}\n` + `      Actual message: "${errorMessage}"`);
-		}
-	}
-	async toResolve() {
-		let didResolve = false;
-		let errorMessage = "";
-		try {
-			await this.actualValue;
-			didResolve = true;
-		} catch (e) {
-			didResolve = false;
-			errorMessage = e?.message || String(e);
-		}
-		this.triggerResult(didResolve, `      Expected promise to ${this.positive ? "resolve" : "reject"}${!didResolve ? `, but it rejected with "${errorMessage}"` : ""}`);
-	}
-};
-const describe = async function(moduleName, callback, options) {
-	const suiteTimeoutMs = typeof options === "number" ? options : options?.timeout ?? timeoutConfig.suiteTimeout;
-	print("\n" + moduleName);
-	const prevSuite = currentSuite;
-	currentSuite = moduleName;
-	const t0 = now();
-	try {
-		await withTimeout(callback, suiteTimeoutMs, `describe: ${moduleName}`);
-	} catch (e) {
-		if (e instanceof TimeoutError) {
-			++countTestsFailed;
-			print(`  ${RED}⏱ Suite timed out: ${e.message}${RESET}`);
-		} else {
-			throw e;
-		}
-	}
-	currentSuite = prevSuite;
-	const duration = now() - t0;
-	print(`  ${GRAY}↳ ${formatDuration(duration)}${RESET}`);
-	beforeEachCb = null;
-	afterEachCb = null;
-};
-describe.skip = async function(moduleName, _callback) {
-	++countTestsIgnored;
-	print(`\n${BLUE}- ${moduleName} (skipped)${RESET}`);
-};
-const hasDisplay = () => {
-	const env = globalThis.process?.env;
-	if (env) {
-		return !!(env.DISPLAY || env.WAYLAND_DISPLAY);
-	}
-	try {
-		const GLib = globalThis?.imports?.gi?.GLib;
-		if (GLib) {
-			return !!(GLib.getenv("DISPLAY") || GLib.getenv("WAYLAND_DISPLAY"));
-		}
-	} catch (_) {}
-	return false;
-};
-const runtimeMatch = async function(onRuntime, version) {
-	if (onRuntime.includes("Display")) {
-		return { matched: hasDisplay() };
-	}
-	const currRuntime = await getRuntime();
-	const foundRuntime = onRuntime.find((r) => currRuntime.includes(r));
-	if (!foundRuntime) {
-		return { matched: false };
-	}
-	if (typeof version === "string") {
-		if (!currRuntime.includes(version)) {
-			return { matched: false };
-		}
-	}
-	return {
-		matched: true,
-		runtime: foundRuntime,
-		version
-	};
-};
-/** E.g on('Deno', () {  it(...) }) */
-const on = async function(onRuntime, version, callback) {
-	if (typeof onRuntime === "string") {
-		onRuntime = [onRuntime];
-	}
-	if (typeof version === "function") {
-		callback = version;
-		version = undefined;
-	}
-	const { matched } = await runtimeMatch(onRuntime, version);
-	if (!matched) {
-		++countTestsIgnored;
-		return;
-	}
-	print(`\nOn ${onRuntime.join(", ")}${version ? " " + version : ""}`);
-	await callback();
-};
-let beforeEachCb;
-let afterEachCb;
-const beforeEach = function(callback) {
-	beforeEachCb = callback;
-};
-const afterEach = function(callback) {
-	afterEachCb = callback;
-};
-const it = async function(expectation, callback, options) {
-	const timeoutMs = typeof options === "number" ? options : options?.timeout ?? timeoutConfig.testTimeout;
-	const t0 = now();
-	try {
-		if (typeof beforeEachCb === "function") {
-			await beforeEachCb();
-		}
-		await withTimeout(callback, timeoutMs, expectation);
-		if (typeof afterEachCb === "function") {
-			await afterEachCb();
-		}
-		const duration = now() - t0;
-		print(`  ${GREEN}✔${RESET} ${GRAY}${expectation}  (${formatDuration(duration)})${RESET}`);
-	} catch (e) {
-		const duration = now() - t0;
-		if (!e.__testFailureCounted) {
-			++countTestsFailed;
-		}
-		testErrors.push({
-			suite: currentSuite,
-			test: expectation,
-			message: e.message ?? String(e)
-		});
-		const icon = e instanceof TimeoutError ? "⏱" : "❌";
-		print(`  ${RED}${icon}${RESET} ${GRAY}${expectation}  (${formatDuration(duration)})${RESET}`);
-		print(`${RED}${e.message}${RESET}`);
-		if (e.stack) print(e.stack);
-	}
-};
-it.skip = async function(expectation, _callback) {
-	++countTestsIgnored;
-	print(`  ${BLUE}-${RESET} ${GRAY}${expectation} (skipped)${RESET}`);
-};
-const expect = function(actualValue) {
-	++countTestsOverall;
-	const expecter = new MatcherFactory(actualValue, true);
-	return expecter;
-};
-const assert = function(success, message) {
-	++countTestsOverall;
-	if (!success) {
-		++countTestsFailed;
-	}
-	try {
-		nodeAssert(success, message);
-	} catch (error) {
-		error.__testFailureCounted = true;
-		throw error;
-	}
-};
-assert.strictEqual = function(actual, expected, message) {
-	++countTestsOverall;
-	try {
-		nodeAssert.strictEqual(actual, expected, message);
-	} catch (error) {
-		++countTestsFailed;
-		error.__testFailureCounted = true;
-		throw error;
-	}
-};
-assert.throws = function(promiseFn, ...args) {
-	++countTestsOverall;
-	let error;
-	try {
-		promiseFn();
-	} catch (e) {
-		error = e;
-	}
-	if (!error) ++countTestsFailed;
-	nodeAssert.throws(() => {
-		if (error) throw error;
-	}, args[0], args[1]);
-};
-assert.deepStrictEqual = function(actual, expected, message) {
-	++countTestsOverall;
-	try {
-		nodeAssert.deepStrictEqual(actual, expected, message);
-	} catch (error) {
-		++countTestsFailed;
-		error.__testFailureCounted = true;
-		throw error;
-	}
-};
-const runTests = async function(namespaces) {
-	for (const subNamespace in namespaces) {
-		const namespace = namespaces[subNamespace];
-		if (typeof namespace === "function") {
-			await namespace();
-		} else if (typeof namespace === "object") {
-			await runTests(namespace);
-		}
-	}
-};
-const browserSignalDone = () => {
-	const doc = globalThis.document;
-	if (!doc) return;
-	globalThis.__gjsify_test_results = {
-		passed: countTestsOverall - countTestsFailed,
-		failed: countTestsFailed,
-		total: countTestsOverall,
-		errors: testErrors
-	};
-	doc.documentElement.dataset.testsDone = "true";
-};
-const printResult = () => {
-	const totalMs = runStartTime > 0 ? now() - runStartTime : 0;
-	const durationStr = totalMs > 0 ? `  ${GRAY}(${formatDuration(totalMs)})` : "";
-	if (countTestsIgnored) {
-		print(`\n${BLUE}✔ ${countTestsIgnored} ignored test${countTestsIgnored > 1 ? "s" : ""}${RESET}`);
-	}
-	if (countTestsFailed) {
-		print(`\n${RED}❌ ${countTestsFailed} of ${countTestsOverall} tests failed${durationStr}${RESET}`);
-	} else {
-		print(`\n${GREEN}✔ ${countTestsOverall} completed${durationStr}${RESET}`);
-	}
-};
-const getRuntime = async () => {
-	if (runtime && runtime !== "Unknown") {
-		return runtime;
-	}
-	if (globalThis.Deno?.version?.deno) {
-		return "Deno " + globalThis.Deno?.version?.deno;
-	}
-	{
-		let process = globalThis.process;
-		if (!process) {
-			try {
-				process = await import("process");
-			} catch (_e) {}
-		}
-		if (process?.versions?.gjs) {
-			runtime = "Gjs " + process.versions.gjs;
-			return runtime;
-		} else if (process?.versions?.node) {
-			runtime = "Node.js " + process.versions.node;
-			return runtime;
-		}
-	}
-	if (typeof globalThis.document !== "undefined") {
-		runtime = "Browser";
-		return runtime;
-	}
-	return runtime || "Unknown";
-};
-const printRuntime = async () => {
-	const runtime = await getRuntime();
-	print(`\nRunning on ${runtime}`);
-};
-const run = async (namespaces, options) => {
-	applyEnvOverrides();
-	runStartTime = now();
-	if (options) {
-		if (typeof options === "number") {
-			timeoutConfig.runTimeout = options;
-		} else {
-			if (options.timeout !== undefined) timeoutConfig.runTimeout = options.timeout;
-			if (options.testTimeout !== undefined) timeoutConfig.testTimeout = options.testTimeout;
-			if (options.suiteTimeout !== undefined) timeoutConfig.suiteTimeout = options.suiteTimeout;
-		}
-	}
-	printRuntime().then(async () => {
-		try {
-			await withTimeout(() => runTests(namespaces), timeoutConfig.runTimeout, "entire test run");
-		} catch (e) {
-			if (e instanceof TimeoutError) {
-				print(`\n${RED}⏱ ${e.message}${RESET}`);
-				++countTestsFailed;
-			} else {
-				throw e;
-			}
-		}
-	}).then(async () => {
-		printResult();
-		browserSignalDone();
-		print();
-		quitMainLoop();
-		mainloop?.quit();
-		if (!mainloop) {
-			const exitCode = countTestsFailed > 0 ? 1 : 0;
-			try {
-				const process = globalThis.process || await import("process");
-				process.exit(exitCode);
-			} catch (_e) {}
-		}
-	});
-	mainloop?.run();
-	if (mainloop) {
-		const exitCode = countTestsFailed > 0 ? 1 : 0;
-		try {
-			globalThis.imports.system.exit(exitCode);
-		} catch (_e) {}
-	}
-};
-var src_default = {
-	run,
-	assert,
-	expect,
-	it,
-	afterEach,
-	beforeEach,
-	on,
-	describe,
-	configure,
-	print
-};
-
-//#endregion
-export { afterEach, assert, beforeEach, configure, src_default as default, describe, expect, it, on, print, run, spy };
+import{spy as e}from"./spy.js";import"@girs/gjs";import t from"node:assert";import{quitMainLoop as n}from"@gjsify/utils/main-loop";const r=globalThis?.imports?.mainloop;let i=0,a=0,o=0,s=``,c=0,l=``,u=[],d={testTimeout:5e3,suiteTimeout:3e4,runTimeout:12e4};var f=class extends Error{constructor(e,t){super(`Timeout: "${e}" exceeded ${t}ms`),this.name=`TimeoutError`}};async function p(e,t,n){if(t<=0)return e();let r,i=new Promise((e,i)=>{r=setTimeout(()=>i(new f(n,t)),t)}),a=Promise.resolve(e());a.catch(()=>{});try{return await Promise.race([a,i])}finally{clearTimeout(r)}}const m=e=>{d={...d,...e}};function h(){try{let e=globalThis.process?.env;if(!e)return;let t=parseInt(e.GJSIFY_TEST_TIMEOUT,10);!isNaN(t)&&t>=0&&(d.testTimeout=t);let n=parseInt(e.GJSIFY_SUITE_TIMEOUT,10);!isNaN(n)&&n>=0&&(d.suiteTimeout=n);let r=parseInt(e.GJSIFY_RUN_TIMEOUT,10);!isNaN(r)&&r>=0&&(d.runTimeout=r)}catch{}}const g=`\x1B[31m`,_=`\x1B[32m`,v=`\x1B[34m`,y=`\x1B[90m`,b=`\x1B[39m`,x=()=>globalThis.performance?.now?.()??Date.now(),S=e=>e>=1e3?`${(e/1e3).toFixed(2)}s`:e>=100?`${Math.round(e)}ms`:`${e.toFixed(1)}ms`,C=typeof globalThis.process?.versions?.gjs!=`string`&&globalThis.document!==void 0?console.log:globalThis.print||console.log;var w=class e{actualValue;positive;not;constructor(t,n,r){this.actualValue=t,this.positive=n,r?this.not=r:this.not=new e(t,!n,this)}triggerResult(e,t){if(e&&!this.positive||!e&&this.positive){let e=Error(t);throw e.__testFailureCounted=!0,++a,e}}to(e){this.triggerResult(e(this.actualValue),`      Expected callback to validate`)}toBe(e){this.triggerResult(this.actualValue===e,`      Expected values to match using ===
+      Expected: ${e} (${typeof e})\n      Actual: ${this.actualValue} (${typeof this.actualValue})`)}toEqual(e){this.triggerResult(this.actualValue==e,`      Expected values to match using ==
+      Expected: ${e} (${typeof e})\n      Actual: ${this.actualValue} (${typeof this.actualValue})`)}toStrictEqual(e){let n=!0,r=``;try{t.deepStrictEqual(this.actualValue,e)}catch(e){n=!1,r=e.message||``}this.triggerResult(n,`      Expected values to be deeply strictly equal
+      Expected: ${JSON.stringify(e)}\n      Actual: ${JSON.stringify(this.actualValue)}`+(r?`\n      ${r}`:``))}toEqualArray(e){let t=Array.isArray(this.actualValue)&&Array.isArray(e)&&this.actualValue.length===e.length;for(let n=0;n<this.actualValue.length&&(t=this.actualValue[n]==e[n],t);n++);this.triggerResult(t,`      Expected array items to match using ==
+      Expected: ${e} (${typeof e})\n      Actual: ${this.actualValue} (${typeof this.actualValue})`)}toBeInstanceOf(e){this.triggerResult(this.actualValue instanceof e,`      Expected value to be instance of ${e.name||e}\n      Actual: ${this.actualValue?.constructor?.name||typeof this.actualValue}`)}toHaveLength(e){let t=this.actualValue?.length;this.triggerResult(t===e,`      Expected length: ${e}\n      Actual length: ${t}`)}toMatch(e){if(typeof this.actualValue.match!=`function`)throw Error(`You can not use toMatch on type ${typeof this.actualValue}`);this.triggerResult(!!this.actualValue.match(e),`      Expected values to match using regular expression
+      Expression: `+e+`
+      Actual: `+this.actualValue)}toBeDefined(){this.triggerResult(this.actualValue!==void 0,`      Expected value to be defined`)}toBeUndefined(){this.triggerResult(this.actualValue===void 0,`      Expected value to be undefined`)}toBeNull(){this.triggerResult(this.actualValue===null,`      Expected value to be null`)}toBeTruthy(){this.triggerResult(this.actualValue,`      Expected value to be truthy`)}toBeFalsy(){this.triggerResult(!this.actualValue,`      Expected value to be falsy`)}toContain(e){let t=this.actualValue,n;n=typeof t==`string`?t.includes(String(e)):t instanceof Array?t.indexOf(e)!==-1:!1,this.triggerResult(n,`      Expected `+t+` to contain `+e)}toBeLessThan(e){this.triggerResult(this.actualValue<e,`      Expected `+this.actualValue+` to be less than `+e)}toBeGreaterThan(e){this.triggerResult(this.actualValue>e,`      Expected `+this.actualValue+` to be greater than `+e)}toBeGreaterThanOrEqual(e){this.triggerResult(this.actualValue>=e,`      Expected ${this.actualValue} to be greater than or equal to ${e}`)}toBeLessThanOrEqual(e){this.triggerResult(this.actualValue<=e,`      Expected ${this.actualValue} to be less than or equal to ${e}`)}toBeCloseTo(e,t){let n=10**t;this.triggerResult(Math.round(this.actualValue*n)/n===Math.round(e*n)/n,`      Expected `+this.actualValue+` with precision `+t+` to be close to `+e)}toThrow(e){let t=``,n=!1,r=!0,i=!0;try{this.actualValue(),n=!1}catch(a){t=a.message||``,n=!0,typeof e==`function`?r=a instanceof e:typeof e==`string`?i=t.includes(e):e instanceof RegExp&&(i=e.test(t))}let a=this.actualValue.name||typeof this.actualValue==`function`?`[anonymous function]`:this.actualValue.toString();this.triggerResult(n,`      Expected ${a} to ${this.positive?`throw`:`not throw`} an exception ${!this.positive&&t?`, but an error with the message "${t}" was thrown`:``}`),typeof e==`function`?this.triggerResult(r,`      Expected Error type '${e.name}', but the error is not an instance of it`):e!==void 0&&this.triggerResult(i,`      Expected error message to match ${e}\n      Actual message: "${t}"`)}async toReject(e){let t=!1,n=``,r=!0,i=!0;try{await this.actualValue,t=!1}catch(a){t=!0,n=a?.message||String(a),typeof e==`function`?r=a instanceof e:typeof e==`string`?i=n.includes(e):e instanceof RegExp&&(i=e.test(n))}this.triggerResult(t,`      Expected promise to ${this.positive?`reject`:`resolve`}${!this.positive&&n?`, but it rejected with "${n}"`:``}`),t&&typeof e==`function`?this.triggerResult(r,`      Expected rejection type '${e.name}', but the error is not an instance of it`):t&&e!==void 0&&this.triggerResult(i,`      Expected rejection message to match ${e}\n      Actual message: "${n}"`)}async toResolve(){let e=!1,t=``;try{await this.actualValue,e=!0}catch(n){e=!1,t=n?.message||String(n)}this.triggerResult(e,`      Expected promise to ${this.positive?`resolve`:`reject`}${e?``:`, but it rejected with "${t}"`}`)}};const T=async function(e,t,n){let r=typeof n==`number`?n:n?.timeout??d.suiteTimeout;C(`
+`+e);let i=l;l=e;let o=x();try{await p(t,r,`describe: ${e}`)}catch(e){if(e instanceof f)++a,C(`  ${g}⏱ Suite timed out: ${e.message}${b}`);else throw e}l=i,C(`  ${y}↳ ${S(x()-o)}${b}`),k=null,A=null};T.skip=async function(e,t){++o,C(`\n${v}- ${e} (skipped)${b}`)};const E=()=>{let e=globalThis.process?.env;if(e)return!!(e.DISPLAY||e.WAYLAND_DISPLAY);try{let e=globalThis?.imports?.gi?.GLib;if(e)return!!(e.getenv(`DISPLAY`)||e.getenv(`WAYLAND_DISPLAY`))}catch{}return!1},D=async function(e,t){if(e.includes(`Display`))return{matched:E()};let n=await z(),r=e.find(e=>n.includes(e));return!r||typeof t==`string`&&!n.includes(t)?{matched:!1}:{matched:!0,runtime:r,version:t}},O=async function(e,t,n){typeof e==`string`&&(e=[e]),typeof t==`function`&&(n=t,t=void 0);let{matched:r}=await D(e,t);if(!r){++o;return}C(`\nOn ${e.join(`, `)}${t?` `+t:``}`),await n()};let k,A;const j=function(e){k=e},M=function(e){A=e},N=async function(e,t,n){let r=typeof n==`number`?n:n?.timeout??d.testTimeout,i=x();try{typeof k==`function`&&await k(),await p(t,r,e),typeof A==`function`&&await A(),C(`  ${_}✔${b} ${y}${e}  (${S(x()-i)})${b}`)}catch(t){let n=x()-i;t.__testFailureCounted||++a,u.push({suite:l,test:e,message:t.message??String(t)}),C(`  ${g}${t instanceof f?`⏱`:`❌`}${b} ${y}${e}  (${S(n)})${b}`),C(`${g}${t.message}${b}`),t.stack&&C(t.stack)}};N.skip=async function(e,t){++o,C(`  ${v}-${b} ${y}${e} (skipped)${b}`)};const P=function(e){return++i,new w(e,!0)},F=function(e,n){++i,e||++a;try{t(e,n)}catch(e){throw e.__testFailureCounted=!0,e}};F.strictEqual=function(e,n,r){++i;try{t.strictEqual(e,n,r)}catch(e){throw++a,e.__testFailureCounted=!0,e}},F.throws=function(e,...n){++i;let r;try{e()}catch(e){r=e}r||++a,t.throws(()=>{if(r)throw r},n[0],n[1])},F.deepStrictEqual=function(e,n,r){++i;try{t.deepStrictEqual(e,n,r)}catch(e){throw++a,e.__testFailureCounted=!0,e}};const I=async function(e){for(let t in e){let n=e[t];typeof n==`function`?await n():typeof n==`object`&&await I(n)}},L=()=>{let e=globalThis.document;e&&(globalThis.__gjsify_test_results={passed:i-a,failed:a,total:i,errors:u},e.documentElement.dataset.testsDone=`true`)},R=()=>{let e=c>0?x()-c:0,t=e>0?`  ${y}(${S(e)})`:``;o&&C(`\n${v}✔ ${o} ignored test${o>1?`s`:``}${b}`),C(a?`\n${g}❌ ${a} of ${i} tests failed${t}${b}`:`\n${_}✔ ${i} completed${t}${b}`)},z=async()=>{if(s&&s!==`Unknown`)return s;if(globalThis.Deno?.version?.deno)return`Deno `+globalThis.Deno?.version?.deno;{let e=globalThis.process;if(!e)try{e=await import(`process`)}catch{}if(e?.versions?.gjs)return s=`Gjs `+e.versions.gjs,s;if(e?.versions?.node)return s=`Node.js `+e.versions.node,s}return globalThis.document===void 0?s||`Unknown`:(s=`Browser`,s)},B=async()=>{C(`\nRunning on ${await z()}`)},V=async(e,t)=>{if(h(),c=x(),t&&(typeof t==`number`?d.runTimeout=t:(t.timeout!==void 0&&(d.runTimeout=t.timeout),t.testTimeout!==void 0&&(d.testTimeout=t.testTimeout),t.suiteTimeout!==void 0&&(d.suiteTimeout=t.suiteTimeout))),B().then(async()=>{try{await p(()=>I(e),d.runTimeout,`entire test run`)}catch(e){if(e instanceof f)C(`\n${g}⏱ ${e.message}${b}`),++a;else throw e}}).then(async()=>{if(R(),L(),C(),n(),r?.quit(),!r){let e=+(a>0);try{(globalThis.process||await import(`process`)).exit(e)}catch{}}}),r?.run(),r){let e=+(a>0);try{globalThis.imports.system.exit(e)}catch{}}};var H={run:V,assert:F,expect:P,it:N,afterEach:M,beforeEach:j,on:O,describe:T,configure:m,print:C};export{M as afterEach,F as assert,j as beforeEach,m as configure,H as default,T as describe,P as expect,N as it,O as on,C as print,V as run,e as spy};

package/lib/esm/spy.js

@@ -1,143 +1 @@
-//#region src/spy.ts
-function spy(f) {
-	const calls = [];
-	function spy(...args) {
-		let retv;
-		try {
-			retv = f ? f.apply(this, args) : undefined;
-		} catch (error) {
-			calls.push({
-				type: "throw",
-				this: this,
-				arguments: args,
-				throw: error
-			});
-			throw error;
-		}
-		calls.push({
-			type: "return",
-			this: this,
-			arguments: args,
-			return: retv
-		});
-		return retv;
-	}
-	Object.defineProperties(spy, {
-		calls: descriptors.calls(calls),
-		returnedCalls: descriptors.returnedCalls,
-		thrownCalls: descriptors.thrownCalls,
-		firstCall: descriptors.firstCall,
-		lastCall: descriptors.lastCall,
-		firstReturnedCall: descriptors.firstReturnedCall,
-		lastReturnedCall: descriptors.lastReturnedCall,
-		firstThrownCall: descriptors.firstThrownCall,
-		lastThrownCall: descriptors.lastThrownCall,
-		reset: descriptors.reset,
-		toString: descriptors.toString(f)
-	});
-	return spy;
-}
-const descriptors = {
-	calls(value) {
-		return {
-			value,
-			configurable: true
-		};
-	},
-	returnedCalls: {
-		get: function returnedCalls() {
-			return this.calls.filter(isReturned);
-		},
-		configurable: true
-	},
-	thrownCalls: {
-		get: function thrownCalls() {
-			return this.calls.filter(isThrown);
-		},
-		configurable: true
-	},
-	firstCall: {
-		get: function firstCall() {
-			return this.calls[0] || null;
-		},
-		configurable: true
-	},
-	lastCall: {
-		get: function lastCall() {
-			return this.calls[this.calls.length - 1] || null;
-		},
-		configurable: true
-	},
-	firstReturnedCall: {
-		get: function firstReturnedCall() {
-			for (let i = 0; i < this.calls.length; ++i) {
-				const call = this.calls[i];
-				if (isReturned(call)) {
-					return call;
-				}
-			}
-			return null;
-		},
-		configurable: true
-	},
-	lastReturnedCall: {
-		get: function lastReturnedCall() {
-			for (let i = this.calls.length - 1; i >= 0; --i) {
-				const call = this.calls[i];
-				if (isReturned(call)) {
-					return call;
-				}
-			}
-			return null;
-		},
-		configurable: true
-	},
-	firstThrownCall: {
-		get: function firstThrownCall() {
-			for (let i = 0; i < this.calls.length; ++i) {
-				const call = this.calls[i];
-				if (isThrown(call)) {
-					return call;
-				}
-			}
-			return null;
-		},
-		configurable: true
-	},
-	lastThrownCall: {
-		get: function lastThrownCall() {
-			for (let i = this.calls.length - 1; i >= 0; --i) {
-				const call = this.calls[i];
-				if (isThrown(call)) {
-					return call;
-				}
-			}
-			return null;
-		},
-		configurable: true
-	},
-	reset: {
-		value: function reset() {
-			;
-			this.calls.length = 0;
-		},
-		configurable: true
-	},
-	toString(f) {
-		return {
-			value: function toString() {
-				return `/* The spy of */ ${f ? f.toString() : "function(){}"}`;
-			},
-			configurable: true
-		};
-	}
-};
-function isReturned(call) {
-	return call.type === "return";
-}
-function isThrown(call) {
-	return call.type === "throw";
-}
-
-//#endregion
-export { spy };
+function e(e){let n=[];function r(...t){let r;try{r=e?e.apply(this,t):void 0}catch(e){throw n.push({type:`throw`,this:this,arguments:t,throw:e}),e}return n.push({type:`return`,this:this,arguments:t,return:r}),r}return Object.defineProperties(r,{calls:t.calls(n),returnedCalls:t.returnedCalls,thrownCalls:t.thrownCalls,firstCall:t.firstCall,lastCall:t.lastCall,firstReturnedCall:t.firstReturnedCall,lastReturnedCall:t.lastReturnedCall,firstThrownCall:t.firstThrownCall,lastThrownCall:t.lastThrownCall,reset:t.reset,toString:t.toString(e)}),r}const t={calls(e){return{value:e,configurable:!0}},returnedCalls:{get:function(){return this.calls.filter(n)},configurable:!0},thrownCalls:{get:function(){return this.calls.filter(r)},configurable:!0},firstCall:{get:function(){return this.calls[0]||null},configurable:!0},lastCall:{get:function(){return this.calls[this.calls.length-1]||null},configurable:!0},firstReturnedCall:{get:function(){for(let e=0;e<this.calls.length;++e){let t=this.calls[e];if(n(t))return t}return null},configurable:!0},lastReturnedCall:{get:function(){for(let e=this.calls.length-1;e>=0;--e){let t=this.calls[e];if(n(t))return t}return null},configurable:!0},firstThrownCall:{get:function(){for(let e=0;e<this.calls.length;++e){let t=this.calls[e];if(r(t))return t}return null},configurable:!0},lastThrownCall:{get:function(){for(let e=this.calls.length-1;e>=0;--e){let t=this.calls[e];if(r(t))return t}return null},configurable:!0},reset:{value:function(){this.calls.length=0},configurable:!0},toString(e){return{value:function(){return`/* The spy of */ ${e?e.toString():`function(){}`}`},configurable:!0}}};function n(e){return e.type===`return`}function r(e){return e.type===`throw`}export{e as spy};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjsify/unit",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "description": "A BDD-style testing framework for Gjs",
   "module": "lib/esm/index.js",
   "types": "lib/types/index.d.ts",
@@ -41,15 +41,15 @@
   },
   "homepage": "https://github.com/gjsify/unit#readme",
   "devDependencies": {
-    "@girs/gjs": "4.0.0-rc.9",
-    "@girs/glib-2.0": "2.88.0-4.0.0-rc.9",
-    "@gjsify/cli": "^0.3.15",
-    "@types/node": "^25.6.0",
+    "@girs/gjs": "4.0.0-rc.14",
+    "@girs/glib-2.0": "2.88.0-4.0.0-rc.14",
+    "@gjsify/cli": "^0.3.17",
+    "@types/node": "^25.6.2",
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@gjsify/assert": "^0.3.15",
-    "@gjsify/process": "^0.3.15",
-    "@gjsify/utils": "^0.3.15"
+    "@gjsify/assert": "^0.3.17",
+    "@gjsify/process": "^0.3.17",
+    "@gjsify/utils": "^0.3.17"
   }
 }