@evolu/common 8.6.2 → 8.8.0

package/src/Microtask.test.ts

@@ -0,0 +1,140 @@
+import { describe, it } from "node:test";
+import { assertEqual, assertThrowsInstanceOf, assertTrue } from "./Assert.ts";
+
+import { createMicrotaskBatch } from "./Microtask.ts";
+
+describe("createMicrotaskBatch", () => {
+  it("coalesces multiple pushes in one tick into one flush", async () => {
+    const flushed: Array<ReadonlyArray<number>> = [];
+    const batch = createMicrotaskBatch<number>((items) => {
+      flushed.push(items);
+    });
+
+    batch.push(1);
+    batch.push(2);
+
+    assertEqual(flushed, []);
+
+    await Promise.resolve();
+
+    assertEqual(flushed, [[1, 2]]);
+  });
+
+  it("flushNow flushes immediately and pending microtask becomes no-op", async () => {
+    const flushed: Array<ReadonlyArray<number>> = [];
+    const batch = createMicrotaskBatch<number>((items) => {
+      flushed.push(items);
+    });
+
+    batch.push(1);
+    batch.flushNow();
+
+    assertEqual(flushed, [[1]]);
+
+    await Promise.resolve();
+
+    assertEqual(flushed, [[1]]);
+
+    batch.push(2);
+    await Promise.resolve();
+
+    assertEqual(flushed, [[1], [2]]);
+  });
+
+  it("flushNow on empty queue does nothing", () => {
+    const flushed: Array<ReadonlyArray<number>> = [];
+    const batch = createMicrotaskBatch<number>((items) => {
+      flushed.push(items);
+    });
+
+    batch.flushNow();
+
+    assertEqual(flushed, []);
+  });
+
+  it("passes snapshot so previous flushed arrays stay unchanged", async () => {
+    const flushed: Array<ReadonlyArray<number>> = [];
+    const batch = createMicrotaskBatch<number>((items) => {
+      flushed.push(items);
+    });
+
+    batch.push(1);
+    batch.push(2);
+    await Promise.resolve();
+
+    batch.push(3);
+    await Promise.resolve();
+
+    assertEqual(flushed[0], [1, 2]);
+    assertEqual(flushed[1], [3]);
+  });
+
+  it("reentrant push during onFlush is processed in next microtask", async () => {
+    const flushed: Array<ReadonlyArray<number>> = [];
+    const batch = createMicrotaskBatch<number>((items) => {
+      flushed.push(items);
+      if (items[0] === 1) {
+        batch.push(2);
+      }
+    });
+
+    batch.push(1);
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    assertEqual(flushed, [[1], [2]]);
+  });
+
+  it("dispose cancels queued flush", async () => {
+    const flushed: Array<ReadonlyArray<number>> = [];
+    const batch = createMicrotaskBatch<number>((items) => {
+      flushed.push(items);
+    });
+
+    batch.push(1);
+    batch[Symbol.dispose]();
+
+    await Promise.resolve();
+
+    assertEqual(flushed, []);
+  });
+
+  it("push and flushNow throw after dispose", async () => {
+    const flushed: Array<ReadonlyArray<number>> = [];
+    const batch = createMicrotaskBatch<number>((items) => {
+      flushed.push(items);
+    });
+
+    batch[Symbol.dispose]();
+
+    const pushError = assertThrowsInstanceOf(() => {
+      batch.push(1);
+    }, Error);
+    assertTrue(pushError.message.includes("Cannot use a disposed object."));
+
+    const flushNowError = assertThrowsInstanceOf(() => {
+      batch.flushNow();
+    }, Error);
+    assertTrue(flushNowError.message.includes("Cannot use a disposed object."));
+
+    await Promise.resolve();
+
+    assertEqual(flushed, []);
+  });
+
+  it("dispose is idempotent", async () => {
+    const flushed: Array<ReadonlyArray<number>> = [];
+    const batch = createMicrotaskBatch<number>((items) => {
+      flushed.push(items);
+    });
+
+    batch.push(1);
+    batch[Symbol.dispose]();
+    batch[Symbol.dispose]();
+
+    await Promise.resolve();
+
+    assertEqual(flushed, []);
+  });
+});

package/src/Number.test.ts

@@ -0,0 +1,218 @@
+import { test } from "node:test";
+import {
+  assertEqual,
+  assertFalse,
+  assertOk,
+  assertSame,
+  assertTrue,
+} from "./Assert.ts";
+
+import {
+  clamp,
+  computeBalancedBuckets,
+  decrement,
+  fibonacciAt,
+  FibonacciIndex,
+  increment,
+  type Int0To100OrNonNegativeInt,
+  type Int1To100,
+  type Int1To100OrPositiveInt,
+  type Int1To99,
+  isBetween,
+  max,
+  min,
+  type Percentage,
+  PercentageLiteral,
+  percentageToRatio,
+} from "./Number.ts";
+import { err, ok } from "./Result.ts";
+import { assertType, NonNegativeInt, PositiveInt, Ratio } from "./Type.ts";
+
+test("bounded integer literal types", () => {
+  assertType<1 extends Int1To99 ? true : false, true>();
+  assertType<50 extends Int1To99 ? true : false, true>();
+  assertType<99 extends Int1To99 ? true : false, true>();
+  assertType<0 extends Int1To99 ? true : false, false>();
+  assertType<100 extends Int1To99 ? true : false, false>();
+  assertType<"1" extends Int1To99 ? true : false, false>();
+
+  assertType<1 extends Int1To100 ? true : false, true>();
+  assertType<100 extends Int1To100 ? true : false, true>();
+  assertType<0 extends Int1To100 ? true : false, false>();
+  assertType<101 extends Int1To100 ? true : false, false>();
+
+  assertType<0 extends Int0To100OrNonNegativeInt ? true : false, true>();
+  assertType<100 extends Int0To100OrNonNegativeInt ? true : false, true>();
+  assertType<
+    NonNegativeInt extends Int0To100OrNonNegativeInt ? true : false,
+    true
+  >();
+
+  assertType<1 extends Int1To100OrPositiveInt ? true : false, true>();
+  assertType<100 extends Int1To100OrPositiveInt ? true : false, true>();
+  assertType<PositiveInt extends Int1To100OrPositiveInt ? true : false, true>();
+});
+
+test("Percentage accepts canonical literals or Ratio", () => {
+  assertType<"0%" extends PercentageLiteral ? true : false, true>();
+  assertType<"25%" extends PercentageLiteral ? true : false, true>();
+  assertType<"12.5%" extends PercentageLiteral ? true : false, true>();
+  assertType<"100%" extends PercentageLiteral ? true : false, true>();
+  assertType<"01%" extends PercentageLiteral ? true : false, false>();
+  assertType<"10.0%" extends PercentageLiteral ? true : false, false>();
+  assertType<"100.1%" extends PercentageLiteral ? true : false, false>();
+  assertType<Ratio extends Percentage ? true : false, true>();
+  assertTrue(PercentageLiteral.is("0%"));
+  assertTrue(PercentageLiteral.is("25%"));
+  assertTrue(PercentageLiteral.is("12.5%"));
+  assertTrue(PercentageLiteral.is("100%"));
+  assertFalse(PercentageLiteral.is("01%"));
+  assertFalse(PercentageLiteral.is("10.0%"));
+  assertFalse(PercentageLiteral.is("100.1%"));
+});
+
+test("percentageToRatio converts percentage literals and preserves Ratio", () => {
+  assertEqual(percentageToRatio("0%"), 0);
+  assertEqual(percentageToRatio("12.5%"), 0.125);
+  assertEqual(percentageToRatio("100%"), 1);
+
+  const ratio = Ratio.orThrow(0.123456);
+  assertSame(percentageToRatio(ratio), ratio);
+});
+
+test("increment", () => {
+  assertEqual(increment(1), 2);
+});
+
+test("decrement", () => {
+  assertEqual(decrement(1), 0);
+});
+
+test("clamp", () => {
+  assertEqual(clamp(0, 2)(1), 1);
+  assertEqual(clamp(0, 2)(3), 2);
+  assertEqual(clamp(0, 10)(5), 5);
+});
+
+test("isBetween", () => {
+  const isBetween10And20 = isBetween(10, 20);
+
+  assertTrue(isBetween10And20(10));
+  assertTrue(isBetween10And20(15));
+  assertTrue(isBetween10And20(20));
+
+  assertFalse(isBetween10And20(9));
+  assertFalse(isBetween10And20(21));
+});
+
+test("computeBalancedBuckets", () => {
+  assertEqual(
+    computeBalancedBuckets(32 as NonNegativeInt),
+    ok([2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32]),
+  );
+
+  assertEqual(computeBalancedBuckets(31 as NonNegativeInt), err(32));
+  assertEqual(computeBalancedBuckets(0 as NonNegativeInt), err(32));
+  assertEqual(
+    computeBalancedBuckets(10 as NonNegativeInt, 3 as PositiveInt),
+    ok([4, 7, 10]),
+  );
+
+  assertEqual(
+    computeBalancedBuckets(5 as NonNegativeInt, 1 as PositiveInt),
+    ok([5]),
+  );
+
+  assertEqual(
+    computeBalancedBuckets(
+      6 as NonNegativeInt,
+      3 as PositiveInt,
+      2 as PositiveInt,
+    ),
+    ok([2, 4, 6]),
+  );
+
+  assertEqual(
+    computeBalancedBuckets(
+      5 as NonNegativeInt,
+      3 as PositiveInt,
+      2 as PositiveInt,
+    ),
+    err(6),
+  );
+});
+
+test("min", () => {
+  const a = 5 as PositiveInt;
+  const b = 3 as PositiveInt;
+  const c = 7 as PositiveInt;
+
+  const result = min(a, b, c);
+  assertSame(result, b);
+  assertType<typeof result, PositiveInt>();
+
+  const result2 = min(5, 3, 7);
+  assertEqual(result2, 3);
+  assertType<typeof result2, number>();
+
+  const e = 1 as PositiveInt;
+  const f = 4 as NonNegativeInt;
+
+  const result3 = min(e, f);
+  assertEqual(result3, 1);
+  assertType<typeof result3, NonNegativeInt>();
+});
+
+test("max", () => {
+  const a = 5 as PositiveInt;
+  const b = 3 as PositiveInt;
+  const c = 7 as PositiveInt;
+
+  const result = max(a, b, c);
+  assertSame(result, c);
+  assertType<typeof result, PositiveInt>();
+
+  const result2 = max(5, 3, 7);
+  assertEqual(result2, 7);
+  assertType<typeof result2, number>();
+
+  const e = 1 as PositiveInt;
+  const f = 4 as NonNegativeInt;
+
+  const result3 = max(e, f);
+  assertEqual(result3, 4);
+  assertType<typeof result3, NonNegativeInt>();
+});
+
+test("FibonacciIndex", () => {
+  assertOk(FibonacciIndex.fromUnknown(1));
+  assertOk(FibonacciIndex.fromUnknown(78));
+  assertFalse(FibonacciIndex.fromUnknown(79).ok);
+  assertFalse(FibonacciIndex.fromUnknown(0).ok);
+  assertFalse(FibonacciIndex.fromUnknown(-1).ok);
+});
+
+test("fibonacciAt", () => {
+  const at = (n: number) => fibonacciAt(FibonacciIndex.orThrow(n));
+
+  // First 10 Fibonacci numbers (1-indexed)
+  assertEqual(at(1), 1);
+  assertEqual(at(2), 1);
+  assertEqual(at(3), 2);
+  assertEqual(at(4), 3);
+  assertEqual(at(5), 5);
+  assertEqual(at(6), 8);
+  assertEqual(at(7), 13);
+  assertEqual(at(8), 21);
+  assertEqual(at(9), 34);
+  assertEqual(at(10), 55);
+
+  // F(78) is the largest Fibonacci within MAX_SAFE_INTEGER
+  assertTrue(at(78) < Number.MAX_SAFE_INTEGER);
+
+  // Return type is PositiveInt
+  {
+    const actual = at(1);
+    assertType<typeof actual, PositiveInt>();
+  }
+});

package/src/Number.ts

@@ -93,7 +93,7 @@ export type Int1To100OrPositiveInt = Int1To100 | PositiveInt;
  * const readableJitter = jitter("50%");
  * const computedJitter = jitter(Ratio.orThrow(0.5));
  *
- * assertType<typeof computedJitter, typeof readableJitter>();
+ * assertType<typeof readableJitter, typeof computedJitter>();
  * ```
  */
 export type Percentage = PercentageLiteral | Ratio;
@@ -121,7 +121,7 @@ export type PercentageLiteral = typeof PercentageLiteral.Output;
 export const percentageToRatio = (percentage: Percentage): Ratio =>
   typeof percentage === "number"
     ? percentage
-    : Ratio.orThrow(globalThis.Number.parseFloat(percentage) / 100);
+    : Ratio.orThrow(Number.parseFloat(percentage) / 100);
 
 export const increment = (n: number): number => n + 1;
 

package/src/Object.test.ts

@@ -0,0 +1,293 @@
+import { test } from "node:test";
+import { assertEqual, assertFalse, assertSame, assertTrue } from "./Assert.ts";
+
+import type { Brand } from "./Brand.ts";
+import type { ReadonlyRecord } from "./Object.ts";
+import {
+  createObjectURL,
+  createMutableRecord,
+  emptyRecord,
+  excludeProp,
+  getObjectKind,
+  getOwnProp,
+  isFunction,
+  isIterable,
+  isPlainObject,
+  mapObject,
+  objectFrom,
+  objectFromEntries,
+  objectToEntries,
+} from "./Object.ts";
+import { assertType } from "./Type.ts";
+
+class NullBase extends null {}
+
+const createNullBase = (): NullBase =>
+  Object.create(NullBase.prototype) as NullBase;
+
+test("getObjectKind", () => {
+  assertEqual(getObjectKind([]), "Array");
+  assertEqual(getObjectKind(new ArrayBuffer(0)), "Unsupported");
+  assertEqual(getObjectKind(new Date()), "Date");
+  assertEqual(getObjectKind(new Map()), "Map");
+  assertEqual(getObjectKind({}), "Object");
+  assertEqual(getObjectKind(Object.create(null) as object), "Object");
+  assertEqual(getObjectKind(new Set()), "Set");
+  assertEqual(getObjectKind(new Uint8Array()), "Uint8Array");
+  assertEqual(getObjectKind(/value/u), "Unsupported");
+  assertEqual(getObjectKind(createNullBase()), "Unsupported");
+
+  const emptyRoot = Object.create(null) as object;
+  assertEqual(getObjectKind(Object.create(emptyRoot) as object), "Unsupported");
+
+  const accessorRoot = Object.defineProperty(
+    Object.create(null) as object,
+    "constructor",
+    { get: () => Object },
+  );
+  assertEqual(
+    getObjectKind(Object.create(accessorRoot) as object),
+    "Unsupported",
+  );
+
+  const nonFunctionRoot = Object.defineProperty(
+    Object.create(null) as object,
+    "constructor",
+    { value: 1 },
+  );
+  assertEqual(
+    getObjectKind(Object.create(nonFunctionRoot) as object),
+    "Unsupported",
+  );
+
+  let reads = 0;
+  const value = Object.defineProperty({}, Symbol.toStringTag, {
+    get: () => {
+      reads++;
+      return "Custom";
+    },
+  });
+  assertEqual(getObjectKind(value), "Object");
+  assertEqual(reads, 0);
+});
+
+test("isPlainObject", () => {
+  assertTrue(isPlainObject({}));
+  assertTrue(isPlainObject(Object.create(null)));
+  assertFalse(isPlainObject(new Date()));
+
+  class Example {
+    readonly id = "a";
+  }
+
+  assertFalse(isPlainObject(new Example()));
+  assertFalse(isPlainObject(createNullBase()));
+  assertFalse(isPlainObject([]));
+  assertFalse(isPlainObject(null));
+
+  const root = Object.create(null) as object;
+  assertFalse(isPlainObject(Object.create(root)));
+
+  const rootWithObjectConstructor = Object.defineProperty(
+    Object.create(null) as object,
+    "constructor",
+    { value: Object },
+  );
+  assertFalse(isPlainObject(Object.create(rootWithObjectConstructor)));
+
+  const partialObjectPrototype = Object.defineProperty(
+    Object.create(null) as object,
+    "hasOwnProperty",
+    { value: () => false },
+  );
+  assertFalse(isPlainObject(Object.create(partialObjectPrototype)));
+});
+
+test("isFunction", () => {
+  assertTrue(isFunction(() => {}));
+  assertTrue(isFunction(function () {}));
+
+  const constructable: unknown = class Example {
+    readonly value = 1;
+  };
+  assertTrue(isFunction(constructable));
+  // oxlint-disable-next-line evolu/no-unnecessary-global-this -- @evolu/common also exports an Evolu Function Type, while isFunction recognizes JavaScript function objects.
+  assertType<typeof constructable, globalThis.Function>();
+
+  assertFalse(isFunction({}));
+  assertFalse(isFunction([]));
+  assertFalse(isFunction("fn"));
+  assertFalse(isFunction(123));
+  assertFalse(isFunction(null));
+  assertFalse(isFunction(undefined));
+});
+
+test("isIterable", () => {
+  assertTrue(isIterable([1, 2, 3]));
+  assertTrue(isIterable("abc"));
+  assertTrue(isIterable(new Set([1])));
+  assertTrue(isIterable(new Map([["a", 1]])));
+  assertFalse(isIterable({}));
+  assertFalse(isIterable(0));
+  assertFalse(isIterable(null));
+  assertFalse(isIterable(undefined));
+  assertFalse(isIterable({ [Symbol.iterator]: 1 }));
+});
+
+test("objectToEntries", () => {
+  const record = { a: 1, b: 2 };
+  const entries = objectToEntries(record);
+
+  assertEqual(entries, [
+    ["a", 1],
+    ["b", 2],
+  ]);
+
+  // Preserves branded key types
+  type UserId = string & Brand<"UserId">;
+  const users: Record<UserId, string> = { ["u1" as UserId]: "Alice" };
+  const userEntries = objectToEntries(users);
+  assertType<typeof userEntries, ReadonlyArray<[UserId, string]>>();
+
+  assertEqual(userEntries, [["u1", "Alice"]]);
+});
+
+test("objectFromEntries", () => {
+  const entries: ReadonlyArray<[string, number]> = [
+    ["a", 1],
+    ["b", 2],
+  ];
+  const record = objectFromEntries(entries);
+
+  assertEqual(record, { a: 1, b: 2 });
+
+  // Preserves branded key types
+  type UserId = string & Brand<"UserId">;
+  const userEntries: ReadonlyArray<[UserId, string]> = [
+    ["u1" as UserId, "Alice"],
+  ];
+  const users = objectFromEntries(userEntries);
+  assertType<typeof users, ReadonlyRecord<UserId, string>>();
+
+  assertEqual(users, { u1: "Alice" });
+});
+
+test("objectFrom", () => {
+  const result = objectFrom(["a", "b", "c"], (key) => key.toUpperCase());
+  assertEqual(result, { a: "A", b: "B", c: "C" });
+
+  // Key is available in the mapper
+  const indexed = objectFrom(["x", "y"], (key) => `value-${key}`);
+  assertEqual(indexed, { x: "value-x", y: "value-y" });
+
+  // Preserves key types
+  type Lang = "en" | "fr" | "de";
+  const langs: ReadonlyArray<Lang> = ["en", "fr", "de"];
+  const translations = objectFrom(langs, (lang) => `Hello in ${lang}`);
+  assertType<typeof translations, ReadonlyRecord<Lang, string>>();
+});
+
+test("mapObject", () => {
+  const record = { a: 1, b: 2, c: 3 };
+  const doubled = mapObject(record, (value) => value * 2);
+
+  assertEqual(doubled, { a: 2, b: 4, c: 6 });
+
+  // Preserves branded key types
+  type UserId = string & Brand<"UserId">;
+  const users: ReadonlyRecord<UserId, number> = {
+    ["u1" as UserId]: 10,
+    ["u2" as UserId]: 20,
+  };
+  const mapped = mapObject(users, (value, key) => `${key}:${value}`);
+  assertType<typeof mapped, ReadonlyRecord<UserId, string>>();
+
+  assertEqual(mapped, { u1: "u1:10", u2: "u2:20" });
+});
+
+test("excludeProp", () => {
+  const obj = { a: 1, b: 2, c: 3 };
+
+  // Without condition (default: excludes)
+  const withoutB = excludeProp(obj, "b");
+  assertEqual(withoutB, { a: 1, c: 3 });
+
+  // With condition = true (keeps all)
+  const keepAll = excludeProp(obj, "b", true);
+  assertEqual(keepAll, { a: 1, b: 2, c: 3 });
+
+  // With condition = false (excludes)
+  const excluded = excludeProp(obj, "a", false);
+  assertEqual(excluded, { b: 2, c: 3 });
+});
+
+test("createMutableRecord", () => {
+  const values = createMutableRecord<string, number>();
+  values.__proto__ = 123;
+
+  assertEqual(values.__proto__, 123);
+
+  // Ensure Object.prototype was not changed
+  const protoValue = Reflect.get(Object.prototype, "__proto__");
+  assertSame(Reflect.get(Object.prototype, "__proto__"), protoValue);
+
+  interface Source {
+    readonly name: string;
+    readonly age?: number;
+  }
+
+  const source: Source = { name: "Ada" };
+  const copy = createMutableRecord(source);
+
+  copy.name = "Grace";
+
+  assertType<typeof copy, { name: string; age?: number }>();
+  assertEqual(copy, { name: "Grace" });
+  assertEqual(source, { name: "Ada" });
+  assertSame(Object.getPrototypeOf(copy), null);
+
+  const compileTimeAssertions = () => {
+    // @ts-expect-error createMutableRecord source must be an object.
+    createMutableRecord("Ada");
+  };
+  assertType<
+    typeof compileTimeAssertions extends (...args: Array<never>) => unknown
+      ? true
+      : false,
+    true
+  >();
+});
+
+test("emptyRecord", () => {
+  assertSame(Object.getPrototypeOf(emptyRecord), null);
+  assertTrue(Object.isFrozen(emptyRecord));
+});
+
+test("getOwnProp", () => {
+  const record = { a: 1, b: 2 };
+  const stringRecord: Readonly<Record<string, number>> = record;
+  const nullPrototypeRecord = createMutableRecord<string, number>();
+  const value = getOwnProp(record, "a");
+
+  assertType<typeof value, number | undefined>();
+  assertEqual(value, 1);
+  assertEqual(getOwnProp(record, "b"), 2);
+  // @ts-expect-error c does not exists
+  assertSame(getOwnProp(record, "c"), undefined);
+  assertSame(getOwnProp(stringRecord, "toString"), undefined);
+  assertSame(getOwnProp(nullPrototypeRecord, "toString"), undefined);
+
+  Reflect.set(nullPrototypeRecord, "toString", 1);
+
+  assertEqual(getOwnProp(nullPrototypeRecord, "toString"), 1);
+});
+
+test("createObjectURL", () => {
+  const blob = new Blob(["test"], { type: "text/plain" });
+  const objectUrl = createObjectURL(blob);
+
+  assertTrue(objectUrl.url.startsWith("blob:"));
+
+  // Dispose revokes the URL
+  objectUrl[Symbol.dispose]();
+});

package/src/Object.ts

@@ -107,6 +107,7 @@ export const isPlainObject = (
  * assertFalse(isFunction({}));
  * ```
  */
+// oxlint-disable-next-line evolu/no-unnecessary-global-this -- @evolu/common also exports an Evolu Function Type, while this predicate recognizes JavaScript function objects.
 export const isFunction = (value: unknown): value is globalThis.Function =>
   typeof value === "function";
 
@@ -147,7 +148,7 @@ export const isIterable = (value: unknown): value is Iterable<unknown> =>
  * const users: ReadonlyRecord<UserId, string> = { [userId]: "Alice" };
  * const entries = objectToEntries(users);
  *
- * assertType<ReadonlyArray<[UserId, string]>, typeof entries>();
+ * assertType<typeof entries, ReadonlyArray<[UserId, string]>>();
  * assertEqual(entries, [[userId, "Alice"]]);
  * ```
  */
@@ -182,7 +183,7 @@ type StringKeyOf<T> = Extract<keyof T, string>;
  * ];
  * const users = objectFromEntries(entries);
  *
- * assertType<ReadonlyRecord<UserId, string>, typeof users>();
+ * assertType<typeof users, ReadonlyRecord<UserId, string>>();
  * assertEqual(users, { u1: "Alice" });
  * ```
  */
@@ -211,7 +212,7 @@ export const objectFromEntries = <K extends string, V>(
  *   (locale): string => `Hello in ${locale}`,
  * );
  *
- * assertType<ReadonlyRecord<"en" | "fr", string>, typeof translations>();
+ * assertType<typeof translations, ReadonlyRecord<"en" | "fr", string>>();
  * assertEqual(translations, {
  *   en: "Hello in en",
  *   fr: "Hello in fr",
@@ -395,7 +396,7 @@ export const emptyRecord: Readonly<Record<string, never>> =
  * };
  * const user = getOwnProp(users, "bob");
  *
- * assertType<User | undefined, typeof user>();
+ * assertType<typeof user, User | undefined>();
  * assertEqual(user, undefined);
  * assertEqual(getOwnProp(users, "toString"), undefined);
  * ```