@go-go-scope/adapter-svelte 2.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 thelinuxlich (Alisson Cavalcante Agiani)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# @go-go-scope/adapter-svelte
+
+Svelte 5 runes integration for go-go-scope. Provides reactive stores that work with Svelte's `$` prefix.
+
+## Installation
+
+```bash
+npm install @go-go-scope/adapter-svelte
+```
+
+## Usage
+
+```svelte
+<script>
+  import { createScope, createTask, createChannel } from '@go-go-scope/adapter-svelte';
+
+  // Create a reactive scope
+  const scope = createScope({ name: 'my-component' });
+
+  // Execute tasks with reactive state
+  const task = createTask(async () => {
+    const response = await fetch('/api/data');
+    return response.json();
+  }, { immediate: true });
+
+  // Use channels for communication
+  const channel = createChannel<string>();
+
+  async function sendMessage() {
+    await channel.send('Hello!');
+  }
+</script>
+
+<div>
+  {#if $task.isLoading}
+    <p>Loading...</p>
+  {:else if $task.error}
+    <p>Error: {$task.error.message}</p>
+  {:else}
+    <p>Data: {$task.data}</p>
+  {/if}
+  
+  <button onclick={sendMessage}>Send Message</button>
+  <p>Latest: {$channel.latest}</p>
+</div>
+```
+
+## API
+
+### `createScope(options?)`
+Creates a reactive scope that auto-disposes on component destroy.
+
+### `createTask(factory, options?)`
+Creates a reactive task store with `data`, `error`, `isLoading`, `isReady`, and `execute()`.
+
+### `createParallel(factories, options?)`
+Executes tasks in parallel with reactive progress tracking.
+
+### `createChannel(options?)`
+Creates a reactive channel for Go-style communication.
+
+### `createBroadcast()`
+Creates a reactive broadcast channel for pub/sub patterns.
+
+### `createPolling(factory, options)`
+Creates a reactive polling mechanism.
+
+### `createStore(initialValue)`
+Creates a simple reactive store compatible with Svelte's `$` prefix.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,280 @@
+import * as svelte_store from 'svelte/store';
+import { Readable } from 'svelte/store';
+import { Result, Scope } from 'go-go-scope';
+export { BroadcastChannel, Channel, Result, Scope } from 'go-go-scope';
+
+/**
+ * Options for creating a scope
+ */
+interface CreateScopeOptions {
+    /** Scope name for debugging */
+    name?: string;
+    /** Timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Reactive scope with automatic cleanup
+ */
+interface ReactiveScope extends Scope {
+    /** Whether the scope is currently active */
+    readonly isActive: Readable<boolean>;
+}
+/**
+ * Create a reactive scope that automatically disposes on component destroy.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   const s = createScope({ name: "my-component" });
+ *
+ *   // Scope is automatically disposed when component is destroyed
+ *   const [err, result] = await s.task(() => fetchData());
+ * </script>
+ * ```
+ */
+declare function createScope(options?: CreateScopeOptions): ReactiveScope;
+/**
+ * Options for creating a task
+ */
+interface CreateTaskOptions<T> {
+    /** Task name for debugging */
+    name?: string;
+    /** Whether to execute immediately */
+    immediate?: boolean;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Retry options */
+    retry?: {
+        maxRetries?: number;
+        delay?: number;
+    };
+    /** Initial data value */
+    initialData?: T;
+}
+/**
+ * Reactive task state
+ */
+interface TaskState<T> {
+    /** Current data (undefined if not loaded) */
+    readonly data: Readable<T | undefined>;
+    /** Error if task failed */
+    readonly error: Readable<Error | undefined>;
+    /** Whether task is currently running */
+    readonly isLoading: Readable<boolean>;
+    /** Whether task has been executed */
+    readonly isReady: Readable<boolean>;
+    /** Execute the task */
+    readonly execute: () => Promise<Result<Error, T>>;
+}
+/**
+ * Create a reactive task that integrates with Svelte's store system.
+ * Returns a store-like object that can be used with `$` prefix.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   const task = createTask(
+ *     async () => fetchUser(userId),
+ *     { immediate: true }
+ *   );
+ * </script>
+ *
+ * {#if $task.isLoading}
+ *   <p>Loading...</p>
+ * {:else if $task.error}
+ *   <p>Error: {$task.error.message}</p>
+ * {:else}
+ *   <p>{$task.data.name}</p>
+ * {/if}
+ * ```
+ */
+declare function createTask<T>(factory: () => Promise<T>, options?: CreateTaskOptions<T>): TaskState<T>;
+/**
+ * Options for parallel execution
+ */
+interface CreateParallelOptions {
+    /** Concurrency limit */
+    concurrency?: number;
+    /** Whether to execute immediately */
+    immediate?: boolean;
+}
+/**
+ * Reactive parallel task state
+ */
+interface ParallelState<T> {
+    /** Results from all tasks */
+    readonly results: Readable<(T | undefined)[]>;
+    /** Errors from failed tasks */
+    readonly errors: Readable<(Error | undefined)[]>;
+    /** Whether any task is running */
+    readonly isLoading: Readable<boolean>;
+    /** Progress percentage (0-100) */
+    readonly progress: Readable<number>;
+    /** Execute all tasks */
+    readonly execute: () => Promise<Result<Error, T>[]>;
+}
+/**
+ * Create reactive parallel task execution.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   const parallel = createParallel(
+ *     urls.map(url => () => fetch(url).then(r => r.json())),
+ *     { concurrency: 3, immediate: true }
+ *   );
+ * </script>
+ *
+ * <progress value={$parallel.progress} max="100" />
+ * ```
+ */
+declare function createParallel<T>(factories: (() => Promise<T>)[], options?: CreateParallelOptions): ParallelState<T>;
+/**
+ * Options for creating a channel
+ */
+interface CreateChannelOptions {
+    /** Buffer size */
+    bufferSize?: number;
+    /** Maximum history to keep */
+    historySize?: number;
+}
+/**
+ * Reactive channel state
+ */
+interface ChannelState<T> {
+    /** Latest received value */
+    readonly latest: Readable<T | undefined>;
+    /** History of values */
+    readonly history: Readable<readonly T[]>;
+    /** Whether channel is closed */
+    readonly isClosed: Readable<boolean>;
+    /** Send a value */
+    readonly send: (value: T) => Promise<void>;
+    /** Close the channel */
+    readonly close: () => void;
+}
+/**
+ * Create a reactive channel for Go-style communication.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   const ch = createChannel<string>();
+ *
+ *   async function sendMessage() {
+ *     await ch.send("Hello!");
+ *   }
+ * </script>
+ *
+ * <p>Latest: {$ch.latest}</p>
+ * <button onclick={sendMessage}>Send</button>
+ * ```
+ */
+declare function createChannel<T>(options?: CreateChannelOptions): ChannelState<T>;
+/**
+ * Reactive broadcast state
+ */
+interface BroadcastState<T> {
+    /** Latest broadcasted value */
+    readonly latest: Readable<T | undefined>;
+    /** Subscribe to broadcasts */
+    readonly subscribe: (callback: (value: T) => void) => {
+        unsubscribe: () => void;
+    };
+    /** Broadcast a value */
+    readonly broadcast: (value: T) => void;
+}
+/**
+ * Create a reactive broadcast channel.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   const bus = createBroadcast<string>();
+ *
+ *   // Subscribe
+ *   bus.subscribe(msg => console.log(msg));
+ *
+ *   function send() {
+ *     bus.broadcast("Hello!");
+ *   }
+ * </script>
+ *
+ * <p>Latest: {$bus.latest}</p>
+ * ```
+ */
+declare function createBroadcast<T>(): BroadcastState<T>;
+/**
+ * Options for polling
+ */
+interface CreatePollingOptions {
+    /** Interval in milliseconds */
+    interval: number;
+    /** Whether to start immediately */
+    immediate?: boolean;
+    /** Continue when tab is hidden */
+    continueOnHidden?: boolean;
+}
+/**
+ * Reactive polling state
+ */
+interface PollingState<T> {
+    /** Latest data */
+    readonly data: Readable<T | undefined>;
+    /** Error if polling failed */
+    readonly error: Readable<Error | undefined>;
+    /** Whether currently polling */
+    readonly isPolling: Readable<boolean>;
+    /** Number of polls completed */
+    readonly pollCount: Readable<number>;
+    /** Start polling */
+    readonly start: () => void;
+    /** Stop polling */
+    readonly stop: () => void;
+}
+/**
+ * Create a reactive polling mechanism.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   const poller = createPolling(
+ *     async () => fetchLatestData(),
+ *     { interval: 5000, immediate: true }
+ *   );
+ * </script>
+ *
+ * {#if $poller.data}
+ *   <p>{$poller.data}</p>
+ * {/if}
+ * <button onclick={() => $poller.stop()}>Stop</button>
+ * ```
+ */
+declare function createPolling<T>(factory: () => Promise<T>, options: CreatePollingOptions): PollingState<T>;
+/**
+ * Create a reactive value that can be subscribed to (Svelte store contract).
+ * Compatible with Svelte 5's `$` prefix.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   const count = createStore(0);
+ *
+ *   function increment() {
+ *     $count++;
+ *   }
+ * </script>
+ *
+ * <button onclick={increment}>
+ *   Count: {$count}
+ * </button>
+ * ```
+ */
+declare function createStore<T>(initialValue: T): {
+    subscribe: (this: void, run: svelte_store.Subscriber<T>, invalidate?: () => void) => svelte_store.Unsubscriber;
+    set: (this: void, value: T) => void;
+    update: (this: void, updater: svelte_store.Updater<T>) => void;
+};
+
+export { createBroadcast, createChannel, createParallel, createPolling, createScope, createStore, createTask };
+export type { BroadcastState, ChannelState, CreateChannelOptions, CreateParallelOptions, CreatePollingOptions, CreateScopeOptions, CreateTaskOptions, ParallelState, PollingState, ReactiveScope, TaskState };

package/dist/index.mjs

@@ -0,0 +1,222 @@
+import { scope, BroadcastChannel } from 'go-go-scope';
+import { onDestroy } from 'svelte';
+import { writable } from 'svelte/store';
+
+function createScope(options = {}) {
+  const isActive = writable(true);
+  const s = scope({
+    name: options.name,
+    timeout: options.timeout
+  });
+  onDestroy(() => {
+    isActive.set(false);
+    s[Symbol.asyncDispose]().catch(() => {
+    });
+  });
+  return Object.assign(s, {
+    isActive: { subscribe: isActive.subscribe }
+  });
+}
+function createTask(factory, options = {}) {
+  const s = createScope({ name: options.name ?? "createTask" });
+  const data = writable(options.initialData);
+  const error = writable(void 0);
+  const isLoading = writable(false);
+  const isReady = writable(false);
+  const execute = async () => {
+    isLoading.set(true);
+    error.set(void 0);
+    try {
+      const [err, result] = await s.task(
+        async () => await factory(),
+        {
+          timeout: options.timeout,
+          retry: options.retry
+        }
+      );
+      if (err) {
+        error.set(err instanceof Error ? err : new Error(String(err)));
+        data.set(void 0);
+        return [err, void 0];
+      }
+      data.set(result);
+      isReady.set(true);
+      return [void 0, result];
+    } finally {
+      isLoading.set(false);
+    }
+  };
+  if (options.immediate) {
+    execute();
+  }
+  return {
+    data: { subscribe: data.subscribe },
+    error: { subscribe: error.subscribe },
+    isLoading: { subscribe: isLoading.subscribe },
+    isReady: { subscribe: isReady.subscribe },
+    execute
+  };
+}
+function createParallel(factories, options = {}) {
+  const s = createScope({ name: "createParallel" });
+  const results = writable([]);
+  const errors = writable([]);
+  const isLoading = writable(false);
+  const progress = writable(0);
+  const execute = async () => {
+    isLoading.set(true);
+    progress.set(0);
+    results.set(new Array(factories.length).fill(void 0));
+    errors.set(new Array(factories.length).fill(void 0));
+    try {
+      const taskFactories = factories.map((factory, index) => {
+        return async () => {
+          const [err, result] = await s.task(async () => await factory());
+          if (err) {
+            errors.update((e) => {
+              e[index] = err instanceof Error ? err : new Error(String(err));
+              return e;
+            });
+          } else {
+            results.update((r) => {
+              r[index] = result;
+              return r;
+            });
+          }
+          progress.set(Math.round((index + 1) / factories.length * 100));
+          return [err, result];
+        };
+      });
+      return await s.parallel(taskFactories, {
+        concurrency: options.concurrency
+      });
+    } finally {
+      isLoading.set(false);
+    }
+  };
+  if (options.immediate) {
+    execute();
+  }
+  return {
+    results: { subscribe: results.subscribe },
+    errors: { subscribe: errors.subscribe },
+    isLoading: { subscribe: isLoading.subscribe },
+    progress: { subscribe: progress.subscribe },
+    execute
+  };
+}
+function createChannel(options = {}) {
+  const s = createScope({ name: "createChannel" });
+  const ch = s.channel(options.bufferSize ?? 0);
+  const latest = writable(void 0);
+  const history = writable([]);
+  const isClosed = writable(false);
+  const receiveLoop = async () => {
+    for await (const value of ch) {
+      latest.set(value);
+      history.update((h) => [...h.slice(-(options.historySize ?? 100)), value]);
+    }
+    isClosed.set(true);
+  };
+  receiveLoop();
+  return {
+    latest: { subscribe: latest.subscribe },
+    history: { subscribe: history.subscribe },
+    isClosed: { subscribe: isClosed.subscribe },
+    send: async (value) => {
+      await ch.send(value);
+    },
+    close: () => {
+      ch.close();
+    }
+  };
+}
+function createBroadcast() {
+  const bc = new BroadcastChannel();
+  const latest = writable(void 0);
+  return {
+    latest: { subscribe: latest.subscribe },
+    subscribe: (callback) => {
+      (async () => {
+        for await (const value of bc.subscribe()) {
+          latest.set(value);
+          callback(value);
+        }
+      })();
+      return {
+        unsubscribe: () => bc.close()
+      };
+    },
+    broadcast: async (value) => {
+      await bc.send(value);
+      latest.set(value);
+    }
+  };
+}
+function createPolling(factory, options) {
+  const s = createScope({ name: "createPolling" });
+  const data = writable(void 0);
+  const error = writable(void 0);
+  const isPolling = writable(false);
+  const pollCount = writable(0);
+  const poller = s.poll(
+    async () => {
+      try {
+        const result = await factory();
+        return { success: true, value: result };
+      } catch (e) {
+        return { success: false, error: e };
+      }
+    },
+    (result) => {
+      pollCount.update((c) => c + 1);
+      if (result.success) {
+        data.set(result.value);
+      } else {
+        error.set(result.error instanceof Error ? result.error : new Error(String(result.error)));
+      }
+    },
+    { interval: options.interval, immediate: options.immediate }
+  );
+  const updateStatus = () => {
+    const status = poller.status();
+    isPolling.set(status.running);
+  };
+  if (!options.continueOnHidden && typeof document !== "undefined") {
+    const handler = () => {
+      if (document.hidden) {
+        poller.stop();
+        updateStatus();
+      } else if (options.immediate !== false) {
+        poller.start();
+        updateStatus();
+      }
+    };
+    document.addEventListener("visibilitychange", handler);
+  }
+  updateStatus();
+  return {
+    data: { subscribe: data.subscribe },
+    error: { subscribe: error.subscribe },
+    isPolling: { subscribe: isPolling.subscribe },
+    pollCount: { subscribe: pollCount.subscribe },
+    start: () => {
+      poller.start();
+      updateStatus();
+    },
+    stop: () => {
+      poller.stop();
+      updateStatus();
+    }
+  };
+}
+function createStore(initialValue) {
+  const { subscribe, set, update } = writable(initialValue);
+  return {
+    subscribe,
+    set,
+    update
+  };
+}
+
+export { createBroadcast, createChannel, createParallel, createPolling, createScope, createStore, createTask };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@go-go-scope/adapter-svelte",
+  "version": "2.7.0",
+  "description": "Svelte 5 runes integration for go-go-scope",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "keywords": [
+    "go-go-scope",
+    "svelte",
+    "svelte5",
+    "runes",
+    "reactivity"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "author": "thelinuxlich",
+  "license": "MIT",
+  "peerDependencies": {
+    "svelte": "^5.0.0",
+    "go-go-scope": "2.7.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.4",
+    "@sveltejs/vite-plugin-svelte": "^4.0.0",
+    "@testing-library/svelte": "^5.2.0",
+    "@types/node": "^24",
+    "jsdom": "^24.0.0",
+    "pkgroll": "^2.26.3",
+    "svelte": "^5.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "go-go-scope": "2.7.0"
+  },
+  "scripts": {
+    "build": "pkgroll --clean-dist",
+    "lint": "biome check --write src/",
+    "test": "vitest run",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit"
+  }
+}