@systemfsoftware/vitest 0.0.0

package/dist/refusals-BQtDszyU.mjs

@@ -0,0 +1,32 @@
+
+//#region src/internal/refusals.ts
+/** @internal */
+const refuseHook = "✗ hooks share state between tests. Build what a test needs inside it; services come fresh per test from layer(Service.layer)((it) => { ... }).";
+/** @internal */
+const refuseNoAssertion = "✗ this test ran no assertion, so it cannot fail. Assert on what the code returned: expect(actual).toEqual(expected).";
+/** @internal */
+const refuseAsync = "✗ an async test runs Effects outside the test runtime: no virtual time, no fresh services, no leak check. Return the Effect instead: it.effect(name, () => Effect.gen(function* () { ... })).";
+/** @internal */
+const refuseBareEffect = "✗ a bare test body that returns an Effect never runs it, so nothing in the test was checked. Register it on the Effect lane: it.effect(name, () => Effect.gen(function* () { ... })).";
+/** @internal */
+const refuseUnprovided = "✗ the test needs a service that nothing provides. Pipe the body through Effect.provide(Service.layer), or write the tests inside layer(Service.layer)((it) => { ... }); every test gets its own fresh build.";
+/** @internal */
+const refuseBoolean = "✗ expect(<boolean>) can only report 'expected false to be true'. Pass the two values instead: expect(Equal.equals(a, b)).toBe(true) becomes expect(a).toEqual(b). A predicate: expect(value).toSatisfy(predicate).";
+/** @internal */
+const refusePositionalProp = "✗ it.prop(name, [arbitraries], predicate) is removed. Name the function under test and pass a budget: it.prop(name, { of, subject, runs }, holds).";
+/** @internal */
+const presenceMessage = (name) => `✗ ${name} passes for almost any value the code returns. Assert the value: toEqual(expected); for a key that must exist: toHaveProperty(key).`;
+/** @internal */
+const narrowVacuous = [
+	"toBeDefined",
+	"toBeTruthy",
+	"toBeFalsy"
+];
+/** @internal */
+const narrowNegated = [
+	...narrowVacuous,
+	"toBeNull",
+	"toBeUndefined"
+];
+//#endregion
+export { refuseBareEffect as a, refuseNoAssertion as c, refuseAsync as i, refusePositionalProp as l, narrowVacuous as n, refuseBoolean as o, presenceMessage as r, refuseHook as s, narrowNegated as t, refuseUnprovided as u };

package/dist/refusals-_6e3GzVK.d.ts

@@ -0,0 +1,37 @@
+
+//#region src/internal/refusals.d.ts
+/** @internal */
+declare const refuseHook = "✗ hooks share state between tests. Build what a test needs inside it; services come fresh per test from layer(Service.layer)((it) => { ... }).";
+/** @internal */
+declare const refuseNoAssertion = "✗ this test ran no assertion, so it cannot fail. Assert on what the code returned: expect(actual).toEqual(expected).";
+/** @internal */
+declare const refuseAsync = "✗ an async test runs Effects outside the test runtime: no virtual time, no fresh services, no leak check. Return the Effect instead: it.effect(name, () => Effect.gen(function* () { ... })).";
+/** @internal */
+declare const refuseBareEffect = "✗ a bare test body that returns an Effect never runs it, so nothing in the test was checked. Register it on the Effect lane: it.effect(name, () => Effect.gen(function* () { ... })).";
+/** @internal */
+declare const refuseUnprovided = "✗ the test needs a service that nothing provides. Pipe the body through Effect.provide(Service.layer), or write the tests inside layer(Service.layer)((it) => { ... }); every test gets its own fresh build.";
+/** @internal */
+declare const refuseBoolean = "✗ expect(<boolean>) can only report 'expected false to be true'. Pass the two values instead: expect(Equal.equals(a, b)).toBe(true) becomes expect(a).toEqual(b). A predicate: expect(value).toSatisfy(predicate).";
+/** @internal */
+declare const refusePositionalProp = "✗ it.prop(name, [arbitraries], predicate) is removed. Name the function under test and pass a budget: it.prop(name, { of, subject, runs }, holds).";
+/** @internal */
+type PresenceMessage<N extends string = string> = `✗ ${N} passes for almost any value the code returns. Assert the value: toEqual(expected); for a key that must exist: toHaveProperty(key).`;
+/**
+ * The narrowed matcher as the type sees it: a call whose `this` is not the assertion cannot compile, and the
+ * refused text is the compiler error (KTD9). The run time throws the same text.
+ *
+ * @internal
+ */
+type PresenceRefusal<N extends string = string> = (this: PresenceMessage<N>, ...args: Array<never>) => void;
+/** @internal */
+declare const presenceMessage: <N extends string>(name: N) => PresenceMessage<N>;
+/** @internal */
+declare const narrowVacuous: readonly ['toBeDefined', 'toBeTruthy', 'toBeFalsy'];
+/** @internal */
+type NarrowVacuousName = (typeof narrowVacuous)[number];
+/** @internal */
+declare const narrowNegated: readonly ["toBeDefined", "toBeTruthy", "toBeFalsy", "toBeNull", "toBeUndefined"];
+/** @internal */
+type NarrowNegatedName = (typeof narrowNegated)[number];
+//#endregion
+export { narrowVacuous as a, refuseBareEffect as c, refuseNoAssertion as d, refusePositionalProp as f, narrowNegated as i, refuseBoolean as l, NarrowVacuousName as n, presenceMessage as o, refuseUnprovided as p, PresenceRefusal as r, refuseAsync as s, NarrowNegatedName as t, refuseHook as u };

package/dist/refusals.d.ts

@@ -0,0 +1,3 @@
+
+import { a as narrowVacuous, c as refuseBareEffect, d as refuseNoAssertion, f as refusePositionalProp, i as narrowNegated, l as refuseBoolean, o as presenceMessage, p as refuseUnprovided, s as refuseAsync, u as refuseHook } from "./refusals-_6e3GzVK.js";
+export { narrowNegated, narrowVacuous, presenceMessage, refuseAsync, refuseBareEffect, refuseBoolean, refuseHook, refuseNoAssertion, refusePositionalProp, refuseUnprovided };

package/dist/refusals.mjs

@@ -0,0 +1,3 @@
+
+import { a as refuseBareEffect, c as refuseNoAssertion, i as refuseAsync, l as refusePositionalProp, n as narrowVacuous, o as refuseBoolean, r as presenceMessage, s as refuseHook, t as narrowNegated, u as refuseUnprovided } from "./refusals-BQtDszyU.mjs";
+export { narrowNegated, narrowVacuous, presenceMessage, refuseAsync, refuseBareEffect, refuseBoolean, refuseHook, refuseNoAssertion, refusePositionalProp, refuseUnprovided };

package/dist/utils.d.ts

@@ -0,0 +1,197 @@
+
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+//#region src/utils.d.ts
+/**
+ * Inspects the value a thunk threw. `A` defaults to `unknown` so a caller passes any inspection function.
+ */
+type ThrownValidator = <A = unknown>(thrown: A) => undefined;
+/**
+ * Any class, abstract ones included: what `assertInstanceOf` accepts and what `instanceof` takes.
+ */
+type AnyConstructor = abstract new (...args: never[]) => object;
+/**
+ * Fails the current test with the provided error message.
+ *
+ * @since 4.0.0
+ */
+export declare function fail(message: string): void;
+/**
+ * Asserts that `actual` is deeply strictly equal to `expected`.
+ *
+ * @since 4.0.0
+ */
+export declare const deepStrictEqual: {
+  <A>(actual: A, expected: A, message?: undefined): void;
+  <A>(expected: A, message?: undefined): (actual: A) => void;
+};
+/**
+ * Asserts that `actual` is not deeply strictly equal to `expected`.
+ *
+ * Chai names the negation of its deep comparison `notDeepEqual`; there, `deepStrictEqual` and `deepEqual` are
+ * one function.
+ *
+ * @since 4.0.0
+ */
+export declare const notDeepStrictEqual: {
+  <A>(actual: A, expected: A, message?: undefined): void;
+  <A>(expected: A, message?: undefined): (actual: A) => void;
+};
+/**
+ * Asserts that `actual` is strictly equal to `expected`.
+ *
+ * @since 4.0.0
+ */
+export declare const strictEqual: {
+  <A>(actual: A, expected: A, message?: undefined): void;
+  <A>(expected: A, message?: undefined): (actual: A) => void;
+};
+/**
+ * Asserts that `actual` is equal to `expected` using the `Equal.equals` trait.
+ *
+ * @since 4.0.0
+ */
+export declare const assertEquals: {
+  <A>(actual: A, expected: A, message?: undefined): void;
+  <A>(expected: A, message?: undefined): (actual: A) => void;
+};
+/**
+ * Asserts that `thunk` does not throw an error.
+ *
+ * @since 4.0.0
+ */
+export declare const doesNotThrow: {
+  (thunk: () => void, message?: string): void;
+  (message?: string): (thunk: () => void) => void;
+};
+/**
+ * Asserts that `value` is an instance of `constructor`.
+ *
+ * @since 4.0.0
+ */
+export declare const assertInstanceOf: {
+  <C extends AnyConstructor>(value: unknown, ctor: C, message?: string): asserts value is InstanceType<C>;
+  <C extends AnyConstructor>(ctor: C, message?: string): (value: unknown) => asserts value is InstanceType<C>;
+};
+/**
+ * Asserts that `self` is `true`.
+ *
+ * @since 4.0.0
+ */
+export declare const assertTrue: {
+  (self: boolean, message?: string): asserts self;
+  (message?: string): (self: boolean) => asserts self;
+};
+/**
+ * Asserts that `self` is `false`.
+ *
+ * @since 4.0.0
+ */
+export declare const assertFalse: {
+  (self: boolean, message?: string): void;
+  (message?: string): (self: boolean) => void;
+};
+/**
+ * Asserts that `actual` includes `expected`.
+ *
+ * @since 4.0.0
+ */
+export declare const assertInclude: {
+  (actual: string | undefined, expected: string): void;
+  (expected: string): (actual: string | undefined) => void;
+};
+/**
+ * Asserts that `actual` matches `regExp`.
+ *
+ * @since 4.0.0
+ */
+export declare const assertMatch: {
+  (actual: string, regExp: RegExp): void;
+  (regExp: RegExp): (actual: string) => void;
+};
+/**
+ * Asserts that `thunk` throws, optionally checking the thrown value against an expected `Error` or validation
+ * function.
+ *
+ * @since 4.0.0
+ */
+export declare const throws: {
+  (thunk: () => void, error?: Error | ThrownValidator): void;
+  (error?: Error | ThrownValidator): (thunk: () => void) => void;
+};
+/**
+ * Asserts that `thunk` throws or returns a rejected promise, optionally checking the failure value against an
+ * expected `Error` or validation function.
+ *
+ * @since 4.0.0
+ */
+export declare const throwsAsync: {
+  (thunk: () => Promise<void>, error?: Error | ThrownValidator): Promise<void>;
+  (error?: Error | ThrownValidator): (thunk: () => Promise<void>) => Promise<void>;
+};
+/**
+ * Asserts that `option` is `None`.
+ *
+ * @since 4.0.0
+ */
+export declare function assertNone<A>(option: Option.Option<A>): asserts option is Option.None<never>;
+/**
+ * Asserts that `a` is not `undefined`.
+ *
+ * @since 4.0.0
+ */
+export declare function assertDefined<A>(a: A | undefined): asserts a is Exclude<A, undefined>;
+/**
+ * Asserts that `a` is `undefined`.
+ *
+ * @since 4.0.0
+ */
+export declare function assertUndefined<A>(a: A | undefined): asserts a is undefined;
+/**
+ * Asserts that `option` is `Some` and contains a value equal to `expected`.
+ *
+ * @since 4.0.0
+ */
+export declare const assertSome: {
+  <A>(option: Option.Option<A>, expected: A): asserts option is Option.Some<A>;
+  <A>(expected: A): (option: Option.Option<A>) => asserts option is Option.Some<A>;
+};
+/**
+ * Asserts that `result` is `Success` and contains a value equal to `expected`.
+ *
+ * @since 4.0.0
+ */
+export declare const assertSuccess: {
+  <A, E>(result: Result.Result<A, E>, expected: A): asserts result is Result.Success<A, never>;
+  <A, E>(expected: A): (result: Result.Result<A, E>) => asserts result is Result.Success<A, never>;
+};
+/**
+ * Asserts that `result` is `Failure` and contains an error equal to `expected`.
+ *
+ * @since 4.0.0
+ */
+export declare const assertFailure: {
+  <A, E>(result: Result.Result<A, E>, expected: E): asserts result is Result.Failure<never, E>;
+  <A, E>(expected: E): (result: Result.Result<A, E>) => asserts result is Result.Failure<never, E>;
+};
+/**
+ * Asserts that `exit` is a failure with a cause equal to `expected`.
+ *
+ * @since 4.0.0
+ */
+export declare const assertExitFailure: {
+  <A, E>(exit: Exit.Exit<A, E>, expected: Cause.Cause<E>): asserts exit is Exit.Failure<never, E>;
+  <A, E>(expected: Cause.Cause<E>): (exit: Exit.Exit<A, E>) => asserts exit is Exit.Failure<never, E>;
+};
+/**
+ * Asserts that `exit` is a success with a value equal to `expected`.
+ *
+ * @since 4.0.0
+ */
+export declare const assertExitSuccess: {
+  <A, E>(exit: Exit.Exit<A, E>, expected: A): asserts exit is Exit.Success<A, never>;
+  <A, E>(expected: A): (exit: Exit.Exit<A, E>) => asserts exit is Exit.Success<A, never>;
+};
+//#endregion

package/dist/utils.mjs

@@ -0,0 +1,227 @@
+
+import { assert } from "vitest";
+import { dual } from "effect/Function";
+import * as Equal from "effect/Equal";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
+//#region src/utils.ts
+/**
+* Whether `actual` — possibly absent — contains `expected`.
+*/
+const includes = (actual, expected) => actual !== void 0 && actual.includes(expected);
+/**
+* `assertEquals`'s message when the caller gave none: the two values are deep-equal, so only the `Equal` trait
+* explains the failure.
+*/
+const equalMismatch = (message) => message ?? "Expected values to be Equal.equals";
+/**
+* `assertInstanceOf`'s message when the caller gave none: the value may be anything, so only the constructor
+* names the expectation.
+*/
+const instanceMismatch = (constructor, message) => message ?? `Expected value to be an instance of ${constructor.name}`;
+/**
+* Runs `thunk`, then applies `error`'s expectation to anything it threw: a validator inspects the value, an
+* `Error` must be deep-strict-equal to it, and no expectation accepts any throw.
+*/
+const applyThrown = (thunk, error) => {
+	try {
+		thunk();
+	} catch (e) {
+		Option.match(Option.fromNullishOr(error), {
+			onNone: () => void 0,
+			onSome: (expectation) => Predicate.isFunction(expectation) ? expectation(e) : deepStrictEqual(e, expectation)
+		});
+		return;
+	}
+	fail("Expected to throw an error");
+};
+/**
+* Whether a dual assertion call is the data-first one: a piped call names the expected value alone, and a
+* pair of values is the only other shape these helpers take.
+*
+* No overload of them carries a message, because a pipeable signature has to repeat its data-first twin
+* parameter for parameter (`effecttsgo/missing-pipeable-signature`). A pair of values therefore cannot be
+* mistaken for a value and a message, in the types or here, and the message a caller might have written is
+* refused rather than dropped.
+*/
+const byTwoValues = (args) => args.length >= 2;
+/**
+* Fails the current test with the provided error message.
+*
+* @since 4.0.0
+*/
+function fail(message) {
+	assert.fail(message);
+}
+/**
+* Asserts that `actual` is deeply strictly equal to `expected`.
+*
+* @since 4.0.0
+*/
+const deepStrictEqual = dual(byTwoValues, (actual, expected, message) => {
+	assert.deepStrictEqual(actual, expected, message);
+});
+/**
+* Asserts that `actual` is not deeply strictly equal to `expected`.
+*
+* Chai names the negation of its deep comparison `notDeepEqual`; there, `deepStrictEqual` and `deepEqual` are
+* one function.
+*
+* @since 4.0.0
+*/
+const notDeepStrictEqual = dual(byTwoValues, (actual, expected, message) => {
+	assert.notDeepEqual(actual, expected, message);
+});
+/**
+* Asserts that `actual` is strictly equal to `expected`.
+*
+* @since 4.0.0
+*/
+const strictEqual = dual(byTwoValues, (actual, expected, message) => {
+	assert.strictEqual(actual, expected, message);
+});
+/**
+* Asserts that `actual` is equal to `expected` using the `Equal.equals` trait.
+*
+* @since 4.0.0
+*/
+const assertEquals = dual(byTwoValues, (actual, expected, message) => {
+	if (Equal.equals(actual, expected)) return;
+	assert.deepStrictEqual(actual, expected, message);
+	fail(equalMismatch(message));
+});
+/**
+* Asserts that `thunk` does not throw an error.
+*
+* @since 4.0.0
+*/
+const doesNotThrow = dual((args) => args.length >= 2 || typeof args[0] === "function", (thunk, message) => {
+	assert.doesNotThrow(thunk, void 0, void 0, message);
+});
+/**
+* Asserts that `value` is an instance of `constructor`.
+*
+* @since 4.0.0
+*/
+const assertInstanceOf = dual((args) => args.length >= 2 && typeof args[1] !== "string", (value, ctor, message) => {
+	if (value instanceof ctor) return;
+	fail(instanceMismatch(ctor, message));
+});
+/**
+* Asserts that `self` is `true`.
+*
+* @since 4.0.0
+*/
+const assertTrue = dual((args) => args.length >= 2 || typeof args[0] === "boolean", (self, message) => {
+	assert.strictEqual(self, true, message);
+});
+/**
+* Asserts that `self` is `false`.
+*
+* @since 4.0.0
+*/
+const assertFalse = dual((args) => args.length >= 2 || typeof args[0] === "boolean", (self, message) => {
+	assert.strictEqual(self, false, message);
+});
+/**
+* Asserts that `actual` includes `expected`.
+*
+* @since 4.0.0
+*/
+const assertInclude = dual((args) => args.length >= 2, (actual, expected) => {
+	if (!includes(actual, expected)) fail(`Expected\n\n${actual}\n\nto include\n\n${expected}`);
+});
+/**
+* Asserts that `actual` matches `regExp`.
+*
+* @since 4.0.0
+*/
+const assertMatch = dual((args) => args.length >= 2, (actual, regExp) => {
+	if (!regExp.test(actual)) fail(`Expected\n\n${actual}\n\nto match\n\n${regExp}`);
+});
+/**
+* Asserts that `thunk` throws, optionally checking the thrown value against an expected `Error` or validation
+* function.
+*
+* @since 4.0.0
+*/
+const throws = dual((args) => args.length >= 2 || typeof args[0] === "function", (thunk, error) => {
+	applyThrown(thunk, error);
+});
+/**
+* Asserts that `thunk` throws or returns a rejected promise, optionally checking the failure value against an
+* expected `Error` or validation function.
+*
+* @since 4.0.0
+*/
+const throwsAsync = dual((args) => args.length >= 2 || typeof args[0] === "function", (thunk, error) => Promise.resolve().then(thunk).then(() => fail("Expected to throw an error"), (thrown) => applyThrown(() => {
+	throw thrown;
+}, error)));
+/**
+* Asserts that `option` is `None`.
+*
+* @since 4.0.0
+*/
+function assertNone(option) {
+	deepStrictEqual(option, Option.none());
+}
+/**
+* Asserts that `a` is not `undefined`.
+*
+* @since 4.0.0
+*/
+function assertDefined(a) {
+	if (a === void 0) fail("Expected value to be defined");
+}
+/**
+* Asserts that `a` is `undefined`.
+*
+* @since 4.0.0
+*/
+function assertUndefined(a) {
+	if (a !== void 0) fail("Expected value to be undefined");
+}
+/**
+* Asserts that `option` is `Some` and contains a value equal to `expected`.
+*
+* @since 4.0.0
+*/
+const assertSome = dual((args) => args.length >= 2, (option, expected) => {
+	deepStrictEqual(option, Option.some(expected));
+});
+/**
+* Asserts that `result` is `Success` and contains a value equal to `expected`.
+*
+* @since 4.0.0
+*/
+const assertSuccess = dual((args) => args.length >= 2, (result, expected) => {
+	deepStrictEqual(result, Result.succeed(expected));
+});
+/**
+* Asserts that `result` is `Failure` and contains an error equal to `expected`.
+*
+* @since 4.0.0
+*/
+const assertFailure = dual((args) => args.length >= 2, (result, expected) => {
+	deepStrictEqual(result, Result.fail(expected));
+});
+/**
+* Asserts that `exit` is a failure with a cause equal to `expected`.
+*
+* @since 4.0.0
+*/
+const assertExitFailure = dual((args) => args.length >= 2, (exit, expected) => {
+	deepStrictEqual(exit, Exit.failCause(expected));
+});
+/**
+* Asserts that `exit` is a success with a value equal to `expected`.
+*
+* @since 4.0.0
+*/
+const assertExitSuccess = dual((args) => args.length >= 2, (exit, expected) => {
+	deepStrictEqual(exit, Exit.succeed(expected));
+});
+//#endregion
+export { assertDefined, assertEquals, assertExitFailure, assertExitSuccess, assertFailure, assertFalse, assertInclude, assertInstanceOf, assertMatch, assertNone, assertSome, assertSuccess, assertTrue, assertUndefined, deepStrictEqual, doesNotThrow, fail, notDeepStrictEqual, strictEqual, throws, throwsAsync };

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@systemfsoftware/vitest",
+  "license": "MIT",
+  "version": "0.0.0",
+  "author": "Ryan Lee <drdgvhbh@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
+    "directory": "packages/vitest"
+  },
+  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/vitest#readme",
+  "bugs": "https://github.com/systemfsoftware/systemfsoftware/issues",
+  "description": "A fork of @effect/vitest whose defaults make the lazy test a good test: fresh layers, a second run that catches leaked state, virtual time, soft checks that stop at the next step, and properties refuted against a constant impostor.",
+  "keywords": [
+    "effect",
+    "effect-ts",
+    "vitest",
+    "testing",
+    "property-testing",
+    "typescript"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./refusals": {
+      "types": "./dist/refusals.d.ts",
+      "default": "./dist/refusals.mjs"
+    },
+    "./TestClock": {
+      "types": "./dist/TestClock.d.ts",
+      "default": "./dist/TestClock.mjs"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "default": "./dist/utils.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
+    "@systemfsoftware/oxlint-config-recommended": "^3.1.0",
+    "@systemfsoftware/tsconfig": "^2.0.1",
+    "@systemfsoftware/tsdown-config": "^0.1.0",
+    "@systemfsoftware/vitest-config": "^0.1.0",
+    "@types/node": "^26",
+    "effect": "4.0.0-rc.117",
+    "oxlint": "~1.82.0",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.23.0",
+    "tstyche": "^7.2.5",
+    "vitest": "^5"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-rc.117",
+    "vitest": "^5"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsdown -l warn",
+    "typecheck": "tsc -b",
+    "test": "vitest run",
+    "test:types": "TSTYCHE_TYPESCRIPT_MODULE=tstyche-typescript tstyche",
+    "lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --format=${f:-default}",
+    "attw": "attw --pack ."
+  }
+}