@fncts/observable 0.0.8 → 0.0.10

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/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/internal/util.ts

@@ -33,7 +33,10 @@ export function reportUnhandledError(err: unknown) {
 
 export function arrayOrObject<T, O extends Record<string, T>>(
   args: ReadonlyArray<T> | [O] | [ReadonlyArray<T>],
-): { args: ReadonlyArray<T>; keys: ReadonlyArray<string> | null } {
+): {
+  args: ReadonlyArray<T>;
+  keys: ReadonlyArray<string> | null;
+} {
   if (args.length === 1) {
     const first = args[0];
     if (Array.isArray(first)) {
@@ -47,7 +50,6 @@ export function arrayOrObject<T, O extends Record<string, T>>(
       };
     }
   }
-
   return { args: args as ReadonlyArray<T>, keys: null };
 }
 
@@ -56,14 +58,16 @@ export function arrayOrObject<T, O extends Record<string, T>>(
  * ReadableStream
  * -------------------------------------------------------------------------------------------------
  */
-
 interface ReadableStreamDefaultReaderLike<T> {
   read(): PromiseLike<
     | {
         done: false;
         value: T;
       }
-    | { done: true; value?: undefined }
+    | {
+        done: true;
+        value?: undefined;
+      }
   >;
   releaseLock(): void;
 }

package/package.json

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