@fncts/observable 0.0.10 → 0.0.12

package/_src/ObservableRef/api.ts

@@ -0,0 +1,169 @@
+import type { Lens } from "@fncts/base/optics/Lens";
+import type { URIO } from "@fncts/io/IO";
+import type { Observable } from "@fncts/observable/Observable";
+import type { Store } from "@fncts/observable/ObservableRef/atomic";
+
+import { Atomic } from "@fncts/observable/ObservableRef/atomic";
+import { ObservableRef, ObservableRefDescriptor } from "@fncts/observable/ObservableRef/definition";
+
+/**
+ * @tsplus static fncts.observable.ObservableRefOps make
+ * @tsplus static fncts.observable.ObservableRefOps __call
+ */
+export function make<A>(initial: A, /** @fncts id */ id?: string): ObservableRef<Store, A, A> {
+  if (id === undefined) {
+    throw new Error("ObservableRef.make: the `id` argument must be provided if not using typescript transformers");
+  }
+  return new Atomic(new ObservableRefDescriptor(Symbol.for(id!), initial));
+}
+
+/**
+ * @tsplus pipeable fncts.observable.ObservableRef update
+ */
+export function update<R, A>(f: (a: A) => A) {
+  return (self: ObservableRef<R, A, A>): URIO<R, void> => self.modify((a) => [undefined, f(a)]);
+}
+
+/**
+ * @tsplus pipeable fncts.observable.ObservableRef getAndUpdate
+ */
+export function getAndUpdate<R, A>(f: (a: A) => A) {
+  return (self: ObservableRef<R, A, A>): URIO<R, A> => {
+    return self.modify((a) => {
+      const value = f(a);
+      return [a, value];
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.observable.ObservableRef updateAndGet
+ */
+export function updateAndGet<R, A>(f: (a: A) => A) {
+  return (self: ObservableRef<R, A, A>): URIO<R, A> => {
+    return self.modify((a) => {
+      const value = f(a);
+      return [value, value];
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.observable.ObservableRef modify
+ */
+export function modify<R, A, B>(f: (a: A) => readonly [B, A]) {
+  return (self: ObservableRef<R, A, A>): URIO<R, B> => {
+    return self.get.flatMap((value) => {
+      const [b, a] = f(value);
+      return self.set(a) > IO.succeedNow(b);
+    });
+  };
+}
+
+class Map<R, A, B, C> extends ObservableRef<R, A, C> {
+  constructor(readonly source: ObservableRef<R, A, B>, readonly f: (b: B) => C) {
+    super(source.descriptor);
+  }
+
+  get: URIO<R, C> = this.source.get.map(this.f);
+
+  set(a: A): URIO<R, void> {
+    return this.source.set(a);
+  }
+
+  has: URIO<R, boolean> = this.source.has;
+
+  delete: URIO<R, boolean> = this.source.delete;
+
+  observable: Observable<R, never, C> = this.source.observable.map(this.f);
+}
+
+/**
+ * @tsplus pipeable fncts.observable.ObservableRef map
+ */
+export function map<R, A, B, C>(f: (a: B) => C) {
+  return (self: ObservableRef<R, A, B>): ObservableRef<R, A, C> => {
+    return new Map(self, f);
+  };
+}
+
+class ContramapIn<R, A, B, C> extends ObservableRef<R, C, B> {
+  constructor(readonly source: ObservableRef<R, A, B>, readonly f: (c: C) => A) {
+    super(source.descriptor);
+  }
+
+  get: URIO<R, B> = this.source.get;
+
+  set(c: C): URIO<R, void> {
+    return this.source.set(this.f(c));
+  }
+
+  has: URIO<R, boolean> = this.source.has;
+
+  delete: URIO<R, boolean> = this.source.delete;
+
+  observable: Observable<R, never, B> = this.source.observable;
+}
+
+/**
+ * @tsplus pipeable fncts.observable.ObservableRef contramapIn
+ */
+export function contramapIn<R, A, B, C>(f: (inp: C) => A) {
+  return (self: ObservableRef<R, A, B>): ObservableRef<R, C, B> => {
+    return new ContramapIn(self, f);
+  };
+}
+
+class Focus<R, A, B> extends ObservableRef<R, B, B> {
+  constructor(readonly source: ObservableRef<R, A, A>, readonly lens: Lens<A, B>) {
+    super(source.descriptor);
+  }
+
+  get: URIO<R, B> = this.source.get.map(this.lens.get);
+
+  set(b: B): URIO<R, void> {
+    return this.source.get.flatMap((a) => this.source.set(this.lens.set(b)(a)));
+  }
+
+  has: URIO<R, boolean> = this.source.has;
+
+  delete: URIO<R, boolean> = this.source.delete;
+
+  observable: Observable<R, never, B> = this.source.observable.map(this.lens.get);
+}
+
+/**
+ * @tsplus pipeable fncts.observable.ObservableRef focus
+ */
+export function focus<R, A, B>(lens: Lens<A, B>) {
+  return (self: ObservableRef<R, A, A>): ObservableRef<R, B, B> => {
+    return new Focus(self, lens);
+  };
+}
+
+export class ZipWith<R, A, R1, B, C> implements ObservableRef.Readable<R | R1, C> {
+  declare _R: (_: never) => R | R1;
+  declare _Out: (_: never) => C;
+  constructor(
+    readonly sourceA: ObservableRef.Readable<R, A>,
+    readonly sourceB: ObservableRef.Readable<R1, B>,
+    readonly f: (a: A, b: B) => C,
+  ) {}
+
+  get: URIO<R | R1, C> = this.sourceA.get.zipWith(this.sourceB.get, this.f);
+
+  has: URIO<R | R1, boolean> = this.sourceA.has.zipWith(this.sourceB.has, (a, b) => a && b);
+
+  delete: URIO<R | R1, void> = this.sourceA.delete > this.sourceB.delete;
+
+  observable: Observable<R | R1, never, C> = this.sourceA.observable.zipWithLatest(this.sourceB.observable, this.f);
+}
+
+/**
+ * @tsplus pipeable fncts.observable.ObservableRef.Readable zipWith
+ */
+export function zipWith<R, A, R1, B, C>(that: ObservableRef.Readable<R1, B>, f: (a: A, b: B) => C) {
+  return (self: ObservableRef.Readable<R, A>): ObservableRef.Readable<R | R1, C> => {
+    return new ZipWith(self, that, f);
+  };
+}

package/_src/ObservableRef/atomic.ts

@@ -0,0 +1,85 @@
+import type { ObservableRefDescriptor } from "@fncts/observable/ObservableRef/definition";
+
+import { BehaviorSubject } from "@fncts/observable/BehaviorSubject";
+
+export class Atomic<A> extends ObservableRef<Store, A, A> {
+  get: URIO<Store, A> = IO.serviceWithIO((reactor) => reactor.get(this.descriptor), Store.Tag);
+
+  set(a: A): URIO<Store, void> {
+    return IO.serviceWithIO((reactor) => reactor.set(this.descriptor, a), Store.Tag);
+  }
+
+  has: URIO<Store, boolean> = IO.serviceWithIO((reactor) => reactor.has(this.descriptor), Store.Tag);
+
+  delete: URIO<Store, boolean> = IO.serviceWithIO((reactor) => reactor.delete(this.descriptor), Store.Tag);
+
+  observable: Observable<Store, never, A> = Observable.serviceWithObservable(
+    (reactor) =>
+      new Observable((subscriber) => {
+        return reactor.unsafeSubscribe(this.descriptor, subscriber);
+      }),
+    Store.Tag,
+  );
+}
+
+/**
+ * @tsplus type fncts.observable.Store
+ * @tsplus companion fncts.observable.StoreOps
+ */
+export class Store {
+  subjectMap = new Map<symbol, BehaviorSubject<any>>();
+  get<A>(ref: ObservableRefDescriptor<A>): UIO<A> {
+    return IO(() => {
+      if (this.subjectMap.has(ref.id)) {
+        return this.subjectMap.get(ref.id)!.value;
+      } else {
+        this.subjectMap.set(ref.id, new BehaviorSubject(ref.initial));
+        return ref.initial;
+      }
+    });
+  }
+
+  set<A>(ref: ObservableRefDescriptor<A>, value: A): UIO<A> {
+    return IO(() => {
+      if (this.subjectMap.has(ref.id)) {
+        this.subjectMap.get(ref.id)!.next(value);
+      } else {
+        this.subjectMap.set(ref.id, new BehaviorSubject(value));
+      }
+      return value;
+    });
+  }
+
+  has<A>(ref: ObservableRefDescriptor<A>): UIO<boolean> {
+    return IO(() => this.subjectMap.has(ref.id));
+  }
+
+  delete<A>(ref: ObservableRefDescriptor<A>): UIO<boolean> {
+    return IO(() => {
+      if (this.subjectMap.has(ref.id)) {
+        this.subjectMap.delete(ref.id);
+        return true;
+      }
+      return false;
+    });
+  }
+
+  unsafeSubscribe<A>(ref: ObservableRefDescriptor<A>, subscriber: Subscriber<never, A>): Subscription {
+    if (this.subjectMap.has(ref.id)) {
+      const subject      = this.subjectMap.get(ref.id)!;
+      const subscription = subject.subscribe(subscriber);
+      return subscription;
+    } else {
+      const subject      = new BehaviorSubject<A>(ref.initial);
+      const subscription = subject.subscribe(subscriber);
+      this.subjectMap.set(ref.id, subject);
+      return subscription;
+    }
+  }
+}
+
+/**
+ * @tsplus static fncts.observable.StoreOps Tag
+ * @tsplus implicit
+ */
+export const StoreTag = Tag<Store>("fncts.observable.ObservableRef.StoreTag");

package/_src/ObservableRef/definition.ts

@@ -0,0 +1,57 @@
+import type { URIO } from "@fncts/io/IO";
+import type { Observable } from "@fncts/observable/Observable";
+
+type Readable_<R, A> = Readable<R, A>;
+type Writable_<R, A> = Writable<R, A>;
+
+export declare namespace ObservableRef {
+  type Readable<R, A> = Readable_<R, A>;
+  type Writable<R, A> = Writable_<R, A>;
+}
+
+export class ObservableRefDescriptor<A> {
+  constructor(readonly id: symbol, readonly initial: A) {}
+}
+
+export interface CommonObservableRef<out R> {
+  readonly _R: (_: never) => R;
+  readonly has: URIO<R, boolean>;
+  readonly delete: URIO<R, void>;
+}
+
+/**
+ * @tsplus type fncts.observable.ObservableRef.Readable
+ */
+export interface Readable<out R, out A> extends CommonObservableRef<R> {
+  readonly _R: (_: never) => R;
+  readonly _Out: (_: never) => A;
+  readonly get: URIO<R, A>;
+  readonly observable: Observable<R, never, A>;
+}
+
+/**
+ * @tsplus type fncts.observable.ObservableRef.Writable
+ */
+export interface Writable<out R, in A> extends CommonObservableRef<R> {
+  readonly _R: (_: never) => R;
+  readonly _In: (_: A) => void;
+  set(a: A): URIO<R, void>;
+}
+
+/**
+ * @tsplus type fncts.observable.ObservableRef
+ * @tsplus companion fncts.observable.ObservableRefOps
+ */
+export abstract class ObservableRef<out R, in A, out B> implements Readable<R, B>, Writable<R, A> {
+  declare _R: (_: never) => R;
+  declare _In: (_: A) => void;
+  declare _Out: (_: never) => B;
+
+  constructor(readonly descriptor: ObservableRefDescriptor<any>) {}
+
+  abstract readonly get: URIO<R, B>;
+  abstract set(a: A): URIO<R, void>;
+  abstract readonly delete: URIO<R, boolean>;
+  abstract readonly has: URIO<R, boolean>;
+  abstract readonly observable: Observable<R, never, B>;
+}

package/_src/global.ts

@@ -18,7 +18,7 @@ import { isDate, isFunction, isIterable, isObject, isPlain } from "@fncts/base/u
 /**
  * @tsplus global
  */
-import { FiberContext } from "@fncts/io/Fiber";
+import { FiberRuntime } from "@fncts/io/Fiber";
 /**
  * @tsplus global
  */
@@ -76,6 +76,10 @@ import { Notification } from "@fncts/observable/Notification";
  * @tsplus global
  */
 import { Observable, ObservableInput, Subscribable } from "@fncts/observable/Observable";
+/**
+ * @tsplus global
+ */
+import { ObservableRef } from "@fncts/observable/ObservableRef/definition";
 /**
  * @tsplus global
  */

package/global.d.ts

@@ -17,7 +17,7 @@ import { isDate, isFunction, isIterable, isObject, isPlain } from "@fncts/base/u
 /**
  * @tsplus global
  */
-import { FiberContext } from "@fncts/io/Fiber";
+import { FiberRuntime } from "@fncts/io/Fiber";
 /**
  * @tsplus global
  */
@@ -66,6 +66,10 @@ import { Notification } from "@fncts/observable/Notification";
  * @tsplus global
  */
 import { Observable, ObservableInput, Subscribable } from "@fncts/observable/Observable";
+/**
+ * @tsplus global
+ */
+import { ObservableRef } from "@fncts/observable/ObservableRef/definition";
 /**
  * @tsplus global
  */

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/observable",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "dependencies": {
-    "@fncts/base": "0.0.21"
+    "@fncts/base": "0.0.23"
   },
   "exports": {
     "./*": {