effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/unstable/reactivity/Atom.ts

@@ -25,7 +25,7 @@ import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as SubscriptionRef from "../../SubscriptionRef.ts"
-import type { NoInfer } from "../../Types.ts"
+import type { Mutable, NoInfer } from "../../Types.ts"
 import * as KeyValueStore from "../persistence/KeyValueStore.ts"
 import * as AsyncResult from "./AsyncResult.ts"
 import { AtomRegistry } from "./AtomRegistry.ts"
@@ -56,6 +56,7 @@ export interface Atom<A> extends Pipeable, Inspectable.Inspectable {
   readonly refresh?: (f: <A>(atom: Atom<A>) => void) => void
   readonly label?: readonly [name: string, stack: string]
   readonly idleTTL?: number
+  readonly initialValueTarget?: Atom<A>
 }
 
 /**
@@ -169,25 +170,25 @@ export const setIdleTTL: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => A
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => A
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): A
+  <A extends Atom<any>>(self: A, duration: Duration.Input): A
 } = dual<
   /**
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput) => <A extends Atom<any>>(self: A) => A,
+  (duration: Duration.Input) => <A extends Atom<any>>(self: A) => A,
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput) => A
+  <A extends Atom<any>>(self: A, duration: Duration.Input) => A
 >(2, (self, durationInput) => {
-  const duration = Duration.fromDurationInputUnsafe(durationInput)
+  const duration = Duration.fromInputUnsafe(durationInput)
   const isFinite = Duration.isFinite(duration)
   return Object.assign(Object.create(Object.getPrototypeOf(self)), {
     ...self,
@@ -417,7 +418,7 @@ export const make: {
     options?: {
       readonly initialValue?: A
     }
-  ): Atom<AsyncResult.AsyncResult<A, E>>
+  ): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>
   // -----------------------------------------------------------------------------
   // constructors
   // -----------------------------------------------------------------------------
@@ -431,7 +432,7 @@ export const make: {
     options?: {
       readonly initialValue?: A
     }
-  ): Atom<AsyncResult.AsyncResult<A, E>>
+  ): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>
   // -----------------------------------------------------------------------------
   // constructors
   // -----------------------------------------------------------------------------
@@ -477,11 +478,11 @@ const makeRead: {
   <A, E>(stream: Stream.Stream<A, E, AtomRegistry>, options?: {
     readonly initialValue?: A
     readonly uninterruptible?: boolean | undefined
-  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E>
+  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>
   <A, E>(create: (get: Context) => Stream.Stream<A, E, AtomRegistry>, options?: {
     readonly initialValue?: A
     readonly uninterruptible?: boolean | undefined
-  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E>
+  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>
   <A>(create: (get: Context) => A): (get: Context, services?: ServiceMap.ServiceMap<any>) => A
   <A>(initialValue: A): Writable<A>
 } = <A, E>(
@@ -606,11 +607,8 @@ function runCallbackSync<R, A, E, ER = never>(
     return undefined
   }
   const runFork = Effect.runForkWith(services)
-  const scheduler = ServiceMap.get(services, Scheduler.Scheduler)
   const fiber = runFork(effect)
-  if ("flush" in scheduler) {
-    ;(scheduler as Scheduler.MixedScheduler).flush()
-  }
+  fiber.currentDispatcher?.flush()
   const result = fiber.pollUnsafe()
   if (result) {
     onExit(result)
@@ -653,10 +651,10 @@ export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult
     }): Atom<AsyncResult.AsyncResult<A, E | ER>>
     <A, E>(create: (get: Context) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
       readonly initialValue?: A
-    }): Atom<AsyncResult.AsyncResult<A, E | ER>>
+    }): 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>>
+    }): Atom<AsyncResult.AsyncResult<A, E | ER | Cause.NoSuchElementError>>
   }
 
   readonly fn: {
@@ -792,7 +790,7 @@ export const context: (options: {
         }))
         get.subscribe(atom, (value) => get.setSelf(value))
         return get.once(atom)
-      }) as any as A
+      }, { initialValueTarget: atom }) as any as A
   return factory
 }
 
@@ -1600,33 +1598,67 @@ export const transform: {
    * @since 4.0.0
    * @category combinators
    */
-  <R extends Atom<any>, B>(f: (get: Context, atom: R) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
+  <R extends Atom<any>, B>(
+    f: (get: Context, atom: R) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <R extends Atom<any>, B>(self: R, f: (get: Context, atom: R) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
+  <R extends Atom<any>, B>(
+    self: R,
+    f: (get: Context, atom: R) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
 } = dual(
-  2,
-  (<A, B>(self: Atom<A>, f: (get: Context, atom: Atom<A>) => B): Atom<B> =>
-    isWritable(self)
-      ? writable(
-        (get) => f(get, self),
-        function(ctx, value) {
-          ctx.set(self, value)
-        },
-        self.refresh ?? function(refresh) {
-          refresh(self)
-        }
-      )
-      : readable(
-        (get) => f(get, self),
-        self.refresh ?? function(refresh) {
-          refresh(self)
-        }
-      )) as any
+  (args) => isAtom(args[0]),
+  (<A, B>(
+    self: Atom<A>,
+    f: (get: Context, atom: Atom<A>, options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): Atom<B> => {
+    const atom = removeTtl(
+      isWritable(self)
+        ? writable(
+          (get) => f(get, self),
+          function(ctx, value) {
+            ctx.set(self, value)
+          },
+          self.refresh ?? function(refresh) {
+            refresh(self)
+          }
+        )
+        : readable(
+          (get) => f(get, self),
+          self.refresh ?? function(refresh) {
+            refresh(self)
+          }
+        )
+    )
+    if (options?.initialValueTarget) {
+      ;(atom as Mutable<Atom<B>>).initialValueTarget = getInitialValueTarget(options.initialValueTarget)
+    }
+    return atom
+  }) as any
 )
 
+const getInitialValueTarget = <A>(atom: Atom<A>): Atom<A> => {
+  let target = atom
+  while (target.initialValueTarget) {
+    target = target.initialValueTarget
+  }
+  return target
+}
+
 /**
  * @since 4.0.0
  * @category combinators
@@ -1684,16 +1716,16 @@ export const debounce: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): WithoutSerializable<A>
+  <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>
 } = dual(
   2,
-  <A>(self: Atom<A>, duration: Duration.DurationInput): Atom<A> => {
-    const millis = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+  <A>(self: Atom<A>, duration: Duration.Input): Atom<A> => {
+    const millis = Duration.toMillis(Duration.fromInputUnsafe(duration))
     return transform(self, function(get) {
       let timeout: number | undefined
       let value = get.once(self)
@@ -1710,7 +1742,7 @@ export const debounce: {
         timeout = setTimeout(update, millis) as any
       })
       return value
-    })
+    }, { initialValueTarget: self })
   }
 )
 
@@ -1729,7 +1761,7 @@ export const withRefresh: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
   /**
    * Ensures that the value of the atom is refreshed at most once per specified
    * duration.
@@ -1737,19 +1769,143 @@ export const withRefresh: {
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): WithoutSerializable<A>
+  <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>
 } = dual(
   2,
-  <A>(self: Atom<A>, duration: Duration.DurationInput): Atom<A> => {
-    const millis = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+  <A>(self: Atom<A>, duration: Duration.Input): Atom<A> => {
+    const millis = Duration.toMillis(Duration.fromInputUnsafe(duration))
     return transform(self, function(get) {
       const handle = setTimeout(() => get.refresh(self), millis) as any
       get.addFinalizer(() => clearTimeout(handle))
       return get(self)
-    })
+    }, { initialValueTarget: self })
   }
 )
 
+/**
+ * Adds stale-while-revalidate refresh behavior to an async result atom.
+ *
+ * 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.
+ *
+ * @since 4.0.0
+ * @category combinators
+ */
+export const swr: {
+  /**
+   * Adds stale-while-revalidate refresh behavior to an async result atom.
+   *
+   * 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.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    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.
+   *
+   * 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.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  <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>
+} = dual(
+  2,
+  <A, E>(
+    self: Atom<AsyncResult.AsyncResult<A, E>>,
+    options: {
+      readonly staleTime: Duration.Input
+      readonly revalidateOnMount?: boolean | undefined
+      readonly revalidateOnFocus?: boolean | "always" | undefined
+      readonly focusSignal?: Atom<any> | undefined
+    }
+  ): Atom<AsyncResult.AsyncResult<A, E>> => {
+    const staleTime = Duration.toMillis(Duration.fromInputUnsafe(options.staleTime))
+    return transform(self, (get) => {
+      const current = get.once(self)
+      get.subscribe(self, (value) => {
+        get.setSelf(value)
+      })
+      if (options.revalidateOnFocus && options.focusSignal) {
+        get.once(options.focusSignal)
+        get.subscribe(
+          options.focusSignal,
+          options.revalidateOnFocus === "always" ? () => get.refresh(self) : () => {
+            const current = get.once(self)
+            if (shouldRevalidateSWR(current, staleTime)) {
+              get.refresh(self)
+            }
+          }
+        )
+      }
+      const firstRead = Option.isNone(get.self<AsyncResult.AsyncResult<A, E>>())
+      if (firstRead && options.revalidateOnMount === false) {
+        return current
+      }
+      if (shouldRevalidateSWR(current, staleTime)) {
+        get.refresh(self)
+      }
+      return current
+    }, { initialValueTarget: self })
+  }
+) as any
+
+const swrTimestamp = <A, E>(result: AsyncResult.AsyncResult<A, E>): Option.Option<number> => {
+  if (result._tag === "Success") {
+    return Option.some(result.timestamp)
+  }
+  if (result._tag === "Failure") {
+    return Option.map(result.previousSuccess, (success) => success.timestamp)
+  }
+  return Option.none()
+}
+
+const isFreshWithin = (timestamp: number, staleTime: number, now: number): boolean => now - timestamp < staleTime
+
+const shouldRevalidateSWR = <A, E>(result: AsyncResult.AsyncResult<A, E>, staleTime: number): boolean => {
+  if (result.waiting) {
+    return false
+  }
+  const timestamp = Option.getOrUndefined(swrTimestamp(result))
+  if (timestamp === undefined) {
+    return result._tag !== "Initial"
+  }
+  return !isFreshWithin(timestamp, staleTime, Date.now())
+}
+
 /**
  * @since 4.0.0
  * @category Optimistic
@@ -1962,7 +2118,7 @@ export const makeRefreshOnSignal = <_>(signal: Atom<_>) => <A extends Atom<any>>
     get.subscribe(signal, (_) => get.refresh(self))
     get.subscribe(self, (value) => get.setSelf(value))
     return get.once(self)
-  }) as any
+  }, { initialValueTarget: self }) as any
 
 /**
  * @since 4.0.0
@@ -2070,7 +2226,7 @@ export const searchParam = <S extends Schema.Codec<any, string> = never>(name: s
         window.removeEventListener("pushstate", handleUpdate)
       })
       const value = new URLSearchParams(window.location.search).get(name) || ""
-      return decode ? Exit.findErrorOption(decode(value)) : value as any
+      return decode ? Exit.getSuccess(decode(value)) : value as any
     },
     (ctx, value: any) => {
       if (typeof window === "undefined") {
@@ -2291,16 +2447,18 @@ export const serializable: {
 } = dual(2, <R extends Atom<any>, A, I>(self: R, options: {
   readonly key: string
   readonly schema: Schema.Codec<A, I>
-}): R & Serializable<any> =>
-  Object.assign(Object.create(Object.getPrototypeOf(self)), {
+}): R & Serializable<any> => {
+  const codecJson = Schema.toCodecJson(options.schema)
+  return Object.assign(Object.create(Object.getPrototypeOf(self)), {
     ...self,
     label: self.label ?? [options.key, new Error().stack?.split("\n")[5] ?? ""],
     [SerializableTypeId]: {
       key: options.key,
-      encode: Schema.encodeSync(options.schema),
-      decode: Schema.decodeSync(options.schema)
+      encode: Schema.encodeSync(codecJson),
+      decode: Schema.decodeSync(codecJson)
     }
-  }))
+  })
+})
 
 /**
  * @since 4.0.0