add Reactive experiment

.changeset/vast-crabs-swim.md

@@ -0,0 +1,6 @@
+---
+"@effect-rx/rx-react": patch
+"@effect-rx/rx": patch
+---
+
+add Reactive module

docs/rx-react/index.ts.md

@@ -12,6 +12,10 @@ Added in v1.0.0
 
 <h2 class="text-delta">Table of contents</h2>
 
+- [Reactive](#reactive)
+  - [ReactiveComponent (interface)](#reactivecomponent-interface)
+  - [action](#action)
+  - [component](#component)
 - [context](#context)
   - [RegistryContext](#registrycontext)
   - [RegistryProvider](#registryprovider)
@@ -31,13 +35,71 @@ Added in v1.0.0
   - [useRxSuspenseSuccess](#userxsuspensesuccess)
   - [useRxValue](#userxvalue)
 - [modules](#modules)
+  - [From "@effect-rx/rx/Reactive"](#from-effect-rxrxreactive)
+  - [From "@effect-rx/rx/ReactiveRef"](#from-effect-rxrxreactiveref)
   - [From "@effect-rx/rx/Registry"](#from-effect-rxrxregistry)
   - [From "@effect-rx/rx/Result"](#from-effect-rxrxresult)
   - [From "@effect-rx/rx/Rx"](#from-effect-rxrxrx)
   - [From "@effect-rx/rx/RxRef"](#from-effect-rxrxrxref)
 
 ---
 
+# Reactive
+
+## ReactiveComponent (interface)
+
+**Signature**
+
+```ts
+export interface ReactiveComponent<Props extends Record<string, any>, R = never> {
+  (
+    props: Props & [R] extends [never]
+      ? {
+          readonly context?: Context.Context<never> | undefined
+        }
+      : { readonly context: Context.Context<R> }
+  ): React.ReactNode
+
+  provide<AL, EL, RL>(layer: Layer.Layer<AL, EL, RL>): ReactiveComponent<Props, Exclude<R, AL> | RL>
+
+  render: Effect.Effect<(props: Props) => React.ReactNode, never, R | Reactive.Reactive>
+}
+```
+
+Added in v1.0.0
+
+## action
+
+**Signature**
+
+```ts
+export declare const action: <Args extends ReadonlyArray<any>, A, E, R>(
+  f: (...args: Args) => Effect.Effect<A, E, R>
+) => Effect.Effect<(...args: Args) => Promise<A>, never, R | Scope>
+```
+
+Added in v1.0.0
+
+## component
+
+**Signature**
+
+```ts
+export declare const component: <E, R, Props extends Record<string, any> = {}>(
+  name: string,
+  build: (
+    props: Props,
+    emit: (_: React.ReactNode) => Effect.Effect<void, never, Reactive.Reactive>
+  ) => Effect.Effect<React.ReactNode, E, R>,
+  options?: {
+    readonly onInitial?: (props: Props) => React.ReactNode
+    readonly deps?: (props: Props) => ReadonlyArray<any>
+  }
+) => ReactiveComponent<Props, Exclude<R, Reactive.Reactive | Scope>>
+```
+
+Added in v1.0.0
+
 # context
 
 ## RegistryContext
@@ -224,6 +286,30 @@ Added in v1.0.0
 
 # modules
 
+## From "@effect-rx/rx/Reactive"
+
+Re-exports all named exports from the "@effect-rx/rx/Reactive" module as `Reactive`.
+
+**Signature**
+
+```ts
+export * as Reactive from "@effect-rx/rx/Reactive"
+```
+
+Added in v1.0.0
+
+## From "@effect-rx/rx/ReactiveRef"
+
+Re-exports all named exports from the "@effect-rx/rx/ReactiveRef" module as `ReactiveRef`.
+
+**Signature**
+
+```ts
+export * as ReactiveRef from "@effect-rx/rx/ReactiveRef"
+```
+
+Added in v1.0.0
+
 ## From "@effect-rx/rx/Registry"
 
 Re-exports all named exports from the "@effect-rx/rx/Registry" module as `Registry`.

docs/rx/Reactive.ts.md

@@ -0,0 +1,177 @@
+---
+title: Reactive.ts
+nav_order: 2
+parent: "@effect-rx/rx"
+---
+
+## Reactive overview
+
+Added in v1.0.0
+
+---
+
+<h2 class="text-delta">Table of contents</h2>
+
+- [Handle](#handle)
+  - [Handle (interface)](#handle-interface)
+- [Layer](#layer)
+  - [layerTimeToLive](#layertimetolive)
+- [Reactive](#reactive)
+  - [Reactive (class)](#reactive-class)
+    - [with (static method)](#with-static-method)
+  - [cache](#cache)
+  - [emit](#emit)
+- [Readable](#readable)
+  - [Readable (interface)](#readable-interface)
+  - [readable](#readable-1)
+- [Subscribable](#subscribable)
+  - [Subscribable (interface)](#subscribable-interface)
+  - [toSubscribable](#tosubscribable)
+  - [toSubscribableWith](#tosubscribablewith)
+
+---
+
+# Handle
+
+## Handle (interface)
+
+**Signature**
+
+```ts
+export interface Handle {
+  unsubscribe(reactive: Reactive["Type"]): void
+}
+```
+
+Added in v1.0.0
+
+# Layer
+
+## layerTimeToLive
+
+**Signature**
+
+```ts
+export declare const layerTimeToLive: {
+  (duration: Duration.DurationInput): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
+  <A, E, R>(self: Layer.Layer<A, E, R>, duration: Duration.DurationInput): Layer.Layer<A, E, R>
+}
+```
+
+Added in v1.0.0
+
+# Reactive
+
+## Reactive (class)
+
+**Signature**
+
+```ts
+export declare class Reactive
+```
+
+Added in v1.0.0
+
+### with (static method)
+
+**Signature**
+
+```ts
+static with<A, E, R>(f: (reactive: Reactive["Type"]) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R | Reactive>
+```
+
+Added in v1.0.0
+
+## cache
+
+Cache an Effect for the lifetime of the current reactive context.
+
+**Signature**
+
+```ts
+export declare const cache: (
+  ...key: ReadonlyArray<unknown>
+) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Scope.Scope> | Reactive>
+```
+
+Added in v1.0.0
+
+## emit
+
+Immediately emits a value for the current reactive context.
+
+**Signature**
+
+```ts
+export declare const emit: <A = unknown>(value: A) => Effect.Effect<void, never, Reactive>
+```
+
+Added in v1.0.0
+
+# Readable
+
+## Readable (interface)
+
+**Signature**
+
+```ts
+export interface Readable<out A, out E, out R> {
+  readonly effect: Effect.Effect<A, E, R | Reactive>
+  readonly result: Effect.Effect<Result.Result<A, E>, never, R | Reactive>
+  readonly success: Effect.Effect<Result.Success<A, never>, E, R | Reactive>
+}
+```
+
+Added in v1.0.0
+
+## readable
+
+**Signature**
+
+```ts
+export declare const readable: <A, E, R>(
+  effect: Effect.Effect<A, E, R>
+) => Readable<A, E, Exclude<R, Reactive | Scope.Scope>>
+```
+
+Added in v1.0.0
+
+# Subscribable
+
+## Subscribable (interface)
+
+**Signature**
+
+```ts
+export interface Subscribable<out A, out E> {
+  subscribe(onResult: (result: Result.Result<A, E>) => void): () => void
+}
+```
+
+Added in v1.0.0
+
+## toSubscribable
+
+**Signature**
+
+```ts
+export declare const toSubscribable: <R, ER>(
+  layer: Layer.Layer<R, ER>,
+  memoMap?: Layer.MemoMap | undefined
+) => <A, E>(effect: Effect.Effect<A, E, Reactive | Scope.Scope | R>) => Subscribable<A, ER | E>
+```
+
+Added in v1.0.0
+
+## toSubscribableWith
+
+**Signature**
+
+```ts
+export declare const toSubscribableWith: <R, ER>(
+  build: (scope: Scope.Scope, memoMap: Layer.MemoMap) => Effect.Effect<Context.Context<R>, ER>,
+  memoMap?: Layer.MemoMap | undefined
+) => <A, E>(effect: Effect.Effect<A, E, R | Reactive | Scope.Scope>) => Subscribable<A, E | ER>
+```
+
+Added in v1.0.0