@evolu/common 8.7.0 → 8.8.0

package/src/Time.ts

@@ -105,8 +105,8 @@ export const createTime = (): Time => {
     now,
 
     performance: {
-      timeOrigin: globalThis.performance.timeOrigin as PerformanceTimeOrigin,
-      now: () => globalThis.performance.now() as PerformanceTime,
+      timeOrigin: performance.timeOrigin as PerformanceTimeOrigin,
+      now: () => performance.now() as PerformanceTime,
     },
 
     setTimeout: (callback, duration) =>
@@ -125,10 +125,10 @@ const scheduleNativeTimeout = (
 ): TimeoutId => {
   const delay = durationToMillis(duration);
   let cancelled = false;
-  let nativeId: ReturnType<typeof globalThis.setTimeout>;
+  let nativeId: ReturnType<typeof setTimeout>;
 
   if (delay <= maxNativeTimeoutMillis) {
-    nativeId = globalThis.setTimeout(() => {
+    nativeId = setTimeout(() => {
       if (cancelled) return;
       cancelled = true;
       callback();
@@ -143,7 +143,7 @@ const scheduleNativeTimeout = (
 
       const remaining = deadline - getSystemNowMillis();
       if (remaining > 0) {
-        nativeId = globalThis.setTimeout(
+        nativeId = setTimeout(
           onTimeout,
           Math.min(remaining, maxNativeTimeoutMillis),
         );
@@ -154,14 +154,14 @@ const scheduleNativeTimeout = (
       callback();
     };
 
-    nativeId = globalThis.setTimeout(onTimeout, maxNativeTimeoutMillis);
+    nativeId = setTimeout(onTimeout, maxNativeTimeoutMillis);
   }
 
   return {
     owner,
     clear: () => {
       cancelled = true;
-      globalThis.clearTimeout(nativeId);
+      clearTimeout(nativeId);
     },
   } as unknown as TimeoutId;
 };
@@ -173,7 +173,7 @@ const scheduleNativeTimeout = (
  */
 const maxNativeTimeoutMillis = 2 ** 31 - 1;
 
-const getSystemNowMillis = (): Millis => Millis.orThrow(globalThis.Date.now());
+const getSystemNowMillis = (): Millis => Millis.orThrow(Date.now());
 
 const clearTimeoutId = (owner: symbol, id: TimeoutId): void => {
   const internal = id as unknown as TimeoutIdInternal;
@@ -356,7 +356,7 @@ export const saturateMillis = (value: NonNaNNumber): Millis =>
  * that always produces a valid ISO string.
  */
 export const millisToDateIso = (value: Millis): DateIso =>
-  new globalThis.Date(value).toISOString() as DateIso;
+  new Date(value).toISOString() as DateIso;
 
 /** Unix epoch milliseconds used as the origin for {@link PerformanceTime}. */
 export type PerformanceTimeOrigin = number & Brand<"PerformanceTimeOrigin">;
@@ -394,7 +394,7 @@ export const performanceDurationBetween = (
  * const readableSchedule = spaced("1s");
  * const validatedSchedule = spaced(Millis.orThrow(1000));
  *
- * assertType<typeof validatedSchedule, typeof readableSchedule>();
+ * assertType<typeof readableSchedule, typeof validatedSchedule>();
  * ```
  */
 export type Duration = DurationLiteral | Millis;
@@ -413,7 +413,7 @@ export type Duration = DurationLiteral | Millis;
  * const readableSleep = sleep("1s");
  * const validatedSleep = sleep(PositiveMillis.orThrow(1000));
  *
- * assertType<typeof validatedSleep, typeof readableSleep>();
+ * assertType<typeof readableSleep, typeof validatedSleep>();
  * ```
  */
 export type PositiveDuration = DurationLiteral | PositiveMillis;
@@ -665,15 +665,7 @@ export const formatMillisAsDuration = (millis: Millis): string => {
  *   Millis,
  * } from "@evolu/common";
  *
- * const timestamp = new globalThis.Date(
- *   2026,
- *   0,
- *   28,
- *   14,
- *   32,
- *   15,
- *   234,
- * ).getTime();
+ * const timestamp = new Date(2026, 0, 28, 14, 32, 15, 234).getTime();
  * assertEqual(
  *   formatMillisAsClockTime(Millis.orThrow(timestamp)),
  *   "14:32:15.234",
@@ -681,7 +673,7 @@ export const formatMillisAsDuration = (millis: Millis): string => {
  * ```
  */
 export const formatMillisAsClockTime = (millis: Millis): string => {
-  const date = new globalThis.Date(millis);
+  const date = new Date(millis);
   const hours = date.getHours().toString().padStart(2, "0");
   const minutes = date.getMinutes().toString().padStart(2, "0");
   const seconds = date.getSeconds().toString().padStart(2, "0");

package/src/Type.base64.test.ts

@@ -0,0 +1,88 @@
+import { afterEach, beforeEach, describe, it, mock } from "node:test";
+import { assertEqualBytes, assertEqual, assertTrue } from "./Assert.ts";
+
+// Keep this coverage in a separate test file. Per-file process isolation gives
+// it a fresh module cache and globals, so Type.ts is first loaded after
+// Platform.ts is mocked and temporary Uint8Array mutations cannot affect
+// Type.test.ts.
+const toBase64Descriptor = Object.getOwnPropertyDescriptor(
+  Uint8Array.prototype,
+  "toBase64",
+);
+const fromBase64Descriptor = Object.getOwnPropertyDescriptor(
+  Uint8Array,
+  "fromBase64",
+);
+
+mock.module("./Platform.ts", {
+  // @ts-expect-error -- Node.js 24.20 replaces the deprecated namedExports option with exports, which @types/node 24.13 does not declare yet.
+  exports: { hasNodeBuffer: false },
+});
+
+const { base64UrlToUint8Array, uint8ArrayToBase64Url } =
+  await import("./Type.ts");
+
+const restoreBase64Methods = (): void => {
+  if (toBase64Descriptor === undefined) {
+    Reflect.deleteProperty(Uint8Array.prototype, "toBase64");
+  } else {
+    // oxlint-disable-next-line eslint/no-extend-native -- The test restores the native method it temporarily replaces.
+    Object.defineProperty(Uint8Array.prototype, "toBase64", toBase64Descriptor);
+  }
+
+  if (fromBase64Descriptor === undefined) {
+    Reflect.deleteProperty(Uint8Array, "fromBase64");
+  } else {
+    Object.defineProperty(Uint8Array, "fromBase64", fromBase64Descriptor);
+  }
+};
+
+describe("Base64Url browser implementations", () => {
+  beforeEach(() => {
+    assertTrue(Reflect.deleteProperty(Uint8Array.prototype, "toBase64"));
+    assertTrue(Reflect.deleteProperty(Uint8Array, "fromBase64"));
+  });
+
+  afterEach(() => {
+    restoreBase64Methods();
+  });
+
+  it("uses Uint8Array Base64 methods when available", () => {
+    // oxlint-disable-next-line eslint/no-extend-native -- The test installs the native API to exercise its code path.
+    Object.defineProperty(Uint8Array.prototype, "toBase64", {
+      configurable: true,
+      value(this: Uint8Array, options: unknown): string {
+        assertEqual(options, { alphabet: "base64url", omitPadding: true });
+        return Buffer.from(this).toString("base64url");
+      },
+    });
+    Object.defineProperty(Uint8Array, "fromBase64", {
+      configurable: true,
+      value(value: string, options: unknown): Uint8Array {
+        assertEqual(options, { alphabet: "base64url", omitPadding: true });
+        return new Uint8Array(Buffer.from(value, "base64url"));
+      },
+    });
+
+    const bytes = new Uint8Array([251, 255]);
+    const encoded = uint8ArrayToBase64Url(bytes);
+
+    assertEqual(encoded, "-_8");
+    assertEqualBytes(base64UrlToUint8Array(encoded), bytes);
+  });
+
+  it("uses btoa and atob when Uint8Array Base64 methods are unavailable", () => {
+    for (const bytes of [
+      new Uint8Array(),
+      new Uint8Array([0]),
+      new Uint8Array([0, 1]),
+      new Uint8Array([0, 1, 2]),
+      new Uint8Array([251, 255]),
+    ]) {
+      const encoded = uint8ArrayToBase64Url(bytes);
+      assertEqualBytes(base64UrlToUint8Array(encoded), bytes);
+    }
+
+    assertEqual(uint8ArrayToBase64Url(new Uint8Array([251, 255])), "-_8");
+  });
+});