@effectionx/bdd 0.1.0

package/esm/mod.d.ts

@@ -0,0 +1,13 @@
+import type { Operation } from "effection";
+export declare function describe(name: string, body: () => void): void;
+export declare namespace describe {
+    var skip: <T>(...args: import("./deps/jsr.io/@std/testing/1.0.15/bdd.js").DescribeArgs<T>) => import("./deps/jsr.io/@std/testing/1.0.15/_test_suite.js").TestSuite<T>;
+    var only: <T>(...args: import("./deps/jsr.io/@std/testing/1.0.15/bdd.js").DescribeArgs<T>) => import("./deps/jsr.io/@std/testing/1.0.15/_test_suite.js").TestSuite<T>;
+}
+export declare function beforeEach(body: () => Operation<void>): void;
+export declare function it(desc: string, body?: () => Operation<void>): void;
+export declare namespace it {
+    var skip: (desc: string, body?: (() => Operation<void>) | undefined) => ReturnType<typeof it>;
+    var only: (desc: string, body: () => Operation<void>) => void;
+}
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAS3C,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,IAAI,QAYtD;yBAZe,QAAQ;;;;AAiBxB,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,SAAS,CAAC,IAAI,CAAC,QAErD;AAED,wBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,CAYnE;yBAZe,EAAE;2CAA4B,SAAS,CAAC,IAAI,CAAC,kBAcjB,UAAU,CAAC,OAAO,EAAE,CAAC;qBAKhD,MAAM,QAAQ,MAAM,SAAS,CAAC,IAAI,CAAC,KAAG,IAAI"}

package/esm/mod.js

@@ -0,0 +1,47 @@
+import { createTestAdapter } from "@effectionx/test-adapter";
+import { afterAll as $afterAll, describe as $describe, it as $it, } from "./deps/jsr.io/@std/testing/1.0.15/bdd.js";
+let current;
+export function describe(name, body) {
+    const original = current;
+    try {
+        const child = current = createTestAdapter({ name, parent: original });
+        $describe(name, () => {
+            $afterAll(() => child.destroy());
+            body();
+        });
+    }
+    finally {
+        current = original;
+    }
+}
+describe.skip = $describe.skip;
+describe.only = $describe.only;
+export function beforeEach(body) {
+    current?.addSetup(body);
+}
+export function it(desc, body) {
+    const adapter = current;
+    if (!body) {
+        $it.skip(desc, () => { });
+        return;
+    }
+    $it(desc, async () => {
+        const result = await adapter.runTest(body);
+        if (!result.ok) {
+            throw result.error;
+        }
+    });
+}
+it.skip = (...args) => {
+    const [desc] = args;
+    return $it.skip(desc, () => { });
+};
+it.only = (desc, body) => {
+    const adapter = current;
+    $it.only(desc, async () => {
+        const result = await adapter.runTest(body);
+        if (!result.ok) {
+            throw result.error;
+        }
+    });
+};

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@effectionx/bdd",
+  "version": "0.1.0",
+  "author": "engineering@frontside.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thefrontside/effectionx.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thefrontside/effectionx/issues"
+  },
+  "main": "./script/mod.js",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
+    }
+  },
+  "scripts": {},
+  "engines": {
+    "node": ">= 16"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@effectionx/test-adapter": "0.4.0",
+    "effection": "^3"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/_dnt.shims.d.ts

@@ -0,0 +1,2 @@
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/script/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}

package/script/_dnt.shims.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = void 0;
+const dntGlobals = {};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/deps/jsr.io/@std/assert/1.0.14/assertion_error.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=assertion_error.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.14/assertion_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion_error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/assertion_error.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}

package/script/deps/jsr.io/@std/assert/1.0.14/assertion_error.js

@@ -0,0 +1,34 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertionError = void 0;
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.name = "AssertionError";
+    }
+}
+exports.AssertionError = AssertionError;

package/script/deps/jsr.io/@std/internal/1.0.10/assertion_state.d.ts

@@ -0,0 +1,150 @@
+export declare class AssertionState {
+    #private;
+    constructor();
+    /**
+     * Get the number that through `expect.assertions` api set.
+     *
+     * @returns the number that through `expect.assertions` api set.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.assertionCount;
+     * ```
+     */
+    get assertionCount(): number | undefined;
+    /**
+     * Get a certain number that assertions were called before.
+     *
+     * @returns return a certain number that assertions were called before.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.assertionTriggeredCount;
+     * ```
+     */
+    get assertionTriggeredCount(): number;
+    /**
+     * If `expect.hasAssertions` called, then through this method to update #state.assertionCheck value.
+     *
+     * @param val Set #state.assertionCheck's value
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionCheck(true);
+     * ```
+     */
+    setAssertionCheck(val: boolean): void;
+    /**
+     * If any matchers was called, `#state.assertionTriggered` will be set through this method.
+     *
+     * @param val Set #state.assertionTriggered's value
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionTriggered(true);
+     * ```
+     */
+    setAssertionTriggered(val: boolean): void;
+    /**
+     * If `expect.assertions` called, then through this method to update #state.assertionCheck value.
+     *
+     * @param num Set #state.assertionCount's value, for example if the value is set 2, that means
+     * you must have two assertion matchers call in your test suite.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionCount(2);
+     * ```
+     */
+    setAssertionCount(num: number): void;
+    /**
+     * If any matchers was called, `#state.assertionTriggeredCount` value will plus one internally.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.updateAssertionTriggerCount();
+     * ```
+     */
+    updateAssertionTriggerCount(): void;
+    /**
+     * Check Assertion internal state, if `#state.assertionCheck` is set true, but
+     * `#state.assertionTriggered` is still false, then should throw an Assertion Error.
+     *
+     * @returns a boolean value, that the test suite is satisfied with the check. If not,
+     * it should throw an AssertionError.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * if (assertionState.checkAssertionErrorState()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionErrorState(): boolean;
+    /**
+     * Reset all assertion state when every test suite function ran completely.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.resetAssertionState();
+     * ```
+     */
+    resetAssertionState(): void;
+    /**
+     * Check Assertion called state, if `#state.assertionCount` is set to a number value, but
+     * `#state.assertionTriggeredCount` is less then it, then should throw an assertion error.
+     *
+     * @returns a boolean value, that the test suite is satisfied with the check. If not,
+     * it should throw an AssertionError.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * if (assertionState.checkAssertionCountSatisfied()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionCountSatisfied(): boolean;
+}
+/**
+ * return an instance of AssertionState
+ *
+ * @returns AssertionState
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { getAssertionState } from "@std/internal";
+ *
+ * const assertionState = getAssertionState();
+ * assertionState.setAssertionTriggered(true);
+ * ```
+ */
+export declare function getAssertionState(): AssertionState;
+//# sourceMappingURL=assertion_state.d.ts.map

package/script/deps/jsr.io/@std/internal/1.0.10/assertion_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion_state.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.10/assertion_state.ts"],"names":[],"mappings":"AAeA,qBAAa,cAAc;;;IAgDzB;;;;;;;;;;;;OAYG;IACH,IAAI,cAAc,IAAI,MAAM,GAAG,SAAS,CAEvC;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,uBAAuB,IAAI,MAAM,CAEpC;IAED;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,GAAG,EAAE,OAAO;IAI9B;;;;;;;;;;;;OAYG;IACH,qBAAqB,CAAC,GAAG,EAAE,OAAO;IAIlC;;;;;;;;;;;;;OAaG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM;IAI7B;;;;;;;;;;OAUG;IACH,2BAA2B;IAM3B;;;;;;;;;;;;;;;;OAgBG;IACH,wBAAwB,IAAI,OAAO;IAInC;;;;;;;;;;OAUG;IACH,mBAAmB,IAAI,IAAI;IAS3B;;;;;;;;;;;;;;;;OAgBG;IACH,4BAA4B,IAAI,OAAO;CAIxC;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAElD"}

package/script/deps/jsr.io/@std/internal/1.0.10/assertion_state.js

@@ -0,0 +1,275 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AssertionState_instances, _AssertionState_state, _AssertionState_ensureCleanedUp;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertionState = void 0;
+exports.getAssertionState = getAssertionState;
+/**
+ * Check the test suite internal state
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionState } from "@std/internal";
+ *
+ * const assertionState = new AssertionState();
+ * ```
+ */
+const dntShim = __importStar(require("../../../../../_dnt.shims.js"));
+class AssertionState {
+    constructor() {
+        _AssertionState_instances.add(this);
+        _AssertionState_state.set(this, void 0);
+        __classPrivateFieldSet(this, _AssertionState_state, {
+            assertionCount: undefined,
+            assertionCheck: false,
+            assertionTriggered: false,
+            assertionTriggeredCount: 0,
+        }, "f");
+        if (typeof globalThis?.addEventListener === "function") {
+            globalThis.addEventListener("unload", () => {
+                __classPrivateFieldGet(this, _AssertionState_instances, "m", _AssertionState_ensureCleanedUp).call(this);
+            });
+        }
+        else if (
+        // deno-lint-ignore no-explicit-any
+        typeof dntShim.dntGlobalThis?.process?.on === "function") {
+            // deno-lint-ignore no-explicit-any
+            dntShim.dntGlobalThis.process.on("exit", () => {
+                __classPrivateFieldGet(this, _AssertionState_instances, "m", _AssertionState_ensureCleanedUp).call(this);
+            });
+        }
+        else {
+            // deno-lint-ignore no-console
+            console.warn("AssertionCounter cleanup step was not registered");
+        }
+    }
+    /**
+     * Get the number that through `expect.assertions` api set.
+     *
+     * @returns the number that through `expect.assertions` api set.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.assertionCount;
+     * ```
+     */
+    get assertionCount() {
+        return __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount;
+    }
+    /**
+     * Get a certain number that assertions were called before.
+     *
+     * @returns return a certain number that assertions were called before.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.assertionTriggeredCount;
+     * ```
+     */
+    get assertionTriggeredCount() {
+        return __classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggeredCount;
+    }
+    /**
+     * If `expect.hasAssertions` called, then through this method to update #state.assertionCheck value.
+     *
+     * @param val Set #state.assertionCheck's value
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionCheck(true);
+     * ```
+     */
+    setAssertionCheck(val) {
+        __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCheck = val;
+    }
+    /**
+     * If any matchers was called, `#state.assertionTriggered` will be set through this method.
+     *
+     * @param val Set #state.assertionTriggered's value
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionTriggered(true);
+     * ```
+     */
+    setAssertionTriggered(val) {
+        __classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggered = val;
+    }
+    /**
+     * If `expect.assertions` called, then through this method to update #state.assertionCheck value.
+     *
+     * @param num Set #state.assertionCount's value, for example if the value is set 2, that means
+     * you must have two assertion matchers call in your test suite.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionCount(2);
+     * ```
+     */
+    setAssertionCount(num) {
+        __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount = num;
+    }
+    /**
+     * If any matchers was called, `#state.assertionTriggeredCount` value will plus one internally.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.updateAssertionTriggerCount();
+     * ```
+     */
+    updateAssertionTriggerCount() {
+        if (__classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount !== undefined) {
+            __classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggeredCount += 1;
+        }
+    }
+    /**
+     * Check Assertion internal state, if `#state.assertionCheck` is set true, but
+     * `#state.assertionTriggered` is still false, then should throw an Assertion Error.
+     *
+     * @returns a boolean value, that the test suite is satisfied with the check. If not,
+     * it should throw an AssertionError.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * if (assertionState.checkAssertionErrorState()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionErrorState() {
+        return __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCheck && !__classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggered;
+    }
+    /**
+     * Reset all assertion state when every test suite function ran completely.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.resetAssertionState();
+     * ```
+     */
+    resetAssertionState() {
+        __classPrivateFieldSet(this, _AssertionState_state, {
+            assertionCount: undefined,
+            assertionCheck: false,
+            assertionTriggered: false,
+            assertionTriggeredCount: 0,
+        }, "f");
+    }
+    /**
+     * Check Assertion called state, if `#state.assertionCount` is set to a number value, but
+     * `#state.assertionTriggeredCount` is less then it, then should throw an assertion error.
+     *
+     * @returns a boolean value, that the test suite is satisfied with the check. If not,
+     * it should throw an AssertionError.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * if (assertionState.checkAssertionCountSatisfied()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionCountSatisfied() {
+        return __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount !== undefined &&
+            __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount !== __classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggeredCount;
+    }
+}
+exports.AssertionState = AssertionState;
+_AssertionState_state = new WeakMap(), _AssertionState_instances = new WeakSet(), _AssertionState_ensureCleanedUp = function _AssertionState_ensureCleanedUp() {
+    // If any checks were registered, after the test suite runs the checks,
+    // `resetAssertionState` should also have been called. If it was not,
+    // then the test suite did not run the checks.
+    if (__classPrivateFieldGet(this, _AssertionState_state, "f").assertionCheck ||
+        __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount !== undefined) {
+        throw new Error("AssertionCounter was not cleaned up: If tests are not otherwise failing, ensure `expect.hasAssertion` and `expect.assertions` are only run in bdd tests");
+    }
+};
+const assertionState = new AssertionState();
+/**
+ * return an instance of AssertionState
+ *
+ * @returns AssertionState
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { getAssertionState } from "@std/internal";
+ *
+ * const assertionState = getAssertionState();
+ * assertionState.setAssertionTriggered(true);
+ * ```
+ */
+function getAssertionState() {
+    return assertionState;
+}