@evolu/common 8.6.2 → 8.8.0

package/src/Brand.test.ts

@@ -0,0 +1,90 @@
+import { test } from "node:test";
+
+import type { Brand, IsBranded } from "./Brand.ts";
+import { constVoid } from "./Function.ts";
+import { assertType } from "./Type.ts";
+
+test("Brand", () => {
+  type UserId = string & Brand<"UserId">;
+  type ProductId = number & Brand<"ProductId">;
+
+  const validUserId: UserId = "user123" as UserId;
+  assertType<typeof validUserId, string & Brand<"UserId">>();
+
+  const validProductId: ProductId = 42 as ProductId;
+  assertType<typeof validProductId, number & Brand<"ProductId">>();
+
+  // Invalid assignment (string to ProductId)
+  // @ts-expect-error - Should not allow a string to be assigned to ProductId
+  const invalidProductId: ProductId = "not-a-number";
+
+  // Invalid assignment (unbranded string to UserId)
+  // @ts-expect-error - Should not allow unbranded string to be assigned to UserId
+  const invalidUserId: UserId = "user123";
+
+  // Invalid assignment (mixing different brands)
+  // @ts-expect-error - Should not allow assigning a ProductId to a UserId
+  const mismatchedId: UserId = validProductId;
+});
+
+test("Brand - multiple brands", () => {
+  type Min1 = string & Brand<"Min1">;
+  type Max100 = string & Brand<"Max100">;
+  type Min1Max100 = string & Brand<"Min1" | "Max100">;
+
+  const requiresMin1 = (_value: Min1) => constVoid;
+  const requiresMax100 = (_value: Max100) => constVoid;
+
+  const min1Value: Min1 = "hello" as Min1;
+  const max100Value: Max100 = "world" as Max100;
+  const min1Max100Value: Min1Max100 = "typescript" as Min1Max100;
+
+  requiresMin1(min1Value);
+  requiresMax100(max100Value);
+  requiresMin1(min1Max100Value);
+  requiresMax100(min1Max100Value);
+
+  // @ts-expect-error: brands works
+  requiresMin1("hello");
+  // @ts-expect-error: brands works
+  requiresMin1(max100Value);
+  // @ts-expect-error: brands works
+  requiresMax100("world");
+  // @ts-expect-error: brands works
+  requiresMax100(min1Value);
+});
+
+test("IsBranded", () => {
+  type UnbrandedString = string;
+  type BrandedString = string & Brand<"UserId">;
+  type BrandedNumber = number & Brand<"ProductId">;
+  type DoubleBranded = string & Brand<"Min"> & Brand<"Max">;
+
+  assertType<IsBranded<UnbrandedString>, false>();
+  assertType<IsBranded<BrandedString>, true>();
+  assertType<IsBranded<BrandedNumber>, true>();
+  assertType<IsBranded<DoubleBranded>, true>();
+});
+
+test("Brand - standalone (nominal type)", () => {
+  // Brand can be used alone without a base type for purely nominal typing.
+  // Useful for platform-specific values where type identity is based on name only.
+  type NativePort = Brand<"NativePort">;
+
+  const requiresNativePort = (_port: NativePort) => constVoid;
+
+  // Only branded values can be passed
+  const nativePort: NativePort = {} as NativePort;
+  requiresNativePort(nativePort);
+
+  // @ts-expect-error: plain unknown cannot be passed
+  requiresNativePort({} as unknown);
+
+  // @ts-expect-error: other types cannot be passed
+  requiresNativePort({});
+
+  // @ts-expect-error: null cannot be passed
+  requiresNativePort(null);
+
+  assertType<IsBranded<NativePort>, true>();
+});

package/src/Cache.test.ts

@@ -0,0 +1,183 @@
+import { test } from "node:test";
+import { assertEqual, assertFalse, assertSame, assertTrue } from "./Assert.ts";
+
+import { createLruCache } from "./Cache.ts";
+import { onePositiveInt, PositiveInt } from "./Type.ts";
+
+test("LRU cache - basic set and get", () => {
+  const cache = createLruCache<string, number>(PositiveInt.orThrow(3));
+
+  cache.set("a", 1);
+  cache.set("b", 2);
+  cache.set("c", 3);
+
+  assertEqual(cache.get("a"), 1);
+  assertEqual(cache.get("b"), 2);
+  assertEqual(cache.get("c"), 3);
+  assertSame(cache.get("d"), undefined);
+});
+
+test("LRU cache - has method", () => {
+  const cache = createLruCache<string, number>(PositiveInt.orThrow(2));
+
+  cache.set("a", 1);
+  cache.set("b", 2);
+
+  assertTrue(cache.has("a"));
+  assertTrue(cache.has("b"));
+  assertFalse(cache.has("c"));
+});
+
+test("LRU cache - delete method", () => {
+  const cache = createLruCache<string, number>(PositiveInt.orThrow(2));
+
+  cache.set("a", 1);
+  cache.set("b", 2);
+
+  assertTrue(cache.has("a"));
+  cache.delete("a");
+  assertFalse(cache.has("a"));
+  assertSame(cache.get("a"), undefined);
+});
+
+test("LRU cache - evicts least recently used on capacity", () => {
+  const cache = createLruCache<string, number>(PositiveInt.orThrow(2));
+
+  cache.set("a", 1);
+  cache.set("b", 2);
+  // Should evict "a"
+  cache.set("c", 3);
+
+  assertFalse(cache.has("a"));
+  assertTrue(cache.has("b"));
+  assertTrue(cache.has("c"));
+});
+
+test("LRU cache - get updates access order", () => {
+  const cache = createLruCache<string, number>(PositiveInt.orThrow(2));
+
+  cache.set("a", 1);
+  cache.set("b", 2);
+  // Access "a", making it most recent
+  cache.get("a");
+  // Should evict "b", not "a"
+  cache.set("c", 3);
+
+  assertTrue(cache.has("a"));
+  assertFalse(cache.has("b"));
+  assertTrue(cache.has("c"));
+});
+
+test("LRU cache - set updates access order for existing key", () => {
+  const cache = createLruCache<string, number>(PositiveInt.orThrow(2));
+
+  cache.set("a", 1);
+  cache.set("b", 2);
+  // Update "a", making it most recent
+  cache.set("a", 10);
+  // Should evict "b", not "a"
+  cache.set("c", 3);
+
+  assertEqual(cache.get("a"), 10);
+  assertFalse(cache.has("b"));
+  assertTrue(cache.has("c"));
+});
+
+test("LRU cache - readonly map view", () => {
+  const cache = createLruCache<string, number>(PositiveInt.orThrow(3));
+
+  cache.set("a", 1);
+  cache.set("b", 2);
+  cache.set("c", 3);
+
+  assertEqual(cache.map.size, 3);
+  assertEqual(cache.map.get("a"), 1);
+  assertEqual(cache.map.get("b"), 2);
+  assertEqual(cache.map.get("c"), 3);
+  assertTrue(cache.map.has("a"));
+  assertFalse(cache.map.has("d"));
+});
+
+test("LRU cache - map view reflects cache changes", () => {
+  const cache = createLruCache<string, number>(PositiveInt.orThrow(2));
+
+  cache.set("a", 1);
+  assertEqual(cache.map.size, 1);
+
+  cache.set("b", 2);
+  assertEqual(cache.map.size, 2);
+
+  // Evicts "a"
+  cache.set("c", 3);
+  assertEqual(cache.map.size, 2);
+  assertFalse(cache.map.has("a"));
+  assertTrue(cache.map.has("b"));
+  assertTrue(cache.map.has("c"));
+});
+
+test("LRU cache - iteration over map", () => {
+  const cache = createLruCache<string, number>(PositiveInt.orThrow(3));
+
+  cache.set("a", 1);
+  cache.set("b", 2);
+  cache.set("c", 3);
+
+  const entries = Array.from(cache.map.entries());
+  assertEqual(entries, [
+    ["a", 1],
+    ["b", 2],
+    ["c", 3],
+  ]);
+
+  const keys = Array.from(cache.map.keys());
+  assertEqual(keys, ["a", "b", "c"]);
+
+  const values = Array.from(cache.map.values());
+  assertEqual(values, [1, 2, 3]);
+});
+
+test("LRU cache - forEach on map", () => {
+  const cache = createLruCache<string, number>(PositiveInt.orThrow(3));
+
+  cache.set("a", 1);
+  cache.set("b", 2);
+  cache.set("c", 3);
+
+  const collected: Array<[string, number]> = [];
+  cache.map.forEach((value, key) => {
+    collected.push([key, value]);
+  });
+
+  assertEqual(collected, [
+    ["a", 1],
+    ["b", 2],
+    ["c", 3],
+  ]);
+});
+
+test("LRU cache - reference-based key comparison", () => {
+  const cache = createLruCache<object, number>(PositiveInt.orThrow(2));
+
+  const key1 = { id: 1 };
+  // Different object, same structure
+  const key2 = { id: 1 };
+
+  cache.set(key1, 100);
+  cache.set(key2, 200);
+
+  assertEqual(cache.get(key1), 100);
+  assertEqual(cache.get(key2), 200);
+  assertTrue(cache.has(key1));
+  assertTrue(cache.has(key2));
+});
+
+test("LRU cache - capacity of 1", () => {
+  const cache = createLruCache<string, number>(onePositiveInt);
+
+  cache.set("a", 1);
+  assertTrue(cache.has("a"));
+
+  cache.set("b", 2);
+  assertFalse(cache.has("a"));
+  assertTrue(cache.has("b"));
+});

package/src/Callbacks.test.ts

@@ -0,0 +1,66 @@
+import { test } from "node:test";
+import { assertEqual, assertFalse, assertSame, assertTrue } from "./Assert.ts";
+
+import { createCallbacks } from "./Callbacks.ts";
+import { testCreateDeps } from "./Task.ts";
+
+test("Callbacks with no argument", () => {
+  const deps = testCreateDeps();
+  const callbacks = createCallbacks(deps);
+
+  let called = false;
+  const id = callbacks.register(() => {
+    called = true;
+  });
+
+  callbacks.execute(id);
+  assertTrue(called);
+
+  called = false;
+  callbacks.execute(id);
+  assertFalse(called);
+});
+
+test("Callbacks with string type", () => {
+  const deps = testCreateDeps();
+  const callbacks = createCallbacks<string>(deps);
+
+  let receivedValue: string | null = null;
+  const id = callbacks.register((value) => {
+    receivedValue = value;
+  });
+
+  callbacks.execute(id, "test value");
+  assertEqual(receivedValue, "test value");
+
+  receivedValue = null;
+  callbacks.execute(id, "should not execute");
+  assertSame(receivedValue, null);
+});
+
+test("Callbacks with Promise.withResolvers pattern", async () => {
+  const deps = testCreateDeps();
+  const callbacks = createCallbacks<string>(deps);
+
+  const { promise, resolve } = Promise.withResolvers<string>();
+  const id = callbacks.register(resolve);
+
+  callbacks.execute(id, "resolved value");
+
+  assertEqual(await promise, "resolved value");
+});
+
+test("Callbacks dispose clears pending callbacks", () => {
+  const deps = testCreateDeps();
+  const callbacks = createCallbacks<string>(deps);
+
+  let called = false;
+  const id = callbacks.register(() => {
+    called = true;
+  });
+
+  callbacks[Symbol.dispose]();
+  callbacks.execute(id, "ignored");
+
+  assertFalse(called);
+});