@fncts/observable 0.0.2 → 0.0.3

package/_src/Observable/definition.ts

@@ -1,6 +1,7 @@
 export declare namespace Observable {
-  export type TypeOf<X> = X extends ObservableInput<any, infer A> ? A : never;
-  export type ErrorOf<X> = X extends ObservableInput<infer E, any> ? E : never;
+  export type TypeOf<X> = X extends ObservableInput<any, any, infer A> ? A : never;
+  export type ErrorOf<X> = X extends ObservableInput<any, infer E, any> ? E : never;
+  export type EnvironmentOf<X> = X extends ObservableInput<infer R, any, any> ? R : never;
 }
 
 export const ObservableTypeId = Symbol.for("@principia/observable/Observable");
@@ -10,16 +11,20 @@ export type ObservableTypeId = typeof ObservableTypeId;
  * @tsplus type fncts.observable.Observable
  * @tsplus companion fncts.observable.ObservableOps
  */
-export class Observable<E, A> implements Subscribable<E, A>, AsyncIterable<A> {
-  readonly _E!: () => E;
-  readonly _A!: () => A;
+export class Observable<R, E, A> implements Subscribable<E, A>, AsyncIterable<A> {
+  declare _R: () => R;
+  declare _E: () => E;
+  declare _A: () => A;
 
   readonly [ObservableTypeId]: ObservableTypeId = ObservableTypeId;
 
-  protected source: Observable<any, any> | undefined;
+  protected source: Observable<any, any, any> | undefined;
   protected operator: Operator<E, A> | undefined;
+  protected environment: Environment<any> = Environment();
 
-  constructor(subscribe?: (this: Observable<E, A>, subscriber: Subscriber<E, A>) => Finalizer) {
+  constructor(
+    subscribe?: (this: Observable<R, E, A>, subscriber: Subscriber<E, A>, environment: Environment<R>) => Finalizer,
+  ) {
     if (subscribe) {
       this.subscribeInternal = subscribe;
     }
@@ -74,45 +79,64 @@ export class Observable<E, A> implements Subscribable<E, A>, AsyncIterable<A> {
     };
   }
 
-  lift<E1, A1>(operator: Operator<E1, A1>): Observable<E1, A1> {
-    const observable    = new Observable<E1, A1>();
+  lift<R1, E1, A1>(operator: Operator<E1, A1>): Observable<R1, E1, A1> {
+    const observable    = new Observable<R1, E1, A1>();
     observable.source   = this;
     observable.operator = operator;
     return observable;
   }
 
-  subscribe(observer?: Partial<Observer<E, A>>): Subscription;
-  subscribe(observer?: (value: A) => void): Subscription;
-  subscribe(observer?: Partial<Observer<E, A>> | ((value: A) => void)): Subscription {
+  provide(environment: Environment<R>): Observable<never, E, A> {
+    const observable       = new Observable<never, E, A>();
+    observable.source      = this;
+    observable.environment = 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 {
     const subscriber: Subscriber<E, A> = isSubscriber(observer) ? observer : new SafeSubscriber(observer);
 
     subscriber.add(
       this.operator
-        ? this.operator.call(subscriber, this.source)
+        ? this.operator.call(subscriber, this.source, environment ?? this.environment)
         : this.source
-        ? this.subscribeInternal(subscriber)
-        : this.trySubscribe(subscriber),
+        ? this.subscribeInternal(subscriber, environment ?? this.environment)
+        : this.trySubscribe(subscriber, environment ?? this.environment),
     );
 
     return subscriber;
   }
 
-  protected trySubscribe(subscriber: Subscriber<E, A>): Finalizer {
+  protected trySubscribe(subscriber: Subscriber<E, A>, environment: Environment<R>): Finalizer {
     try {
-      return this.subscribeInternal(subscriber);
+      return this.subscribeInternal(subscriber, environment);
     } catch (err) {
       subscriber.error(Cause.halt(err));
       return noop;
     }
   }
 
-  protected subscribeInternal(subscriber: Subscriber<E, A>): Finalizer {
-    this.source?.subscribe(subscriber);
+  protected subscribeInternal(subscriber: Subscriber<E, A>, environment: Environment<R>): Finalizer {
+    this.source?.subscribe(subscriber, environment);
+  }
+}
+
+export class EnvironmentWith<R0, R, E, A> extends Observable<R0 | R, E, A> {
+  private map: WeakMap<Environment<any>, Observable<any, any, any>> = new WeakMap();
+  constructor(f: (environment: Environment<R0>) => Observable<R, E, A>) {
+    super((subsciber, environment) => {
+      if (!this.map.has(environment)) {
+        this.map.set(environment, f(environment as Environment<R0>));
+      }
+      return this.map.get(environment)!.subscribe(subsciber);
+    });
   }
 }
 
-export const EMPTY: Observable<never, never> = new Observable((subscriber) => subscriber.complete());
+export const EMPTY: Observable<never, never, never> = new Observable((subscriber) => subscriber.complete());
 
-export function isObservable(u: unknown): u is Observable<unknown, unknown> {
+export function isObservable(u: unknown): u is Observable<unknown, unknown, unknown> {
   return isObject(u) && ObservableTypeId in u;
 }

package/_src/Observable/dom/animationFrames.ts

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

package/_src/Operator.ts

@@ -1,5 +1,5 @@
 export interface Operator<E, A> {
-  call(subscriber: Subscriber<E, A>, source: any): Finalizer;
+  call(subscriber: Subscriber<E, A>, source: any, environment: Environment<any>): Finalizer;
 }
 
 export class OperatorSubscriber<E, A> extends Subscriber<E, A> {
@@ -59,11 +59,11 @@ export function operatorSubscriber<E, A, E1, A1>(
 /**
  * @tsplus fluent fncts.observable.Observable operate
  */
-export function operate_<E, A, E1, A1>(
-  source: Observable<E, A>,
-  f: (source: Observable<E, A>, subscriber: Subscriber<E1, A1>) => (() => void) | void,
-): Observable<E1, A1> {
-  return source.lift(function (this: Subscriber<E1, A1>, liftedSource: Observable<E, A>) {
+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) {

package/_src/Subject.ts

@@ -2,7 +2,7 @@ import { arrayRemove } from "@fncts/observable/internal/util";
 
 export interface SubjectLike<E, A> extends Observer<E, A>, Subscribable<E, A> {}
 
-export class Subject<E, A> extends Observable<E, A> implements SubscriptionLike {
+export class Subject<R, E, A> extends Observable<R, E, A> implements SubscriptionLike {
   closed = false;
   protected observers: Array<Observer<E, A>> = [];
   protected isStopped             = false;
@@ -13,7 +13,7 @@ export class Subject<E, A> extends Observable<E, A> implements SubscriptionLike
     super();
   }
 
-  lift<E1, B>(operator: Operator<E1, B>): Observable<E1, B> {
+  lift<R1, E1, B>(operator: Operator<E1, B>): Observable<R1, E1, B> {
     const subject    = new AnonymousSubject(this, this);
     subject.operator = operator as any;
     return subject as any;
@@ -67,9 +67,9 @@ export class Subject<E, A> extends Observable<E, A> implements SubscriptionLike
     }
   }
 
-  protected trySubscribe(subscriber: Subscriber<E, A>): Finalizer {
+  protected trySubscribe(subscriber: Subscriber<E, A>, environment: Environment<R>): Finalizer {
     this.throwIfClosed();
-    return super.trySubscribe(subscriber);
+    return super.trySubscribe(subscriber, environment);
   }
 
   protected subscribeInternal(subscriber: Subscriber<E, A>): Subscription {
@@ -94,15 +94,15 @@ export class Subject<E, A> extends Observable<E, A> implements SubscriptionLike
     }
   }
 
-  asObservable(): Observable<E, A> {
-    const observable: any = new Observable<E, A>();
+  asObservable(): Observable<R, E, A> {
+    const observable: any = new Observable<R, E, A>();
     observable.source     = this;
     return observable;
   }
 }
 
-export class AnonymousSubject<E, A> extends Subject<E, A> {
-  constructor(protected destination?: Observer<E, A>, source?: Observable<E, A>) {
+export class AnonymousSubject<R, E, A> extends Subject<R, E, A> {
+  constructor(protected destination?: Observer<E, A>, source?: Observable<R, E, A>) {
     super();
     this.source = source;
   }
@@ -122,7 +122,7 @@ export class AnonymousSubject<E, A> extends Subject<E, A> {
   }
 }
 
-export class AsyncSubject<E, A> extends Subject<E, A> {
+export class AsyncSubject<R, E, A> extends Subject<R, E, A> {
   private value: Either<Cause<E>, A> | null = null;
   private hasValue   = false;
   private isComplete = false;

package/_src/global.ts

@@ -1,37 +1,12 @@
-import "@fncts/observable";
-
-/**
- * @tsplus global
- */
-import { HashSet } from "@fncts/base/collection/immutable/HashSet";
-/**
- * @tsplus global
- */
-import { Cause } from "@fncts/base/data/Cause";
-/**
- * @tsplus global
- */
-import { Either } from "@fncts/base/data/Either";
-/**
- * @tsplus global
- */
-import { Exit } from "@fncts/base/data/Exit";
-/**
- * @tsplus global
- */
-import { Lazy } from "@fncts/base/data/function";
 /**
  * @tsplus global
  */
-import { Just, Maybe, Nothing } from "@fncts/base/data/Maybe";
+import type {} from "@fncts/io/global";
 /**
  * @tsplus global
  */
-import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate";
-/**
- * @tsplus global
- */
-import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement";
+import type {} from "@fncts/observable";
+
 /**
  * @tsplus global
  */
@@ -43,27 +18,11 @@ import { isDate, isFunction, isIterable, isObject, isPlain } from "@fncts/base/u
 /**
  * @tsplus global
  */
-import { Clock } from "@fncts/io/Clock";
-/**
- * @tsplus global
- */
-import { Console } from "@fncts/io/Console";
-/**
- * @tsplus global
- */
-import { Fiber, FiberContext } from "@fncts/io/Fiber";
-/**
- * @tsplus global
- */
-import { IO, isIO, UIO } from "@fncts/io/IO";
-/**
- * @tsplus global
- */
-import { IOEnv } from "@fncts/io/IOEnv";
+import { FiberContext } from "@fncts/io/Fiber";
 /**
  * @tsplus global
  */
-import { Random } from "@fncts/io/Random";
+import { isIO } from "@fncts/io/IO";
 /**
  * @tsplus global
  */

package/global.d.ts

@@ -1,35 +1,11 @@
 /**
  * @tsplus global
  */
-import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+import type {} from "@fncts/io/global";
 /**
  * @tsplus global
  */
-import { Cause } from "@fncts/base/data/Cause";
-/**
- * @tsplus global
- */
-import { Either } from "@fncts/base/data/Either";
-/**
- * @tsplus global
- */
-import { Exit } from "@fncts/base/data/Exit";
-/**
- * @tsplus global
- */
-import { Lazy } from "@fncts/base/data/function";
-/**
- * @tsplus global
- */
-import { Just, Maybe, Nothing } from "@fncts/base/data/Maybe";
-/**
- * @tsplus global
- */
-import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate";
-/**
- * @tsplus global
- */
-import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement";
+import type {} from "@fncts/observable";
 /**
  * @tsplus global
  */
@@ -41,27 +17,11 @@ import { isDate, isFunction, isIterable, isObject, isPlain } from "@fncts/base/u
 /**
  * @tsplus global
  */
-import { Clock } from "@fncts/io/Clock";
-/**
- * @tsplus global
- */
-import { Console } from "@fncts/io/Console";
-/**
- * @tsplus global
- */
-import { Fiber, FiberContext } from "@fncts/io/Fiber";
-/**
- * @tsplus global
- */
-import { IO, isIO, UIO } from "@fncts/io/IO";
-/**
- * @tsplus global
- */
-import { IOEnv } from "@fncts/io/IOEnv";
+import { FiberContext } from "@fncts/io/Fiber";
 /**
  * @tsplus global
  */
-import { Random } from "@fncts/io/Random";
+import { isIO } from "@fncts/io/IO";
 /**
  * @tsplus global
  */
@@ -134,4 +94,4 @@ import { isSubscriber, SafeSubscriber, Subscriber } from "@fncts/observable/Subs
  * @tsplus global
  */
 import { Finalizer, isSubscription, Subscription, SubscriptionLike, Unsubscribable, } from "@fncts/observable/Subscription";
-import "@fncts/observable";
+export {};

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/observable",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "dependencies": {
-    "@fncts/base": "0.0.13"
+    "@fncts/base": "0.0.14"
   },
   "exports": {
     "./*": {