@thomasfosterau/effect-svelte 0.0.0

package/dist/effect.svelte.d.ts

@@ -0,0 +1,51 @@
+import { Effect } from "effect";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+
+//#region src/effect.svelte.d.ts
+interface UseEffectOptions {
+  /**
+   * If true, the effect will run immediately on mount.
+   * If false, the effect will only run when manually triggered via run().
+   * @default false
+   */
+  immediate?: boolean;
+}
+interface UseEffectReturn<A, E> {
+  /**
+   * The current result state of the effect. Re-running preserves the previous
+   * value as a waiting `Success` (stale-while-revalidate).
+   */
+  readonly current: AsyncResult.AsyncResult<A, E>;
+  /**
+   * Manually trigger execution of the effect
+   */
+  run: () => void;
+  /**
+   * Interrupt the currently running effect
+   */
+  interrupt: () => void;
+}
+/**
+ * Run a single Effect and track its result state.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useEffect, AsyncResult } from '@thomasfosterau/effect-svelte';
+ *   import { Effect } from 'effect';
+ *
+ *   const fetchData = useEffect(
+ *     Effect.delay(Effect.succeed(42), '1 second'),
+ *     { immediate: true }
+ *   );
+ * </script>
+ *
+ * {#if AsyncResult.isSuccess(fetchData.current)}
+ *   <p>Result: {fetchData.current.value}</p>
+ * {/if}
+ * ```
+ */
+declare function useEffect<A, E, R>(effect: Effect.Effect<A, E, R>, options?: UseEffectOptions): UseEffectReturn<A, E>;
+//#endregion
+export { UseEffectOptions, UseEffectReturn, useEffect };
+//# sourceMappingURL=effect.svelte.d.ts.map

package/dist/effect.svelte.js

@@ -0,0 +1,68 @@
+import { getRuntimeContext } from "./context.svelte.js";
+import { interruptFiber, runFork } from "./internal/run.js";
+import { makeResult } from "./internal/result.svelte.js";
+import { Effect, Fiber } from "effect";
+//#region src/effect.svelte.ts
+/**
+* Run a single Effect and track its result state.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { useEffect, AsyncResult } from '@thomasfosterau/effect-svelte';
+*   import { Effect } from 'effect';
+*
+*   const fetchData = useEffect(
+*     Effect.delay(Effect.succeed(42), '1 second'),
+*     { immediate: true }
+*   );
+* <\/script>
+*
+* {#if AsyncResult.isSuccess(fetchData.current)}
+*   <p>Result: {fetchData.current.value}</p>
+* {/if}
+* ```
+*/
+function useEffect(effect, options = {}) {
+	const { immediate = false } = options;
+	const runtime = getRuntimeContext();
+	const state = makeResult();
+	let currentFiber = null;
+	const run = () => {
+		if (currentFiber !== null) interruptFiber(currentFiber);
+		state.startWaiting();
+		const runningFiber = runFork(runtime)(effect);
+		currentFiber = runningFiber;
+		runFork(runtime)(Effect.gen(function* () {
+			const exit = yield* Fiber.await(runningFiber);
+			if (currentFiber === runningFiber) {
+				state.settle(exit);
+				currentFiber = null;
+			}
+		}));
+	};
+	const interrupt = () => {
+		if (currentFiber !== null) {
+			interruptFiber(currentFiber);
+			currentFiber = null;
+			state.reset();
+		}
+	};
+	$effect(() => {
+		if (immediate) run();
+		return () => {
+			interrupt();
+		};
+	});
+	return {
+		get current() {
+			return state.current;
+		},
+		run,
+		interrupt
+	};
+}
+//#endregion
+export { useEffect };
+
+//# sourceMappingURL=effect.svelte.js.map

package/dist/effect.svelte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.svelte.js","names":["getRuntime"],"sources":["../src/effect.svelte.ts"],"sourcesContent":["import { Effect, Fiber } from \"effect\";\nimport type * as AsyncResult from \"effect/unstable/reactivity/AsyncResult\";\nimport { getRuntime } from \"./context.svelte.js\";\nimport { interruptFiber, runFork, type RuntimeLike } from \"./internal/run.js\";\nimport { makeResult } from \"./internal/result.svelte.js\";\n\nexport interface UseEffectOptions {\n  /**\n   * If true, the effect will run immediately on mount.\n   * If false, the effect will only run when manually triggered via run().\n   * @default false\n   */\n  immediate?: boolean;\n}\n\nexport interface UseEffectReturn<A, E> {\n  /**\n   * The current result state of the effect. Re-running preserves the previous\n   * value as a waiting `Success` (stale-while-revalidate).\n   */\n  readonly current: AsyncResult.AsyncResult<A, E>;\n\n  /**\n   * Manually trigger execution of the effect\n   */\n  run: () => void;\n\n  /**\n   * Interrupt the currently running effect\n   */\n  interrupt: () => void;\n}\n\n/**\n * Run a single Effect and track its result state.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { useEffect, AsyncResult } from '@thomasfosterau/effect-svelte';\n *   import { Effect } from 'effect';\n *\n *   const fetchData = useEffect(\n *     Effect.delay(Effect.succeed(42), '1 second'),\n *     { immediate: true }\n *   );\n * </script>\n *\n * {#if AsyncResult.isSuccess(fetchData.current)}\n *   <p>Result: {fetchData.current.value}</p>\n * {/if}\n * ```\n */\nexport function useEffect<A, E, R>(\n  effect: Effect.Effect<A, E, R>,\n  options: UseEffectOptions = {},\n): UseEffectReturn<A, E> {\n  const { immediate = false } = options;\n  const runtime = getRuntime() as RuntimeLike<R>;\n\n  const state = makeResult<A, E>();\n  let currentFiber: Fiber.Fiber<A, E> | null = null;\n\n  const run = () => {\n    // Interrupt any existing fiber\n    if (currentFiber !== null) {\n      interruptFiber(currentFiber);\n    }\n\n    // Mark as waiting, preserving the previous value if there is one.\n    state.startWaiting();\n\n    // Run the effect and capture the fiber reference\n    const runningFiber = runFork(runtime)(effect);\n    currentFiber = runningFiber;\n\n    // Settle the result when the fiber completes, unless a newer run replaced it.\n    runFork(runtime)(\n      Effect.gen(function* () {\n        const exit = yield* Fiber.await(runningFiber);\n        if (currentFiber === runningFiber) {\n          state.settle(exit);\n          currentFiber = null;\n        }\n      }),\n    );\n  };\n\n  const interrupt = () => {\n    if (currentFiber !== null) {\n      interruptFiber(currentFiber);\n      currentFiber = null;\n      // Return to the initial state so the effect can be run again cleanly.\n      state.reset();\n    }\n  };\n\n  // Set up effect lifecycle\n  $effect(() => {\n    if (immediate) {\n      run();\n    }\n\n    // Cleanup: interrupt any running fiber on unmount\n    return () => {\n      interrupt();\n    };\n  });\n\n  return {\n    get current() {\n      return state.current;\n    },\n    run,\n    interrupt,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,SAAgB,UACd,QACA,UAA4B,CAAC,GACN;CACvB,MAAM,EAAE,YAAY,UAAU;CAC9B,MAAM,UAAUA,kBAAW;CAE3B,MAAM,QAAQ,WAAiB;CAC/B,IAAI,eAAyC;CAE7C,MAAM,YAAY;EAEhB,IAAI,iBAAiB,MACnB,eAAe,YAAY;EAI7B,MAAM,aAAa;EAGnB,MAAM,eAAe,QAAQ,OAAO,EAAE,MAAM;EAC5C,eAAe;EAGf,QAAQ,OAAO,EACb,OAAO,IAAI,aAAa;GACtB,MAAM,OAAO,OAAO,MAAM,MAAM,YAAY;GAC5C,IAAI,iBAAiB,cAAc;IACjC,MAAM,OAAO,IAAI;IACjB,eAAe;GACjB;EACF,CAAC,CACH;CACF;CAEA,MAAM,kBAAkB;EACtB,IAAI,iBAAiB,MAAM;GACzB,eAAe,YAAY;GAC3B,eAAe;GAEf,MAAM,MAAM;EACd;CACF;CAGA,cAAc;EACZ,IAAI,WACF,IAAI;EAIN,aAAa;GACX,UAAU;EACZ;CACF,CAAC;CAED,OAAO;EACL,IAAI,UAAU;GACZ,OAAO,MAAM;EACf;EACA;EACA;CACF;AACF"}

package/dist/emitter.d.ts

@@ -0,0 +1,45 @@
+import { Stream } from "effect";
+
+//#region src/emitter.d.ts
+/**
+ * A bridge that converts Svelte reactive state into Effect streams.
+ * Use emit() to push values from Svelte's $effect, and consume via the stream property.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { SignalEmitter } from 'effect-svelte';
+ *
+ *   let count = $state(0);
+ *   const emitter = new SignalEmitter<number>();
+ *
+ *   $effect(() => {
+ *     emitter.emit(count);
+ *   });
+ *
+ *   // Now emitter.stream can be used in Effect pipelines
+ *   // Example: Process the stream with Effect
+ *   const processed = emitter.stream.pipe(
+ *     Stream.map(n => n * 2)
+ *   );
+ * </script>
+ * ```
+ */
+declare class SignalEmitter<A> {
+  private _stream;
+  private _emit;
+  constructor();
+  /**
+   * Emit a value into the stream.
+   * This should typically be called from within a $effect to track reactive dependencies.
+   */
+  emit(value: A): void;
+  /**
+   * The Effect stream that emits values pushed via emit().
+   * Can be used in Effect pipelines, composed with other streams, etc.
+   */
+  get stream(): Stream.Stream<A, never, never>;
+}
+//#endregion
+export { SignalEmitter };
+//# sourceMappingURL=emitter.d.ts.map

package/dist/emitter.js

@@ -0,0 +1,60 @@
+import { Effect, Queue, Stream } from "effect";
+//#region src/emitter.ts
+/**
+* A bridge that converts Svelte reactive state into Effect streams.
+* Use emit() to push values from Svelte's $effect, and consume via the stream property.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { SignalEmitter } from 'effect-svelte';
+*
+*   let count = $state(0);
+*   const emitter = new SignalEmitter<number>();
+*
+*   $effect(() => {
+*     emitter.emit(count);
+*   });
+*
+*   // Now emitter.stream can be used in Effect pipelines
+*   // Example: Process the stream with Effect
+*   const processed = emitter.stream.pipe(
+*     Stream.map(n => n * 2)
+*   );
+* <\/script>
+* ```
+*/
+var SignalEmitter = class {
+	_stream;
+	_emit = () => {};
+	constructor() {
+		this._stream = Stream.callback((queue) => {
+			let isDone = false;
+			this._emit = (value) => {
+				if (!isDone) Queue.offerUnsafe(queue, value);
+			};
+			return Effect.sync(() => {
+				isDone = true;
+				this._emit = () => {};
+			});
+		});
+	}
+	/**
+	* Emit a value into the stream.
+	* This should typically be called from within a $effect to track reactive dependencies.
+	*/
+	emit(value) {
+		this._emit(value);
+	}
+	/**
+	* The Effect stream that emits values pushed via emit().
+	* Can be used in Effect pipelines, composed with other streams, etc.
+	*/
+	get stream() {
+		return this._stream;
+	}
+};
+//#endregion
+export { SignalEmitter };
+
+//# sourceMappingURL=emitter.js.map

package/dist/emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.js","names":[],"sources":["../src/emitter.ts"],"sourcesContent":["import { Stream, Effect, Queue } from \"effect\";\n\n/**\n * A bridge that converts Svelte reactive state into Effect streams.\n * Use emit() to push values from Svelte's $effect, and consume via the stream property.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { SignalEmitter } from 'effect-svelte';\n *\n *   let count = $state(0);\n *   const emitter = new SignalEmitter<number>();\n *\n *   $effect(() => {\n *     emitter.emit(count);\n *   });\n *\n *   // Now emitter.stream can be used in Effect pipelines\n *   // Example: Process the stream with Effect\n *   const processed = emitter.stream.pipe(\n *     Stream.map(n => n * 2)\n *   );\n * </script>\n * ```\n */\nexport class SignalEmitter<A> {\n  private _stream: Stream.Stream<A, never, never>;\n  private _emit: (value: A) => void = () => {};\n\n  constructor() {\n    // Use Stream.callback to create a stream with a push-based API\n    this._stream = Stream.callback<A>((queue) => {\n      let isDone = false;\n\n      // Set up the emit function to immediately emit values\n      this._emit = (value: A) => {\n        if (!isDone) {\n          Queue.offerUnsafe(queue, value);\n        }\n      };\n\n      // Return cleanup function\n      return Effect.sync(() => {\n        isDone = true;\n        this._emit = () => {};\n      });\n    });\n  }\n\n  /**\n   * Emit a value into the stream.\n   * This should typically be called from within a $effect to track reactive dependencies.\n   */\n  emit(value: A): void {\n    this._emit(value);\n  }\n\n  /**\n   * The Effect stream that emits values pushed via emit().\n   * Can be used in Effect pipelines, composed with other streams, etc.\n   */\n  get stream(): Stream.Stream<A, never, never> {\n    return this._stream;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAa,gBAAb,MAA8B;CAC5B;CACA,cAA0C,CAAC;CAE3C,cAAc;EAEZ,KAAK,UAAU,OAAO,UAAa,UAAU;GAC3C,IAAI,SAAS;GAGb,KAAK,SAAS,UAAa;IACzB,IAAI,CAAC,QACH,MAAM,YAAY,OAAO,KAAK;GAElC;GAGA,OAAO,OAAO,WAAW;IACvB,SAAS;IACT,KAAK,cAAc,CAAC;GACtB,CAAC;EACH,CAAC;CACH;;;;;CAMA,KAAK,OAAgB;EACnB,KAAK,MAAM,KAAK;CAClB;;;;;CAMA,IAAI,SAAyC;EAC3C,OAAO,KAAK;CACd;AACF"}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { RuntimeLike } from "./internal/run.js";
+import { getRuntimeContext, provideRuntime } from "./context.svelte.js";
+import { SvelteRuntime, defaultSvelteRuntime } from "./runtime.js";
+import { useScope, useScopeCallback } from "./scope.svelte.js";
+import { UseEffectOptions, UseEffectReturn, useEffect } from "./effect.svelte.js";
+import { UseStreamReturn, useStream } from "./stream.svelte.js";
+import { DerivedReturn, useDerived } from "./derived.svelte.js";
+import { UseQueryReturn, useQuery } from "./query.svelte.js";
+import { UsePubSubReturn, UseSubscriptionRefReturn, usePubSub, useSubscriptionRef } from "./subscription.svelte.js";
+import { ReactiveMutationReturn, ReactiveQueryReturn, ReactiveStreamReturn, reactiveMutation, reactiveQuery, reactiveStream, useInvalidateKeys } from "./reactivity.svelte.js";
+import { SignalEmitter } from "./emitter.js";
+import { Store_d_exports } from "./Store.js";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+export { AsyncResult, type DerivedReturn, type ReactiveMutationReturn, type ReactiveQueryReturn, type ReactiveStreamReturn, type RuntimeLike, SignalEmitter, Store_d_exports as Store, SvelteRuntime, type UseEffectOptions, type UseEffectReturn, type UsePubSubReturn, type UseQueryReturn, type UseStreamReturn, type UseSubscriptionRefReturn, defaultSvelteRuntime, getRuntimeContext as getRuntime, provideRuntime, reactiveMutation, reactiveQuery, reactiveStream, useDerived, useEffect, useInvalidateKeys, usePubSub, useQuery, useScope, useScopeCallback, useStream, useSubscriptionRef };

package/dist/index.js

@@ -0,0 +1,13 @@
+import { SvelteRuntime, defaultSvelteRuntime } from "./runtime.js";
+import { getRuntimeContext, provideRuntime } from "./context.svelte.js";
+import { useScope, useScopeCallback } from "./scope.svelte.js";
+import { useEffect } from "./effect.svelte.js";
+import { useStream } from "./stream.svelte.js";
+import { useDerived } from "./derived.svelte.js";
+import { useQuery } from "./query.svelte.js";
+import { usePubSub, useSubscriptionRef } from "./subscription.svelte.js";
+import { reactiveMutation, reactiveQuery, reactiveStream, useInvalidateKeys } from "./reactivity.svelte.js";
+import { SignalEmitter } from "./emitter.js";
+import { Store_exports } from "./Store.js";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+export { AsyncResult, SignalEmitter, Store_exports as Store, SvelteRuntime, defaultSvelteRuntime, getRuntimeContext as getRuntime, provideRuntime, reactiveMutation, reactiveQuery, reactiveStream, useDerived, useEffect, useInvalidateKeys, usePubSub, useQuery, useScope, useScopeCallback, useStream, useSubscriptionRef };

package/dist/internal/result.svelte.js

@@ -0,0 +1,36 @@
+import { Cause, Exit, Option } from "effect";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+//#region src/internal/result.svelte.ts
+/**
+* Creates a {@link ResultState}. Must be called during component
+* initialisation (it allocates `$state`).
+*/
+function makeResult() {
+	let current = $state(AsyncResult.initial());
+	return {
+		get current() {
+			return current;
+		},
+		startWaiting() {
+			current = AsyncResult.waiting(current);
+		},
+		reset() {
+			current = AsyncResult.initial();
+		},
+		settle(exit) {
+			if (Exit.isFailure(exit) && Cause.hasInterrupts(exit.cause)) return;
+			current = AsyncResult.fromExitWithPrevious(exit, Option.some(current));
+		},
+		succeed(value) {
+			current = AsyncResult.success(value);
+		},
+		failCause(cause) {
+			if (Cause.hasInterrupts(cause)) return;
+			current = AsyncResult.failureWithPrevious(cause, { previous: Option.some(current) });
+		}
+	};
+}
+//#endregion
+export { makeResult };
+
+//# sourceMappingURL=result.svelte.js.map

package/dist/internal/result.svelte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.svelte.js","names":[],"sources":["../../src/internal/result.svelte.ts"],"sourcesContent":["import { Cause, Exit, Option } from \"effect\";\nimport * as AsyncResult from \"effect/unstable/reactivity/AsyncResult\";\n\n/**\n * A reactive holder for an {@link AsyncResult.AsyncResult}, used by the hooks\n * that drive a result from a fiber's lifecycle (`useEffect`, `useDerived`,\n * `reactiveQuery`, ...).\n *\n * The value lives in a `$state` field, so reassigning it through the methods\n * below re-runs any effect or template that read `current`. The transitions\n * follow Effect's native stale-while-revalidate semantics: marking a result as\n * waiting preserves the previous value, and settling a failure carries the last\n * success forward so the UI never has to flash back to a spinner.\n */\nexport interface ResultState<A, E> {\n  /** The current result. Read this inside an effect or template to track it. */\n  readonly current: AsyncResult.AsyncResult<A, E>;\n\n  /**\n   * Mark the current result as waiting, preserving any value it already holds\n   * (an `Initial` becomes a waiting `Initial`, a `Success` keeps its value).\n   */\n  startWaiting(): void;\n\n  /** Reset back to the non-waiting `Initial` state. */\n  reset(): void;\n\n  /**\n   * Settle from a fiber `Exit`. Interruptions are ignored (a new run is\n   * presumably starting); successes and failures carry the previous value\n   * forward.\n   */\n  settle(exit: Exit.Exit<A, E>): void;\n\n  /** Replace the result with a non-waiting `Success`. */\n  succeed(value: A): void;\n\n  /**\n   * Replace the result with a `Failure` (carrying the previous success\n   * forward). Interrupt-only causes are ignored.\n   */\n  failCause(cause: Cause.Cause<E>): void;\n}\n\n/**\n * Creates a {@link ResultState}. Must be called during component\n * initialisation (it allocates `$state`).\n */\nexport function makeResult<A, E>(): ResultState<A, E> {\n  let current = $state<AsyncResult.AsyncResult<A, E>>(AsyncResult.initial<A, E>());\n\n  return {\n    get current() {\n      return current;\n    },\n    startWaiting() {\n      current = AsyncResult.waiting(current);\n    },\n    reset() {\n      current = AsyncResult.initial<A, E>();\n    },\n    settle(exit) {\n      if (Exit.isFailure(exit) && Cause.hasInterrupts(exit.cause)) return;\n      current = AsyncResult.fromExitWithPrevious(exit, Option.some(current));\n    },\n    succeed(value) {\n      current = AsyncResult.success<A, E>(value);\n    },\n    failCause(cause) {\n      if (Cause.hasInterrupts(cause)) return;\n      current = AsyncResult.failureWithPrevious<A, E>(cause, { previous: Option.some(current) });\n    },\n  };\n}\n"],"mappings":";;;;;;;AAgDA,SAAgB,aAAsC;CACpD,IAAI,UAAU,OAAsC,YAAY,QAAc,CAAC;CAE/E,OAAO;EACL,IAAI,UAAU;GACZ,OAAO;EACT;EACA,eAAe;GACb,UAAU,YAAY,QAAQ,OAAO;EACvC;EACA,QAAQ;GACN,UAAU,YAAY,QAAc;EACtC;EACA,OAAO,MAAM;GACX,IAAI,KAAK,UAAU,IAAI,KAAK,MAAM,cAAc,KAAK,KAAK,GAAG;GAC7D,UAAU,YAAY,qBAAqB,MAAM,OAAO,KAAK,OAAO,CAAC;EACvE;EACA,QAAQ,OAAO;GACb,UAAU,YAAY,QAAc,KAAK;EAC3C;EACA,UAAU,OAAO;GACf,IAAI,MAAM,cAAc,KAAK,GAAG;GAChC,UAAU,YAAY,oBAA0B,OAAO,EAAE,UAAU,OAAO,KAAK,OAAO,EAAE,CAAC;EAC3F;CACF;AACF"}

package/dist/internal/run.d.ts

@@ -0,0 +1,15 @@
+import { Context, Effect, Fiber, ManagedRuntime } from "effect";
+
+//#region src/internal/run.d.ts
+/**
+ * A runtime that the Svelte hooks can run effects against.
+ *
+ * Both a plain services context (e.g. `Context.empty()` or
+ * `defaultSvelteRuntime`) and managed runtimes (e.g.
+ * `SvelteRuntime.defaultRuntime` or the result of `SvelteRuntime.extend`)
+ * are supported.
+ */
+type RuntimeLike<R> = Context.Context<R> | ManagedRuntime.ManagedRuntime<R, never>;
+//#endregion
+export { RuntimeLike };
+//# sourceMappingURL=run.d.ts.map

package/dist/internal/run.js

@@ -0,0 +1,25 @@
+import { Context, Effect } from "effect";
+//#region src/internal/run.ts
+/**
+* Forks an effect on the given runtime, returning the running fiber.
+* Dispatches to the correct API depending on the kind of runtime provided.
+*/
+const runFork = (runtime) => (effect) => Context.isContext(runtime) ? Effect.runForkWith(runtime)(effect) : runtime.runFork(effect);
+/**
+* Runs an effect synchronously on the given runtime.
+* Dispatches to the correct API depending on the kind of runtime provided.
+*/
+const runSync = (runtime) => (effect) => Context.isContext(runtime) ? Effect.runSyncWith(runtime)(effect) : runtime.runSync(effect);
+/**
+* Interrupts a fiber in the background without waiting for it to finish.
+*
+* Interruption must not be run with `runSync` because interrupting a fiber
+* that is suspended on an async operation cannot complete synchronously.
+*/
+const interruptFiber = (fiber) => {
+	fiber.interruptUnsafe();
+};
+//#endregion
+export { interruptFiber, runFork, runSync };
+
+//# sourceMappingURL=run.js.map

package/dist/internal/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","names":[],"sources":["../../src/internal/run.ts"],"sourcesContent":["import { Context, Effect, Fiber, ManagedRuntime } from \"effect\";\n\n/**\n * A runtime that the Svelte hooks can run effects against.\n *\n * Both a plain services context (e.g. `Context.empty()` or\n * `defaultSvelteRuntime`) and managed runtimes (e.g.\n * `SvelteRuntime.defaultRuntime` or the result of `SvelteRuntime.extend`)\n * are supported.\n */\nexport type RuntimeLike<R> = Context.Context<R> | ManagedRuntime.ManagedRuntime<R, never>;\n\n/**\n * Forks an effect on the given runtime, returning the running fiber.\n * Dispatches to the correct API depending on the kind of runtime provided.\n */\nexport const runFork =\n  <R>(runtime: RuntimeLike<R>) =>\n  <A, E>(effect: Effect.Effect<A, E, R>): Fiber.Fiber<A, E> =>\n    Context.isContext(runtime) ? Effect.runForkWith(runtime)(effect) : runtime.runFork(effect);\n\n/**\n * Runs an effect synchronously on the given runtime.\n * Dispatches to the correct API depending on the kind of runtime provided.\n */\nexport const runSync =\n  <R>(runtime: RuntimeLike<R>) =>\n  <A, E>(effect: Effect.Effect<A, E, R>): A =>\n    Context.isContext(runtime) ? Effect.runSyncWith(runtime)(effect) : runtime.runSync(effect);\n\n/**\n * Interrupts a fiber in the background without waiting for it to finish.\n *\n * Interruption must not be run with `runSync` because interrupting a fiber\n * that is suspended on an async operation cannot complete synchronously.\n */\nexport const interruptFiber = <A, E>(fiber: Fiber.Fiber<A, E>): void => {\n  fiber.interruptUnsafe();\n};\n"],"mappings":";;;;;;AAgBA,MAAa,WACP,aACG,WACL,QAAQ,UAAU,OAAO,IAAI,OAAO,YAAY,OAAO,EAAE,MAAM,IAAI,QAAQ,QAAQ,MAAM;;;;;AAM7F,MAAa,WACP,aACG,WACL,QAAQ,UAAU,OAAO,IAAI,OAAO,YAAY,OAAO,EAAE,MAAM,IAAI,QAAQ,QAAQ,MAAM;;;;;;;AAQ7F,MAAa,kBAAwB,UAAmC;CACtE,MAAM,gBAAgB;AACxB"}

package/dist/internal/subscribe.js

@@ -0,0 +1,79 @@
+import { interruptFiber, runFork } from "./run.js";
+import { Cause, Effect, Exit, Option, Stream } from "effect";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import { createSubscriber } from "svelte/reactivity";
+//#region src/internal/subscribe.ts
+/**
+* Reactive bridges built on Svelte's [`createSubscriber`](https://svelte.dev/docs/svelte/svelte-reactivity#createSubscriber).
+*
+* `createSubscriber` is the idiomatic Svelte 5 primitive for turning an
+* external, push-based source into something the runes system can track. The
+* `start` callback runs the first time the returned `subscribe` function is
+* read inside an effect (including a template), and its teardown runs once the
+* last reader is destroyed — so a single Effect fiber backs any number of
+* readers, and is interrupted automatically on unmount. No `$effect` or manual
+* `$state` bookkeeping is required.
+*/
+/**
+* Subscribes to a `Stream`, accumulating every emitted value. Tracks the
+* stream's lifecycle as an {@link AsyncResult.AsyncResult} (waiting while the
+* stream is live, then settling on completion or failure).
+*/
+function streamState(runtime, makeStream) {
+	let values = [];
+	let current = AsyncResult.initial();
+	const subscribe = createSubscriber((update) => {
+		values = [];
+		current = AsyncResult.initial(true);
+		const program = Stream.runForEach(makeStream(), (value) => Effect.sync(() => {
+			values = [...values, value];
+			current = AsyncResult.success(values, { waiting: true });
+			update();
+		})).pipe(Effect.onExit((exit) => Effect.sync(() => {
+			if (Exit.isFailure(exit) && Cause.hasInterrupts(exit.cause)) return;
+			current = AsyncResult.fromExitWithPrevious(Exit.map(exit, () => values), Option.some(current));
+			update();
+		})));
+		const fiber = runFork(runtime)(program);
+		return () => interruptFiber(fiber);
+	});
+	return {
+		get current() {
+			subscribe();
+			return current;
+		},
+		get values() {
+			subscribe();
+			return values;
+		},
+		get latest() {
+			subscribe();
+			return values.length > 0 ? values[values.length - 1] : void 0;
+		}
+	};
+}
+/**
+* Subscribes to a `Stream` that always emits a current value (e.g. the
+* `changes` of a `SubscriptionRef`), tracking only the latest value.
+*
+* @param initial - the synchronous starting value, used before the subscription
+*   activates and during SSR (where effects do not run).
+*/
+function valueState(runtime, initial, makeStream) {
+	let value = initial;
+	const subscribe = createSubscriber((update) => {
+		const fiber = runFork(runtime)(Stream.runForEach(makeStream(), (next) => Effect.sync(() => {
+			value = next;
+			update();
+		})));
+		return () => interruptFiber(fiber);
+	});
+	return { get current() {
+		subscribe();
+		return value;
+	} };
+}
+//#endregion
+export { streamState, valueState };
+
+//# sourceMappingURL=subscribe.js.map

package/dist/internal/subscribe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe.js","names":[],"sources":["../../src/internal/subscribe.ts"],"sourcesContent":["import { Cause, Effect, Exit, Option, Stream } from \"effect\";\nimport * as AsyncResult from \"effect/unstable/reactivity/AsyncResult\";\nimport { createSubscriber } from \"svelte/reactivity\";\nimport { interruptFiber, runFork, type RuntimeLike } from \"./run.js\";\n\n/**\n * Reactive bridges built on Svelte's [`createSubscriber`](https://svelte.dev/docs/svelte/svelte-reactivity#createSubscriber).\n *\n * `createSubscriber` is the idiomatic Svelte 5 primitive for turning an\n * external, push-based source into something the runes system can track. The\n * `start` callback runs the first time the returned `subscribe` function is\n * read inside an effect (including a template), and its teardown runs once the\n * last reader is destroyed — so a single Effect fiber backs any number of\n * readers, and is interrupted automatically on unmount. No `$effect` or manual\n * `$state` bookkeeping is required.\n */\n\n/**\n * Subscribes to a `Stream`, accumulating every emitted value. Tracks the\n * stream's lifecycle as an {@link AsyncResult.AsyncResult} (waiting while the\n * stream is live, then settling on completion or failure).\n */\nexport function streamState<A, E, R>(\n  runtime: RuntimeLike<R>,\n  makeStream: () => Stream.Stream<A, E, R>,\n): {\n  readonly current: AsyncResult.AsyncResult<ReadonlyArray<A>, E>;\n  readonly values: ReadonlyArray<A>;\n  readonly latest: A | undefined;\n} {\n  let values: Array<A> = [];\n  let current: AsyncResult.AsyncResult<ReadonlyArray<A>, E> = AsyncResult.initial();\n\n  const subscribe = createSubscriber((update) => {\n    values = [];\n    current = AsyncResult.initial<ReadonlyArray<A>, E>(true);\n\n    const program = Stream.runForEach(makeStream(), (value) =>\n      Effect.sync(() => {\n        values = [...values, value];\n        current = AsyncResult.success<ReadonlyArray<A>, E>(values, { waiting: true });\n        update();\n      }),\n    ).pipe(\n      Effect.onExit((exit) =>\n        Effect.sync(() => {\n          // Interruption is normal teardown; keep the last good state.\n          if (Exit.isFailure(exit) && Cause.hasInterrupts(exit.cause)) return;\n          current = AsyncResult.fromExitWithPrevious(\n            Exit.map(exit, () => values as ReadonlyArray<A>),\n            Option.some(current),\n          );\n          update();\n        }),\n      ),\n    );\n\n    const fiber = runFork(runtime)(program);\n    return () => interruptFiber(fiber);\n  });\n\n  return {\n    get current() {\n      subscribe();\n      return current;\n    },\n    get values() {\n      subscribe();\n      return values;\n    },\n    get latest() {\n      subscribe();\n      return values.length > 0 ? values[values.length - 1] : undefined;\n    },\n  };\n}\n\n/**\n * Subscribes to a `Stream` that always emits a current value (e.g. the\n * `changes` of a `SubscriptionRef`), tracking only the latest value.\n *\n * @param initial - the synchronous starting value, used before the subscription\n *   activates and during SSR (where effects do not run).\n */\nexport function valueState<A, E, R>(\n  runtime: RuntimeLike<R>,\n  initial: A,\n  makeStream: () => Stream.Stream<A, E, R>,\n): { readonly current: A } {\n  let value = initial;\n\n  const subscribe = createSubscriber((update) => {\n    const fiber = runFork(runtime)(\n      Stream.runForEach(makeStream(), (next) =>\n        Effect.sync(() => {\n          value = next;\n          update();\n        }),\n      ),\n    );\n    return () => interruptFiber(fiber);\n  });\n\n  return {\n    get current() {\n      subscribe();\n      return value;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,YACd,SACA,YAKA;CACA,IAAI,SAAmB,CAAC;CACxB,IAAI,UAAwD,YAAY,QAAQ;CAEhF,MAAM,YAAY,kBAAkB,WAAW;EAC7C,SAAS,CAAC;EACV,UAAU,YAAY,QAA6B,IAAI;EAEvD,MAAM,UAAU,OAAO,WAAW,WAAW,IAAI,UAC/C,OAAO,WAAW;GAChB,SAAS,CAAC,GAAG,QAAQ,KAAK;GAC1B,UAAU,YAAY,QAA6B,QAAQ,EAAE,SAAS,KAAK,CAAC;GAC5E,OAAO;EACT,CAAC,CACH,EAAE,KACA,OAAO,QAAQ,SACb,OAAO,WAAW;GAEhB,IAAI,KAAK,UAAU,IAAI,KAAK,MAAM,cAAc,KAAK,KAAK,GAAG;GAC7D,UAAU,YAAY,qBACpB,KAAK,IAAI,YAAY,MAA0B,GAC/C,OAAO,KAAK,OAAO,CACrB;GACA,OAAO;EACT,CAAC,CACH,CACF;EAEA,MAAM,QAAQ,QAAQ,OAAO,EAAE,OAAO;EACtC,aAAa,eAAe,KAAK;CACnC,CAAC;CAED,OAAO;EACL,IAAI,UAAU;GACZ,UAAU;GACV,OAAO;EACT;EACA,IAAI,SAAS;GACX,UAAU;GACV,OAAO;EACT;EACA,IAAI,SAAS;GACX,UAAU;GACV,OAAO,OAAO,SAAS,IAAI,OAAO,OAAO,SAAS,KAAK,KAAA;EACzD;CACF;AACF;;;;;;;;AASA,SAAgB,WACd,SACA,SACA,YACyB;CACzB,IAAI,QAAQ;CAEZ,MAAM,YAAY,kBAAkB,WAAW;EAC7C,MAAM,QAAQ,QAAQ,OAAO,EAC3B,OAAO,WAAW,WAAW,IAAI,SAC/B,OAAO,WAAW;GAChB,QAAQ;GACR,OAAO;EACT,CAAC,CACH,CACF;EACA,aAAa,eAAe,KAAK;CACnC,CAAC;CAED,OAAO,EACL,IAAI,UAAU;EACZ,UAAU;EACV,OAAO;CACT,EACF;AACF"}

package/dist/query.svelte.d.ts

@@ -0,0 +1,45 @@
+import { Effect } from "effect";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+
+//#region src/query.svelte.d.ts
+interface UseQueryReturn<A, E> {
+  /**
+   * The current result state of the query. Refetching preserves the previous
+   * value as a waiting `Success` (stale-while-revalidate).
+   */
+  readonly current: AsyncResult.AsyncResult<A, E>;
+  /**
+   * Re-fetch the data by re-running the effect
+   */
+  refetch: () => void;
+}
+/**
+ * Query pattern with refetch capability.
+ * Runs the effect immediately on mount and provides a refetch function.
+ * Built on top of useEffect with immediate: true.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useQuery, AsyncResult } from '@thomasfosterau/effect-svelte';
+ *   import { Effect } from 'effect';
+ *
+ *   const query = useQuery(
+ *     Effect.gen(function* () {
+ *       const data = yield* fetchData();
+ *       return data;
+ *     })
+ *   );
+ * </script>
+ *
+ * <button onclick={query.refetch}>Refresh</button>
+ *
+ * {#if AsyncResult.isSuccess(query.current)}
+ *   <p>Data: {JSON.stringify(query.current.value)}</p>
+ * {/if}
+ * ```
+ */
+declare function useQuery<A, E, R>(effect: Effect.Effect<A, E, R>): UseQueryReturn<A, E>;
+//#endregion
+export { UseQueryReturn, useQuery };
+//# sourceMappingURL=query.svelte.d.ts.map

package/dist/query.svelte.js

@@ -0,0 +1,41 @@
+import { useEffect } from "./effect.svelte.js";
+//#region src/query.svelte.ts
+/**
+* Query pattern with refetch capability.
+* Runs the effect immediately on mount and provides a refetch function.
+* Built on top of useEffect with immediate: true.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { useQuery, AsyncResult } from '@thomasfosterau/effect-svelte';
+*   import { Effect } from 'effect';
+*
+*   const query = useQuery(
+*     Effect.gen(function* () {
+*       const data = yield* fetchData();
+*       return data;
+*     })
+*   );
+* <\/script>
+*
+* <button onclick={query.refetch}>Refresh</button>
+*
+* {#if AsyncResult.isSuccess(query.current)}
+*   <p>Data: {JSON.stringify(query.current.value)}</p>
+* {/if}
+* ```
+*/
+function useQuery(effect) {
+	const effectHook = useEffect(effect, { immediate: true });
+	return {
+		get current() {
+			return effectHook.current;
+		},
+		refetch: effectHook.run
+	};
+}
+//#endregion
+export { useQuery };
+
+//# sourceMappingURL=query.svelte.js.map

package/dist/query.svelte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.svelte.js","names":[],"sources":["../src/query.svelte.ts"],"sourcesContent":["import type { Effect } from \"effect\";\nimport type * as AsyncResult from \"effect/unstable/reactivity/AsyncResult\";\nimport { useEffect } from \"./effect.svelte.js\";\n\nexport interface UseQueryReturn<A, E> {\n  /**\n   * The current result state of the query. Refetching preserves the previous\n   * value as a waiting `Success` (stale-while-revalidate).\n   */\n  readonly current: AsyncResult.AsyncResult<A, E>;\n\n  /**\n   * Re-fetch the data by re-running the effect\n   */\n  refetch: () => void;\n}\n\n/**\n * Query pattern with refetch capability.\n * Runs the effect immediately on mount and provides a refetch function.\n * Built on top of useEffect with immediate: true.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { useQuery, AsyncResult } from '@thomasfosterau/effect-svelte';\n *   import { Effect } from 'effect';\n *\n *   const query = useQuery(\n *     Effect.gen(function* () {\n *       const data = yield* fetchData();\n *       return data;\n *     })\n *   );\n * </script>\n *\n * <button onclick={query.refetch}>Refresh</button>\n *\n * {#if AsyncResult.isSuccess(query.current)}\n *   <p>Data: {JSON.stringify(query.current.value)}</p>\n * {/if}\n * ```\n */\nexport function useQuery<A, E, R>(effect: Effect.Effect<A, E, R>): UseQueryReturn<A, E> {\n  const effectHook = useEffect(effect, { immediate: true });\n\n  return {\n    get current() {\n      return effectHook.current;\n    },\n    refetch: effectHook.run,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,SAAgB,SAAkB,QAAsD;CACtF,MAAM,aAAa,UAAU,QAAQ,EAAE,WAAW,KAAK,CAAC;CAExD,OAAO;EACL,IAAI,UAAU;GACZ,OAAO,WAAW;EACpB;EACA,SAAS,WAAW;CACtB;AACF"}