@pezkuwi/dev-test 0.84.2 → 0.84.3

package/env/expect.d.ts

@@ -0,0 +1,297 @@
+type AssertMatchFn = (value: unknown) => void;
+/**
+ * @internal
+ *
+ * A helper that wraps a matching function in an ExpectMatcher. This is (currently)
+ * only used/checked for in the calledWith* helpers
+ *
+ * TODO We don't use it in polkadot-js, but a useful enhancement could be for
+ * any of the to* expectations to detect and use those. An example of useful code
+ * in that case:
+ *
+ * ```js
+ * expect({
+ *   a: 'blah',
+ *   b: 3
+ * }).toEqual(
+ *   expect.objectContaining({ b: 3 })
+ * )
+ * ```
+ *
+ * An example of matcher use can be seen in the isCalledWith loops
+ */
+declare class Matcher {
+    assertMatch: AssertMatchFn;
+    constructor(assertFn: (value: any, check: any) => void, check?: unknown);
+}
+/**
+ * Sets up the shimmed expect(...) function, including all .to* and .not.to*
+ * functions. This is not comprehensive, rather is contains what we need to
+ * make all polkadot-js usages pass
+ **/
+export declare function expect(): {
+    expect: ((value: unknown) => {
+        not: {
+            toBe: (other: unknown) => void;
+            toBeDefined: () => void;
+            toBeNull: (value: unknown) => void;
+            toBeUndefined: () => void;
+            toEqual: (other: unknown) => void;
+            toHaveBeenCalled: () => void;
+            toThrow: (message?: RegExp | Error | string) => void;
+        } & Omit<{
+            not: import("../types.js").StubFn;
+            toMatchInlineSnapshot: import("../types.js").StubFn;
+            toMatchSnapshot: import("../types.js").StubFn;
+            toThrowErrorMatchingInlineSnapshot: import("../types.js").StubFn;
+            toThrowErrorMatchingSnapshot: import("../types.js").StubFn;
+            lastCalledWith: import("../types.js").StubFn;
+            lastReturnedWith: import("../types.js").StubFn;
+            nthCalledWith: import("../types.js").StubFn;
+            nthReturnedWith: import("../types.js").StubFn;
+            rejects: import("../types.js").StubFn;
+            resolves: import("../types.js").StubFn;
+            toBe: import("../types.js").StubFn;
+            toBeCalled: import("../types.js").StubFn;
+            toBeCalledTimes: import("../types.js").StubFn;
+            toBeCalledWith: import("../types.js").StubFn;
+            toBeCloseTo: import("../types.js").StubFn;
+            toBeDefined: import("../types.js").StubFn;
+            toBeFalsy: import("../types.js").StubFn;
+            toBeGreaterThan: import("../types.js").StubFn;
+            toBeGreaterThanOrEqual: import("../types.js").StubFn;
+            toBeInstanceOf: import("../types.js").StubFn;
+            toBeLessThan: import("../types.js").StubFn;
+            toBeLessThanOrEqual: import("../types.js").StubFn;
+            toBeNaN: import("../types.js").StubFn;
+            toBeNull: import("../types.js").StubFn;
+            toBeTruthy: import("../types.js").StubFn;
+            toBeUndefined: import("../types.js").StubFn;
+            toContain: import("../types.js").StubFn;
+            toContainEqual: import("../types.js").StubFn;
+            toEqual: import("../types.js").StubFn;
+            toHaveBeenCalled: import("../types.js").StubFn;
+            toHaveBeenCalledTimes: import("../types.js").StubFn;
+            toHaveBeenCalledWith: import("../types.js").StubFn;
+            toHaveBeenLastCalledWith: import("../types.js").StubFn;
+            toHaveBeenNthCalledWith: import("../types.js").StubFn;
+            toHaveLastReturnedWith: import("../types.js").StubFn;
+            toHaveLength: import("../types.js").StubFn;
+            toHaveNthReturnedWith: import("../types.js").StubFn;
+            toHaveProperty: import("../types.js").StubFn;
+            toHaveReturned: import("../types.js").StubFn;
+            toHaveReturnedTimes: import("../types.js").StubFn;
+            toHaveReturnedWith: import("../types.js").StubFn;
+            toMatch: import("../types.js").StubFn;
+            toMatchObject: import("../types.js").StubFn;
+            toReturn: import("../types.js").StubFn;
+            toReturnTimes: import("../types.js").StubFn;
+            toReturnWith: import("../types.js").StubFn;
+            toStrictEqual: import("../types.js").StubFn;
+            toThrow: import("../types.js").StubFn;
+            toThrowError: import("../types.js").StubFn;
+        }, "toBe" | "toBeDefined" | "toBeNull" | "toBeUndefined" | "toEqual" | "toHaveBeenCalled" | "toThrow">;
+        rejects: {
+            toThrow: (message?: RegExp | Error | string) => Promise<void>;
+        } & Omit<{
+            not: import("../types.js").StubFn;
+            toMatchInlineSnapshot: import("../types.js").StubFn;
+            toMatchSnapshot: import("../types.js").StubFn;
+            toThrowErrorMatchingInlineSnapshot: import("../types.js").StubFn;
+            toThrowErrorMatchingSnapshot: import("../types.js").StubFn;
+            lastCalledWith: import("../types.js").StubFn;
+            lastReturnedWith: import("../types.js").StubFn;
+            nthCalledWith: import("../types.js").StubFn;
+            nthReturnedWith: import("../types.js").StubFn;
+            rejects: import("../types.js").StubFn;
+            resolves: import("../types.js").StubFn;
+            toBe: import("../types.js").StubFn;
+            toBeCalled: import("../types.js").StubFn;
+            toBeCalledTimes: import("../types.js").StubFn;
+            toBeCalledWith: import("../types.js").StubFn;
+            toBeCloseTo: import("../types.js").StubFn;
+            toBeDefined: import("../types.js").StubFn;
+            toBeFalsy: import("../types.js").StubFn;
+            toBeGreaterThan: import("../types.js").StubFn;
+            toBeGreaterThanOrEqual: import("../types.js").StubFn;
+            toBeInstanceOf: import("../types.js").StubFn;
+            toBeLessThan: import("../types.js").StubFn;
+            toBeLessThanOrEqual: import("../types.js").StubFn;
+            toBeNaN: import("../types.js").StubFn;
+            toBeNull: import("../types.js").StubFn;
+            toBeTruthy: import("../types.js").StubFn;
+            toBeUndefined: import("../types.js").StubFn;
+            toContain: import("../types.js").StubFn;
+            toContainEqual: import("../types.js").StubFn;
+            toEqual: import("../types.js").StubFn;
+            toHaveBeenCalled: import("../types.js").StubFn;
+            toHaveBeenCalledTimes: import("../types.js").StubFn;
+            toHaveBeenCalledWith: import("../types.js").StubFn;
+            toHaveBeenLastCalledWith: import("../types.js").StubFn;
+            toHaveBeenNthCalledWith: import("../types.js").StubFn;
+            toHaveLastReturnedWith: import("../types.js").StubFn;
+            toHaveLength: import("../types.js").StubFn;
+            toHaveNthReturnedWith: import("../types.js").StubFn;
+            toHaveProperty: import("../types.js").StubFn;
+            toHaveReturned: import("../types.js").StubFn;
+            toHaveReturnedTimes: import("../types.js").StubFn;
+            toHaveReturnedWith: import("../types.js").StubFn;
+            toMatch: import("../types.js").StubFn;
+            toMatchObject: import("../types.js").StubFn;
+            toReturn: import("../types.js").StubFn;
+            toReturnTimes: import("../types.js").StubFn;
+            toReturnWith: import("../types.js").StubFn;
+            toStrictEqual: import("../types.js").StubFn;
+            toThrow: import("../types.js").StubFn;
+            toThrowError: import("../types.js").StubFn;
+        }, "toThrow">;
+        resolves: Omit<{
+            not: import("../types.js").StubFn;
+            toMatchInlineSnapshot: import("../types.js").StubFn;
+            toMatchSnapshot: import("../types.js").StubFn;
+            toThrowErrorMatchingInlineSnapshot: import("../types.js").StubFn;
+            toThrowErrorMatchingSnapshot: import("../types.js").StubFn;
+            lastCalledWith: import("../types.js").StubFn;
+            lastReturnedWith: import("../types.js").StubFn;
+            nthCalledWith: import("../types.js").StubFn;
+            nthReturnedWith: import("../types.js").StubFn;
+            rejects: import("../types.js").StubFn;
+            resolves: import("../types.js").StubFn;
+            toBe: import("../types.js").StubFn;
+            toBeCalled: import("../types.js").StubFn;
+            toBeCalledTimes: import("../types.js").StubFn;
+            toBeCalledWith: import("../types.js").StubFn;
+            toBeCloseTo: import("../types.js").StubFn;
+            toBeDefined: import("../types.js").StubFn;
+            toBeFalsy: import("../types.js").StubFn;
+            toBeGreaterThan: import("../types.js").StubFn;
+            toBeGreaterThanOrEqual: import("../types.js").StubFn;
+            toBeInstanceOf: import("../types.js").StubFn;
+            toBeLessThan: import("../types.js").StubFn;
+            toBeLessThanOrEqual: import("../types.js").StubFn;
+            toBeNaN: import("../types.js").StubFn;
+            toBeNull: import("../types.js").StubFn;
+            toBeTruthy: import("../types.js").StubFn;
+            toBeUndefined: import("../types.js").StubFn;
+            toContain: import("../types.js").StubFn;
+            toContainEqual: import("../types.js").StubFn;
+            toEqual: import("../types.js").StubFn;
+            toHaveBeenCalled: import("../types.js").StubFn;
+            toHaveBeenCalledTimes: import("../types.js").StubFn;
+            toHaveBeenCalledWith: import("../types.js").StubFn;
+            toHaveBeenLastCalledWith: import("../types.js").StubFn;
+            toHaveBeenNthCalledWith: import("../types.js").StubFn;
+            toHaveLastReturnedWith: import("../types.js").StubFn;
+            toHaveLength: import("../types.js").StubFn;
+            toHaveNthReturnedWith: import("../types.js").StubFn;
+            toHaveProperty: import("../types.js").StubFn;
+            toHaveReturned: import("../types.js").StubFn;
+            toHaveReturnedTimes: import("../types.js").StubFn;
+            toHaveReturnedWith: import("../types.js").StubFn;
+            toMatch: import("../types.js").StubFn;
+            toMatchObject: import("../types.js").StubFn;
+            toReturn: import("../types.js").StubFn;
+            toReturnTimes: import("../types.js").StubFn;
+            toReturnWith: import("../types.js").StubFn;
+            toStrictEqual: import("../types.js").StubFn;
+            toThrow: import("../types.js").StubFn;
+            toThrowError: import("../types.js").StubFn;
+        }, never>;
+        toBe: (other: unknown) => void;
+        toBeDefined: () => void;
+        toBeFalsy: () => void;
+        toBeInstanceOf: (Clazz: Function) => void;
+        toBeNull: (value: unknown) => void;
+        toBeTruthy: () => void;
+        toBeUndefined: () => void;
+        toEqual: (other: unknown) => void;
+        toHaveBeenCalled: () => void;
+        toHaveBeenCalledTimes: (count: number) => void;
+        toHaveBeenCalledWith: (...args: unknown[]) => void;
+        toHaveBeenLastCalledWith: (...args: unknown[]) => void;
+        toHaveLength: (length: number) => void;
+        toMatch: (check: string | RegExp) => void;
+        toMatchObject: (check: object) => void;
+        toThrow: (message?: RegExp | Error | string) => void;
+    } & Omit<{
+        not: import("../types.js").StubFn;
+        toMatchInlineSnapshot: import("../types.js").StubFn;
+        toMatchSnapshot: import("../types.js").StubFn;
+        toThrowErrorMatchingInlineSnapshot: import("../types.js").StubFn;
+        toThrowErrorMatchingSnapshot: import("../types.js").StubFn;
+        lastCalledWith: import("../types.js").StubFn;
+        lastReturnedWith: import("../types.js").StubFn;
+        nthCalledWith: import("../types.js").StubFn;
+        nthReturnedWith: import("../types.js").StubFn;
+        rejects: import("../types.js").StubFn;
+        resolves: import("../types.js").StubFn;
+        toBe: import("../types.js").StubFn;
+        toBeCalled: import("../types.js").StubFn;
+        toBeCalledTimes: import("../types.js").StubFn;
+        toBeCalledWith: import("../types.js").StubFn;
+        toBeCloseTo: import("../types.js").StubFn;
+        toBeDefined: import("../types.js").StubFn;
+        toBeFalsy: import("../types.js").StubFn;
+        toBeGreaterThan: import("../types.js").StubFn;
+        toBeGreaterThanOrEqual: import("../types.js").StubFn;
+        toBeInstanceOf: import("../types.js").StubFn;
+        toBeLessThan: import("../types.js").StubFn;
+        toBeLessThanOrEqual: import("../types.js").StubFn;
+        toBeNaN: import("../types.js").StubFn;
+        toBeNull: import("../types.js").StubFn;
+        toBeTruthy: import("../types.js").StubFn;
+        toBeUndefined: import("../types.js").StubFn;
+        toContain: import("../types.js").StubFn;
+        toContainEqual: import("../types.js").StubFn;
+        toEqual: import("../types.js").StubFn;
+        toHaveBeenCalled: import("../types.js").StubFn;
+        toHaveBeenCalledTimes: import("../types.js").StubFn;
+        toHaveBeenCalledWith: import("../types.js").StubFn;
+        toHaveBeenLastCalledWith: import("../types.js").StubFn;
+        toHaveBeenNthCalledWith: import("../types.js").StubFn;
+        toHaveLastReturnedWith: import("../types.js").StubFn;
+        toHaveLength: import("../types.js").StubFn;
+        toHaveNthReturnedWith: import("../types.js").StubFn;
+        toHaveProperty: import("../types.js").StubFn;
+        toHaveReturned: import("../types.js").StubFn;
+        toHaveReturnedTimes: import("../types.js").StubFn;
+        toHaveReturnedWith: import("../types.js").StubFn;
+        toMatch: import("../types.js").StubFn;
+        toMatchObject: import("../types.js").StubFn;
+        toReturn: import("../types.js").StubFn;
+        toReturnTimes: import("../types.js").StubFn;
+        toReturnWith: import("../types.js").StubFn;
+        toStrictEqual: import("../types.js").StubFn;
+        toThrow: import("../types.js").StubFn;
+        toThrowError: import("../types.js").StubFn;
+    }, "not" | "rejects" | "resolves" | "toBe" | "toBeDefined" | "toBeFalsy" | "toBeInstanceOf" | "toBeNull" | "toBeTruthy" | "toBeUndefined" | "toEqual" | "toHaveBeenCalled" | "toHaveBeenCalledTimes" | "toHaveBeenCalledWith" | "toHaveBeenLastCalledWith" | "toHaveLength" | "toMatch" | "toMatchObject" | "toThrow">) & Omit<{
+        any: (Clazz: Function) => Matcher;
+        anything: () => Matcher;
+        arrayContaining: (check: string) => Matcher;
+        objectContaining: (check: object) => Matcher;
+        stringContaining: (check: string) => Matcher;
+        stringMatching: (check: string | RegExp) => Matcher;
+    }, never> & Omit<{
+        addEqualityTesters: import("../types.js").StubFn;
+        addSnapshotSerializer: import("../types.js").StubFn;
+        any: import("../types.js").StubFn;
+        anything: import("../types.js").StubFn;
+        arrayContaining: import("../types.js").StubFn;
+        assertions: import("../types.js").StubFn;
+        closeTo: import("../types.js").StubFn;
+        extend: import("../types.js").StubFn;
+        extractExpectedAssertionsErrors: import("../types.js").StubFn;
+        getState: import("../types.js").StubFn;
+        hasAssertions: import("../types.js").StubFn;
+        not: import("../types.js").StubFn;
+        objectContaining: import("../types.js").StubFn;
+        setState: import("../types.js").StubFn;
+        stringContaining: import("../types.js").StubFn;
+        stringMatching: import("../types.js").StubFn;
+        toMatchInlineSnapshot: import("../types.js").StubFn;
+        toMatchSnapshot: import("../types.js").StubFn;
+        toThrowErrorMatchingInlineSnapshot: import("../types.js").StubFn;
+        toThrowErrorMatchingSnapshot: import("../types.js").StubFn;
+    }, "any" | "anything" | "arrayContaining" | "objectContaining" | "stringContaining" | "stringMatching">;
+};
+export {};

package/env/expect.js

@@ -0,0 +1,210 @@
+import { strict as assert } from 'node:assert';
+import { enhanceObj, stubObj } from '../util.js';
+const EXPECT_KEYS = ['addEqualityTesters', 'addSnapshotSerializer', 'any', 'anything', 'arrayContaining', 'assertions', 'closeTo', 'extend', 'extractExpectedAssertionsErrors', 'getState', 'hasAssertions', 'not', 'objectContaining', 'setState', 'stringContaining', 'stringMatching', 'toMatchInlineSnapshot', 'toMatchSnapshot', 'toThrowErrorMatchingInlineSnapshot', 'toThrowErrorMatchingSnapshot'];
+const EXPECT_KEYS_FN = ['lastCalledWith', 'lastReturnedWith', 'not', 'nthCalledWith', 'nthReturnedWith', 'rejects', 'resolves', 'toBe', 'toBeCalled', 'toBeCalledTimes', 'toBeCalledWith', 'toBeCloseTo', 'toBeDefined', 'toBeFalsy', 'toBeGreaterThan', 'toBeGreaterThanOrEqual', 'toBeInstanceOf', 'toBeLessThan', 'toBeLessThanOrEqual', 'toBeNaN', 'toBeNull', 'toBeTruthy', 'toBeUndefined', 'toContain', 'toContainEqual', 'toEqual', 'toHaveBeenCalled', 'toHaveBeenCalledTimes', 'toHaveBeenCalledWith', 'toHaveBeenLastCalledWith', 'toHaveBeenNthCalledWith', 'toHaveLastReturnedWith', 'toHaveLength', 'toHaveNthReturnedWith', 'toHaveProperty', 'toHaveReturned', 'toHaveReturnedTimes', 'toHaveReturnedWith', 'toMatch', 'toMatchInlineSnapshot', 'toMatchObject', 'toMatchSnapshot', 'toReturn', 'toReturnTimes', 'toReturnWith', 'toStrictEqual', 'toThrow', 'toThrowError', 'toThrowErrorMatchingInlineSnapshot', 'toThrowErrorMatchingSnapshot'];
+const stubExpect = stubObj('expect', EXPECT_KEYS);
+const stubExpectFn = stubObj('expect(...)', EXPECT_KEYS_FN, {
+    toThrowError: 'expect(...).toThrow'
+});
+const stubExpectFnRejects = stubObj('expect(...).rejects', EXPECT_KEYS_FN, {
+    toThrowError: 'expect(...).rejects.toThrow'
+});
+const stubExpectFnResolves = stubObj('expect(...).resolves', EXPECT_KEYS_FN);
+const stubExpectFnNot = stubObj('expect(...).not', EXPECT_KEYS_FN, {
+    toBeFalsy: 'expect(...).toBeTruthy',
+    toBeTruthy: 'expect(...).toBeFalsy',
+    toThrowError: 'expect(...).not.toThrow'
+});
+/**
+ * @internal
+ *
+ * A helper that wraps a matching function in an ExpectMatcher. This is (currently)
+ * only used/checked for in the calledWith* helpers
+ *
+ * TODO We don't use it in polkadot-js, but a useful enhancement could be for
+ * any of the to* expectations to detect and use those. An example of useful code
+ * in that case:
+ *
+ * ```js
+ * expect({
+ *   a: 'blah',
+ *   b: 3
+ * }).toEqual(
+ *   expect.objectContaining({ b: 3 })
+ * )
+ * ```
+ *
+ * An example of matcher use can be seen in the isCalledWith loops
+ */
+class Matcher {
+    assertMatch;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(assertFn, check) {
+        this.assertMatch = (value) => assertFn(value, check);
+    }
+}
+/**
+ * @internal
+ *
+ * Asserts that the input value is non-nullish
+ */
+function assertNonNullish(value) {
+    assert.ok(value !== null && value !== undefined, `Expected non-nullish value, found ${value}`);
+}
+/**
+ * @internal
+ *
+ * A helper that checks a single call arguments, which may include the
+ * use of matchers. This is used in finding any call or checking a specific
+ * call
+ */
+function assertCallHasArgs(call, args) {
+    assert.ok(call && args.length === call.arguments?.length, 'Number of arguments does not match');
+    args.forEach((arg, i) => assertMatch(call.arguments[i], arg));
+}
+/**
+ * @internal
+ *
+ * A helper that checks for the first instance of a match on the actual call
+ * arguments (this extracts the toHaveBeenCalledWith logic)
+ */
+function assertSomeCallHasArgs(value, args) {
+    assert.ok(value?.mock?.calls.some((call) => {
+        try {
+            assertCallHasArgs(call, args);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }), 'No call found matching arguments');
+}
+/**
+ * @internal
+ *
+ * Asserts that the value is either (equal deep) or matches the matcher (if supplied)
+ */
+function assertMatch(value, check) {
+    check instanceof Matcher
+        ? check.assertMatch(value)
+        : Array.isArray(check)
+            ? assertMatchArr(value, check)
+            : check && typeof check === 'object'
+                ? assertMatchObj(value, check)
+                : assert.deepStrictEqual(value, check);
+}
+/**
+ * @internal
+ *
+ * A helper to match the supplied array check against the resulting array
+ *
+ * @param {unknown} value
+ * @param {unknown[]} check
+ */
+function assertMatchArr(value, check) {
+    assert.ok(value && Array.isArray(value), `Expected array value, found ${typeof value}`);
+    assert.ok(value.length === check.length, `Expected array with ${check.length} entries, found ${value.length}`);
+    check.forEach((other, i) => assertMatch(value[i], other));
+}
+/**
+ * @internal
+ *
+ * A helper to match the supplied fields against the resulting object
+ */
+function assertMatchObj(value, check) {
+    assert.ok(value && typeof value === 'object', `Expected object value, found ${typeof value}`);
+    Object
+        .entries(check)
+        .forEach(([key, other]) => assertMatch(value[key], other));
+}
+/**
+ * @internal
+ *
+ * A helper to match a string value against another string or regex
+ */
+function assertMatchStr(value, check) {
+    assert.ok(typeof value === 'string', `Expected string value, found ${typeof value}`);
+    typeof check === 'string'
+        ? assert.strictEqual(value, check)
+        : assert.match(value, check);
+}
+/**
+ * @internal
+ *
+ * A helper to check the type of a specific value as used in the expect.any(Clazz) matcher
+ *
+ * @see https://github.com/facebook/jest/blob/a49c88610e49a3242576160740a32a2fe11161e1/packages/expect/src/asymmetricMatchers.ts#L103-L133
+ */
+function assertInstanceOf(value, Clazz) {
+    assert.ok((Clazz === Array && Array.isArray(value)) ||
+        (Clazz === BigInt && typeof value === 'bigint') ||
+        (Clazz === Boolean && typeof value === 'boolean') ||
+        (Clazz === Function && typeof value === 'function') ||
+        (Clazz === Number && typeof value === 'number') ||
+        (Clazz === Object && typeof value === 'object') ||
+        (Clazz === String && typeof value === 'string') ||
+        (Clazz === Symbol && typeof value === 'symbol') ||
+        (value instanceof Clazz), `${value} is not an instance of ${Clazz.name}`);
+}
+/**
+ * @internal
+ *
+ * A helper to ensure that the supplied string/array does include the checker string.
+ *
+ * @param {string | unknown[]} value
+ * @param {string} check
+ */
+function assertIncludes(value, [check, Clazz]) {
+    assertInstanceOf(value, Clazz);
+    assert.ok(value?.includes(check), `${value} does not include ${check}`);
+}
+/**
+ * Sets up the shimmed expect(...) function, including all .to* and .not.to*
+ * functions. This is not comprehensive, rather is contains what we need to
+ * make all polkadot-js usages pass
+ **/
+export function expect() {
+    const rootMatchers = {
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        any: (Clazz) => new Matcher(assertInstanceOf, Clazz),
+        anything: () => new Matcher(assertNonNullish),
+        arrayContaining: (check) => new Matcher(assertIncludes, [check, Array]),
+        objectContaining: (check) => new Matcher(assertMatchObj, check),
+        stringContaining: (check) => new Matcher(assertIncludes, [check, String]),
+        stringMatching: (check) => new Matcher(assertMatchStr, check)
+    };
+    return {
+        expect: enhanceObj(enhanceObj((value) => enhanceObj({
+            not: enhanceObj({
+                toBe: (other) => assert.notStrictEqual(value, other),
+                toBeDefined: () => assert.ok(value === undefined),
+                toBeNull: (value) => assert.ok(value !== null),
+                toBeUndefined: () => assert.ok(value !== undefined),
+                toEqual: (other) => assert.notDeepEqual(value, other),
+                toHaveBeenCalled: () => assert.ok(!value?.mock?.calls.length),
+                toThrow: (message) => assert.doesNotThrow(value, message && { message })
+            }, stubExpectFnNot),
+            rejects: enhanceObj({
+                toThrow: (message) => assert.rejects(value, message && { message })
+            }, stubExpectFnRejects),
+            resolves: enhanceObj({}, stubExpectFnResolves),
+            toBe: (other) => assert.strictEqual(value, other),
+            toBeDefined: () => assert.ok(value !== undefined),
+            toBeFalsy: () => assert.ok(!value),
+            // eslint-disable-next-line @typescript-eslint/ban-types
+            toBeInstanceOf: (Clazz) => assertInstanceOf(value, Clazz),
+            toBeNull: (value) => assert.ok(value === null),
+            toBeTruthy: () => assert.ok(value),
+            toBeUndefined: () => assert.ok(value === undefined),
+            toEqual: (other) => assert.deepEqual(value, other),
+            toHaveBeenCalled: () => assert.ok(value?.mock?.calls.length),
+            toHaveBeenCalledTimes: (count) => assert.equal(value?.mock?.calls.length, count),
+            toHaveBeenCalledWith: (...args) => assertSomeCallHasArgs(value, args),
+            toHaveBeenLastCalledWith: (...args) => assertCallHasArgs(value?.mock?.calls.at(-1), args),
+            toHaveLength: (length) => assert.equal(value?.length, length),
+            toMatch: (check) => assertMatchStr(value, check),
+            toMatchObject: (check) => assertMatchObj(value, check),
+            toThrow: (message) => assert.throws(value, message && { message })
+        }, stubExpectFn), rootMatchers), stubExpect)
+    };
+}

package/env/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Exposes the jest-y environment via globals.
+ */
+export declare function exposeEnv(isBrowser: boolean): void;

package/env/index.js

@@ -0,0 +1,17 @@
+import { browser } from './browser.js';
+import { expect } from './expect.js';
+import { jest } from './jest.js';
+import { lifecycle } from './lifecycle.js';
+import { suite } from './suite.js';
+/**
+ * Exposes the jest-y environment via globals.
+ */
+export function exposeEnv(isBrowser) {
+    [expect, jest, lifecycle, suite, isBrowser && browser].forEach((env) => {
+        env && Object
+            .entries(env())
+            .forEach(([key, fn]) => {
+            globalThis[key] ??= fn;
+        });
+    });
+}

package/env/jest.d.ts

@@ -0,0 +1,127 @@
+import type { AnyFn } from '../types.js';
+/**
+ * Sets up the jest object. This is certainly not extensive, and probably
+ * not quite meant to be (never say never). Rather this adds the functionality
+ * that we use in the polkadot-js projects.
+ **/
+export declare function jest(): {
+    jest: {
+        fn: <F extends AnyFn>(fn?: F) => F & {
+            mock: {
+                calls: {
+                    arguments: unknown[];
+                }[];
+                mockImplementation: (fn: AnyFn) => void;
+                mockImplementationOnce: (fn: AnyFn) => void;
+                resetCalls: () => void;
+                restore: () => void;
+            };
+        } & Omit<{
+            mockImplementation: <F_1 extends AnyFn>(fn: F_1) => void;
+            mockImplementationOnce: <F_1 extends AnyFn>(fn: F_1) => void;
+            mockReset: () => void;
+            mockRestore: () => void;
+        }, "mock" | keyof F> & Omit<{
+            mock: import("../types.js").StubFn;
+            _isMockFunction: import("../types.js").StubFn;
+            getMockImplementation: import("../types.js").StubFn;
+            getMockName: import("../types.js").StubFn;
+            mockClear: import("../types.js").StubFn;
+            mockImplementation: import("../types.js").StubFn;
+            mockImplementationOnce: import("../types.js").StubFn;
+            mockName: import("../types.js").StubFn;
+            mockRejectedValue: import("../types.js").StubFn;
+            mockRejectedValueOnce: import("../types.js").StubFn;
+            mockReset: import("../types.js").StubFn;
+            mockResolvedValue: import("../types.js").StubFn;
+            mockResolvedValueOnce: import("../types.js").StubFn;
+            mockRestore: import("../types.js").StubFn;
+            mockReturnThis: import("../types.js").StubFn;
+            mockReturnValue: import("../types.js").StubFn;
+            mockReturnValueOnce: import("../types.js").StubFn;
+            withImplementation: import("../types.js").StubFn;
+        }, "mock" | keyof F | Exclude<"mockImplementation", "mock" | keyof F> | Exclude<"mockImplementationOnce", "mock" | keyof F> | Exclude<"mockReset", "mock" | keyof F> | Exclude<"mockRestore", "mock" | keyof F>>;
+        restoreAllMocks: () => void;
+        spyOn: <F extends AnyFn>(obj: object, key: string) => F & {
+            mock: {
+                calls: {
+                    arguments: unknown[];
+                }[];
+                mockImplementation: (fn: AnyFn) => void;
+                mockImplementationOnce: (fn: AnyFn) => void;
+                resetCalls: () => void;
+                restore: () => void;
+            };
+        } & Omit<{
+            mockImplementation: <F_1 extends AnyFn>(fn: F_1) => void;
+            mockImplementationOnce: <F_1 extends AnyFn>(fn: F_1) => void;
+            mockReset: () => void;
+            mockRestore: () => void;
+        }, "mock" | keyof F> & Omit<{
+            mock: import("../types.js").StubFn;
+            _isMockFunction: import("../types.js").StubFn;
+            getMockImplementation: import("../types.js").StubFn;
+            getMockName: import("../types.js").StubFn;
+            mockClear: import("../types.js").StubFn;
+            mockImplementation: import("../types.js").StubFn;
+            mockImplementationOnce: import("../types.js").StubFn;
+            mockName: import("../types.js").StubFn;
+            mockRejectedValue: import("../types.js").StubFn;
+            mockRejectedValueOnce: import("../types.js").StubFn;
+            mockReset: import("../types.js").StubFn;
+            mockResolvedValue: import("../types.js").StubFn;
+            mockResolvedValueOnce: import("../types.js").StubFn;
+            mockRestore: import("../types.js").StubFn;
+            mockReturnThis: import("../types.js").StubFn;
+            mockReturnValue: import("../types.js").StubFn;
+            mockReturnValueOnce: import("../types.js").StubFn;
+            withImplementation: import("../types.js").StubFn;
+        }, "mock" | keyof F | Exclude<"mockImplementation", "mock" | keyof F> | Exclude<"mockImplementationOnce", "mock" | keyof F> | Exclude<"mockReset", "mock" | keyof F> | Exclude<"mockRestore", "mock" | keyof F>>;
+    } & Omit<{
+        setTimeout: import("../types.js").StubFn;
+    }, "fn" | "restoreAllMocks" | "spyOn"> & Omit<{
+        setTimeout: import("../types.js").StubFn;
+        mock: import("../types.js").StubFn;
+        advanceTimersByTime: import("../types.js").StubFn;
+        advanceTimersToNextTimer: import("../types.js").StubFn;
+        autoMockOff: import("../types.js").StubFn;
+        autoMockOn: import("../types.js").StubFn;
+        clearAllMocks: import("../types.js").StubFn;
+        clearAllTimers: import("../types.js").StubFn;
+        createMockFromModule: import("../types.js").StubFn;
+        deepUnmock: import("../types.js").StubFn;
+        disableAutomock: import("../types.js").StubFn;
+        doMock: import("../types.js").StubFn;
+        dontMock: import("../types.js").StubFn;
+        enableAutomock: import("../types.js").StubFn;
+        fn: import("../types.js").StubFn;
+        genMockFromModule: import("../types.js").StubFn;
+        getRealSystemTime: import("../types.js").StubFn;
+        getSeed: import("../types.js").StubFn;
+        getTimerCount: import("../types.js").StubFn;
+        isEnvironmentTornDown: import("../types.js").StubFn;
+        isMockFunction: import("../types.js").StubFn;
+        isolateModules: import("../types.js").StubFn;
+        isolateModulesAsync: import("../types.js").StubFn;
+        mocked: import("../types.js").StubFn;
+        now: import("../types.js").StubFn;
+        replaceProperty: import("../types.js").StubFn;
+        requireActual: import("../types.js").StubFn;
+        requireMock: import("../types.js").StubFn;
+        resetAllMocks: import("../types.js").StubFn;
+        resetModules: import("../types.js").StubFn;
+        restoreAllMocks: import("../types.js").StubFn;
+        retryTimes: import("../types.js").StubFn;
+        runAllImmediates: import("../types.js").StubFn;
+        runAllTicks: import("../types.js").StubFn;
+        runAllTimers: import("../types.js").StubFn;
+        runOnlyPendingTimers: import("../types.js").StubFn;
+        setMock: import("../types.js").StubFn;
+        setSystemTime: import("../types.js").StubFn;
+        spyOn: import("../types.js").StubFn;
+        unmock: import("../types.js").StubFn;
+        unstable_mockModule: import("../types.js").StubFn;
+        useFakeTimers: import("../types.js").StubFn;
+        useRealTimers: import("../types.js").StubFn;
+    }, "setTimeout" | "fn" | "restoreAllMocks" | "spyOn">;
+};