silentium-components 0.0.78 → 0.0.80

package/src/behaviors/Task.test.ts

@@ -0,0 +1,61 @@
+import { Late, Transport } from "silentium";
+import { Task } from "../behaviors/Task";
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+
+beforeEach(() => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+});
+
+afterEach(() => {
+  vi.runOnlyPendingTimers();
+  vi.useRealTimers();
+});
+
+test("Task delays emission", () => {
+  const $trigger = Late<string>();
+  const delayed = Task($trigger, 100);
+  const data: string[] = [];
+  delayed.event(
+    Transport((v) => {
+      data.push(v);
+    }),
+  );
+
+  $trigger.use("first");
+
+  // Before delay, no emission
+  expect(data).toStrictEqual([]);
+
+  // Advance time to trigger emission
+  vi.advanceTimersByTime(100);
+
+  expect(data).toStrictEqual(["first"]);
+});
+
+test("Task emits only last value when multiple before delay", () => {
+  const $trigger = Late<string>();
+  const delayed = Task($trigger, 100);
+  const data: string[] = [];
+  delayed.event(
+    Transport((v) => {
+      data.push(v);
+    }),
+  );
+
+  $trigger.use("first");
+  $trigger.use("second");
+  $trigger.use("third");
+
+  // Before delay, no emission
+  expect(data).toStrictEqual([]);
+
+  // Advance time partially
+  vi.advanceTimersByTime(50);
+  expect(data).toStrictEqual([]);
+
+  // Advance to full delay
+  vi.advanceTimersByTime(50);
+
+  // Only last value should be emitted
+  expect(data).toStrictEqual(["third"]);
+});

package/src/navigation/Router._destroy.test.ts

@@ -0,0 +1,98 @@
+import {
+  Applied,
+  Late,
+  Of,
+  Shared,
+  Transport,
+  Event,
+  TransportEvent,
+} from "silentium";
+import { Router } from "../navigation/Router";
+import { expect, test, vi } from "vitest";
+
+const drop = (dropPart: string) => (value: string) => {
+  return value.replace(dropPart, "");
+};
+
+test("Router destroys previous route events when switching routes", () => {
+  const $url = Late<string>("http://domain.com/");
+  const $urlPath = Shared(Applied($url, drop("http://domain.com")));
+  const g = vi.fn();
+  $urlPath.event(Transport(g));
+
+  // Create mock destroyable events for routes
+  const firstRouteDestroy = vi.fn();
+  const secondRouteDestroy = vi.fn();
+  const defaultDestroy = vi.fn();
+
+  const firstRouteEvent = TransportEvent(() =>
+    Event<string>((transport) => {
+      transport.use("first-route-response");
+      return firstRouteDestroy;
+    }),
+  );
+
+  const secondRouteEvent = TransportEvent(() =>
+    Event<string>((transport) => {
+      transport.use("second-route-response");
+      return secondRouteDestroy;
+    }),
+  );
+
+  const defaultEvent = TransportEvent(() =>
+    Event<string>((transport) => {
+      transport.use("default-response");
+      return defaultDestroy;
+    }),
+  );
+
+  const $router = Router(
+    $urlPath,
+    Of([
+      {
+        pattern: "^/first$",
+        event: firstRouteEvent,
+      },
+      {
+        pattern: "^/second$",
+        event: secondRouteEvent,
+      },
+    ]),
+    defaultEvent,
+  );
+
+  const g2 = vi.fn();
+  $router.event(Transport(g2));
+
+  // Initially no route matches, should use default
+  expect(g2).toHaveBeenLastCalledWith("default-response");
+  expect(defaultDestroy).not.toHaveBeenCalled();
+
+  // Change to first route
+  $url.use("http://domain.com/first");
+
+  expect(g2).toHaveBeenLastCalledWith("first-route-response");
+  expect(defaultDestroy).toHaveBeenCalledTimes(1); // Default should be destroyed
+  expect(firstRouteDestroy).not.toHaveBeenCalled();
+
+  // Change to second route
+  $url.use("http://domain.com/second");
+
+  expect(g2).toHaveBeenLastCalledWith("second-route-response");
+  expect(firstRouteDestroy).toHaveBeenCalledTimes(1); // First route should be destroyed
+  expect(secondRouteDestroy).not.toHaveBeenCalled();
+
+  // Change back to no match (default)
+  $url.use("http://domain.com/nomatch");
+
+  expect(g2).toHaveBeenLastCalledWith("default-response");
+  expect(secondRouteDestroy).toHaveBeenCalledTimes(1); // Second route should be destroyed
+  expect(defaultDestroy).toHaveBeenCalledTimes(1); // Still only once, as it was destroyed before
+
+  // Change back to first route
+  $url.use("http://domain.com/first");
+
+  expect(g2).toHaveBeenLastCalledWith("first-route-response");
+  expect(defaultDestroy).toHaveBeenCalledTimes(2); // Default destroyed again
+  expect(firstRouteDestroy).toHaveBeenCalledTimes(1); // Still only once
+});

package/src/navigation/Router.ts

@@ -1,9 +1,9 @@
 import {
   All,
   DestroyableType,
+  DestroyContainer,
   Event,
   EventType,
-  isDestroyable,
   Of,
   Transport,
   TransportType,
@@ -26,15 +26,9 @@ export function Router<T = "string">(
   $default: TransportType<void, EventType<T>>,
 ): EventType<T> & DestroyableType {
   return Event<T>((transport) => {
-    const destroyableList: DestroyableType[] = [];
-    const checkDestroyable = (instance: unknown) => {
-      if (isDestroyable(instance)) {
-        destroyableList.push(instance);
-      }
-    };
+    const dc = DestroyContainer();
     const destructor = () => {
-      destroyableList.forEach((d) => d.destroy());
-      destroyableList.length = 0;
+      dc.destroy();
     };
     All($routes, $url).event(
       Transport(([routes, url]) => {
@@ -54,13 +48,13 @@ export function Router<T = "string">(
 
             if (index === -1) {
               const instance = $default.use();
-              checkDestroyable(instance);
+              dc.add(instance);
               instance.event(transport);
             }
 
             if (index > -1) {
               const instance = routes[index].event.use();
-              checkDestroyable(instance);
+              dc.add(instance);
               instance.event(transport);
             }
           }),