@go-go-scope/adapter-svelte 2.7.0

package/tests/TestComponent.svelte

@@ -0,0 +1,189 @@
+<script lang="ts">
+  import {
+    createScope,
+    createTask,
+    createParallel,
+    createChannel,
+    createBroadcast,
+    createPolling
+  } from "../src/index.js";
+
+  export let testType: string;
+  export let onDispose: () => void = () => {};
+  export let onBroadcast: (msg: string) => void = () => {};
+
+  // Create all possible stores at top level
+  const scope = createScope({ name: "test" });
+  scope.onDispose(onDispose);
+
+  const task = createTask(async () => "fetched-data", { immediate: true });
+  const manualTask = createTask(async () => "result-1", { immediate: false });
+  const errorTask = createTask(async () => { throw new Error("Task failed"); }, { immediate: false });
+
+  const delays = [50, 30, 70];
+  const factories = delays.map((delay, i) => async () => {
+    await new Promise(r => setTimeout(r, delay));
+    return `task-${i}`;
+  });
+  const parallel = createParallel(factories, { immediate: true });
+
+  const ch = createChannel<string>();
+  const chClose = createChannel<string>();
+
+  const bus = createBroadcast<string>();
+  bus.subscribe((msg) => onBroadcast(msg));
+
+  let pollCount1 = 0;
+  const poller = createPolling(async () => {
+    pollCount1++;
+    return `poll-${pollCount1}`;
+  }, { interval: 1000, immediate: true });
+  
+  let pollCount2 = 0;
+  const pollerStop = createPolling(async () => {
+    pollCount2++;
+    return `poll-${pollCount2}`;
+  }, { interval: 1000, immediate: true });
+
+  // Subscribe to store values individually
+  let scopeActiveVal = false;
+  scope.isActive.subscribe(v => scopeActiveVal = v);
+  $: scopeActive = String(scopeActiveVal);
+
+  let taskDataVal: string | undefined;
+  task.data.subscribe(v => taskDataVal = v);
+  $: taskData = taskDataVal ?? "no-data";
+
+  let taskLoadingVal = false;
+  task.isLoading.subscribe(v => taskLoadingVal = v);
+  $: taskLoading = String(taskLoadingVal);
+
+  let manualTaskDataVal: string | undefined;
+  manualTask.data.subscribe(v => manualTaskDataVal = v);
+  $: manualTaskData = manualTaskDataVal ?? "no-data";
+
+  let errorTaskErrorVal: Error | undefined;
+  errorTask.error.subscribe(v => errorTaskErrorVal = v);
+  $: errorTaskError = errorTaskErrorVal?.message ?? "no-error";
+
+  let errorTaskDataVal: string | undefined;
+  errorTask.data.subscribe(v => errorTaskDataVal = v);
+  $: errorTaskData = errorTaskDataVal ?? "no-data";
+
+  let parallelProgressVal = 0;
+  parallel.progress.subscribe(v => parallelProgressVal = v);
+  $: parallelProgress = String(parallelProgressVal);
+
+  let parallelResultsVal: (string | undefined)[] = [];
+  parallel.results.subscribe(v => {
+    parallelResultsVal = v;
+  });
+  $: parallelResults = parallelResultsVal ? parallelResultsVal.filter((r): r is string => r !== undefined) : [];
+
+  let channelLatestVal: string | undefined;
+  ch.latest.subscribe(v => channelLatestVal = v);
+  $: channelLatest = channelLatestVal ?? "no-msg";
+
+  let channelHistoryVal: string[] = [];
+  ch.history.subscribe(v => channelHistoryVal = v);
+  $: channelHistory = [...channelHistoryVal];
+
+  let channelClosedVal = false;
+  chClose.isClosed.subscribe(v => channelClosedVal = v);
+  $: channelClosed = String(channelClosedVal);
+
+  let broadcastLatestVal: string | undefined;
+  bus.latest.subscribe(v => broadcastLatestVal = v);
+  $: broadcastLatest = broadcastLatestVal ?? "no-msg";
+
+  let pollDataVal: string | undefined;
+  poller.data.subscribe(v => pollDataVal = v);
+  $: pollData = pollDataVal ?? "no-data";
+
+  let pollCountVal = 0;
+  poller.pollCount.subscribe(v => pollCountVal = v);
+  $: pollCountStr = String(pollCountVal);
+
+  let isPollingVal = false;
+  pollerStop.isPolling.subscribe(v => isPollingVal = v);
+  $: isPolling = String(isPollingVal);
+
+  let pollStopDataVal: string | undefined;
+  pollerStop.data.subscribe(v => pollStopDataVal = v);
+  $: pollStopData = pollStopDataVal ?? "no-data";
+
+  // Action handlers
+  async function executeManualTask() {
+    await manualTask.execute();
+  }
+
+  async function executeErrorTask() {
+    await errorTask.execute();
+  }
+
+  async function sendMessages() {
+    await ch.send("msg-1");
+    await ch.send("msg-2");
+  }
+
+  function doBroadcast() {
+    bus.broadcast("hello");
+    bus.broadcast("world");
+  }
+
+  function stopPolling() {
+    pollerStop.stop();
+  }
+</script>
+
+{#if testType === "scope"}
+  <span data-testid="active">{scopeActive}</span>
+{/if}
+
+{#if testType === "task-immediate"}
+  <span data-testid="data">{taskData}</span>
+  <span data-testid="loading">{taskLoading}</span>
+{/if}
+
+{#if testType === "task-manual"}
+  <span data-testid="data">{manualTaskData}</span>
+  <button data-testid="execute-btn" on:click={executeManualTask}>Execute</button>
+{/if}
+
+{#if testType === "task-error"}
+  <span data-testid="data">{errorTaskData}</span>
+  <span data-testid="error">{errorTaskError}</span>
+  <button data-testid="execute-btn" on:click={executeErrorTask}>Execute</button>
+{/if}
+
+{#if testType === "parallel"}
+  <span data-testid="progress">{parallelProgress}</span>
+  <span data-testid="results">{JSON.stringify(parallelResults)}</span>
+{/if}
+
+{#if testType === "channel"}
+  <span data-testid="latest">{channelLatest}</span>
+  <span data-testid="history">{JSON.stringify(channelHistory)}</span>
+  <button data-testid="send-btn" on:click={sendMessages}>Send</button>
+{/if}
+
+{#if testType === "channel-close"}
+  <span data-testid="closed">{channelClosed}</span>
+  <button data-testid="close-btn" on:click={() => chClose.close()}>Close</button>
+{/if}
+
+{#if testType === "broadcast"}
+  <span data-testid="latest">{broadcastLatest}</span>
+  <button data-testid="broadcast-btn" on:click={doBroadcast}>Broadcast</button>
+{/if}
+
+{#if testType === "polling"}
+  <span data-testid="data">{pollData}</span>
+  <span data-testid="count">{pollCountStr}</span>
+{/if}
+
+{#if testType === "polling-stop"}
+  <span data-testid="data">{pollStopData}</span>
+  <span data-testid="polling">{isPolling}</span>
+  <button data-testid="stop-btn" on:click={stopPolling}>Stop</button>
+{/if}

package/tests/svelte.test.ts

@@ -0,0 +1,199 @@
+/**
+ * Integration tests for @go-go-scope/adapter-svelte
+ */
+import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, waitFor, fireEvent } from "@testing-library/svelte";
+import { tick } from "svelte";
+import Component from "./TestComponent.svelte";
+
+describe("Svelte adapter integration", () => {
+	describe("createScope", () => {
+		test("creates and auto-disposes scope", async () => {
+			const onDispose = vi.fn();
+
+			const { unmount } = render(Component, {
+				props: { testType: "scope", onDispose },
+			});
+
+			// Component should be active
+			expect(screen.getByTestId("active").textContent).toBe("true");
+
+			// Unmount
+			unmount();
+			await tick();
+
+			// Give time for async disposal
+			await new Promise((r) => setTimeout(r, 50));
+			expect(onDispose).toHaveBeenCalled();
+		});
+	});
+
+	describe("createTask", () => {
+		test("executes task immediately when immediate is true", async () => {
+			render(Component, {
+				props: { testType: "task-immediate" },
+			});
+
+			// Should start loading
+			expect(screen.getByTestId("loading").textContent).toBe("true");
+
+			// Wait for completion
+			await waitFor(() => {
+				expect(screen.getByTestId("data").textContent).toBe("fetched-data");
+			}, { timeout: 1000 });
+
+			expect(screen.getByTestId("loading").textContent).toBe("false");
+		});
+
+		test("manual execution with execute()", async () => {
+			const { component } = render(Component, {
+				props: { testType: "task-manual" },
+			});
+
+			// Should not have data initially
+			expect(screen.getByTestId("data").textContent).toBe("no-data");
+
+			// Execute manually
+			await fireEvent.click(screen.getByTestId("execute-btn"));
+
+			await waitFor(() => {
+				expect(screen.getByTestId("data").textContent).toBe("result-1");
+			});
+		});
+
+		test("handles task errors", async () => {
+			render(Component, {
+				props: { testType: "task-error" },
+			});
+
+			// Execute failing task
+			await fireEvent.click(screen.getByTestId("execute-btn"));
+
+			await waitFor(() => {
+				expect(screen.getByTestId("error").textContent).toBe("Task failed");
+			});
+
+			expect(screen.getByTestId("data").textContent).toBe("no-data");
+		});
+	});
+
+	describe("createParallel", () => {
+		test("executes tasks in parallel with progress", async () => {
+			render(Component, {
+				props: { testType: "parallel" },
+			});
+
+			// Should show progress
+			await waitFor(() => {
+				const progress = screen.getByTestId("progress").textContent;
+				return progress === "100";
+			}, { timeout: 5000 });
+
+			// Wait a bit more for results to update
+			await new Promise(r => setTimeout(r, 100));
+
+			const results = JSON.parse(screen.getByTestId("results").textContent ?? "[]");
+			expect(results).toContain("task-0");
+			expect(results).toContain("task-1");
+			expect(results).toContain("task-2");
+		});
+	});
+
+	describe("createChannel", () => {
+		test("sends and receives messages", async () => {
+			render(Component, {
+				props: { testType: "channel" },
+			});
+
+			// Send messages
+			await fireEvent.click(screen.getByTestId("send-btn"));
+
+			await waitFor(() => {
+				expect(screen.getByTestId("latest").textContent).toBe("msg-2");
+			});
+
+			const history = JSON.parse(screen.getByTestId("history").textContent ?? "[]");
+			expect(history).toEqual(["msg-1", "msg-2"]);
+		});
+
+		test("closes channel properly", async () => {
+			render(Component, {
+				props: { testType: "channel-close" },
+			});
+
+			expect(screen.getByTestId("closed").textContent).toBe("false");
+
+			// Close channel
+			await fireEvent.click(screen.getByTestId("close-btn"));
+
+			await waitFor(() => {
+				expect(screen.getByTestId("closed").textContent).toBe("true");
+			});
+		});
+	});
+
+	describe("createBroadcast", () => {
+		test("broadcasts to subscribers", async () => {
+			render(Component, {
+				props: { 
+					testType: "broadcast",
+				},
+			});
+
+			// Initial state
+			expect(screen.getByTestId("latest").textContent).toBe("no-msg");
+
+			// Broadcast
+			await fireEvent.click(screen.getByTestId("broadcast-btn"));
+
+			await waitFor(() => {
+				expect(screen.getByTestId("latest").textContent).toBe("world");
+			});
+		});
+	});
+
+	describe("createPolling", () => {
+		beforeEach(() => {
+			vi.useFakeTimers();
+		});
+
+		afterEach(() => {
+			vi.useRealTimers();
+		});
+
+		test("polls at specified interval", async () => {
+			render(Component, {
+				props: { testType: "polling" },
+			});
+
+			// First poll
+			await vi.advanceTimersByTimeAsync(10);
+			await tick();
+
+			expect(screen.getByTestId("data").textContent).toBe("poll-1");
+
+			// Second poll
+			await vi.advanceTimersByTimeAsync(1000);
+			await tick();
+
+			expect(screen.getByTestId("data").textContent).toBe("poll-2");
+		});
+
+		test("stops polling when stop() called", async () => {
+			render(Component, {
+				props: { testType: "polling-stop" },
+			});
+
+			await vi.advanceTimersByTimeAsync(10);
+			await tick();
+
+			expect(screen.getByTestId("polling").textContent).toBe("true");
+
+			// Stop polling
+			await fireEvent.click(screen.getByTestId("stop-btn"));
+			await tick();
+
+			expect(screen.getByTestId("polling").textContent).toBe("false");
+		});
+	});
+});

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"lib": ["ES2022", "ES2022.Error", "ESNext.Disposable", "DOM"],
+		"verbatimModuleSyntax": true
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "vitest/config";
+import { svelte } from "@sveltejs/vite-plugin-svelte";
+
+export default defineConfig({
+	plugins: [svelte()],
+	test: {
+		environment: "jsdom",
+		globals: true,
+	},
+	resolve: {
+		conditions: ['browser'],
+	},
+});