EdgeAIG's picture
download
raw
55.3 kB
/** * Reactive state primitives for values managed by an `AtomRegistry`. * * An `Atom` describes how to produce or update one piece of reactive state. The * registry runs atom reads, remembers current values, tracks dependencies * between atoms, starts effects and streams, and cleans up atoms that are no * longer used. This module includes the atom constructors and update helpers * used for cached values, effect-backed values, streams, browser state, stored * values, and server-rendered values. * * @since 4.0.0 */ import * as Arr from "../../Array.ts"; import * as Cause from "../../Cause.ts"; import * as Context from "../../Context.ts"; import * as Duration from "../../Duration.ts"; import * as Effect from "../../Effect.ts"; import type { LazyArg } from "../../Function.ts"; import type * as Inspectable from "../../Inspectable.ts"; import * as Layer from "../../Layer.ts"; import * as Option from "../../Option.ts"; import type { Pipeable } from "../../Pipeable.ts"; import type { ReadonlyRecord } from "../../Record.ts"; import * as Schema from "../../Schema.ts"; import * as Scope from "../../Scope.ts"; import * as Stream from "../../Stream.ts"; import * as SubscriptionRef from "../../SubscriptionRef.ts"; import type { NoInfer } from "../../Types.ts"; import * as KeyValueStore from "../persistence/KeyValueStore.ts"; import * as AsyncResult from "./AsyncResult.ts"; import { AtomRegistry } from "./AtomRegistry.ts"; import * as Registry from "./AtomRegistry.ts"; import * as Reactivity from "./Reactivity.ts"; /** * Type-level identifier used to recognize `Atom` values. * * @category type IDs * @since 4.0.0 */ export type TypeId = "~effect/reactivity/Atom"; /** * Runtime identifier attached to `Atom` values and used by `isAtom`. * * @category type IDs * @since 4.0.0 */ export declare const TypeId: TypeId; /** * Reactive value read by an `AtomRegistry`, with metadata controlling caching, laziness, refresh behavior, and initial value targeting. * * @category models * @since 4.0.0 */ export interface Atom<A> extends Pipeable, Inspectable.Inspectable { readonly [TypeId]: TypeId; readonly keepAlive: boolean; readonly lazy: boolean; readonly read: (get: AtomContext) => A; readonly refresh?: (f: <A>(atom: Atom<A>) => void) => void; readonly label?: readonly [name: string, stack: string]; readonly idleTTL?: number; readonly initialValueTarget?: Atom<A>; } /** * Returns `true` when a value is an `Atom`. * * @category guards * @since 4.0.0 */ export declare const isAtom: (u: unknown) => u is Atom<any>; /** * Extracts the value type produced by an `Atom`. * * @category utility types * @since 4.0.0 */ export type Type<T extends Atom<any>> = T extends Atom<infer A> ? A : never; /** * Extracts the success value type from an atom whose value is an `AsyncResult`. * * @category utility types * @since 4.0.0 */ export type Success<T extends Atom<any>> = T extends Atom<AsyncResult.AsyncResult<infer A, infer _>> ? A : never; /** * Extracts the item type from an atom whose value is a `PullResult`. * * @category utility types * @since 4.0.0 */ export type PullSuccess<T extends Atom<any>> = T extends Atom<PullResult<infer A, infer _>> ? A : never; /** * Extracts the failure error type from an atom whose value is an `AsyncResult`. * * @category utility types * @since 4.0.0 */ export type Failure<T extends Atom<any>> = T extends Atom<AsyncResult.AsyncResult<infer _, infer E>> ? E : never; /** * Returns an atom type without serializable metadata, preserving `Writable` read and write types when the input atom is writable. * * @category utility types * @since 4.0.0 */ export type WithoutSerializable<T extends Atom<any>> = T extends Writable<infer R, infer W> ? Writable<R, W> : Atom<Type<T>>; /** * Runtime identifier attached to writable atoms and used by `isWritable`. * * @category type IDs * @since 4.0.0 */ export declare const WritableTypeId: WritableTypeId; /** * Type-level identifier used to recognize writable atoms. * * @category type IDs * @since 4.0.0 */ export type WritableTypeId = "~effect/reactivity/Atom/Writable"; /** * Atom that can also be written to, using a `WriteContext` and an input value to update reactive state. * * @category models * @since 4.0.0 */ export interface Writable<R, W = R> extends Atom<R> { readonly [WritableTypeId]: WritableTypeId; readonly write: (ctx: WriteContext<R>, value: W) => void; } /** * Context passed to atom read functions for reading dependencies, awaiting `AsyncResult` or `Option` values, managing subscriptions and finalizers, refreshing atoms, and updating writable atoms. * * @category context * @since 4.0.0 */ export interface AtomContext { <A>(atom: Atom<A>): A; get<A>(this: AtomContext, atom: Atom<A>): A; result<A, E>(this: AtomContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: { readonly suspendOnWaiting?: boolean | undefined; }): Effect.Effect<A, E>; resultOnce<A, E>(this: AtomContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: { readonly suspendOnWaiting?: boolean | undefined; }): Effect.Effect<A, E>; once<A>(this: AtomContext, atom: Atom<A>): A; addFinalizer(this: AtomContext, f: () => void): void; mount<A>(this: AtomContext, atom: Atom<A>): void; refresh<A>(this: AtomContext, atom: Atom<A>): void; refreshSelf(this: AtomContext): void; self<A>(this: AtomContext): Option.Option<A>; setSelf<A>(this: AtomContext, a: A): void; set<R, W>(this: AtomContext, atom: Writable<R, W>, value: W): void; setResult<A, E, W>(this: AtomContext, atom: Writable<AsyncResult.AsyncResult<A, E>, W>, value: W): Effect.Effect<A, E>; some<A>(this: AtomContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>; someOnce<A>(this: AtomContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>; stream<A>(this: AtomContext, atom: Atom<A>, options?: { readonly withoutInitialValue?: boolean; readonly bufferSize?: number; }): Stream.Stream<A>; streamResult<A, E>(this: AtomContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: { readonly withoutInitialValue?: boolean; readonly bufferSize?: number; }): Stream.Stream<A, E>; subscribe<A>(this: AtomContext, atom: Atom<A>, f: (_: A) => void, options?: { readonly immediate?: boolean; }): void; readonly registry: Registry.AtomRegistry; } /** * Context passed to writable atom write functions for reading atoms, refreshing or setting the current atom, and writing to other writable atoms. * * @category context * @since 4.0.0 */ export interface WriteContext<A> { get<T>(this: WriteContext<A>, atom: Atom<T>): T; refreshSelf(this: WriteContext<A>): void; setSelf(this: WriteContext<A>, a: A): void; set<R, W>(this: WriteContext<A>, atom: Writable<R, W>, value: W): void; } /** * Returns a copy of an atom with an idle time-to-live: finite durations dispose it after inactivity, while an infinite duration keeps it alive. * * @category combinators * @since 4.0.0 */ export declare const setIdleTTL: { /** * Returns a copy of an atom with an idle time-to-live: finite durations dispose it after inactivity, while an infinite duration keeps it alive. * * @category combinators * @since 4.0.0 */ (duration: Duration.Input): <A extends Atom<any>>(self: A) => A; /** * Returns a copy of an atom with an idle time-to-live: finite durations dispose it after inactivity, while an infinite duration keeps it alive. * * @category combinators * @since 4.0.0 */ <A extends Atom<any>>(self: A, duration: Duration.Input): A; }; /** * Returns `true` when an atom is writable. * * @category refinements * @since 4.0.0 */ export declare const isWritable: <R, W>(atom: Atom<R>) => atom is Writable<R, W>; /** * Creates a read-only atom from a read function and an optional custom refresh registration callback. * * @category constructors * @since 4.0.0 */ export declare const readable: <A>(read: (get: AtomContext) => A, refresh?: (f: <A_1>(atom: Atom<A_1>) => void) => void) => Atom<A>; /** * Creates a writable atom from read and write functions, with an optional custom refresh registration callback. * * @category constructors * @since 4.0.0 */ export declare const writable: <R, W>(read: (get: AtomContext) => R, write: (ctx: WriteContext<R>, value: W) => void, refresh?: (f: <A>(atom: Atom<A>) => void) => void) => Writable<R, W>; /** * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms. * * @category constructors * @since 4.0.0 */ export declare const make: { /** * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms. * * @category constructors * @since 4.0.0 */ <A, E>(create: (get: AtomContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: { readonly initialValue?: A | undefined; readonly uninterruptible?: boolean | undefined; }): Atom<AsyncResult.AsyncResult<A, E>>; /** * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms. * * @category constructors * @since 4.0.0 */ <A, E>(effect: Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: { readonly initialValue?: A; readonly uninterruptible?: boolean | undefined; }): Atom<AsyncResult.AsyncResult<A, E>>; /** * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms. * * @category constructors * @since 4.0.0 */ <A, E>(create: (get: AtomContext) => Stream.Stream<A, E, AtomRegistry>, options?: { readonly initialValue?: A; }): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>; /** * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms. * * @category constructors * @since 4.0.0 */ <A, E>(stream: Stream.Stream<A, E, AtomRegistry>, options?: { readonly initialValue?: A; }): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>; /** * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms. * * @category constructors * @since 4.0.0 */ <A>(create: (get: AtomContext) => A): Atom<A>; /** * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms. * * @category constructors * @since 4.0.0 */ <A>(initialValue: A): Writable<A>; }; /** * Atom that builds a `Context` from a `Layer` and exposes constructors for atoms, functions, pulls, and subscription refs that run with that context. * * @category models * @since 4.0.0 */ export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult<Context.Context<R>, ER>> { readonly factory: RuntimeFactory; readonly layer: Atom<Layer.Layer<R, ER>>; readonly atom: { <A, E>(create: (get: AtomContext) => Effect.Effect<A, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>, options?: { readonly initialValue?: A; readonly uninterruptible?: boolean | undefined; }): Atom<AsyncResult.AsyncResult<A, E | ER>>; <A, E>(effect: Effect.Effect<A, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>, options?: { readonly initialValue?: A; readonly uninterruptible?: boolean | undefined; }): Atom<AsyncResult.AsyncResult<A, E | ER>>; <A, E>(create: (get: AtomContext) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: { readonly initialValue?: A; }): Atom<AsyncResult.AsyncResult<A, E | ER | Cause.NoSuchElementError>>; <A, E>(stream: Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: { readonly initialValue?: A; }): Atom<AsyncResult.AsyncResult<A, E | ER | Cause.NoSuchElementError>>; }; readonly fn: { <Arg>(): { <E, A>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry | Reactivity.Reactivity | R>, options?: { readonly initialValue?: A | undefined; readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined; readonly concurrent?: boolean | undefined; }): AtomResultFn<Arg, A, E | ER>; <E, A>(fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: { readonly initialValue?: A | undefined; readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined; readonly concurrent?: boolean | undefined; }): AtomResultFn<Arg, A, E | ER | Cause.NoSuchElementError>; }; <E, A, Arg = void>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry | Reactivity.Reactivity | R>, options?: { readonly initialValue?: A | undefined; readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined; readonly concurrent?: boolean | undefined; }): AtomResultFn<Arg, A, E | ER>; <E, A, Arg = void>(fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: { readonly initialValue?: A | undefined; readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined; readonly concurrent?: boolean | undefined; }): AtomResultFn<Arg, A, E | ER | Cause.NoSuchElementError>; }; readonly pull: <A, E>(create: ((get: AtomContext) => Stream.Stream<A, E, R | AtomRegistry | Reactivity.Reactivity>) | Stream.Stream<A, E, R | AtomRegistry | Reactivity.Reactivity>, options?: { readonly disableAccumulation?: boolean; readonly initialValue?: ReadonlyArray<A>; }) => Writable<PullResult<A, E | ER>, void>; readonly subscriptionRef: <A, E>(create: Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity> | ((get: AtomContext) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>)) => Writable<AsyncResult.AsyncResult<A, E>, A>; } /** * Factory for `AtomRuntime` values that share a `Layer.MemoMap` and a set of global layers. * * @category models * @since 4.0.0 */ export interface RuntimeFactory { <R, E>(create: Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity> | ((get: AtomContext) => Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>)): AtomRuntime<R, E>; readonly memoMap: Layer.MemoMap; readonly addGlobalLayer: <A, E>(layer: Layer.Layer<A, E, AtomRegistry | Reactivity.Reactivity>) => void; /** * Uses the `Reactivity` service from the runtime to refresh the atom whenever * the keys change. */ readonly withReactivity: (keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>) => <A extends Atom<any>>(atom: A) => A; } /** * Creates a `RuntimeFactory` backed by the supplied `Layer.MemoMap`. * * @category constructors * @since 4.0.0 */ export declare const context: (options: { readonly memoMap: Layer.MemoMap; }) => RuntimeFactory; /** * Default `Layer.MemoMap` used by the module-level `runtime` factory. * * @category context * @since 4.0.0 */ export declare const defaultMemoMap: Layer.MemoMap; /** * Default `RuntimeFactory` created with `defaultMemoMap`. * * @category context * @since 4.0.0 */ export declare const runtime: RuntimeFactory; /** * Returns `Rx.runtime.withReactivity` for refreshing an atom whenever the * keys change in the `Reactivity` service. * * **When to use** * * Use to refresh an atom whenever one or more invalidation keys change in the * default reactivity runtime. * * @category reactivity * @since 4.0.0 */ export declare const withReactivity: (keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>) => <A extends Atom<any>>(atom: A) => A; /** * Creates a writable atom backed by a `SubscriptionRef`, or by an effect that produces one, updating from ref changes and writing atom updates back to the ref. * * @category constructors * @since 4.0.0 */ export declare const subscriptionRef: { /** * Creates a writable atom backed by a `SubscriptionRef`, or by an effect that produces one, updating from ref changes and writing atom updates back to the ref. * * @category constructors * @since 4.0.0 */ <A>(ref: SubscriptionRef.SubscriptionRef<A> | ((get: AtomContext) => SubscriptionRef.SubscriptionRef<A>)): Writable<A>; /** * Creates a writable atom backed by a `SubscriptionRef`, or by an effect that produces one, updating from ref changes and writing atom updates back to the ref. * * @category constructors * @since 4.0.0 */ <A, E>(effect: Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | AtomRegistry> | ((get: AtomContext) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | AtomRegistry>)): Writable<AsyncResult.AsyncResult<A, E>, A>; }; /** * Context passed to `fn` and `fnSync` computations for reading atoms, awaiting results, registering finalizers, refreshing atoms, subscribing to changes, and writing updates. * * @category models * @since 4.0.0 */ export interface FnContext { <A>(atom: Atom<A>): A; result<A, E>(this: FnContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: { readonly suspendOnWaiting?: boolean | undefined; }): Effect.Effect<A, E>; addFinalizer(this: FnContext, f: () => void): void; mount<A>(this: FnContext, atom: Atom<A>): void; refresh<A>(this: FnContext, atom: Atom<A>): void; self<A>(this: FnContext): Option.Option<A>; setSelf<A>(this: FnContext, a: A): void; set<R, W>(this: FnContext, atom: Writable<R, W>, value: W): void; setResult<A, E, W>(this: FnContext, atom: Writable<AsyncResult.AsyncResult<A, E>, W>, value: W): Effect.Effect<A, E>; some<A>(this: FnContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>; stream<A>(this: FnContext, atom: Atom<A>, options?: { readonly withoutInitialValue?: boolean; readonly bufferSize?: number; }): Stream.Stream<A>; streamResult<A, E>(this: FnContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: { readonly withoutInitialValue?: boolean; readonly bufferSize?: number; }): Stream.Stream<A, E>; subscribe<A>(this: FnContext, atom: Atom<A>, f: (_: A) => void, options?: { readonly immediate?: boolean; }): void; readonly registry: Registry.AtomRegistry; } /** * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied. * * @category constructors * @since 4.0.0 */ export declare const fnSync: { /** * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied. * * @category constructors * @since 4.0.0 */ <Arg>(): { /** * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied. * * @category constructors * @since 4.0.0 */ <A>(f: (arg: Arg, get: FnContext) => A): Writable<Option.Option<A>, Arg>; /** * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied. * * @category constructors * @since 4.0.0 */ <A>(f: (arg: Arg, get: FnContext) => A, options: { readonly initialValue: A; }): Writable<A, Arg>; }; /** * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied. * * @category constructors * @since 4.0.0 */ <A, Arg = void>(f: (arg: Arg, get: FnContext) => A): Writable<Option.Option<A>, Arg>; /** * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied. * * @category constructors * @since 4.0.0 */ <A, Arg = void>(f: (arg: Arg, get: FnContext) => A, options: { readonly initialValue: A; }): Writable<A, Arg>; }; /** * Writable async function atom whose value is an `AsyncResult` and whose writes accept function arguments plus `Reset` and `Interrupt` controls. * * @category models * @since 4.0.0 */ export interface AtomResultFn<Arg, A, E = never> extends Writable<AsyncResult.AsyncResult<A, E>, Arg | Reset | Interrupt> { } /** * Defines the control symbol that can be written to an `AtomResultFn` to reset it to its initial state. * * **When to use** * * Use when you need an `AtomResultFn` write value that clears the current async * result and returns it to the initial state. * * @category symbols * @since 4.0.0 */ export declare const Reset: unique symbol; /** * Type of the `Reset` control symbol accepted by `AtomResultFn` writes. * * @category symbols * @since 4.0.0 */ export type Reset = typeof Reset; /** * Defines the control symbol that can be written to an `AtomResultFn` to interrupt the current asynchronous computation. * * **When to use** * * Use when you need an `AtomResultFn` write value that interrupts the currently * running async computation. * * @category symbols * @since 4.0.0 */ export declare const Interrupt: unique symbol; /** * Type of the `Interrupt` control symbol accepted by `AtomResultFn` writes. * * @category symbols * @since 4.0.0 */ export type Interrupt = typeof Interrupt; /** * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`. * * @category constructors * @since 4.0.0 */ export declare const fn: { /** * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`. * * @category constructors * @since 4.0.0 */ <Arg>(): <E, A>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: { readonly initialValue?: A | undefined; readonly concurrent?: boolean | undefined; }) => AtomResultFn<Arg, A, E>; /** * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`. * * @category constructors * @since 4.0.0 */ <E, A, Arg = void>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: { readonly initialValue?: A | undefined; readonly concurrent?: boolean | undefined; }): AtomResultFn<Arg, A, E>; /** * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`. * * @category constructors * @since 4.0.0 */ <Arg>(): <E, A>(fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry>, options?: { readonly initialValue?: A | undefined; readonly concurrent?: boolean | undefined; }) => AtomResultFn<Arg, A, E | Cause.NoSuchElementError>; /** * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`. * * @category constructors * @since 4.0.0 */ <E, A, Arg = void>(fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry>, options?: { readonly initialValue?: A | undefined; readonly concurrent?: boolean | undefined; }): AtomResultFn<Arg, A, E | Cause.NoSuchElementError>; }; /** * `AsyncResult` produced by `pull`, containing a non-empty batch of pulled items and a `done` flag, or `NoSuchElementError` when the stream completes without items. * * @category models * @since 4.0.0 */ export type PullResult<A, E = never> = AsyncResult.AsyncResult<{ readonly done: boolean; readonly items: Arr.NonEmptyArray<A>; }, E | Cause.NoSuchElementError>; /** * Creates a writable atom that pulls an initial chunk from a stream and then pulls the next chunk whenever it is written to, accumulating items unless `disableAccumulation` is enabled. * * @category constructors * @since 4.0.0 */ export declare const pull: <A, E>(create: ((get: AtomContext) => Stream.Stream<A, E, AtomRegistry>) | Stream.Stream<A, E, AtomRegistry>, options?: { readonly disableAccumulation?: boolean | undefined; }) => Writable<PullResult<A, E>, void>; /** * Creates a memoized atom factory that returns the same object for the same argument, using weak references for cached values when the platform supports them. * * @category constructors * @since 4.0.0 */ export declare const family: <Arg, T extends object>(f: (arg: Arg) => T) => (arg: Arg) => T; /** * Uses a fallback `AsyncResult` atom while the primary atom is `Initial`, marking the fallback result as waiting until the primary atom produces a non-initial result. * * @category combinators * @since 4.0.0 */ export declare const withFallback: { /** * Uses a fallback `AsyncResult` atom while the primary atom is `Initial`, marking the fallback result as waiting until the primary atom produces a non-initial result. * * @category combinators * @since 4.0.0 */ <E2, A2>(fallback: Atom<AsyncResult.AsyncResult<A2, E2>>): <R extends Atom<AsyncResult.AsyncResult<any, any>>>(self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>, RW> : Atom<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>>; /** * Uses a fallback `AsyncResult` atom while the primary atom is `Initial`, marking the fallback result as waiting until the primary atom produces a non-initial result. * * @category combinators * @since 4.0.0 */ <R extends Atom<AsyncResult.AsyncResult<any, any>>, A2, E2>(self: R, fallback: Atom<AsyncResult.AsyncResult<A2, E2>>): [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>, RW> : Atom<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>>; }; /** * Returns a copy of an atom that remains cached and mounted even when no subscribers are using it. * * @category combinators * @since 4.0.0 */ export declare const keepAlive: <A extends Atom<any>>(self: A) => A; /** * Allows a reactive value to be disposed of when it is not in use. * * **Details** * * Atoms have this behavior by default, so use this to undo `keepAlive` on a copied atom. * * @category combinators * @since 4.0.0 */ export declare const autoDispose: <A extends Atom<any>>(self: A) => A; /** * Sets whether an atom should be lazy. * * **Details** * * Lazy atoms defer recomputation while they have no active listeners or active * non-lazy dependents, rebuilding the next time their value is observed. * * @category combinators * @since 4.0.0 */ export declare const setLazy: { /** * Sets whether an atom should be lazy. * * **Details** * * Lazy atoms defer recomputation while they have no active listeners or active * non-lazy dependents, rebuilding the next time their value is observed. * * @category combinators * @since 4.0.0 */ (lazy: boolean): <A extends Atom<any>>(self: A) => A; /** * Sets whether an atom should be lazy. * * **Details** * * Lazy atoms defer recomputation while they have no active listeners or active * non-lazy dependents, rebuilding the next time their value is observed. * * @category combinators * @since 4.0.0 */ <A extends Atom<any>>(self: A, lazy: boolean): A; }; /** * Attaches a diagnostic label to an atom. * * **Details** * * The label is used for inspection and debugging metadata and does not change the * atom's read or write behavior. * * @category combinators * @since 4.0.0 */ export declare const withLabel: { /** * Attaches a diagnostic label to an atom. * * **Details** * * The label is used for inspection and debugging metadata and does not change the * atom's read or write behavior. * * @category combinators * @since 4.0.0 */ (name: string): <A extends Atom<any>>(self: A) => A; /** * Attaches a diagnostic label to an atom. * * **Details** * * The label is used for inspection and debugging metadata and does not change the * atom's read or write behavior. * * @category combinators * @since 4.0.0 */ <A extends Atom<any>>(self: A, name: string): A; }; /** * Pairs an atom with an initial value for registry initialization. * * **When to use** * * Use to preload an atom value when constructing or seeding a registry. * * **Details** * * The returned tuple can be supplied to `AtomRegistry` initial values so the atom * starts with the provided value before it is first rebuilt. * * @category combinators * @since 4.0.0 */ export declare const initialValue: { /** * Pairs an atom with an initial value for registry initialization. * * **When to use** * * Use to preload an atom value when constructing or seeding a registry. * * **Details** * * The returned tuple can be supplied to `AtomRegistry` initial values so the atom * starts with the provided value before it is first rebuilt. * * @category combinators * @since 4.0.0 */ <A>(initialValue: A): (self: Atom<A>) => readonly [Atom<A>, A]; /** * Pairs an atom with an initial value for registry initialization. * * **When to use** * * Use to preload an atom value when constructing or seeding a registry. * * **Details** * * The returned tuple can be supplied to `AtomRegistry` initial values so the atom * starts with the provided value before it is first rebuilt. * * @category combinators * @since 4.0.0 */ <A>(self: Atom<A>, initialValue: A): readonly [Atom<A>, A]; }; /** * Creates a derived atom by reading another atom with a custom `AtomContext` * function. * * **Details** * * If the source is writable, the derived atom keeps the source write input and * forwards writes to the source. `initialValueTarget` controls which atom receives * preloaded initial values for the derived atom. * * @category combinators * @since 4.0.0 */ export declare const transform: { /** * Creates a derived atom by reading another atom with a custom `AtomContext` * function. * * **Details** * * If the source is writable, the derived atom keeps the source write input and * forwards writes to the source. `initialValueTarget` controls which atom receives * preloaded initial values for the derived atom. * * @category combinators * @since 4.0.0 */ <R extends Atom<any>, B>(f: (get: AtomContext, atom: R) => B, options?: { readonly initialValueTarget?: Atom<B> | undefined; }): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>; /** * Creates a derived atom by reading another atom with a custom `AtomContext` * function. * * **Details** * * If the source is writable, the derived atom keeps the source write input and * forwards writes to the source. `initialValueTarget` controls which atom receives * preloaded initial values for the derived atom. * * @category combinators * @since 4.0.0 */ <R extends Atom<any>, B>(self: R, f: (get: AtomContext, atom: R) => B, options?: { readonly initialValueTarget?: Atom<B> | undefined; }): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>; }; /** * Maps the current value of an atom with a pure function. * * **Details** * * When the source atom is writable, the returned atom remains writable and keeps * the source atom's write input type. * * @category combinators * @since 4.0.0 */ export declare const map: { /** * Maps the current value of an atom with a pure function. * * **Details** * * When the source atom is writable, the returned atom remains writable and keeps * the source atom's write input type. * * @category combinators * @since 4.0.0 */ <R extends Atom<any>, B>(f: (_: Type<R>) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>; /** * Maps the current value of an atom with a pure function. * * **Details** * * When the source atom is writable, the returned atom remains writable and keeps * the source atom's write input type. * * @category combinators * @since 4.0.0 */ <R extends Atom<any>, B>(self: R, f: (_: Type<R>) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>; }; /** * Maps the successful value inside an `AsyncResult` atom. * * **Details** * * Initial and failure states are preserved, and writable source atoms keep their * original write input type. * * @category combinators * @since 4.0.0 */ export declare const mapResult: { /** * Maps the successful value inside an `AsyncResult` atom. * * **Details** * * Initial and failure states are preserved, and writable source atoms keep their * original write input type. * * @category combinators * @since 4.0.0 */ <R extends Atom<AsyncResult.AsyncResult<any, any>>, B>(f: (_: AsyncResult.AsyncResult.Success<Type<R>>) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>, RW> : Atom<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>>; /** * Maps the successful value inside an `AsyncResult` atom. * * **Details** * * Initial and failure states are preserved, and writable source atoms keep their * original write input type. * * @category combinators * @since 4.0.0 */ <R extends Atom<AsyncResult.AsyncResult<any, any>>, B>(self: R, f: (_: AsyncResult.AsyncResult.Success<Type<R>>) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>, RW> : Atom<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>>; }; /** * Creates an atom that publishes source changes only after the source has stopped * changing for the specified duration. * * **Details** * * The current source value is used immediately, and any pending debounce timer is * cleared when the derived atom is disposed. * * @category combinators * @since 4.0.0 */ export declare const debounce: { /** * Creates an atom that publishes source changes only after the source has stopped * changing for the specified duration. * * **Details** * * The current source value is used immediately, and any pending debounce timer is * cleared when the derived atom is disposed. * * @category combinators * @since 4.0.0 */ (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>; /** * Creates an atom that publishes source changes only after the source has stopped * changing for the specified duration. * * **Details** * * The current source value is used immediately, and any pending debounce timer is * cleared when the derived atom is disposed. * * @category combinators * @since 4.0.0 */ <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>; }; /** * Creates a derived atom that reads the source and schedules a refresh after the * specified duration. * * **Details** * * The scheduled refresh is canceled when the derived atom's lifetime is disposed. * * @category combinators * @since 4.0.0 */ export declare const withRefresh: { /** * Creates a derived atom that reads the source and schedules a refresh after the * specified duration. * * **Details** * * The scheduled refresh is canceled when the derived atom's lifetime is disposed. * * @category combinators * @since 4.0.0 */ (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>; /** * Creates a derived atom that reads the source and schedules a refresh after the * specified duration. * * **Details** * * The scheduled refresh is canceled when the derived atom's lifetime is disposed. * * @category combinators * @since 4.0.0 */ <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>; }; /** * Adds stale-while-revalidate refresh behavior to an async result atom. * * **Details** * * Automatic revalidation during reads is skipped while the current value is * fresh within `staleTime`. Manual `refresh` calls remain forceful and always * forward to the wrapped atom. Use `revalidateOnMount` to control whether stale data should trigger a * background refresh on first mount. Use `revalidateOnFocus` to control * focus behavior. `true` respects `staleTime` and `"always"` forces refetch. * * @category combinators * @since 4.0.0 */ export declare const swr: { /** * Adds stale-while-revalidate refresh behavior to an async result atom. * * **Details** * * Automatic revalidation during reads is skipped while the current value is * fresh within `staleTime`. Manual `refresh` calls remain forceful and always * forward to the wrapped atom. Use `revalidateOnMount` to control whether stale data should trigger a * background refresh on first mount. Use `revalidateOnFocus` to control * focus behavior. `true` respects `staleTime` and `"always"` forces refetch. * * @category combinators * @since 4.0.0 */ (options: { readonly staleTime: Duration.Input; readonly revalidateOnMount?: boolean | undefined; readonly revalidateOnFocus?: boolean | "always" | undefined; readonly focusSignal?: Atom<any> | undefined; }): <R extends Atom<AsyncResult.AsyncResult<any, any>>>(self: R) => WithoutSerializable<R>; /** * Adds stale-while-revalidate refresh behavior to an async result atom. * * **Details** * * Automatic revalidation during reads is skipped while the current value is * fresh within `staleTime`. Manual `refresh` calls remain forceful and always * forward to the wrapped atom. Use `revalidateOnMount` to control whether stale data should trigger a * background refresh on first mount. Use `revalidateOnFocus` to control * focus behavior. `true` respects `staleTime` and `"always"` forces refetch. * * @category combinators * @since 4.0.0 */ <R extends Atom<AsyncResult.AsyncResult<any, any>>>(self: R, options: { readonly staleTime: Duration.Input; readonly revalidateOnMount?: boolean | undefined; readonly revalidateOnFocus?: boolean | "always" | undefined; readonly focusSignal?: Atom<any> | undefined; }): WithoutSerializable<R>; }; /** * Wraps an atom in a writable optimistic atom. * * **Details** * * Writes accept transition atoms containing `AsyncResult` values. Waiting * successes are shown optimistically while transitions run; when successful * transitions finish, the source atom is refreshed, and failures roll the value * back to the latest source value. * * @category Optimistic * @since 4.0.0 */ export declare const optimistic: <A>(self: Atom<A>) => Writable<A, Atom<AsyncResult.AsyncResult<A, unknown>>>; /** * Creates an `AtomResultFn` that applies an optimistic update before running the * underlying mutation. * * **Details** * * The reducer computes the provisional value from the current value and mutation * input. The wrapped function result then completes the transition or updates the * optimistic value through the provided setter callback. * * @category Optimistic * @since 4.0.0 */ export declare const optimisticFn: { /** * Creates an `AtomResultFn` that applies an optimistic update before running the * underlying mutation. * * **Details** * * The reducer computes the provisional value from the current value and mutation * input. The wrapped function result then completes the transition or updates the * optimistic value through the provided setter callback. * * @category Optimistic * @since 4.0.0 */ <A, W, XA, XE, OW = void>(options: { readonly reducer: (current: NoInfer<A>, update: OW) => NoInfer<W>; readonly fn: AtomResultFn<OW, XA, XE> | ((set: (result: NoInfer<W>) => void) => AtomResultFn<OW, XA, XE>); }): (self: Writable<A, Atom<AsyncResult.AsyncResult<W, unknown>>>) => AtomResultFn<OW, XA, XE>; /** * Creates an `AtomResultFn` that applies an optimistic update before running the * underlying mutation. * * **Details** * * The reducer computes the provisional value from the current value and mutation * input. The wrapped function result then completes the transition or updates the * optimistic value through the provided setter callback. * * @category Optimistic * @since 4.0.0 */ <A, W, XA, XE, OW = void>(self: Writable<A, Atom<AsyncResult.AsyncResult<W, unknown>>>, options: { readonly reducer: (current: NoInfer<A>, update: OW) => NoInfer<W>; readonly fn: AtomResultFn<OW, XA, XE> | ((set: (result: NoInfer<W>) => void) => AtomResultFn<OW, XA, XE>); }): AtomResultFn<OW, XA, XE>; }; /** * Runs synchronous atom updates as a batch. * * **Details** * * Stale nodes are rebuilt and listeners are notified after the callback completes, * so dependent updates observe the final batched state. * * @category batching * @since 4.0.0 */ export declare const batch: (f: () => void) => void; /** * Creates a browser-only signal atom that increments when the document becomes visible. * * **Details** * * It listens for `visibilitychange` events on `window` and removes the listener * when the atom is disposed. * * @category Focus * @since 4.0.0 */ export declare const windowFocusSignal: Atom<number>; /** * Creates a combinator that refreshes an atom whenever the supplied signal atom * changes. * * **Details** * * The derived atom also subscribes to the source atom so normal source updates are * forwarded to its own value. * * @category Focus * @since 4.0.0 */ export declare const makeRefreshOnSignal: <_>(signal: Atom<_>) => <A extends Atom<any>>(self: A) => WithoutSerializable<A>; /** * Refreshes an atom whenever `windowFocusSignal` changes. * * **Details** * * This helper is browser-only because `windowFocusSignal` depends on `window` and * `document.visibilityState`. * * @category Focus * @since 4.0.0 */ export declare const refreshOnWindowFocus: <A extends Atom<any>>(self: A) => WithoutSerializable<A>; /** * Creates a writable atom backed by a `KeyValueStore` entry. * * **Details** * * Values are encoded and decoded with the supplied schema. In sync mode the atom * exposes the decoded value and writes the default value when the key is missing; * in async mode it exposes an `AsyncResult` of the decoded value. * * @category KeyValueStore * @since 4.0.0 */ export declare const kvs: <S extends Schema.Codec<any, any>, const Mode extends "sync" | "async" = never>(options: { readonly runtime: AtomRuntime<KeyValueStore.KeyValueStore, any>; readonly key: string; readonly schema: S; readonly defaultValue: LazyArg<S["Type"]>; readonly mode?: Mode | undefined; }) => Writable<"async" extends Mode ? AsyncResult.AsyncResult<S["Type"]> : S["Type"], S["Type"]>; /** * Creates an atom that reads and writes a URL search parameter. * * **Gotchas** * * If you pass a schema, it has to be synchronous and have no context. * * @category search params * @since 4.0.0 */ export declare const searchParam: <S extends Schema.Codec<any, string> = never>(name: string, options?: { readonly schema?: S | undefined; }) => Writable<[S] extends [never] ? string : Option.Option<S["Type"]>>; /** * Converts an atom into a stream using the `AtomRegistry` service. * * **Details** * * The stream emits the atom's current value immediately and then emits subsequent * changes until the stream scope is closed. * * @category converting * @since 4.0.0 */ export declare const toStream: <A>(self: Atom<A>) => Stream.Stream<A, never, AtomRegistry>; /** * Converts an `AsyncResult` atom into a stream using the `AtomRegistry` service. * * **Details** * * Initial results are skipped, successes are emitted as stream values, and * failures fail the stream with the result cause. * * @category converting * @since 4.0.0 */ export declare const toStreamResult: <A, E>(self: Atom<AsyncResult.AsyncResult<A, E>>) => Stream.Stream<A, E, AtomRegistry>; /** * Reads an atom's current value from the `AtomRegistry` service. * * @category converting * @since 4.0.0 */ export declare const get: <A>(self: Atom<A>) => Effect.Effect<A, never, AtomRegistry>; /** * Reads a writable atom, computes a return value and next write value, writes the * next value, and returns the computed result. * * @category converting * @since 4.0.0 */ export declare const modify: { /** * Reads a writable atom, computes a return value and next write value, writes the * next value, and returns the computed result. * * @category converting * @since 4.0.0 */ <R, W, A>(f: (_: R) => [returnValue: A, nextValue: W]): (self: Writable<R, W>) => Effect.Effect<A, never, AtomRegistry>; /** * Reads a writable atom, computes a return value and next write value, writes the * next value, and returns the computed result. * * @category converting * @since 4.0.0 */ <R, W, A>(self: Writable<R, W>, f: (_: R) => [returnValue: A, nextValue: W]): Effect.Effect<A, never, AtomRegistry>; }; /** * Writes a value to a writable atom through the `AtomRegistry` service. * * @category converting * @since 4.0.0 */ export declare const set: { /** * Writes a value to a writable atom through the `AtomRegistry` service. * * @category converting * @since 4.0.0 */ <W>(value: W): <R>(self: Writable<R, W>) => Effect.Effect<void, never, AtomRegistry>; /** * Writes a value to a writable atom through the `AtomRegistry` service. * * @category converting * @since 4.0.0 */ <R, W>(self: Writable<R, W>, value: W): Effect.Effect<void, never, AtomRegistry>; }; /** * Updates a writable atom by reading its current value from the registry and * writing the value returned by the update function. * * @category converting * @since 4.0.0 */ export declare const update: { /** * Updates a writable atom by reading its current value from the registry and * writing the value returned by the update function. * * @category converting * @since 4.0.0 */ <R, W>(f: (_: R) => W): (self: Writable<R, W>) => Effect.Effect<void, never, AtomRegistry>; /** * Updates a writable atom by reading its current value from the registry and * writing the value returned by the update function. * * @category converting * @since 4.0.0 */ <R, W>(self: Writable<R, W>, f: (_: R) => W): Effect.Effect<void, never, AtomRegistry>; }; /** * Reads an `AsyncResult` atom as an effect through the `AtomRegistry` service. * * **Details** * * The effect waits while the result is `Initial`, and also while it is waiting * when `suspendOnWaiting` is enabled. Successes succeed with the value and * failures fail with the result cause. * * @category converting * @since 4.0.0 */ export declare const getResult: <A, E>(self: Atom<AsyncResult.AsyncResult<A, E>>, options?: { readonly suspendOnWaiting?: boolean | undefined; }) => Effect.Effect<A, E, AtomRegistry>; /** * Runs a refresh request for an atom through the `AtomRegistry` service. * * **When to use** * * Use to invalidate and recompute an atom from an Effect that has access to the * active registry. * * @category converting * @since 4.0.0 */ export declare const refresh: <A>(self: Atom<A>) => Effect.Effect<void, never, AtomRegistry>; /** * Mounts an atom in the `AtomRegistry` for the lifetime of the current scope. * * **Details** * * Mounting keeps the atom subscribed with a no-op listener until the scope * finalizer releases it. * * @category converting * @since 4.0.0 */ export declare const mount: <A>(self: Atom<A>) => Effect.Effect<void, never, AtomRegistry | Scope.Scope>; /** * The type id used to mark atoms that carry serialization metadata. * * @category type IDs * @since 4.0.0 */ export declare const SerializableTypeId: SerializableTypeId; /** * The literal type of the serializable atom marker. * * @category type IDs * @since 4.0.0 */ export type SerializableTypeId = "~effect-atom/atom/Atom/Serializable"; /** * Serialization metadata attached to an atom. * * **Details** * * The key identifies the atom in dehydrated state, and the encode/decode * functions convert between the atom value and the schema encoded value. * * @category Serializable * @since 4.0.0 */ export interface Serializable<S extends Schema.Top> { readonly [SerializableTypeId]: { readonly key: string; readonly encode: (value: S["Type"]) => S["Encoded"]; readonly decode: (value: S["Encoded"]) => S["Type"]; }; } /** * Returns `true` when an atom carries `Serializable` metadata. * * @category Serializable * @since 4.0.0 */ export declare const isSerializable: (self: Atom<any>) => self is Atom<any> & Serializable<any>; /** * Attaches serialization metadata to an atom using a schema and stable key. * * **Details** * * The schema is converted to a JSON codec for synchronous encode/decode, and the * key is also used as the atom label when the atom does not already have one. * * @category combinators * @since 4.0.0 */ export declare const serializable: { /** * Attaches serialization metadata to an atom using a schema and stable key. * * **Details** * * The schema is converted to a JSON codec for synchronous encode/decode, and the * key is also used as the atom label when the atom does not already have one. * * @category combinators * @since 4.0.0 */ <R extends Atom<any>, S extends Schema.Codec<Type<R>, any>>(options: { readonly key: string; readonly schema: S; }): (self: R) => R & Serializable<S>; /** * Attaches serialization metadata to an atom using a schema and stable key. * * **Details** * * The schema is converted to a JSON codec for synchronous encode/decode, and the * key is also used as the atom label when the atom does not already have one. * * @category combinators * @since 4.0.0 */ <R extends Atom<any>, S extends Schema.Codec<Type<R>, any>>(self: R, options: { readonly key: string; readonly schema: S; }): R & Serializable<S>; }; /** * The type id used to mark atoms with a server-side read override. * * @category type IDs * @since 4.0.0 */ export declare const ServerValueTypeId: "~effect-atom/atom/Atom/ServerValue"; /** * Sets the value of an Atom when read on the server. * * @category ServerValue * @since 4.0.0 */ export declare const withServerValue: { /** * Sets the value of an Atom when read on the server. * * @category ServerValue * @since 4.0.0 */ <A extends Atom<any>>(read: (get: <A>(atom: Atom<A>) => A) => Type<A>): (self: A) => A; /** * Sets the value of an Atom when read on the server. * * @category ServerValue * @since 4.0.0 */ <A extends Atom<any>>(self: A, read: (get: <A>(atom: Atom<A>) => A) => Type<A>): A; }; /** * Sets an `AsyncResult` atom's server-side value to * `AsyncResult.initial(true)`. * * @category ServerValue * @since 4.0.0 */ export declare const withServerValueInitial: <A extends Atom<AsyncResult.AsyncResult<any, any>>>(self: A) => A; /** * Reads an atom from a registry, using its server-side read override when one is * present. * * **Details** * * Nested reads performed by the override are resolved against the same registry. * * @category ServerValue * @since 4.0.0 */ export declare const getServerValue: { /** * Reads an atom from a registry, using its server-side read override when one is * present. * * **Details** * * Nested reads performed by the override are resolved against the same registry. * * @category ServerValue * @since 4.0.0 */ (registry: Registry.AtomRegistry): <A>(self: Atom<A>) => A; /** * Reads an atom from a registry, using its server-side read override when one is * present. * * **Details** * * Nested reads performed by the override are resolved against the same registry. * * @category ServerValue * @since 4.0.0 */ <A>(self: Atom<A>, registry: Registry.AtomRegistry): A; }; //# sourceMappingURL=Atom.d.ts.map
/**
* Reactive state primitives for values managed by an `AtomRegistry`.
*
* An `Atom` describes how to produce or update one piece of reactive state. The
* registry runs atom reads, remembers current values, tracks dependencies
* between atoms, starts effects and streams, and cleans up atoms that are no
* longer used. This module includes the atom constructors and update helpers
* used for cached values, effect-backed values, streams, browser state, stored
* values, and server-rendered values.
*
* @since 4.0.0
*/
import * as Arr from "../../Array.ts";
import * as Cause from "../../Cause.ts";
import * as Context from "../../Context.ts";
import * as Duration from "../../Duration.ts";
import * as Effect from "../../Effect.ts";
import type { LazyArg } from "../../Function.ts";
import type * as Inspectable from "../../Inspectable.ts";
import * as Layer from "../../Layer.ts";
import * as Option from "../../Option.ts";
import type { Pipeable } from "../../Pipeable.ts";
import type { ReadonlyRecord } from "../../Record.ts";
import * as Schema from "../../Schema.ts";
import * as Scope from "../../Scope.ts";
import * as Stream from "../../Stream.ts";
import * as SubscriptionRef from "../../SubscriptionRef.ts";
import type { NoInfer } from "../../Types.ts";
import * as KeyValueStore from "../persistence/KeyValueStore.ts";
import * as AsyncResult from "./AsyncResult.ts";
import { AtomRegistry } from "./AtomRegistry.ts";
import * as Registry from "./AtomRegistry.ts";
import * as Reactivity from "./Reactivity.ts";
/**
* Type-level identifier used to recognize `Atom` values.
*
* @category type IDs
* @since 4.0.0
*/
export type TypeId = "~effect/reactivity/Atom";
/**
* Runtime identifier attached to `Atom` values and used by `isAtom`.
*
* @category type IDs
* @since 4.0.0
*/
export declare const TypeId: TypeId;
/**
* Reactive value read by an `AtomRegistry`, with metadata controlling caching, laziness, refresh behavior, and initial value targeting.
*
* @category models
* @since 4.0.0
*/
export interface Atom<A> extends Pipeable, Inspectable.Inspectable {
readonly [TypeId]: TypeId;
readonly keepAlive: boolean;
readonly lazy: boolean;
readonly read: (get: AtomContext) => A;
readonly refresh?: (f: <A>(atom: Atom<A>) => void) => void;
readonly label?: readonly [name: string, stack: string];
readonly idleTTL?: number;
readonly initialValueTarget?: Atom<A>;
}
/**
* Returns `true` when a value is an `Atom`.
*
* @category guards
* @since 4.0.0
*/
export declare const isAtom: (u: unknown) => u is Atom<any>;
/**
* Extracts the value type produced by an `Atom`.
*
* @category utility types
* @since 4.0.0
*/
export type Type<T extends Atom<any>> = T extends Atom<infer A> ? A : never;
/**
* Extracts the success value type from an atom whose value is an `AsyncResult`.
*
* @category utility types
* @since 4.0.0
*/
export type Success<T extends Atom<any>> = T extends Atom<AsyncResult.AsyncResult<infer A, infer _>> ? A : never;
/**
* Extracts the item type from an atom whose value is a `PullResult`.
*
* @category utility types
* @since 4.0.0
*/
export type PullSuccess<T extends Atom<any>> = T extends Atom<PullResult<infer A, infer _>> ? A : never;
/**
* Extracts the failure error type from an atom whose value is an `AsyncResult`.
*
* @category utility types
* @since 4.0.0
*/
export type Failure<T extends Atom<any>> = T extends Atom<AsyncResult.AsyncResult<infer _, infer E>> ? E : never;
/**
* Returns an atom type without serializable metadata, preserving `Writable` read and write types when the input atom is writable.

Xet Storage Details

Size:
55.3 kB
·
Xet hash:
08ae7de524b0f0f1b702b91ca7e84c6fc4bb30540e20b954ef5b5dca43ec34b7

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.