effect-atom-svelte 0.1.2 → 0.3.0

package/README.md

@@ -10,7 +10,7 @@ This is a community project by Jarred Norris. It is not part of Effect, and the
 
 - `effect` 4.0.x. The peer range is `~4.0.0`, not `^4.0.0`: the bindings use parts of the atom registry that aren't public API, which a minor release of `effect` can change.
 - Svelte 5.57.2 or later. `experimental.async` is needed for `useAtomSuspense`, `useAtomResult` and server rendering.
-- SvelteKit is optional. The docs site and its tests run on SvelteKit 3. On SvelteKit 2, the error hooks in `effect-atom-svelte/sveltekit` work with less detail.
+- SvelteKit is optional. The docs site and its tests run on SvelteKit 3. On SvelteKit 2, the error hooks in `effect-atom-svelte/sveltekit` work with less detail, and reach `<svelte:boundary>` only with `kit.experimental.handleRenderingErrors` turned on.
 
 ## Installation
 

package/dist/Hooks.svelte.d.ts

@@ -122,12 +122,14 @@ export declare const useAtomMount: (input: AtomInput<Atom.Atom<unknown>>) => voi
  *
  * In `promise` and `promiseExit` modes the setter waits for the atom's next settled result. The
  * wait holds the atom, so a call still in flight keeps it running after the component is
- * destroyed, until it settles. The call's `signal` cancels only the wait: an `Atom.fn` already
+ * destroyed, until it settles, unless the `RegistryProvider` that created the registry is
+ * destroyed: that interrupts the call and settles it as interrupted. The call's `signal` cancels only the wait: an `Atom.fn` already
  * running keeps going (send `Atom.Interrupt` to stop it). A signal that is already aborted settles
  * the call as interrupted without writing, as `fetch` does. Calls on one `Atom.fn` share its single
  * result, so a new call supersedes one in flight and every pending call resolves with the latest
  * call's result. `Atom.Reset` has no result to wait for, so these modes leave it out of their
- * types and reject it; reset with a `value` mode setter.
+ * types and reject it; reset with a `value` mode setter. A reset written while a promise-mode call
+ * is pending settles that promise as interrupted. To cancel a call, send `Atom.Interrupt`.
  *
  * **Example** (Updating an atom from its current value)
  *
@@ -207,9 +209,10 @@ export declare const useAtomSubscribe: <A>(input: AtomInput<Atom.Atom<A>>, f: (v
  * an atom that can only compute in the browser can start from a value on the server.
  *
  * A value applies once while the atom is held, so a component mounted later, or a second
- * component with its own value, does not overwrite a value the atom has moved on from. Once nothing
- * holds the atom and the registry disposes it, the next component to start it applies its value
- * again. On the server a value lasts one render, so each request against a shared registry applies
+ * component with its own value, does not overwrite a value the atom has moved on from since the
+ * first applied one. An atom that is already in use without one, read by another component, is set
+ * to the value, as `@effect/atom-react` does. Once nothing holds the atom and the registry disposes
+ * it, the next component to start it applies its value again. On the server a value lasts one render, so each request against a shared registry applies
  * its own; requests rendering at the same time share the registry's atoms, and with them the value
  * the first one applied.
  *
@@ -232,8 +235,9 @@ export declare const useAtomSubscribe: <A>(input: AtomInput<Atom.Atom<A>>, f: (v
  */
 export declare const useAtomInitialValues: (initialValues: Iterable<readonly [Atom.Atom<unknown>, unknown]>) => void;
 /**
- * Reads an `AtomRef`, following it when the getter returns a different ref. For one property of a
- * ref, use `useAtomRefPropValue`.
+ * Reads an `AtomRef`, following it when the getter returns a different ref. For a writable ref,
+ * `current` can be assigned too, which sets the ref, so `bind:value={name.current}` works; a
+ * read-only ref, as from `map`, can't be. For one property of a ref, use `useAtomRefPropValue`.
  *
  * A ref has no registry. On the server, one created at module level is shared by every request,
  * so don't write a visitor's data to it there: see
@@ -253,7 +257,8 @@ export declare const useAtomInitialValues: (initialValues: Iterable<readonly [At
  * @since 0.1.0
  * @category hooks
  */
-export declare const useAtomRef: <A>(input: AtomInput<AtomRef.ReadonlyRef<A>>) => AtomValue<A>;
+export declare function useAtomRef<A>(input: AtomInput<AtomRef.AtomRef<A>>): AtomState<A>;
+export declare function useAtomRef<A>(input: AtomInput<AtomRef.ReadonlyRef<A>>): AtomValue<A>;
 /**
  * Returns `ref.prop(prop)`, the `AtomRef` for one property of an `AtomRef`. It takes the ref
  * itself, not a getter, and does not follow later changes to `ref` or `prop`; to read a property
@@ -276,7 +281,8 @@ export declare const useAtomRef: <A>(input: AtomInput<AtomRef.ReadonlyRef<A>>) =
 export declare const useAtomRefProp: <A, K extends keyof A>(ref: AtomRef.AtomRef<A>, prop: K) => AtomRef.AtomRef<A[K]>;
 /**
  * Reads one property of an `AtomRef`, following the getter to a different ref. `prop` is taken
- * once, when the component starts, and is not followed.
+ * once, when the component starts, and is not followed. Assigning `current` sets the property, so
+ * `bind:checked={done.current}` works.
  *
  * **Example** (Reading one property of a ref)
  *
@@ -292,7 +298,7 @@ export declare const useAtomRefProp: <A, K extends keyof A>(ref: AtomRef.AtomRef
  * @since 0.1.0
  * @category hooks
  */
-export declare const useAtomRefPropValue: <A, K extends keyof A>(input: AtomInput<AtomRef.AtomRef<A>>, prop: K) => AtomValue<A[K]>;
+export declare const useAtomRefPropValue: <A, K extends keyof A>(input: AtomInput<AtomRef.AtomRef<A>>, prop: K) => AtomState<A[K]>;
 /**
  * Options for `useAtomResult`.
  *