@fncts/observable 0.0.9 → 0.0.11

package/_src/Observable/definition.ts

@@ -30,13 +30,14 @@ export class Observable<R, E, A> implements Subscribable<E, A>, AsyncIterable<A>
     }
   }
 
-  [Symbol.asyncIterator]() {
+  [Symbol.asyncIterator]<E, A>(this: Observable<never, E, A>) {
     let done         = false;
     const queue: A[] = [];
-    let error: Cause<E>;
 
+    let error: Cause<E>;
     let resolveCurrent: ((a: A) => void) | undefined;
     let rejectCurrent: ((err: unknown) => void) | undefined;
+
     this.subscribe({
       next: (value) => {
         if (resolveCurrent) {
@@ -86,30 +87,37 @@ export class Observable<R, E, A> implements Subscribable<E, A>, AsyncIterable<A>
     return observable;
   }
 
-  provide(environment: Environment<R>): Observable<never, E, A> {
-    const observable       = new Observable<never, E, A>();
-    observable.source      = this;
-    observable.environment = environment;
+  provideEnvironment(environment: Environment<R>): Observable<never, E, A>;
+  provideEnvironment<In>(environment: Environment<In>): Observable<Exclude<R, In>, E, A>;
+  provideEnvironment<In>(environment: Environment<In>): Observable<Exclude<R, In>, E, A> {
+    const observable       = new Observable<never, E, A>(this.subscribeInternal);
+    observable.source      = this.source;
+    observable.operator    = this.operator;
+    observable.environment = this.environment.union(environment);
     return observable;
   }
 
-  subscribe(observer?: Partial<Observer<E, A>>, environment?: Environment<R>): Subscription;
-  subscribe(observer?: (value: A) => void, environment?: Environment<R>): Subscription;
-  subscribe(observer?: Partial<Observer<E, A>> | ((value: A) => void), environment?: Environment<R>): Subscription {
+  subscribe<E, A>(this: Observable<never, E, A>, observer?: Subscriber<E, A>): Subscription;
+  subscribe<E, A>(this: Observable<never, E, A>, observer?: Partial<Observer<E, A>>): Subscription;
+  subscribe<E, A>(this: Observable<never, E, A>, observer?: (value: A) => void): Subscription;
+  subscribe<E, A>(
+    this: Observable<never, E, A>,
+    observer?: Partial<Observer<E, A>> | ((value: A) => void),
+  ): Subscription {
     const subscriber: Subscriber<E, A> = isSubscriber(observer) ? observer : new SafeSubscriber(observer);
 
     subscriber.add(
       this.operator
-        ? this.operator.call(subscriber, this.source, environment ?? this.environment)
+        ? this.operator.call(subscriber, this.source, this.environment)
         : this.source
-        ? this.subscribeInternal(subscriber, environment ?? this.environment)
-        : this.trySubscribe(subscriber, environment ?? this.environment),
+        ? this.subscribeInternal(subscriber, this.environment)
+        : this.trySubscribe(subscriber, this.environment),
     );
 
     return subscriber;
   }
 
-  protected trySubscribe(subscriber: Subscriber<E, A>, environment: Environment<R>): Finalizer {
+  protected trySubscribe(subscriber: Subscriber<E, A>, environment: Environment<any>): Finalizer {
     try {
       return this.subscribeInternal(subscriber, environment);
     } catch (err) {
@@ -118,8 +126,8 @@ export class Observable<R, E, A> implements Subscribable<E, A>, AsyncIterable<A>
     }
   }
 
-  protected subscribeInternal(subscriber: Subscriber<E, A>, environment: Environment<R>): Finalizer {
-    this.source?.subscribe(subscriber, environment);
+  protected subscribeInternal(subscriber: Subscriber<E, A>, environment: Environment<any>): Finalizer {
+    this.source?.provideEnvironment(environment).subscribe(subscriber);
   }
 }
 
@@ -130,13 +138,11 @@ export class EnvironmentWith<R0, R, E, A> extends Observable<R0 | R, E, A> {
       if (!this.map.has(environment)) {
         this.map.set(environment, f(environment as Environment<R0>));
       }
-      return this.map.get(environment)!.subscribe(subsciber);
+      return this.map.get(environment)!.provideEnvironment(environment).subscribe(subsciber);
     });
   }
 }
-
 export const EMPTY: Observable<never, never, never> = new Observable((subscriber) => subscriber.complete());
-
 export function isObservable(u: unknown): u is Observable<unknown, unknown, unknown> {
   return isObject(u) && ObservableTypeId in u;
 }

package/_src/Observable/dom/animationFrames.ts

@@ -1,15 +1,25 @@
 import { animationFrameProvider } from "@fncts/observable/internal/animationFrameProvider";
 import { performanceTimestampProvider } from "@fncts/observable/internal/performanceTimestampProvider";
 
-export function animationFrames(
-  timestampProvider?: TimestampProvider,
-): Observable<never, never, { timestamp: number; elapsed: number }> {
+export function animationFrames(timestampProvider?: TimestampProvider): Observable<
+  never,
+  never,
+  {
+    timestamp: number;
+    elapsed: number;
+  }
+> {
   return timestampProvider ? animationFramesInternal(timestampProvider) : DEFAULT_ANIMATION_FRAMES;
 }
 
-function animationFramesInternal(
-  timestampProvider?: TimestampProvider,
-): Observable<never, never, { timestamp: number; elapsed: number }> {
+function animationFramesInternal(timestampProvider?: TimestampProvider): Observable<
+  never,
+  never,
+  {
+    timestamp: number;
+    elapsed: number;
+  }
+> {
   const { schedule } = animationFrameProvider;
   return new Observable((subscriber) => {
     const subscription = new Subscription();

package/_src/Observable/instances.ts

@@ -1,9 +1,6 @@
 // import type * as HKT from "@principia/base/HKT";
-
 // import * as P from "@principia/base/prelude";
-
 // import * as O from "./core.js";
-
 // export interface ObservableF extends HKT.HKT {
 //   readonly type: O.Observable<this["E"], this["A"]>;
 //   readonly index: number;
@@ -12,43 +9,33 @@
 //     A: "+";
 //   };
 // }
-
 // export const Functor: P.Functor<ObservableF> = P.Functor({
 //   map_: O.map_,
 // });
-
 // export const FunctorWithIndex: P.FunctorWithIndex<ObservableF> = P.FunctorWithIndex({
 //   imap_: O.mapWithIndex,
 // });
-
 // export const SemimonoidalFunctor: P.SemimonoidalFunctor<ObservableF> = P.SemimonoidalFunctor({
 //   map_: O.map_,
 //   cross_: O.cross_,
 //   crossWith_: O.crossWith_,
 // });
-
 // export const Apply: P.Apply<ObservableF> = P.Apply({
 //   map_: O.map_,
 //   cross_: O.cross_,
 //   crossWith_: O.crossWith_,
 //   ap_: O.ap_,
 // });
-
 // export const apS = P.apSF(Apply);
-
 // export const apT = P.apTF(Apply);
-
 // export const sequenceS = P.sequenceSF(Apply);
-
 // export const sequenceT = P.sequenceTF(Apply);
-
 // export const MonoidalFunctor: P.MonoidalFunctor<ObservableF> = P.MonoidalFunctor({
 //   map_: O.map_,
 //   cross_: O.cross_,
 //   crossWith_: O.crossWith_,
 //   unit: O.unit,
 // });
-
 // export const Applicative: P.Applicative<ObservableF> = P.Applicative({
 //   map_: O.map_,
 //   cross_: O.cross_,
@@ -56,7 +43,6 @@
 //   unit: O.unit,
 //   pure: O.pure,
 // });
-
 // export const Monad: P.Monad<ObservableF> = P.Monad({
 //   map_: O.map_,
 //   cross_: O.cross_,
@@ -66,19 +52,12 @@
 //   chain_: O.concatMap_,
 //   flatten: O.flatten,
 // });
-
 // const _do = O.pure({});
-
 // export { _do as do };
-
 // export const chainS_ = P.chainSF_(Monad);
-
 // export const chainS = P.chainSF(Monad);
-
 // export const pureS_ = P.pureSF_(Monad);
-
 // export const pureS = P.pureSF(Monad);
-
 // export const MonadSwitch: P.Monad<ObservableF> = P.Monad({
 //   map_: O.map_,
 //   cross_: O.cross_,
@@ -88,7 +67,6 @@
 //   chain_: O.switchMap_,
 //   flatten: O.switchFlatten,
 // });
-
 // export const Filterable: P.Filterable<ObservableF> = P.Filterable({
 //   map_: O.map_,
 //   filter_: O.filter_,
@@ -96,7 +74,6 @@
 //   partition_: O.partition_,
 //   partitionMap_: O.partitionMap_,
 // });
-
 // export const FilterableWithIndex: P.FilterableWithIndex<ObservableF> = P.FilterableWithIndex({
 //   imap_: O.mapWithIndex,
 //   ifilter_: O.ifilter_,

package/_src/Observable.ts

@@ -3,7 +3,6 @@ export * from "./Observable/api.js";
 export * from "./Observable/definition.js";
 export * from "./Observable/instances.js";
 // codegen:end
-
 // codegen:start { preset: barrel, include: Observable/api/*.ts }
 export * from "./Observable/api/connect.js";
 export * from "./Observable/api/connectable.js";
@@ -21,7 +20,6 @@ export * from "./Observable/api/windowTime.js";
 export * from "./Observable/api/windowToggle.js";
 export * from "./Observable/api/windowWhen.js";
 // codegen:end
-
 // codegen:start { preset: barrel, include: Observable/dom/*.ts }
 export * from "./Observable/dom/animationFrames.js";
 // codegen:end

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/Operator.ts

@@ -1,7 +1,6 @@
 export interface Operator<E, A> {
   call(subscriber: Subscriber<E, A>, source: any, environment: Environment<any>): Finalizer;
 }
-
 export class OperatorSubscriber<E, A> extends Subscriber<E, A> {
   constructor(destination: Subscriber<any, any>, observer: Partial<Observer<E, A>>, private onFinalize?: () => void) {
     super(destination);
@@ -40,14 +39,12 @@ export class OperatorSubscriber<E, A> extends Subscriber<E, A> {
         }
       : super.complete;
   }
-
   unsubscribe() {
     const { closed } = this;
     super.unsubscribe();
     !closed && this.onFinalize?.();
   }
 }
-
 export function operatorSubscriber<E, A, E1, A1>(
   destination: Subscriber<E1, A1>,
   observer: Partial<Observer<E, A>>,
@@ -55,19 +52,27 @@ export function operatorSubscriber<E, A, E1, A1>(
 ): OperatorSubscriber<E, A> {
   return new OperatorSubscriber(destination, observer, onFinalize);
 }
-
 /**
- * @tsplus fluent fncts.observable.Observable operate
+ * @tsplus pipeable fncts.observable.Observable operate
  */
 export function operate_<R, E, A, R1, E1, A1>(
-  source: Observable<R, E, A>,
-  f: (source: Observable<R, E, A>, subscriber: Subscriber<E1, A1>) => (() => void) | void,
-): Observable<R1, E1, A1> {
-  return source.lift(function (this: Subscriber<E1, A1>, liftedSource: Observable<R, E, A>) {
-    try {
-      f(liftedSource, this);
-    } catch (err) {
-      this.error(Cause.halt(err));
-    }
-  });
+  f: (
+    source: Observable<R, E, A>,
+    subscriber: Subscriber<E1, A1>,
+    environment: Environment<R | R1>,
+  ) => (() => void) | void,
+) {
+  return (source: Observable<R, E, A>): Observable<R1, E1, A1> => {
+    return source.lift(function (
+      this: Subscriber<E1, A1>,
+      liftedSource: Observable<R, E, A>,
+      environment: Environment<R | R1>,
+    ) {
+      try {
+        f(liftedSource, this, environment);
+      } catch (err) {
+        this.error(Cause.halt(err));
+      }
+    });
+  };
 }

package/_src/Scheduler.ts

@@ -8,12 +8,6 @@ export interface SchedulerAction<T> extends Subscription {
   schedule(state?: T, delay?: number): Subscription;
 }
 
-/*
- * -------------------------------------------------------------------------------------------------
- * Scheduler
- * -------------------------------------------------------------------------------------------------
- */
-
 export const SchedulerTypeId = Symbol.for("fncts.observable.Scheduler");
 export type SchedulerTypeId = typeof SchedulerTypeId;
 

package/_src/Subject.ts

@@ -118,7 +118,7 @@ export class AnonymousSubject<R, E, A> extends Subject<R, E, A> {
 
   /** @internal */
   protected subscribeInternal<E, A>(subscriber: Subscriber<E, A>) {
-    return this.source?.subscribe(subscriber) ?? Subscription.empty;
+    return this.source?.provideEnvironment(this.environment).subscribe(subscriber) ?? Subscription.empty;
   }
 }
 

package/_src/Subscriber.ts

@@ -63,7 +63,6 @@ export class Subscriber<E, A> extends Subscription implements Observer<E, A> {
     }
   }
 }
-
 export class SafeSubscriber<E, A> extends Subscriber<E, A> {
   constructor(observer?: Partial<Observer<E, A>> | ((value: A) => void)) {
     super();
@@ -118,7 +117,9 @@ function defaultErrorHandler(error: any) {
   throw error;
 }
 
-export const EMPTY_OBSERVER: Readonly<Observer<any, any>> & { closed: true } = {
+export const EMPTY_OBSERVER: Readonly<Observer<any, any>> & {
+  closed: true;
+} = {
   closed: true,
   next: noop,
   error: defaultErrorHandler,

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
  */