@evolu/common 8.4.0 → 8.6.0

package/dist/src/Object.js

@@ -4,39 +4,79 @@
  * @module
  */
 /**
- * Checks if a value is a plain object (e.g., created with `{}` or `Object`).
+ * Classifies Object representations supported by Evolu's structural data APIs.
+ *
+ * Plain Objects are classified from their prototype without reading their
+ * properties, including `Symbol.toStringTag`.
  *
- * Accepts objects with `Object.prototype` and objects with a `null` prototype
- * created via `Object.create(null)`. Rejects class instances and other built-in
- * objects because their prototype chain includes an application-specific or
- * built-in prototype before `Object.prototype`.
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, getObjectKind } from "@evolu/common";
+ *
+ * assertEqual(getObjectKind({}), "Object");
+ * assertEqual(getObjectKind(new Map()), "Map");
+ * assertEqual(getObjectKind(/value/u), "Unsupported");
+ * ```
+ */
+export const getObjectKind = (value) => {
+    if (Array.isArray(value))
+        return "Array";
+    if (isPlainObject(value))
+        return "Object";
+    switch (Object.prototype.toString.call(value)) {
+        case "[object Date]":
+            return "Date";
+        case "[object Map]":
+            return "Map";
+        case "[object Set]":
+            return "Set";
+        case "[object Uint8Array]":
+            return "Uint8Array";
+        default:
+            return "Unsupported";
+    }
+};
+/**
+ * Checks if a value is a plain object (e.g., created with `{}` or `Object`).
  *
- * The prototype-chain check uses structure instead of `prototype ===
- * Object.prototype` so it also works for plain objects coming from another
- * JavaScript realm.
+ * Accepts objects with a `null` prototype. Otherwise, it uses a realm-neutral
+ * structural heuristic: the immediate prototype must be a root object with own
+ * `hasOwnProperty` and `isPrototypeOf` properties. This recognizes ordinary
+ * Objects from another JavaScript realm without relying on prototype identity.
  *
- * TODO: deprecated Use `Object.is` from Type. Define a dedicated Type when
- * another object domain is required.
+ * A custom root prototype with the same shape can therefore be classified as
+ * plain. This function assumes trusted JavaScript and is not a prototype
+ * authentication or security boundary. Other custom prototypes, class
+ * instances, and built-in objects are rejected.
  *
  * ### Example
  *
  * ```ts
- * import { isPlainObject } from "@evolu/common";
- *
- * expect(isPlainObject({})).toBe(true);
- * expect(isPlainObject(Object.create(null))).toBe(true);
- * expect(isPlainObject(new Date())).toBe(false);
- * expect(isPlainObject(new (class Example {})())).toBe(false);
- * expect(isPlainObject([])).toBe(false);
- * expect(isPlainObject(null)).toBe(false);
+ * import { assertFalse, assertTrue, isPlainObject } from "@evolu/common";
+ *
+ * class Example {
+ *   readonly value = "example";
+ * }
+ *
+ * assertTrue(isPlainObject({}));
+ * assertTrue(isPlainObject(Object.create(null)));
+ * assertFalse(isPlainObject(new Date()));
+ * assertFalse(isPlainObject(new Example()));
+ * assertFalse(isPlainObject([]));
+ * assertFalse(isPlainObject(null));
  * ```
  */
 export const isPlainObject = (value) => {
-    if (Object.prototype.toString.call(value) !== "[object Object]") {
+    if (value === null || typeof value !== "object") {
         return false;
     }
     const prototype = Object.getPrototypeOf(value);
-    return prototype === null || Object.getPrototypeOf(prototype) === null;
+    if (prototype === null)
+        return true;
+    return (Object.getPrototypeOf(prototype) === null &&
+        Object.hasOwn(prototype, "hasOwnProperty") &&
+        Object.hasOwn(prototype, "isPrototypeOf"));
 };
 /**
  * Checks if a value is a function.
@@ -44,11 +84,11 @@ export const isPlainObject = (value) => {
  * ### Example
  *
  * ```ts
- * import { isFunction } from "@evolu/common";
+ * import { assertFalse, assertTrue, isFunction } from "@evolu/common";
  *
- * expect(isFunction(() => {})).toBe(true);
- * expect(isFunction(function () {})).toBe(true);
- * expect(isFunction({})).toBe(false);
+ * assertTrue(isFunction(() => {}));
+ * assertTrue(isFunction(function () {}));
+ * assertFalse(isFunction({}));
  * ```
  */
 export const isFunction = (value) => typeof value === "function";
@@ -58,11 +98,11 @@ export const isFunction = (value) => typeof value === "function";
  * ### Example
  *
  * ```ts
- * import { isIterable } from "@evolu/common";
+ * import { assertFalse, assertTrue, isIterable } from "@evolu/common";
  *
- * expect(isIterable([1, 2, 3])).toBe(true);
- * expect(isIterable("abc")).toBe(true);
- * expect(isIterable({})).toBe(false);
+ * assertTrue(isIterable([1, 2, 3]));
+ * assertTrue(isIterable("abc"));
+ * assertFalse(isIterable({}));
  * ```
  */
 export const isIterable = (value) => value != null &&
@@ -74,6 +114,8 @@ export const isIterable = (value) => value != null &&
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   objectToEntries,
  *   type Brand,
  *   type ReadonlyRecord,
@@ -85,8 +127,8 @@ export const isIterable = (value) => value != null &&
  * const users: ReadonlyRecord<UserId, string> = { [userId]: "Alice" };
  * const entries = objectToEntries(users);
  *
- * expectTypeOf(entries).toEqualTypeOf<ReadonlyArray<[UserId, string]>>();
- * expect(entries).toEqual([[userId, "Alice"]]);
+ * assertType<ReadonlyArray<[UserId, string]>, typeof entries>();
+ * assertEqual(entries, [[userId, "Alice"]]);
  * ```
  */
 export const objectToEntries = (record) => Object.entries(record);
@@ -100,6 +142,8 @@ export const objectToEntries = (record) => Object.entries(record);
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   objectFromEntries,
  *   type Brand,
  *   type ReadonlyRecord,
@@ -111,8 +155,8 @@ export const objectToEntries = (record) => Object.entries(record);
  * ];
  * const users = objectFromEntries(entries);
  *
- * expectTypeOf(users).toEqualTypeOf<ReadonlyRecord<UserId, string>>();
- * expect(users).toEqual({ u1: "Alice" });
+ * assertType<ReadonlyRecord<UserId, string>, typeof users>();
+ * assertEqual(users, { u1: "Alice" });
  * ```
  */
 export const objectFromEntries = (entries) => Object.fromEntries(entries);
@@ -125,17 +169,20 @@ export const objectFromEntries = (entries) => Object.fromEntries(entries);
  * ### Example
  *
  * ```ts
- * import { objectFrom, type ReadonlyRecord } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   objectFrom,
+ *   type ReadonlyRecord,
+ * } from "@evolu/common";
  *
  * const translations = objectFrom(
  *   ["en", "fr"] as const,
  *   (locale): string => `Hello in ${locale}`,
  * );
  *
- * expectTypeOf(translations).toEqualTypeOf<
- *   ReadonlyRecord<"en" | "fr", string>
- * >();
- * expect(translations).toEqual({
+ * assertType<ReadonlyRecord<"en" | "fr", string>, typeof translations>();
+ * assertEqual(translations, {
  *   en: "Hello in en",
  *   fr: "Hello in fr",
  * });
@@ -193,7 +240,7 @@ export const emptyRecord =
  * ### Example
  *
  * ```ts
- * import { getOwnProp } from "@evolu/common";
+ * import { assertEqual, assertType, getOwnProp } from "@evolu/common";
  *
  * interface User {
  *   readonly name: string;
@@ -204,9 +251,9 @@ export const emptyRecord =
  * };
  * const user = getOwnProp(users, "bob");
  *
- * expectTypeOf(user).toEqualTypeOf<User | undefined>();
- * expect(user).toBeUndefined();
- * expect(getOwnProp(users, "toString")).toBeUndefined();
+ * assertType<User | undefined, typeof user>();
+ * assertEqual(user, undefined);
+ * assertEqual(getOwnProp(users, "toString"), undefined);
  * ```
  */
 export const getOwnProp = (record, key) => (Object.hasOwn(record, key) ? record[key] : undefined);

package/dist/src/Option.d.ts

@@ -9,7 +9,16 @@
  * ### Example
  *
  * ```ts
- * import { isNone, isSome, none, type Option, some } from "@evolu/common";
+ * import {
+ *   assert,
+ *   assertSame,
+ *   assertTrue,
+ *   isNone,
+ *   isSome,
+ *   none,
+ *   type Option,
+ *   some,
+ * } from "@evolu/common";
  *
  * const cache = new Map<string, Option<unknown>>();
  *
@@ -19,10 +28,10 @@
  * cache.set("b", some(undefined));
  *
  * const a = get("a");
- * assert(isSome(a));
- * expect(a.value).toBeNull();
- * expect(isSome(get("b"))).toBe(true);
- * expect(isNone(get("c"))).toBe(true);
+ * assert(isSome(a), "Expected Some.");
+ * assertSame(a.value, null);
+ * assertTrue(isSome(get("b")));
+ * assertTrue(isNone(get("c")));
  * ```
  *
  * @module

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

@@ -1 +1 @@
-{"version":3,"file":"Option.d.ts","sourceRoot":"","sources":["../../src/Option.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,sBAAsB;AACtB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAEvC,sBAAsB;AACtB,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;AAEvC,0CAA0C;AAC1C,MAAM,WAAW,IAAI,CAAC,GAAG,CAAC,CAAC,CAAE,SAAQ,KAAK,CAAC,MAAM,CAAC;IAChD,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED,yCAAyC;AACzC,MAAM,WAAW,IAAK,SAAQ,KAAK,CAAC,MAAM,CAAC;CAAG;AAE9C;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,IAC3C,CAAC,SAAS,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEtC,8BAA8B;AAC9B,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,CAAC,KAAG,MAAM,CAAC,CAAC,CAGzC,CAAC;AAEH,oCAAoC;AACpC,eAAO,MAAM,IAAI,EAAE,IAAuB,CAAC;AAE3C,mCAAmC;AACnC,eAAO,MAAM,MAAM,GAAI,CAAC,UAAU,MAAM,CAAC,CAAC,CAAC,KAAG,MAAM,IAAI,IAAI,CAAC,CAAC,CACtC,CAAC;AAEzB,mCAAmC;AACnC,eAAO,MAAM,MAAM,GAAI,CAAC,UAAU,MAAM,CAAC,CAAC,CAAC,KAAG,MAAM,IAAI,IAChC,CAAC;AAEzB;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SACrB,CAAC,GAAG,IAAI,GAAG,SAAS,KAC1B,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAyC,CAAC"}
+{"version":3,"file":"Option.d.ts","sourceRoot":"","sources":["../../src/Option.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,sBAAsB;AACtB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAEvC,sBAAsB;AACtB,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;AAEvC,0CAA0C;AAC1C,MAAM,WAAW,IAAI,CAAC,GAAG,CAAC,CAAC,CAAE,SAAQ,KAAK,CAAC,MAAM,CAAC;IAChD,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED,yCAAyC;AACzC,MAAM,WAAW,IAAK,SAAQ,KAAK,CAAC,MAAM,CAAC;CAAG;AAE9C;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,IAC3C,CAAC,SAAS,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEtC,8BAA8B;AAC9B,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,CAAC,KAAG,MAAM,CAAC,CAAC,CAGzC,CAAC;AAEH,oCAAoC;AACpC,eAAO,MAAM,IAAI,EAAE,IAAuB,CAAC;AAE3C,mCAAmC;AACnC,eAAO,MAAM,MAAM,GAAI,CAAC,UAAU,MAAM,CAAC,CAAC,CAAC,KAAG,MAAM,IAAI,IAAI,CAAC,CAAC,CACtC,CAAC;AAEzB,mCAAmC;AACnC,eAAO,MAAM,MAAM,GAAI,CAAC,UAAU,MAAM,CAAC,CAAC,CAAC,KAAG,MAAM,IAAI,IAChC,CAAC;AAEzB;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SACrB,CAAC,GAAG,IAAI,GAAG,SAAS,KAC1B,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAyC,CAAC"}

package/dist/src/Option.js

@@ -9,7 +9,16 @@
  * ### Example
  *
  * ```ts
- * import { isNone, isSome, none, type Option, some } from "@evolu/common";
+ * import {
+ *   assert,
+ *   assertSame,
+ *   assertTrue,
+ *   isNone,
+ *   isSome,
+ *   none,
+ *   type Option,
+ *   some,
+ * } from "@evolu/common";
  *
  * const cache = new Map<string, Option<unknown>>();
  *
@@ -19,10 +28,10 @@
  * cache.set("b", some(undefined));
  *
  * const a = get("a");
- * assert(isSome(a));
- * expect(a.value).toBeNull();
- * expect(isSome(get("b"))).toBe(true);
- * expect(isNone(get("c"))).toBe(true);
+ * assert(isSome(a), "Expected Some.");
+ * assertSame(a.value, null);
+ * assertTrue(isSome(get("b")));
+ * assertTrue(isNone(get("c")));
  * ```
  *
  * @module

package/dist/src/Order.d.ts

@@ -28,12 +28,12 @@ export type Ordering = -1 | 0 | 1;
  * ### Example
  *
  * ```ts
- * import { createOrder } from "@evolu/common";
+ * import { assertEqual, createOrder } from "@evolu/common";
  *
  * const orderNumber = createOrder<number>((x, y) => x < y);
- * expect(orderNumber(1, 2)).toBe(-1);
- * expect(orderNumber(2, 1)).toBe(1);
- * expect(orderNumber(1, 1)).toBe(0);
+ * assertEqual(orderNumber(1, 2), -1);
+ * assertEqual(orderNumber(2, 1), 1);
+ * assertEqual(orderNumber(1, 1), 0);
  * ```
  */
 export declare const createOrder: <A>(isLessThan: (x: A, y: A) => boolean) => Order<A>;
@@ -43,10 +43,10 @@ export declare const createOrder: <A>(isLessThan: (x: A, y: A) => boolean) => Or
  * ### Example
  *
  * ```ts
- * import { orderNumber, reverseOrder } from "@evolu/common";
+ * import { assertEqual, orderNumber, reverseOrder } from "@evolu/common";
  *
  * const descendingOrderNumber = reverseOrder(orderNumber);
- * expect([3, 1, 2].toSorted(descendingOrderNumber)).toEqual([3, 2, 1]);
+ * assertEqual([3, 1, 2].toSorted(descendingOrderNumber), [3, 2, 1]);
  * ```
  */
 export declare const reverseOrder: <A>(order: Order<A>) => Order<A>;
@@ -56,9 +56,9 @@ export declare const reverseOrder: <A>(order: Order<A>) => Order<A>;
  * ### Example
  *
  * ```ts
- * import { orderString } from "@evolu/common";
+ * import { assertEqual, orderString } from "@evolu/common";
  *
- * expect(["c", "b", "a"].toSorted(orderString)).toEqual(["a", "b", "c"]);
+ * assertEqual(["c", "b", "a"].toSorted(orderString), ["a", "b", "c"]);
  * ```
  */
 export declare const orderString: Order<string>;
@@ -68,9 +68,9 @@ export declare const orderString: Order<string>;
  * ### Example
  *
  * ```ts
- * import { orderNumber } from "@evolu/common";
+ * import { assertEqual, orderNumber } from "@evolu/common";
  *
- * expect([2, 1, 3].toSorted(orderNumber)).toEqual([1, 2, 3]);
+ * assertEqual([2, 1, 3].toSorted(orderNumber), [1, 2, 3]);
  * ```
  */
 export declare const orderNumber: Order<number>;
@@ -80,9 +80,9 @@ export declare const orderNumber: Order<number>;
  * ### Example
  *
  * ```ts
- * import { orderBigInt } from "@evolu/common";
+ * import { assertEqual, orderBigInt } from "@evolu/common";
  *
- * expect([2n, 1n, 3n].toSorted(orderBigInt)).toEqual([1n, 2n, 3n]);
+ * assertEqual([2n, 1n, 3n].toSorted(orderBigInt), [1n, 2n, 3n]);
  * ```
  */
 export declare const orderBigInt: Order<bigint>;

package/dist/src/Order.js

@@ -9,12 +9,12 @@
  * ### Example
  *
  * ```ts
- * import { createOrder } from "@evolu/common";
+ * import { assertEqual, createOrder } from "@evolu/common";
  *
  * const orderNumber = createOrder<number>((x, y) => x < y);
- * expect(orderNumber(1, 2)).toBe(-1);
- * expect(orderNumber(2, 1)).toBe(1);
- * expect(orderNumber(1, 1)).toBe(0);
+ * assertEqual(orderNumber(1, 2), -1);
+ * assertEqual(orderNumber(2, 1), 1);
+ * assertEqual(orderNumber(1, 1), 0);
  * ```
  */
 export const createOrder = (isLessThan) => (x, y) => x === y ? 0 : isLessThan(x, y) ? -1 : 1;
@@ -24,10 +24,10 @@ export const createOrder = (isLessThan) => (x, y) => x === y ? 0 : isLessThan(x,
  * ### Example
  *
  * ```ts
- * import { orderNumber, reverseOrder } from "@evolu/common";
+ * import { assertEqual, orderNumber, reverseOrder } from "@evolu/common";
  *
  * const descendingOrderNumber = reverseOrder(orderNumber);
- * expect([3, 1, 2].toSorted(descendingOrderNumber)).toEqual([3, 2, 1]);
+ * assertEqual([3, 1, 2].toSorted(descendingOrderNumber), [3, 2, 1]);
  * ```
  */
 export const reverseOrder = (order) => (a, b) => order(b, a);
@@ -37,9 +37,9 @@ export const reverseOrder = (order) => (a, b) => order(b, a);
  * ### Example
  *
  * ```ts
- * import { orderString } from "@evolu/common";
+ * import { assertEqual, orderString } from "@evolu/common";
  *
- * expect(["c", "b", "a"].toSorted(orderString)).toEqual(["a", "b", "c"]);
+ * assertEqual(["c", "b", "a"].toSorted(orderString), ["a", "b", "c"]);
  * ```
  */
 export const orderString = /*#__PURE__*/ createOrder((a, b) => a < b);
@@ -49,9 +49,9 @@ export const orderString = /*#__PURE__*/ createOrder((a, b) => a < b);
  * ### Example
  *
  * ```ts
- * import { orderNumber } from "@evolu/common";
+ * import { assertEqual, orderNumber } from "@evolu/common";
  *
- * expect([2, 1, 3].toSorted(orderNumber)).toEqual([1, 2, 3]);
+ * assertEqual([2, 1, 3].toSorted(orderNumber), [1, 2, 3]);
  * ```
  */
 export const orderNumber = /*#__PURE__*/ createOrder((a, b) => a < b);
@@ -61,9 +61,9 @@ export const orderNumber = /*#__PURE__*/ createOrder((a, b) => a < b);
  * ### Example
  *
  * ```ts
- * import { orderBigInt } from "@evolu/common";
+ * import { assertEqual, orderBigInt } from "@evolu/common";
  *
- * expect([2n, 1n, 3n].toSorted(orderBigInt)).toEqual([1n, 2n, 3n]);
+ * assertEqual([2n, 1n, 3n].toSorted(orderBigInt), [1n, 2n, 3n]);
  * ```
  */
 export const orderBigInt = /*#__PURE__*/ createOrder((a, b) => a < b);

package/dist/src/Platform.d.ts

@@ -68,8 +68,8 @@ export interface TestGlobalErrors extends Disposable {
      * Platforms deliver global errors asynchronously and provide no hook for
      * "nothing was reported", so settle emits a sentinel of the same kind and
      * resolves when it arrives. Platform delivery is ordered, so all earlier
-     * errors are recorded by then. Use it to assert absence: `expect(await
-     * unhandledRejections.settle()).toEqual([])`.
+     * errors are recorded by then. Assert absence with `assertEqual(await
+     * unhandledRejections.settle(), [])`.
      */
     readonly settle: () => Promise<ReadonlyArray<unknown>>;
 }

package/dist/src/Platform.js

@@ -104,6 +104,7 @@ const createTestGlobalErrors = (kind) => {
         });
     }
     else {
+        // oxlint-disable-next-line unicorn/prefer-type-error -- An unsupported runtime environment is not an invalid argument type.
         throw new Error(`Unsupported platform global ${errorType} reporting.`);
     }
     return {

package/dist/src/Random.d.ts

@@ -20,6 +20,9 @@ export type RandomNumber = number & Brand<"RandomNumber">;
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertTrue,
+ *   assertType,
  *   createRandom,
  *   testCreateRandom,
  *   type RandomNumber,
@@ -28,14 +31,14 @@ export type RandomNumber = number & Brand<"RandomNumber">;
  * // For apps, use the Math.random-backed implementation.
  * const random = createRandom();
  * const value = random.next();
- * expectTypeOf(value).toEqualTypeOf<RandomNumber>();
- * expect(value).toBeGreaterThanOrEqual(0);
- * expect(value).toBeLessThan(1);
+ * assertType<RandomNumber, typeof value>();
+ * assertTrue(value >= 0);
+ * assertTrue(value < 1);
  *
  * // For tests, use a seed.
  * const firstTestRandom = testCreateRandom("test");
  * const secondTestRandom = testCreateRandom("test");
- * expect(firstTestRandom.next()).toBe(secondTestRandom.next());
+ * assertEqual(firstTestRandom.next(), secondTestRandom.next());
  * ```
  */
 export interface Random {

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

@@ -1 +1 @@
-{"version":3,"file":"Random.d.ts","sourceRoot":"","sources":["../../src/Random.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,IAAI,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,MAAM;IACrB,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,YAAY,CAAC;CACnC;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,oDAAoD;AACpD,eAAO,MAAM,YAAY,QAAO,MAE9B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,qBAAqB,MAKjD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;CAC/B;AAED,uEAAuE;AACvE,eAAO,MAAM,eAAe,QAAO,SAA4B,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,qBAAqB,SAChC,CAAC"}
+{"version":3,"file":"Random.d.ts","sourceRoot":"","sources":["../../src/Random.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,IAAI,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,MAAM;IACrB,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,YAAY,CAAC;CACnC;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,oDAAoD;AACpD,eAAO,MAAM,YAAY,QAAO,MAE9B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,qBAAqB,MAKjD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;CAC/B;AAED,uEAAuE;AACvE,eAAO,MAAM,eAAe,QAAO,SAA4B,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,qBAAqB,SAChC,CAAC"}

package/dist/src/Redacted.d.ts

@@ -27,8 +27,11 @@ import type { Eq } from "./Eq.ts";
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertEqual,
  *   createRedacted,
  *   revealRedacted,
+ *   trySync,
  *   type Brand,
  *   type Redacted,
  * } from "@evolu/common";
@@ -42,11 +45,13 @@ import type { Eq } from "./Eq.ts";
  * using redactedKey: RedactedApiKey = createRedacted(apiKey);
  * const fetchUser = (key: RedactedApiKey): ApiKey => revealRedacted(key);
  *
- * expect(redactedKey.toString()).toBe("<redacted>");
- * expect(JSON.stringify({ apiKey: redactedKey })).toBe(
+ * // oxlint-disable-next-line typescript/no-base-to-string -- Redacted intentionally implements a safe custom toString.
+ * assertEqual(redactedKey.toString(), "<redacted>");
+ * assertEqual(
+ *   JSON.stringify({ apiKey: redactedKey }),
  *   '{"apiKey":"<redacted>"}',
  * );
- * expect(fetchUser(redactedKey)).toBe(apiKey);
+ * assertEqual(fetchUser(redactedKey), apiKey);
  *
  * using password = createRedacted("password" as DbPassword);
  * // @ts-expect-error Redacted secrets retain their distinct branded types.
@@ -57,7 +62,7 @@ import type { Eq } from "./Eq.ts";
  *   return key;
  * })();
  * // Leaving the `using` scope removes the value from memory.
- * expect(() => revealRedacted(disposedKey)).toThrow();
+ * assertErr(trySync(() => revealRedacted(disposedKey)));
  * ```
  */
 export interface Redacted<A> extends Brand<"Redacted">, Disposable {
@@ -84,6 +89,8 @@ export declare const isRedacted: (value: unknown) => value is Redacted<unknown>;
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertTrue,
  *   createEqRedacted,
  *   createRedacted,
  *   eqString,
@@ -98,8 +105,8 @@ export declare const isRedacted: (value: unknown) => value is Redacted<unknown>;
  * using b = createRedacted("x" as ApiKey);
  * using c = createRedacted("y" as ApiKey);
  *
- * expect(eqRedactedApiKey(a, b)).toBe(true);
- * expect(eqRedactedApiKey(a, c)).toBe(false);
+ * assertTrue(eqRedactedApiKey(a, b));
+ * assertFalse(eqRedactedApiKey(a, c));
  * ```
  */
 export declare const createEqRedacted: <A>(eq: Eq<A>) => Eq<Redacted<A>>;

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

@@ -1 +1 @@
-{"version":3,"file":"Redacted.d.ts","sourceRoot":"","sources":["../../src/Redacted.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,CAAE,SAAQ,KAAK,CAAC,UAAU,CAAC,EAAE,UAAU;IAChE,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;CAClB;AAED,gEAAgE;AAChE,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,CAAC,KAAG,QAAQ,CAAC,CAAC,CAItD,CAAC;AAaF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,YAAY,QAAQ,CAAC,CAAC,CAAC,KAAG,CAGzD,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAAQ,CAAC,OAAO,CAG7B,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,gBAAgB,GAC1B,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,KAAG,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAEY,CAAC"}
+{"version":3,"file":"Redacted.d.ts","sourceRoot":"","sources":["../../src/Redacted.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,CAAE,SAAQ,KAAK,CAAC,UAAU,CAAC,EAAE,UAAU;IAChE,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;CAClB;AAED,gEAAgE;AAChE,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,CAAC,KAAG,QAAQ,CAAC,CAAC,CAItD,CAAC;AAaF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,YAAY,QAAQ,CAAC,CAAC,CAAC,KAAG,CAGzD,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAAQ,CAAC,OAAO,CAG7B,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gBAAgB,GAC1B,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,KAAG,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAEY,CAAC"}

package/dist/src/Redacted.js

@@ -43,6 +43,8 @@ export const isRedacted = (value) => typeof value === "object" &&
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertTrue,
  *   createEqRedacted,
  *   createRedacted,
  *   eqString,
@@ -57,8 +59,8 @@ export const isRedacted = (value) => typeof value === "object" &&
  * using b = createRedacted("x" as ApiKey);
  * using c = createRedacted("y" as ApiKey);
  *
- * expect(eqRedactedApiKey(a, b)).toBe(true);
- * expect(eqRedactedApiKey(a, c)).toBe(false);
+ * assertTrue(eqRedactedApiKey(a, b));
+ * assertFalse(eqRedactedApiKey(a, c));
  * ```
  */
 export const createEqRedacted = (eq) => (x, y) => eq(revealRedacted(x), revealRedacted(y));

package/dist/src/Ref.d.ts

@@ -18,18 +18,18 @@
  * ### Example
  *
  * ```ts
- * import { createRef } from "@evolu/common";
+ * import { assertEqual, createRef } from "@evolu/common";
  *
  * const count = createRef(0);
  * count.set(1);
  * count.update((n) => n + 1);
- * expect(count.get()).toBe(2);
+ * assertEqual(count.get(), 2);
  * ```
  *
  * ### As a dependency
  *
  * ```ts
- * import { createRef, type Ref } from "@evolu/common";
+ * import { assertEqual, createRef, type Ref } from "@evolu/common";
  *
  * interface CounterRefDep {
  *   readonly counterRef: Ref<number>;
@@ -37,7 +37,7 @@
  *
  * const deps: CounterRefDep = { counterRef: createRef(0) };
  * deps.counterRef.update((count) => count + 1);
- * expect(deps.counterRef.get()).toBe(1);
+ * assertEqual(deps.counterRef.get(), 1);
  * ```
  */
 export interface Ref<T> {

package/dist/src/Relation.d.ts

@@ -40,7 +40,7 @@ import { NonNegativeInt, PositiveInt } from "./Type.ts";
  * Use the default identity semantics.
  *
  * ```ts
- * import { createRelation } from "@evolu/common";
+ * import { assertFalse, assertTrue, createRelation } from "@evolu/common";
  *
  * interface Socket {
  *   readonly id: string;
@@ -51,8 +51,8 @@ import { NonNegativeInt, PositiveInt } from "./Type.ts";
  *
  * relation.add(socket, "owner-1");
  *
- * expect(relation.has(socket, "owner-1")).toBe(true);
- * expect(relation.has({ id: "socket-1" }, "owner-1")).toBe(false);
+ * assertTrue(relation.has(socket, "owner-1"));
+ * assertFalse(relation.has({ id: "socket-1" }, "owner-1"));
  * ```
  *
  * ### Lookup-derived equality
@@ -60,7 +60,7 @@ import { NonNegativeInt, PositiveInt } from "./Type.ts";
  * Use lookup-derived equality.
  *
  * ```ts
- * import { createRelation } from "@evolu/common";
+ * import { assertTrue, createRelation } from "@evolu/common";
  *
  * interface Person {
  *   readonly id: string;
@@ -74,9 +74,7 @@ import { NonNegativeInt, PositiveInt } from "./Type.ts";
  *
  * relation.add({ id: "1", name: "Ada" }, { id: "admins" });
  *
- * expect(relation.has({ id: "1", name: "Grace" }, { id: "admins" })).toBe(
- *   true,
- * );
+ * assertTrue(relation.has({ id: "1", name: "Grace" }, { id: "admins" }));
  * ```
  *
  * @see {@link createRelation}

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

@@ -1 +1 @@
-{"version":3,"file":"Relation.d.ts","sourceRoot":"","sources":["../../src/Relation.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Relation.d.ts","sourceRoot":"","sources":["../../src/Relation.ts"],"names":[],"mappings":"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"}