@evolu/common 8.4.0 → 8.6.0

package/dist/src/Array.d.ts

@@ -16,13 +16,16 @@
  * to track:
  *
  * ```ts
- * const sortScores = (arr: number[]) => arr.sort((a, b) => a - b);
+ * import { assertEqual, assertSame } from "@evolu/common";
+ *
+ * // oxlint-disable-next-line unicorn/no-array-sort -- This example intentionally demonstrates mutating Array.sort.
+ * const sortScores = (arr: Array<number>) => arr.sort((a, b) => a - b);
  *
  * const scores = [3, 1, 2];
  * const leaderboard = sortScores(scores);
- * expect(leaderboard).toEqual([1, 2, 3]);
- * expect(scores).toEqual([1, 2, 3]);
- * expect(leaderboard).toBe(scores);
+ * assertEqual(leaderboard, [1, 2, 3]);
+ * assertEqual(scores, [1, 2, 3]);
+ * assertSame(leaderboard, scores);
  * ```
  *
  * Imagine every method doing that.
@@ -31,30 +34,35 @@
  * instead:
  *
  * ```ts
- * import { sortArray } from "@evolu/common";
+ * import { assertEqual, assertTrue, sortArray } from "@evolu/common";
  *
  * const sortScores = (arr: ReadonlyArray<number>) =>
  *   sortArray(arr, (a, b) => a - b);
  *
  * const scores: ReadonlyArray<number> = [3, 1, 2];
  * const leaderboard = sortScores(scores);
- * expect(leaderboard).toEqual([1, 2, 3]);
- * expect(scores).toEqual([3, 1, 2]);
- * expect(leaderboard).not.toBe(scores);
+ * assertEqual(leaderboard, [1, 2, 3]);
+ * assertEqual(scores, [3, 1, 2]);
+ * assertTrue(leaderboard !== scores);
  * ```
  *
  * Even better, require a {@link NonEmptyReadonlyArray} — there's nothing to sort
  * if the array is empty anyway:
  *
  * ```ts
- * import { sortArray, type NonEmptyReadonlyArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   sortArray,
+ *   type NonEmptyReadonlyArray,
+ * } from "@evolu/common";
  *
  * const sortScores = (arr: NonEmptyReadonlyArray<number>) =>
  *   sortArray(arr, (a, b) => a - b);
  *
  * const leaderboard = sortScores([3, 1, 2]);
- * expect(leaderboard).toEqual([1, 2, 3]);
- * expectTypeOf(leaderboard).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
+ * assertEqual(leaderboard, [1, 2, 3]);
+ * assertType<NonEmptyReadonlyArray<number>, typeof leaderboard>();
  * ```
  *
  * Sorting an empty array isn't expensive, but functions can have side effects
@@ -68,13 +76,16 @@
  * readonly arrays without mutation — use them directly.
  *
  * ```ts
- * import { type NonEmptyReadonlyArray } from "@evolu/common";
+ * import { assertEqual, type NonEmptyReadonlyArray } from "@evolu/common";
  *
  * const valid: NonEmptyReadonlyArray<number> = [1, 2, 3];
  * // @ts-expect-error An empty array is not non-empty.
- * const invalid: NonEmptyReadonlyArray<number> = [];
+ * const _invalid: NonEmptyReadonlyArray<number> = [];
  *
- * expect(valid.find((value) => value === 2)).toBe(2);
+ * assertEqual(
+ *   valid.find((value) => value === 2),
+ *   2,
+ * );
  * ```
  *
  * ## Composition
@@ -83,7 +94,7 @@
  * because it's natural for single operations:
  *
  * ```ts
- * import { mapArray } from "@evolu/common";
+ * import { assertEqual, mapArray } from "@evolu/common";
  *
  * interface Message {
  *   readonly timestamp: number;
@@ -94,7 +105,7 @@
  *   { timestamp: 20 },
  * ];
  * const timestamps = mapArray(messages, (m) => m.timestamp);
- * expect(timestamps).toEqual([10, 20]);
+ * assertEqual(timestamps, [10, 20]);
  * ```
  *
  * Data-first style also reads well for a few operations, often fitting on a
@@ -102,6 +113,7 @@
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   dedupeArray,
  *   filterArray,
  *   firstInArray,
@@ -113,11 +125,11 @@
  * } from "@evolu/common";
  *
  * const cheapest = firstInArray(sortArray([30, 10, 20], orderNumber));
- * expect(cheapest).toBe(10);
+ * assertEqual(cheapest, 10);
  *
  * const users = [{ name: "Ada" }, { name: "Linus" }, { name: "Ada" }];
  * const uniqueNames = dedupeArray(mapArray(users, (u) => u.name));
- * expect(uniqueNames).toEqual(["Ada", "Linus"]);
+ * assertEqual(uniqueNames, ["Ada", "Linus"]);
  *
  * const jobs = [
  *   { id: 1, done: false },
@@ -127,7 +139,7 @@
  * if (!isNonEmptyArray(completedJobs)) throw new Error("Expected a job");
  * const latestDone = lastInArray(completedJobs);
  *
- * expect(latestDone).toEqual({ id: 2, done: true });
+ * assertEqual(latestDone, { id: 2, done: true });
  * ```
  *
  * For more operations, create a function like `getOldestActiveUser` or a
@@ -168,6 +180,34 @@ export type AtLeastTwoReadonlyArray<T> = readonly [T, T, ...ReadonlyArray<T>];
  * @group Constants
  */
 export declare const emptyArray: ReadonlyArray<never>;
+/**
+ * Creates a mutable sparse Array with the specified length.
+ *
+ * Use it to build an Array with indexed writes when its final length is known.
+ * Assign every index before exposing the completed Array as readonly.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   createMutableArray,
+ * } from "@evolu/common";
+ *
+ * const values = createMutableArray<number>(3);
+ *
+ * for (let index = 0; index < values.length; index++) {
+ *   values[index] = index * 10;
+ * }
+ *
+ * assertEqual(values, [0, 10, 20]);
+ * assertType<Array<number>, typeof values>();
+ * ```
+ *
+ * @group Constructors
+ */
+export declare const createMutableArray: <T>(length: number) => Array<T>;
 /**
  * Better `Array.from`.
  *
@@ -179,16 +219,24 @@ export declare const emptyArray: ReadonlyArray<never>;
  * ### Creating from iterables and lengths
  *
  * ```ts
- * import { arrayFrom } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertSame,
+ *   assertType,
+ *   arrayFrom,
+ * } from "@evolu/common";
  *
  * const fromSet = arrayFrom(new Set([1, 2, 3]));
- * expect(fromSet).toEqual([1, 2, 3]);
- * expectTypeOf(fromSet).toEqualTypeOf<ReadonlyArray<number>>();
+ * assertEqual(fromSet, [1, 2, 3]);
+ * assertType<ReadonlyArray<number>, typeof fromSet>();
  *
- * expect(arrayFrom(3, (i) => i * 10)).toEqual([0, 10, 20]);
+ * assertEqual(
+ *   arrayFrom(3, (i) => i * 10),
+ *   [0, 10, 20],
+ * );
  *
  * const existing: ReadonlyArray<number> = [1, 2, 3];
- * expect(arrayFrom(existing)).toBe(existing);
+ * assertSame(arrayFrom(existing), existing);
  * ```
  *
  * Unlike `Array.from`, there's no map parameter for iterables — use
@@ -210,19 +258,24 @@ export declare function arrayFrom<T>(length: number, map: (index: number) => T):
  * ### Awaiting sync and async iterables
  *
  * ```ts
- * import { arrayFromAsync } from "@evolu/common";
+ * import { assertEqual, assertType, arrayFromAsync } from "@evolu/common";
  *
- * const fromIterable = await arrayFromAsync(new Set([1, 2, 3]));
- * expect(fromIterable).toEqual([1, 2, 3]);
+ * const fromIterable = await arrayFromAsync([
+ *   Promise.resolve(1),
+ *   Promise.resolve(2),
+ *   Promise.resolve(3),
+ * ]);
+ * assertEqual(fromIterable, [1, 2, 3]);
  *
  * const fromAsyncIterable = await arrayFromAsync(
- *   (async function* () {
- *     yield Promise.resolve(1);
- *     yield Promise.resolve(2);
+ *   (async function* (): AsyncGenerator<number> {
+ *     await Promise.resolve();
+ *     yield 1;
+ *     yield 2;
  *   })(),
  * );
- * expect(fromAsyncIterable).toEqual([1, 2]);
- * expectTypeOf(fromAsyncIterable).toEqualTypeOf<ReadonlyArray<number>>();
+ * assertEqual(fromAsyncIterable, [1, 2]);
+ * assertType<ReadonlyArray<number>, typeof fromAsyncIterable>();
  * ```
  *
  * Unlike `Array.fromAsync`, there's no map parameter — map the result with
@@ -245,6 +298,8 @@ export declare const arrayFromAsync: <T>(iterable: AsyncIterable<T> | Iterable<T
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   firstInArray,
  *   isNonEmptyArray,
  *   type NonEmptyArray,
@@ -257,9 +312,9 @@ export declare const arrayFromAsync: <T>(iterable: AsyncIterable<T> | Iterable<T
  *   throw new Error("Expected values");
  * }
  *
- * expectTypeOf(mutable).toEqualTypeOf<NonEmptyArray<number>>();
- * expectTypeOf(readonly).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
- * expect(firstInArray(readonly)).toBe(1);
+ * assertType<NonEmptyArray<number>, typeof mutable>();
+ * assertType<NonEmptyReadonlyArray<number>, typeof readonly>();
+ * assertEqual(firstInArray(readonly), 1);
  * ```
  *
  * @group Types
@@ -274,13 +329,15 @@ export declare function isNonEmptyArray<T>(array: ReadonlyArray<T>): array is No
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   appendToArray,
  *   type NonEmptyReadonlyArray,
  * } from "@evolu/common";
  *
  * const values = appendToArray([1, 2, 3], 4);
- * expect(values).toEqual([1, 2, 3, 4]);
- * expectTypeOf(values).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
+ * assertEqual(values, [1, 2, 3, 4]);
+ * assertType<NonEmptyReadonlyArray<number>, typeof values>();
  * ```
  *
  * @group Transformations
@@ -293,13 +350,15 @@ export declare const appendToArray: <T>(array: ReadonlyArray<T>, item: T) => Non
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   prependToArray,
  *   type NonEmptyReadonlyArray,
  * } from "@evolu/common";
  *
  * const values = prependToArray([2, 3], 1);
- * expect(values).toEqual([1, 2, 3]);
- * expectTypeOf(values).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
+ * assertEqual(values, [1, 2, 3]);
+ * assertType<NonEmptyReadonlyArray<number>, typeof values>();
  * ```
  *
  * @group Transformations
@@ -313,17 +372,21 @@ export declare const prependToArray: <T>(array: ReadonlyArray<T>, item: T) => No
  * ### Mapping with indexes while preserving non-emptiness
  *
  * ```ts
- * import { mapArray, type NonEmptyReadonlyArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   mapArray,
+ *   type NonEmptyReadonlyArray,
+ * } from "@evolu/common";
  *
  * const values: ReadonlyArray<number> = [1, 2, 3];
  * const indexed = mapArray(values, (value, index) => value + index);
- * expect(indexed).toEqual([1, 3, 5]);
- * expectTypeOf(indexed).toEqualTypeOf<ReadonlyArray<number>>();
+ * assertEqual(indexed, [1, 3, 5]);
+ * assertType<ReadonlyArray<number>, typeof indexed>();
  *
  * const nonEmpty: NonEmptyReadonlyArray<number> = [1, 2, 3];
- * expectTypeOf(mapArray(nonEmpty, (x) => x * 2)).toEqualTypeOf<
- *   NonEmptyReadonlyArray<number>
- * >();
+ * const doubled = mapArray(nonEmpty, (x) => x * 2);
+ * assertType<NonEmptyReadonlyArray<number>, typeof doubled>();
  * ```
  *
  * The mapper receives `(item, index, array)`, matching native `Array.map`.
@@ -343,7 +406,12 @@ export declare function mapArray<T, U>(array: ReadonlyArray<T>, mapper: (item: T
  * ### Flattening and expanding values
  *
  * ```ts
- * import { flatMapArray, type NonEmptyReadonlyArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   flatMapArray,
+ *   type NonEmptyReadonlyArray,
+ * } from "@evolu/common";
  *
  * const flattened = flatMapArray([
  *   [1, 2],
@@ -354,9 +422,9 @@ export declare function mapArray<T, U>(array: ReadonlyArray<T>, mapper: (item: T
  *   values,
  *   (value, index): NonEmptyReadonlyArray<number> => [value, index],
  * );
- * expect(flattened).toEqual([1, 2, 3, 4]);
- * expectTypeOf(expanded).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
- * expect(expanded).toEqual([1, 0, 2, 1, 3, 2]);
+ * assertEqual(flattened, [1, 2, 3, 4]);
+ * assertType<NonEmptyReadonlyArray<number>, typeof expanded>();
+ * assertEqual(expanded, [1, 0, 2, 1, 3, 2]);
  * ```
  *
  * ### Filter and map in one pass
@@ -364,7 +432,7 @@ export declare function mapArray<T, U>(array: ReadonlyArray<T>, mapper: (item: T
  * Return `[]` to filter out, `[value]` to keep:
  *
  * ```ts
- * import { err, flatMapArray, ok } from "@evolu/common";
+ * import { assertEqual, err, flatMapArray, ok } from "@evolu/common";
  *
  * const validate = (value: number) =>
  *   value > 0 ? ok(value) : err(`${value} is not positive`);
@@ -373,7 +441,7 @@ export declare function mapArray<T, U>(array: ReadonlyArray<T>, mapper: (item: T
  *   const result = validate(f);
  *   return result.ok ? [] : [result.error];
  * });
- * expect(errors).toEqual(["-2 is not positive", "-4 is not positive"]);
+ * assertEqual(errors, ["-2 is not positive", "-4 is not positive"]);
  * ```
  *
  * The mapper receives `(item, index, array)`, matching native `Array.flatMap`.
@@ -395,16 +463,21 @@ export declare function flatMapArray<T, U>(array: ReadonlyArray<T>, mapper: (ite
  * ### Concatenating non-empty inputs
  *
  * ```ts
- * import { concatArrays, type NonEmptyReadonlyArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   concatArrays,
+ *   type NonEmptyReadonlyArray,
+ * } from "@evolu/common";
  *
  * const nonEmpty: NonEmptyReadonlyArray<number> = [1];
  * const joined = concatArrays([1, 2], [3, 4]);
  * const fromLeft = concatArrays(nonEmpty, []);
  * const fromRight = concatArrays([], nonEmpty);
  *
- * expect(joined).toEqual([1, 2, 3, 4]);
- * expectTypeOf(fromLeft).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
- * expectTypeOf(fromRight).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
+ * assertEqual(joined, [1, 2, 3, 4]);
+ * assertType<NonEmptyReadonlyArray<number>, typeof fromLeft>();
+ * assertType<NonEmptyReadonlyArray<number>, typeof fromRight>();
  * ```
  *
  * @group Transformations
@@ -425,16 +498,18 @@ export declare function concatArrays<T>(first: ReadonlyArray<T>, second: Readonl
  * ### With predicate
  *
  * ```ts
- * import { filterArray } from "@evolu/common";
+ * import { assertEqual, filterArray } from "@evolu/common";
  *
  * const evens = filterArray([1, 2, 3, 4, 5], (x) => x % 2 === 0);
- * expect(evens).toEqual([2, 4]);
+ * assertEqual(evens, [2, 4]);
  * ```
  *
  * ### With refinement
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   filterArray,
  *   NonEmptyTrimmedString,
  *   PositiveInt,
@@ -445,8 +520,8 @@ export declare function concatArrays<T>(first: ReadonlyArray<T>, second: Readonl
  *   PositiveInt.orThrow(42),
  * ];
  * const positiveInts = filterArray(mixed, PositiveInt.is);
- * expect(positiveInts).toEqual([42]);
- * expectTypeOf(positiveInts).toEqualTypeOf<ReadonlyArray<PositiveInt>>();
+ * assertEqual(positiveInts, [42]);
+ * assertType<ReadonlyArray<PositiveInt>, typeof positiveInts>();
  * ```
  *
  * The predicate receives `(item, index, array)`, matching native
@@ -467,7 +542,12 @@ export declare function filterArray<T>(array: ReadonlyArray<T>, predicate: (item
  * ### Deduplicating by value or key
  *
  * ```ts
- * import { dedupeArray, type NonEmptyReadonlyArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   dedupeArray,
+ *   type NonEmptyReadonlyArray,
+ * } from "@evolu/common";
  *
  * const numbers = dedupeArray([1, 2, 1, 3, 2]);
  * const people = dedupeArray(
@@ -478,9 +558,9 @@ export declare function filterArray<T>(array: ReadonlyArray<T>, predicate: (item
  *   ],
  *   (item) => item.id,
  * );
- * expectTypeOf(numbers).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
- * expect(numbers).toEqual([1, 2, 3]);
- * expect(people).toEqual([
+ * assertType<NonEmptyReadonlyArray<number>, typeof numbers>();
+ * assertEqual(numbers, [1, 2, 3]);
+ * assertEqual(people, [
  *   { id: 1, name: "Alice" },
  *   { id: 2, name: "Bob" },
  * ]);
@@ -505,20 +585,22 @@ export declare function dedupeArray<T>(array: ReadonlyArray<T>, by?: (item: T) =
  * ### With predicate
  *
  * ```ts
- * import { partitionArray } from "@evolu/common";
+ * import { assertEqual, partitionArray } from "@evolu/common";
  *
  * const [evens, odds] = partitionArray(
  *   [1, 2, 3, 4, 5],
  *   (x) => x % 2 === 0,
  * );
- * expect(evens).toEqual([2, 4]);
- * expect(odds).toEqual([1, 3, 5]);
+ * assertEqual(evens, [2, 4]);
+ * assertEqual(odds, [1, 3, 5]);
  * ```
  *
  * ### With refinement
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   NonEmptyTrimmedString,
  *   partitionArray,
  *   PositiveInt,
@@ -529,11 +611,9 @@ export declare function dedupeArray<T>(array: ReadonlyArray<T>, by?: (item: T) =
  *   PositiveInt.orThrow(42),
  * ];
  * const [positiveInts, strings] = partitionArray(mixed, PositiveInt.is);
- * expect(positiveInts).toEqual([42]);
- * expectTypeOf(positiveInts).toEqualTypeOf<ReadonlyArray<PositiveInt>>();
- * expectTypeOf(strings).toEqualTypeOf<
- *   ReadonlyArray<NonEmptyTrimmedString>
- * >();
+ * assertEqual(positiveInts, [42]);
+ * assertType<ReadonlyArray<PositiveInt>, typeof positiveInts>();
+ * assertType<ReadonlyArray<NonEmptyTrimmedString>, typeof strings>();
  * ```
  *
  * The predicate receives `(item, index, array)`.
@@ -551,12 +631,17 @@ export declare function partitionArray<T>(array: ReadonlyArray<T>, predicate: (i
  * ### Sorting without mutation
  *
  * ```ts
- * import { sortArray, type NonEmptyReadonlyArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   sortArray,
+ *   type NonEmptyReadonlyArray,
+ * } from "@evolu/common";
  *
  * const values: NonEmptyReadonlyArray<number> = [3, 1, 2];
  * const sorted = sortArray(values, (a, b) => a - b);
- * expect(sorted).toEqual([1, 2, 3]);
- * expectTypeOf(sorted).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
+ * assertEqual(sorted, [1, 2, 3]);
+ * assertType<NonEmptyReadonlyArray<number>, typeof sorted>();
  * ```
  *
  * @group Transformations
@@ -572,12 +657,17 @@ export declare function sortArray<T>(array: ReadonlyArray<T>, compareFn?: (a: T,
  * ### Reversing without mutation
  *
  * ```ts
- * import { reverseArray, type NonEmptyReadonlyArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   reverseArray,
+ *   type NonEmptyReadonlyArray,
+ * } from "@evolu/common";
  *
  * const values: NonEmptyReadonlyArray<number> = [1, 2, 3];
  * const reversed = reverseArray(values);
- * expect(reversed).toEqual([3, 2, 1]);
- * expectTypeOf(reversed).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
+ * assertEqual(reversed, [3, 2, 1]);
+ * assertType<NonEmptyReadonlyArray<number>, typeof reversed>();
  * ```
  *
  * @group Transformations
@@ -593,12 +683,12 @@ export declare function reverseArray<T>(array: ReadonlyArray<T>): ReadonlyArray<
  * ### Removing and replacing values
  *
  * ```ts
- * import { spliceArray } from "@evolu/common";
+ * import { assertEqual, spliceArray } from "@evolu/common";
  *
  * const values: ReadonlyArray<number> = [1, 2, 3, 4];
- * expect(spliceArray(values, 1, 2)).toEqual([1, 4]);
- * expect(spliceArray([1, 2, 3], 1, 1, 10, 11)).toEqual([1, 10, 11, 3]);
- * expect(values).toEqual([1, 2, 3, 4]);
+ * assertEqual(spliceArray(values, 1, 2), [1, 4]);
+ * assertEqual(spliceArray([1, 2, 3], 1, 1, 10, 11), [1, 10, 11, 3]);
+ * assertEqual(values, [1, 2, 3, 4]);
  * ```
  *
  * @group Transformations
@@ -623,29 +713,36 @@ export type ZipArrayResult<T extends ReadonlyArray<ReadonlyArray<unknown>>> = {
  * ### Zipping to the shortest input
  *
  * ```ts
- * import { zipArray, type NonEmptyReadonlyArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   zipArray,
+ *   type NonEmptyReadonlyArray,
+ * } from "@evolu/common";
  *
  * const pairs = zipArray([
  *   [1, 2, 3],
  *   ["a", "b", "c"],
  * ]);
- * expect(pairs).toEqual([
+ * assertEqual(pairs, [
  *   [1, "a"],
  *   [2, "b"],
  *   [3, "c"],
  * ]);
- * expect(
+ * assertEqual(
  *   zipArray([
  *     [1, 2],
  *     ["a", "b", "c"],
  *     [true, false],
  *   ]),
- * ).toEqual([
- *   [1, "a", true],
- *   [2, "b", false],
- * ]);
- * expectTypeOf(pairs).toEqualTypeOf<
- *   NonEmptyReadonlyArray<Readonly<[number, string]>>
+ *   [
+ *     [1, "a", true],
+ *     [2, "b", false],
+ *   ],
+ * );
+ * assertType<
+ *   NonEmptyReadonlyArray<Readonly<[number, string]>>,
+ *   typeof pairs
  * >();
  * ```
  *
@@ -660,9 +757,9 @@ export declare function zipArray<const T extends ReadonlyArray<ReadonlyArray<unk
  * ### Reading the first value
  *
  * ```ts
- * import { firstInArray } from "@evolu/common";
+ * import { assertEqual, firstInArray } from "@evolu/common";
  *
- * expect(firstInArray(["a", "b", "c"])).toBe("a");
+ * assertEqual(firstInArray(["a", "b", "c"]), "a");
  * ```
  *
  * @group Accessors
@@ -674,9 +771,9 @@ export declare const firstInArray: <T>(array: NonEmptyReadonlyArray<T>) => T;
  * ### Reading the last value
  *
  * ```ts
- * import { lastInArray } from "@evolu/common";
+ * import { assertEqual, lastInArray } from "@evolu/common";
  *
- * expect(lastInArray(["a", "b", "c"])).toBe("c");
+ * assertEqual(lastInArray(["a", "b", "c"]), "c");
  * ```
  *
  * @group Accessors

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

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