@effect-atom/atom 0.1.0

package/src/AtomRef.ts

@@ -0,0 +1,282 @@
+/**
+ * @since 1.0.0
+ */
+import * as Equal from "effect/Equal"
+import { globalValue } from "effect/GlobalValue"
+import * as Hash from "effect/Hash"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId: TypeId = "~effect-atom/atom/AtomRef"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = "~effect-atom/atom/AtomRef"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface ReadonlyRef<A> extends Equal.Equal {
+  readonly [TypeId]: TypeId
+  readonly key: string
+  readonly value: A
+  readonly subscribe: (f: (a: A) => void) => () => void
+  readonly map: <B>(f: (a: A) => B) => ReadonlyRef<B>
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface AtomRef<A> extends ReadonlyRef<A> {
+  readonly prop: <K extends keyof A>(prop: K) => AtomRef<A[K]>
+  readonly set: (value: A) => AtomRef<A>
+  readonly update: (f: (value: A) => A) => AtomRef<A>
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Collection<A> extends ReadonlyRef<ReadonlyArray<AtomRef<A>>> {
+  readonly push: (item: A) => Collection<A>
+  readonly insertAt: (index: number, item: A) => Collection<A>
+  readonly remove: (ref: AtomRef<A>) => Collection<A>
+  readonly toArray: () => Array<A>
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make = <A>(value: A): AtomRef<A> => new AtomRefImpl(value)
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const collection = <A>(items: Iterable<A>): Collection<A> => new CollectionImpl(items)
+
+const keyState = globalValue("@effect-atom/atom/AtomRef/keyState", () => ({
+  count: 0,
+  generate() {
+    return `AtomRef-${this.count++}`
+  }
+}))
+
+class ReadonlyRefImpl<A> implements ReadonlyRef<A> {
+  readonly [TypeId]: TypeId
+  readonly key = keyState.generate()
+  constructor(public value: A) {
+    this[TypeId] = TypeId
+  }
+
+  [Equal.symbol](that: Equal.Equal) {
+    return Equal.equals(this.value, (that as ReadonlyRef<A>).value)
+  }
+
+  [Hash.symbol]() {
+    return Hash.hash(this.value)
+  }
+
+  listeners: Array<(a: A) => void> = []
+  listenerCount = 0
+
+  notify(a: A) {
+    for (let i = 0; i < this.listenerCount; i++) {
+      this.listeners[i](a)
+    }
+  }
+
+  subscribe(f: (a: A) => void): () => void {
+    this.listeners.push(f)
+    this.listenerCount++
+
+    return () => {
+      const index = this.listeners.indexOf(f)
+      if (index !== -1) {
+        this.listeners[index] = this.listeners[this.listenerCount - 1]
+        this.listeners.pop()
+        this.listenerCount--
+      }
+    }
+  }
+
+  map<B>(f: (a: A) => B): ReadonlyRef<B> {
+    return new MapRefImpl(this, f)
+  }
+}
+
+class AtomRefImpl<A> extends ReadonlyRefImpl<A> implements AtomRef<A> {
+  prop<K extends keyof A>(prop: K): AtomRef<A[K]> {
+    return new PropRefImpl(this, prop)
+  }
+  set(value: A) {
+    if (Equal.equals(value, this.value)) {
+      return this
+    }
+    this.value = value
+    this.notify(value)
+    return this
+  }
+
+  update(f: (value: A) => A) {
+    return this.set(f(this.value))
+  }
+}
+
+class MapRefImpl<A, B> implements ReadonlyRef<B> {
+  readonly [TypeId]: TypeId
+  readonly key = keyState.generate()
+  constructor(readonly parent: ReadonlyRef<A>, readonly transform: (a: A) => B) {
+    this[TypeId] = TypeId
+  }
+  [Equal.symbol](that: Equal.Equal) {
+    return Equal.equals(this.value, (that as ReadonlyRef<B>).value)
+  }
+  [Hash.symbol]() {
+    return Hash.hash(this.value)
+  }
+  get value() {
+    return this.transform(this.parent.value)
+  }
+  subscribe(f: (a: B) => void): () => void {
+    let previous = this.transform(this.parent.value)
+    return this.parent.subscribe((a) => {
+      const next = this.transform(a)
+      if (Equal.equals(next, previous)) {
+        return
+      }
+      previous = next
+      f(next)
+    })
+  }
+  map<C>(f: (a: B) => C): ReadonlyRef<C> {
+    return new MapRefImpl(this, f)
+  }
+}
+
+class PropRefImpl<A, K extends keyof A> implements AtomRef<A[K]> {
+  readonly [TypeId]: TypeId
+  readonly key = keyState.generate()
+  private previous: A[K]
+  constructor(readonly parent: AtomRef<A>, readonly _prop: K) {
+    this[TypeId] = TypeId
+    this.previous = parent.value[_prop]
+  }
+  [Equal.symbol](that: Equal.Equal) {
+    return Equal.equals(this.value, (that as ReadonlyRef<A>).value)
+  }
+  [Hash.symbol]() {
+    return Hash.hash(this.value)
+  }
+  get value() {
+    if (this.parent.value && this._prop in (this.parent.value as any)) {
+      this.previous = this.parent.value[this._prop]
+    }
+    return this.previous
+  }
+  subscribe(f: (a: A[K]) => void): () => void {
+    let previous = this.value
+    return this.parent.subscribe((a) => {
+      if (!a || !(this._prop in (a as any))) {
+        return
+      }
+      const next = a[this._prop]
+      if (Equal.equals(next, previous)) {
+        return
+      }
+      previous = next
+      f(next)
+    })
+  }
+  map<C>(f: (a: A[K]) => C): ReadonlyRef<C> {
+    return new MapRefImpl(this, f)
+  }
+  prop<CK extends keyof A[K]>(prop: CK): AtomRef<A[K][CK]> {
+    return new PropRefImpl(this, prop)
+  }
+  set(value: A[K]): AtomRef<A[K]> {
+    if (Array.isArray(this.parent.value)) {
+      const newArray = this.parent.value.slice()
+      newArray[this._prop as number] = value
+      this.parent.set(newArray as A)
+    } else {
+      this.parent.set({
+        ...this.parent.value,
+        [this._prop]: value
+      })
+    }
+    return this
+  }
+  update(f: (value: A[K]) => A[K]): AtomRef<A[K]> {
+    if (Array.isArray(this.parent.value)) {
+      const newArray = this.parent.value.slice()
+      newArray[this._prop as number] = f(this.parent.value[this._prop])
+      this.parent.set(newArray as A)
+    } else {
+      this.parent.set({
+        ...this.parent.value,
+        [this._prop]: f(this.parent.value[this._prop])
+      })
+    }
+    return this
+  }
+}
+
+class CollectionImpl<A> extends ReadonlyRefImpl<Array<AtomRef<A>>> implements Collection<A> {
+  constructor(items: Iterable<A>) {
+    super([])
+    for (const item of items) {
+      this.value.push(this.makeRef(item))
+    }
+  }
+
+  makeRef(value: A) {
+    const ref = new AtomRefImpl(value)
+    const notify = (value: A) => {
+      ref.notify(value)
+      this.notify(this.value)
+    }
+    return new Proxy(ref, {
+      get(target, p, _receiver) {
+        if (p === "notify") {
+          return notify
+        }
+        return target[p as keyof AtomRef<A>]
+      }
+    })
+  }
+
+  push(item: A) {
+    const ref = this.makeRef(item)
+    this.value.push(ref)
+    this.notify(this.value)
+    return this
+  }
+
+  insertAt(index: number, item: A) {
+    const ref = this.makeRef(item)
+    this.value.splice(index, 0, ref)
+    this.notify(this.value)
+    return this
+  }
+
+  remove(ref: AtomRef<A>) {
+    const index = this.value.indexOf(ref)
+    if (index !== -1) {
+      this.value.splice(index, 1)
+      this.notify(this.value)
+    }
+    return this
+  }
+
+  toArray() {
+    return this.value.map((ref) => ref.value)
+  }
+}

package/src/Hydration.ts

@@ -0,0 +1,98 @@
+/**
+ * @since 1.0.0
+ */
+import * as Arr from "effect/Array"
+import * as Atom from "./Atom.js"
+import type * as Registry from "./Registry.js"
+import * as Result from "./Result.js"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface DehydratedAtom {
+  readonly key: string
+  readonly value: unknown
+  readonly dehydratedAt: number
+  readonly resultPromise?: Promise<unknown> | undefined
+}
+
+/**
+ * @since 1.0.0
+ * @category dehydration
+ */
+export const dehydrate = (
+  registry: Registry.Registry,
+  options?: {
+    /**
+     * How to encode `Result.Initial` values. Default is "ignore".
+     */
+    readonly encodeInitialAs?: "ignore" | "promise" | "value-only" | undefined
+  }
+): Array<DehydratedAtom> => {
+  const encodeInitialResultMode = options?.encodeInitialAs ?? "ignore"
+  const arr = Arr.empty<DehydratedAtom>()
+  const now = Date.now()
+  registry.getNodes().forEach((node, key) => {
+    if (!Atom.isSerializable(node.atom)) return
+    const atom = node.atom
+    const value = node.value()
+    const isInitial = Result.isResult(value) && Result.isInitial(value)
+    if (encodeInitialResultMode === "ignore" && isInitial) return
+    const encodedValue = atom[Atom.SerializableTypeId].encode(value)
+
+    // Create a promise that resolves when the atom moves out of Initial state
+    let resultPromise: Promise<unknown> | undefined
+    if (encodeInitialResultMode === "promise" && isInitial) {
+      resultPromise = new Promise((resolve) => {
+        const unsubscribe = registry.subscribe(atom, (newValue) => {
+          if (Result.isResult(newValue) && !Result.isInitial(newValue)) {
+            resolve(atom[Atom.SerializableTypeId].encode(newValue))
+            unsubscribe()
+          }
+        })
+      })
+    }
+
+    arr.push({
+      key: key as string,
+      value: encodedValue,
+      dehydratedAt: now,
+      resultPromise
+    })
+  })
+  return arr
+}
+
+/**
+ * @since 1.0.0
+ * @category hydration
+ */
+export const hydrate = (
+  registry: Registry.Registry,
+  dehydratedState: Iterable<DehydratedAtom>
+): void => {
+  for (const datom of dehydratedState) {
+    registry.setSerializable(datom.key, datom.value)
+
+    // If there's a resultPromise, it means this was in Initial state when dehydrated
+    // and we should wait for it to resolve to a non-Initial state, then update the registry
+    if (!datom.resultPromise) continue
+    datom.resultPromise.then((resolvedValue) => {
+      // Try to update the existing node directly instead of using setSerializable
+      const nodes = (registry as any).getNodes()
+      const node = nodes.get(datom.key)
+      if (node) {
+        // Decode the resolved value using the node's atom serializable decoder
+        const atom = node.atom as any
+        if (atom[Atom.SerializableTypeId]) {
+          const decoded = atom[Atom.SerializableTypeId].decode(resolvedValue)
+          node.setValue(decoded)
+        }
+      } else {
+        // Fallback to setSerializable if node doesn't exist yet
+        registry.setSerializable(datom.key, resolvedValue)
+      }
+    })
+  }
+}

package/src/Registry.ts

@@ -0,0 +1,204 @@
+/**
+ * @since 1.0.0
+ */
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as FiberRef from "effect/FiberRef"
+import { dual } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Mailbox from "effect/Mailbox"
+import { hasProperty } from "effect/Predicate"
+import * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
+import type * as Atom from "./Atom.js"
+import type { Registry } from "./index.js"
+import * as internal from "./internal/registry.js"
+import * as Result from "./Result.js"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId: TypeId = "~effect-atom/atom/Registry"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = "~effect-atom/atom/Registry"
+
+/**
+ * @since 1.0.0
+ * @category guards
+ */
+export const isRegistry = (u: unknown): u is Registry => hasProperty(u, TypeId)
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Registry {
+  readonly [TypeId]: TypeId
+  readonly getNodes: () => ReadonlyMap<Atom.Atom<any> | string, Node<any>>
+  readonly get: <A>(atom: Atom.Atom<A>) => A
+  readonly mount: <A>(atom: Atom.Atom<A>) => () => void
+  readonly refresh: <A>(atom: Atom.Atom<A>) => void
+  readonly set: <R, W>(atom: Atom.Writable<R, W>, value: W) => void
+  readonly setSerializable: (key: string, encoded: unknown) => void
+  readonly modify: <R, W, A>(atom: Atom.Writable<R, W>, f: (_: R) => [returnValue: A, nextValue: W]) => A
+  readonly update: <R, W>(atom: Atom.Writable<R, W>, f: (_: R) => W) => void
+  readonly subscribe: <A>(atom: Atom.Atom<A>, f: (_: A) => void, options?: {
+    readonly immediate?: boolean
+  }) => () => void
+  readonly reset: () => void
+  readonly dispose: () => void
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+interface Node<A> {
+  readonly atom: Atom.Atom<A>
+  readonly value: () => A
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: (
+  options?: {
+    readonly initialValues?: Iterable<readonly [Atom.Atom<any>, any]> | undefined
+    readonly scheduleTask?: ((f: () => void) => void) | undefined
+    readonly timeoutResolution?: number | undefined
+    readonly defaultIdleTTL?: number | undefined
+  } | undefined
+) => Registry = internal.make
+
+/**
+ * @since 1.0.0
+ * @category Tags
+ */
+export class AtomRegistry extends Context.Tag("@effect/atom/Registry/CurrentRegistry")<
+  AtomRegistry,
+  Registry
+>() {}
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerOptions = (options?: {
+  readonly initialValues?: Iterable<readonly [Atom.Atom<any>, any]> | undefined
+  readonly scheduleTask?: ((f: () => void) => void) | undefined
+  readonly timeoutResolution?: number | undefined
+  readonly defaultIdleTTL?: number | undefined
+}): Layer.Layer<AtomRegistry> =>
+  Layer.scoped(
+    AtomRegistry,
+    Effect.gen(function*() {
+      const scope = yield* Effect.scope
+      const scheduler = yield* FiberRef.get(FiberRef.currentScheduler)
+      const registry = internal.make({
+        ...options,
+        scheduleTask: options?.scheduleTask ?? ((f) => scheduler.scheduleTask(f, 0))
+      })
+      yield* Scope.addFinalizer(scope, Effect.sync(() => registry.dispose()))
+      return registry
+    })
+  )
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layer: Layer.Layer<Registry.AtomRegistry> = layerOptions()
+
+// -----------------------------------------------------------------------------
+// conversions
+// -----------------------------------------------------------------------------
+
+/**
+ * @since 1.0.0
+ * @category Conversions
+ */
+export const toStream: {
+  <A>(atom: Atom.Atom<A>): (self: Registry) => Stream.Stream<A>
+  <A>(self: Registry, atom: Atom.Atom<A>): Stream.Stream<A>
+} = dual(
+  2,
+  <A>(self: Registry, atom: Atom.Atom<A>) =>
+    Stream.unwrapScoped(
+      Effect.contextWithEffect((context: Context.Context<Scope.Scope>) => {
+        const scope = Context.get(context, Scope.Scope)
+        return Mailbox.make<A>().pipe(
+          Effect.tap((mailbox) => {
+            const cancel = self.subscribe(atom, (value) => mailbox.unsafeOffer(value), {
+              immediate: true
+            })
+            return Scope.addFinalizer(
+              scope,
+              Effect.suspend(() => {
+                cancel()
+                return mailbox.shutdown
+              })
+            )
+          }),
+          Effect.uninterruptible,
+          Effect.map((mailbox) => Mailbox.toStream(mailbox))
+        )
+      })
+    )
+)
+
+/**
+ * @since 1.0.0
+ * @category Conversions
+ */
+export const toStreamResult: {
+  <A, E>(atom: Atom.Atom<Result.Result<A, E>>): (self: Registry) => Stream.Stream<A, E>
+  <A, E>(self: Registry, atom: Atom.Atom<Result.Result<A, E>>): Stream.Stream<A, E>
+} = dual(
+  2,
+  <A, E>(self: Registry, atom: Atom.Atom<Result.Result<A, E>>): Stream.Stream<A, E> =>
+    toStream(self, atom).pipe(
+      Stream.filter(Result.isNotInitial),
+      Stream.mapEffect((result) =>
+        result._tag === "Success" ? Effect.succeed(result.value) : Effect.failCause(result.cause)
+      )
+    )
+)
+
+/**
+ * @since 1.0.0
+ * @category Conversions
+ */
+export const getResult: {
+  <A, E>(atom: Atom.Atom<Result.Result<A, E>>, options?: {
+    readonly suspendOnWaiting?: boolean | undefined
+  }): (self: Registry) => Effect.Effect<A, E>
+  <A, E>(self: Registry, atom: Atom.Atom<Result.Result<A, E>>, options?: {
+    readonly suspendOnWaiting?: boolean | undefined
+  }): Effect.Effect<A, E>
+} = dual(
+  (args) => isRegistry(args[0]),
+  <A, E>(self: Registry, atom: Atom.Atom<Result.Result<A, E>>, options?: {
+    readonly suspendOnWaiting?: boolean | undefined
+  }): Effect.Effect<A, E> => {
+    const suspendOnWaiting = options?.suspendOnWaiting ?? false
+    return Effect.async((resume) => {
+      const result = self.get(atom)
+      if (result._tag !== "Initial" && !(suspendOnWaiting && result.waiting)) {
+        return resume(Result.toExit(result) as any)
+      }
+      const cancel = self.subscribe(atom, (value) => {
+        if (value._tag !== "Initial" && !(suspendOnWaiting && value.waiting)) {
+          resume(Result.toExit(value) as any)
+          cancel()
+        }
+      })
+      return Effect.sync(cancel)
+    })
+  }
+)