@evolu/common 8.4.0 → 8.6.0

package/dist/src/Assert.js

@@ -1,8 +1,9 @@
 /**
- * Runtime assertions for invariant checking.
+ * Runtime assertions for invariants and value checks.
  *
  * @module
  */
+import { eqData, eqStrict } from "./Eq.js";
 /**
  * Ensures a condition is true, throwing an error with the provided message if
  * not.
@@ -17,19 +18,103 @@
  * ### Example
  *
  * ```ts
- * import { assert as assertInvariant } from "@evolu/common";
+ * import { assert, assertEqual, assertErr, trySync } from "@evolu/common";
  *
- * expect(() => assertInvariant(true, "Expected true.")).not.toThrow();
- * expect(() => assertInvariant(false, "Expected true.")).toThrow(
- *   "Expected true.",
- * );
+ * assert(true, "Expected true.");
+ * const result = trySync(() => assert(false, "Expected true."));
+ * assertErr(result);
+ * assert(result.error instanceof Error, "Expected an Error.");
+ * assertEqual(result.error.message, "Expected true.");
  * ```
  */
 export const assert = (condition, message) => {
+    // oxlint-disable-next-line typescript/strict-boolean-expressions -- JavaScript truthiness is the contract of assert.
     if (!condition) {
         throw new Error(message);
     }
 };
+/**
+ * Asserts that two values are the same according to {@link eqStrict}.
+ *
+ * `eqStrict` uses SameValue equality: it considers `NaN` the same as itself,
+ * distinguishes `0` from `-0`, and compares objects by reference identity.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertSame, assertType } from "@evolu/common";
+ *
+ * interface User {
+ *   readonly name: string;
+ * }
+ *
+ * const user: User = { name: "Ada" };
+ * const value: unknown = user;
+ *
+ * assertSame(value, user);
+ * assertType<User, typeof value>();
+ * ```
+ */
+export const assertSame = (actual, expected) => {
+    assert(eqStrict(actual, expected), "Expected values to be the same.");
+};
+/**
+ * Asserts that a value is exactly `true` and narrows it to `true`.
+ *
+ * Unlike {@link assert}, this checks an exact boolean value instead of
+ * truthiness and does not require a custom message.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertTrue, assertType } from "@evolu/common";
+ *
+ * const value: unknown = true;
+ * assertTrue(value);
+ * assertType<true, typeof value>();
+ * ```
+ */
+export const assertTrue = (value) => {
+    assert(value === true, "Expected true.");
+};
+/**
+ * Asserts that a value is exactly `false` and narrows it to `false`.
+ *
+ * Unlike {@link assert}, this checks an exact boolean value instead of falsiness
+ * and does not require a custom message.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertFalse, assertType } from "@evolu/common";
+ *
+ * const value: unknown = false;
+ * assertFalse(value);
+ * assertType<false, typeof value>();
+ * ```
+ */
+export const assertFalse = (value) => {
+    assert(value === false, "Expected false.");
+};
+export function assertEqual(actual, expected) {
+    assert(eqData(actual, expected), "Expected values to be equal.");
+}
+export function assertOk(result, ...comparison) {
+    assert(result.ok, "Expected an Ok result.");
+    if (comparison.length === 0)
+        return;
+    const expectedValue = comparison[0];
+    const eq = comparison[1] ?? eqData;
+    assert(eq(result.value, expectedValue), "Expected the value to equal the expected value.");
+}
+export function assertErr(result, ...comparison) {
+    assert(!result.ok, "Expected an Err result.");
+    if (comparison.length === 0)
+        return;
+    const expectedError = comparison[0];
+    const eq = comparison[1] ?? eqData;
+    assert(eq(result.error, expectedError), "Expected the error to equal the expected error.");
+}
 /**
  * Asserts that a value is non-nullable.
  *
@@ -49,15 +134,23 @@ export const assertNonNullable = (value, message = "Expected value to be non-nul
  * ### Example
  *
  * ```ts
- * import { assertNotNull } from "@evolu/common";
+ * import {
+ *   assert,
+ *   assertEqual,
+ *   assertErr,
+ *   assertNotNull,
+ *   assertType,
+ *   trySync,
+ * } from "@evolu/common";
  *
  * const value = undefined as string | null | undefined;
  * assertNotNull(value);
- * expectTypeOf(value).toEqualTypeOf<string | undefined>();
- * expect(value).toBeUndefined();
- * expect(() => assertNotNull(null)).toThrow(
- *   "Expected value not to be null.",
- * );
+ * assertType<string | undefined, typeof value>();
+ * assertEqual(value, undefined);
+ * const result = trySync(() => assertNotNull(null));
+ * assertErr(result);
+ * assert(result.error instanceof Error, "Expected an Error.");
+ * assertEqual(result.error.message, "Expected value not to be null.");
  * ```
  */
 export const assertNotNull = (value, message = "Expected value not to be null.") => {
@@ -72,15 +165,23 @@ export const assertNotNull = (value, message = "Expected value not to be null.")
  * ### Example
  *
  * ```ts
- * import { assertNotUndefined } from "@evolu/common";
+ * import {
+ *   assert,
+ *   assertEqual,
+ *   assertErr,
+ *   assertNotUndefined,
+ *   assertType,
+ *   trySync,
+ * } from "@evolu/common";
  *
  * const value = null as string | null | undefined;
  * assertNotUndefined(value);
- * expectTypeOf(value).toEqualTypeOf<string | null>();
- * expect(value).toBeNull();
- * expect(() => assertNotUndefined(undefined)).toThrow(
- *   "Expected value not to be undefined.",
- * );
+ * assertType<string | null, typeof value>();
+ * assertEqual(value, null);
+ * const result = trySync(() => assertNotUndefined(undefined));
+ * assertErr(result);
+ * assert(result.error instanceof Error, "Expected an Error.");
+ * assertEqual(result.error.message, "Expected value not to be undefined.");
  * ```
  */
 export const assertNotUndefined = (value, message = "Expected value not to be undefined.") => {
@@ -95,13 +196,21 @@ export const assertNotUndefined = (value, message = "Expected value not to be un
  * ### Example
  *
  * ```ts
- * import { assertNonEmptyArray, type NonEmptyArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertNonEmptyArray,
+ *   assertType,
+ *   trySync,
+ *   type NonEmptyArray,
+ * } from "@evolu/common";
  *
  * const values = [1, 2, 3];
  * assertNonEmptyArray(values);
- * expectTypeOf(values).toEqualTypeOf<NonEmptyArray<number>>();
- * expect(values[0]).toBe(1);
- * expect(() => assertNonEmptyArray([])).toThrow();
+ * assertType<NonEmptyArray<number>, typeof values>();
+ * assertEqual(values[0], 1);
+ * const result = trySync(() => assertNonEmptyArray([]));
+ * assertErr(result);
  * ```
  */
 export const assertNonEmptyArray = (arr, message = "Expected a non-empty array.") => {
@@ -117,15 +226,20 @@ export const assertNonEmptyArray = (arr, message = "Expected a non-empty array."
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
  *   assertNonEmptyReadonlyArray,
+ *   assertType,
+ *   trySync,
  *   type NonEmptyReadonlyArray,
  * } from "@evolu/common";
  *
  * const values: ReadonlyArray<number> = [1, 2, 3];
  * assertNonEmptyReadonlyArray(values);
- * expectTypeOf(values).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
- * expect(values[0]).toBe(1);
- * expect(() => assertNonEmptyReadonlyArray([])).toThrow();
+ * assertType<NonEmptyReadonlyArray<number>, typeof values>();
+ * assertEqual(values[0], 1);
+ * const result = trySync(() => assertNonEmptyReadonlyArray([]));
+ * assertErr(result);
  * ```
  */
 export const assertNonEmptyReadonlyArray = (arr, message = "Expected a non-empty readonly array.") => {
@@ -139,14 +253,21 @@ export const assertNonEmptyReadonlyArray = (arr, message = "Expected a non-empty
  * ### Example
  *
  * ```ts
- * import { assertNotDisposed } from "@evolu/common";
+ * import {
+ *   assert,
+ *   assertEqual,
+ *   assertErr,
+ *   assertNotDisposed,
+ *   trySync,
+ * } from "@evolu/common";
  *
  * await using disposer = new globalThis.AsyncDisposableStack();
- * expect(() => assertNotDisposed(disposer)).not.toThrow();
+ * assertNotDisposed(disposer);
  * await disposer.disposeAsync();
- * expect(() => assertNotDisposed(disposer)).toThrow(
- *   "Cannot use a disposed object.",
- * );
+ * const result = trySync(() => assertNotDisposed(disposer));
+ * assertErr(result);
+ * assert(result.error instanceof Error, "Expected an Error.");
+ * assertEqual(result.error.message, "Cannot use a disposed object.");
  * ```
  *
  * This is the JavaScript equivalent of the .NET `ObjectDisposedException`

package/dist/src/BigInt.d.ts

@@ -16,12 +16,12 @@ export declare const clampBigInt: (min: bigint, max: bigint) => (n: bigint) => b
  * ### Example
  *
  * ```ts
- * import { isBetweenBigInt } from "@evolu/common";
+ * import { assertFalse, assertTrue, isBetweenBigInt } from "@evolu/common";
  *
  * const isBetween10And20 = isBetweenBigInt(10n, 20n);
  *
- * expect(isBetween10And20(20n)).toBe(true);
- * expect(isBetween10And20(25n)).toBe(false);
+ * assertTrue(isBetween10And20(20n));
+ * assertFalse(isBetween10And20(25n));
  * ```
  */
 export declare const isBetweenBigInt: (min: bigint, max: bigint) => Predicate<bigint>;

package/dist/src/BigInt.js

@@ -15,12 +15,12 @@ export const clampBigInt = (min, max) => (n) => n < min ? min : n > max ? max :
  * ### Example
  *
  * ```ts
- * import { isBetweenBigInt } from "@evolu/common";
+ * import { assertFalse, assertTrue, isBetweenBigInt } from "@evolu/common";
  *
  * const isBetween10And20 = isBetweenBigInt(10n, 20n);
  *
- * expect(isBetween10And20(20n)).toBe(true);
- * expect(isBetween10And20(25n)).toBe(false);
+ * assertTrue(isBetween10And20(20n));
+ * assertFalse(isBetween10And20(25n));
  * ```
  */
 export const isBetweenBigInt = (min, max) => (value) => value >= min && value <= max;

package/dist/src/Brand.d.ts

@@ -17,7 +17,7 @@
  * ### Single brand
  *
  * ```ts
- * import type { Brand } from "@evolu/common";
+ * import { assertEqual, type Brand } from "@evolu/common";
  *
  * type UserId = number & Brand<"UserId">;
  *
@@ -26,7 +26,7 @@
  * const createUserId = (value: number): UserId => value as UserId;
  * const getUser = (id: UserId): number => id;
  * const userId = createUserId(123);
- * expect(getUser(userId)).toBe(123);
+ * assertEqual(getUser(userId), 123);
  * // @ts-expect-error A plain number is not a UserId.
  * getUser(123);
  * ```
@@ -34,7 +34,7 @@
  * ### Multiple brands
  *
  * ```ts
- * import type { Brand } from "@evolu/common";
+ * import { assertEqual, type Brand } from "@evolu/common";
  *
  * type Min1 = string & Brand<"Min1">;
  * type Max100 = string & Brand<"Max100">;
@@ -45,8 +45,8 @@
  *
  * const min1Max100Value: Min1Max100 = "typescript" as Min1Max100;
  *
- * expect(requiresMin1(min1Max100Value)).toBe("typescript");
- * expect(requiresMax100(min1Max100Value)).toBe("typescript");
+ * assertEqual(requiresMin1(min1Max100Value), "typescript");
+ * assertEqual(requiresMax100(min1Max100Value), "typescript");
  * ```
  *
  * ### Standalone brand
@@ -58,7 +58,7 @@
  * code platform-agnostic.
  *
  * ```ts
- * import type { Brand } from "@evolu/common";
+ * import { assertSame, type Brand } from "@evolu/common";
  *
  * type NativePort = Brand<"NativePort">;
  *
@@ -66,7 +66,7 @@
  *
  * const nativeValue: unknown = { id: 1 };
  * const port = nativeValue as NativePort;
- * expect(requiresNativePort(port)).toBe(nativeValue);
+ * assertSame(requiresNativePort(port), nativeValue);
  * // @ts-expect-error An unknown value is not a NativePort.
  * requiresNativePort(nativeValue);
  * ```

package/dist/src/Buffer.d.ts

@@ -37,6 +37,9 @@ export declare class BufferError extends Error {
  *
  * ```ts
  * import {
+ *   assert,
+ *   assertEqual,
+ *   assertErr,
  *   createBuffer,
  *   createIdFromString,
  *   IdBytes,
@@ -44,6 +47,7 @@ export declare class BufferError extends Error {
  *   idBytesTypeValueLength,
  *   idToIdBytes,
  *   NonNegativeInt,
+ *   trySync,
  * } from "@evolu/common";
  * import {
  *   decodeNonNegativeInt,
@@ -56,13 +60,17 @@ export declare class BufferError extends Error {
  * buffer.extend(idToIdBytes(id));
  *
  * const decoder = createBuffer(buffer.unwrap());
- * expect(decodeNonNegativeInt(decoder)).toBe(300);
+ * assertEqual(decodeNonNegativeInt(decoder), 300);
  * const decodedId = idBytesToId(
  *   IdBytes.orThrow(decoder.shiftN(idBytesTypeValueLength)),
  * );
- * expect(decodedId).toBe(id);
- * expect(() => decodeNonNegativeInt(decoder)).toThrow(
- *   "Buffer parse ended prematurely",
+ * assertEqual(decodedId, id);
+ * const result = trySync(() => decodeNonNegativeInt(decoder));
+ * assertErr(result);
+ * assert(
+ *   result.error instanceof Error &&
+ *     result.error.message === "Buffer parse ended prematurely",
+ *   "Expected the premature-buffer-end error.",
  * );
  * ```
  *

package/dist/src/Buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Buffer.d.ts","sourceRoot":"","sources":["../../src/Buffer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,cAAc,EAAsB,MAAM,WAAW,CAAC;AAC/D,OAAO,EACL,UAAU,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,WAAW,GACZ,MAAM,yBAAyB,CAAC;AAEjC;;;GAGG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC,YAAY,OAAO,EAAE,MAAM,EAK1B;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,WAAW,MAAM;IACrB,kDAAkD;IAClD,WAAW,EAAE,MAAM,cAAc,CAAC;IAElC,gEAAgE;IAChE,SAAS,EAAE,MAAM,cAAc,CAAC;IAEhC;;;OAGG;IACH,MAAM,EAAE,CAAC,GAAG,EAAE,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC;IAEtD;;;OAGG;IACH,KAAK,EAAE,MAAM,cAAc,CAAC;IAE5B;;;OAGG;IACH,MAAM,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,UAAU,CAAC;IAE1C;;;OAGG;IACH,QAAQ,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAE3C;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;IAElB;;;;OAIG;IACH,MAAM,EAAE,MAAM,UAAU,CAAC;CAC1B;AAED,8DAA8D;AAC9D,eAAO,MAAM,YAAY,eACX,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,KACzC,MA4DF,CAAC"}
+{"version":3,"file":"Buffer.d.ts","sourceRoot":"","sources":["../../src/Buffer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,cAAc,EAAsB,MAAM,WAAW,CAAC;AAC/D,OAAO,EACL,UAAU,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,WAAW,GACZ,MAAM,yBAAyB,CAAC;AAEjC;;;GAGG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC,YAAY,OAAO,EAAE,MAAM,EAK1B;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,MAAM,WAAW,MAAM;IACrB,kDAAkD;IAClD,WAAW,EAAE,MAAM,cAAc,CAAC;IAElC,gEAAgE;IAChE,SAAS,EAAE,MAAM,cAAc,CAAC;IAEhC;;;OAGG;IACH,MAAM,EAAE,CAAC,GAAG,EAAE,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC;IAEtD;;;OAGG;IACH,KAAK,EAAE,MAAM,cAAc,CAAC;IAE5B;;;OAGG;IACH,MAAM,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,UAAU,CAAC;IAE1C;;;OAGG;IACH,QAAQ,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAE3C;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;IAElB;;;;OAIG;IACH,MAAM,EAAE,MAAM,UAAU,CAAC;CAC1B;AAED,8DAA8D;AAC9D,eAAO,MAAM,YAAY,eACX,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,KACzC,MA4DF,CAAC"}

package/dist/src/Cache.d.ts

@@ -36,16 +36,21 @@ export interface Cache<K, V> {
  * ### Example
  *
  * ```ts
- * import { createLruCache, PositiveInt } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertFalse,
+ *   createLruCache,
+ *   PositiveInt,
+ * } from "@evolu/common";
  *
  * const cache = createLruCache<string, number>(PositiveInt.orThrow(2));
  * cache.set("a", 1);
  * cache.set("b", 2);
  * // Reading "a" makes "b" the least recently used entry.
- * expect(cache.get("a")).toBe(1);
+ * assertEqual(cache.get("a"), 1);
  * cache.set("c", 3);
  *
- * expect(cache.has("b")).toBe(false);
+ * assertFalse(cache.has("b"));
  * ```
  */
 export declare const createLruCache: <K, V>(capacity: PositiveInt) => Cache<K, V>;

package/dist/src/Cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../src/Cache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,EAAE,CAAC;IACzB,2CAA2C;IAC3C,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IAEzB,kEAAkE;IAClE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAE/B,4CAA4C;IAC5C,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC;IAE9B,oCAAoC;IACpC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC;IAEzB,mDAAmD;IACnD,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,YAAY,WAAW,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAmCtE,CAAC"}
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../src/Cache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,EAAE,CAAC;IACzB,2CAA2C;IAC3C,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IAEzB,kEAAkE;IAClE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAE/B,4CAA4C;IAC5C,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC;IAE9B,oCAAoC;IACpC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC;IAEzB,mDAAmD;IACnD,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,YAAY,WAAW,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAmCtE,CAAC"}

package/dist/src/Cache.js

@@ -13,16 +13,21 @@ import { PositiveInt } from "./Type.js";
  * ### Example
  *
  * ```ts
- * import { createLruCache, PositiveInt } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertFalse,
+ *   createLruCache,
+ *   PositiveInt,
+ * } from "@evolu/common";
  *
  * const cache = createLruCache<string, number>(PositiveInt.orThrow(2));
  * cache.set("a", 1);
  * cache.set("b", 2);
  * // Reading "a" makes "b" the least recently used entry.
- * expect(cache.get("a")).toBe(1);
+ * assertEqual(cache.get("a"), 1);
  * cache.set("c", 3);
  *
- * expect(cache.has("b")).toBe(false);
+ * assertFalse(cache.has("b"));
  * ```
  */
 export const createLruCache = (capacity) => {

package/dist/src/Callbacks.d.ts

@@ -22,7 +22,11 @@ import type { Callback } from "./Types.ts";
  * ### Correlating callback responses
  *
  * ```ts
- * import { createCallbacks, testCreateDeps } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   createCallbacks,
+ *   testCreateDeps,
+ * } from "@evolu/common";
  *
  * const deps = testCreateDeps();
  *
@@ -34,7 +38,7 @@ import type { Callback } from "./Types.ts";
  * });
  * callbacks.execute(noArgumentId);
  * callbacks.execute(noArgumentId);
- * expect(noArgumentCalls).toBe(1);
+ * assertEqual(noArgumentCalls, 1);
  *
  * // Typed callback
  * using stringCallbacks = createCallbacks<string>(deps);
@@ -43,14 +47,14 @@ import type { Callback } from "./Types.ts";
  *   received = value;
  * });
  * stringCallbacks.execute(stringCallbackId, "hello");
- * expect(received).toBe("hello");
+ * assertEqual(received, "hello");
  *
  * // Promise.withResolvers
  * using promiseCallbacks = createCallbacks<string>(deps);
  * const { promise, resolve } = Promise.withResolvers<string>();
  * const promiseCallbackId = promiseCallbacks.register(resolve);
  * promiseCallbacks.execute(promiseCallbackId, "resolved value");
- * expect(await promise).toBe("resolved value");
+ * assertEqual(await promise, "resolved value");
  * ```
  *
  * @template T - The type of argument passed to callbacks (defaults to undefined

package/dist/src/Callbacks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Callbacks.d.ts","sourceRoot":"","sources":["../../src/Callbacks.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,EAAY,EAAE,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,SAAS,CAAE,SAAQ,UAAU;IAC1D,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;IAEjD,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,SAAS,GACjC,CAAC,EAAE,EAAE,EAAE,KAAK,SAAS,GACrB,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,KAAK,SAAS,CAAC;CACnC;AAED,mEAAmE;AACnE,eAAO,MAAM,eAAe,GAAI,CAAC,GAAG,SAAS,QACrC,cAAc,KACnB,SAAS,CAAC,CAAC,CA6Bb,CAAC"}
+{"version":3,"file":"Callbacks.d.ts","sourceRoot":"","sources":["../../src/Callbacks.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,EAAY,EAAE,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,SAAS,CAAE,SAAQ,UAAU;IAC1D,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;IAEjD,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,SAAS,GACjC,CAAC,EAAE,EAAE,EAAE,KAAK,SAAS,GACrB,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,KAAK,SAAS,CAAC;CACnC;AAED,mEAAmE;AACnE,eAAO,MAAM,eAAe,GAAI,CAAC,GAAG,SAAS,QACrC,cAAc,KACnB,SAAS,CAAC,CAAC,CA6Bb,CAAC"}