mutoid/http/ObservableResource.d.ts

Reactive library for data fetching, caching, state management

import type { Applicative2 } from 'fp-ts/Applicative';
import type { Apply2 } from 'fp-ts/Apply';
import type { Bifunctor2 } from 'fp-ts/Bifunctor';
import type { Chain2 } from 'fp-ts/Chain';
import * as E from 'fp-ts/Either';
import type { Functor2 } from 'fp-ts/Functor';
import type { IO } from 'fp-ts/IO';
import type { Monad2 } from 'fp-ts/Monad';
import type { MonadIO2 } from 'fp-ts/MonadIO';
import type { MonadTask2 } from 'fp-ts/MonadTask';
import type * as T from 'fp-ts/Task';
import type * as TE from 'fp-ts/TaskEither';
import type { Predicate, Refinement } from 'fp-ts/function';
import type { MonadObservable2 } from 'fp-ts-reactive/MonadObservable';
import type { ObservableEither } from 'fp-ts-reactive/lib/ObservableEither';
import type { Observable } from 'rxjs';
import type { AjaxResponse } from 'rxjs/ajax';
import * as RES from './Resource';
export type ObservableResource<E, A> = Observable<RES.Resource<E, A>>;
export type ObservableResourceTypeOf<DS extends RES.ResourceDecoders, AE = never> = Observable<RES.ResourceTypeOf<DS, AE>>;
export declare const init: ObservableResource<never, never>;
export declare const submitted: ObservableResource<never, never>;
export declare const done: <E = never, A = never>(d: A) => ObservableResource<E, A>;
export declare const doneObservable: <E = never, A = never>(oa: Observable<A>) => ObservableResource<E, A>;
export declare const fail: <E = never, A = never>(e: E) => ObservableResource<E, A>;
export declare const failObservable: <E = never, A = never>(oe: Observable<E>) => ObservableResource<E, A>;
export declare const failAppError: <AE = never, A = never>(ae: AE) => ObservableResource<RES.ResourceAjaxError<AE>, A>;
export declare const ajaxFail: <AE = never, A = never>(e: RES.ResourceAjaxError<AE>) => ObservableResource<RES.ResourceAjaxError<AE>, A>;
export declare const ajaxFailObservable: <AE = never, A = never>(e: Observable<RES.ResourceAjaxError<AE>>) => ObservableResource<RES.ResourceAjaxError<AE>, A>;
export type ObservableAjax<AE = never, R = any> = Observable<AjaxResponse<R> | RES.ResourceAjaxFail<AE>>;
export declare const fromAjax: <DS extends RES.ResourceDecoders, AE = never>(ajax$: ObservableAjax<AE, any>, decoders: DS) => ObservableResourceTypeOf<DS, AE>;
export declare const doneIO: <E = never, A = never>(ma: IO<A>) => ObservableResource<E, A>;
export declare const fromIO: MonadIO2<URI>['fromIO'];
export declare const fromObservable: MonadObservable2<URI>['fromObservable'];
export declare const fromEither: <E, A>(e: E.Either<E, A>) => ObservableResource<E, A>;
export declare const fromObservableEither: <E, A>(oe: ObservableEither<E, A>) => ObservableResource<E, A>;
export declare const fromTaskResource: <E, A>(t: T.Task<RES.Resource<E, A>>) => ObservableResource<E, A>;
export declare const doneTask: <E = never, A = never>(ma: T.Task<A>) => ObservableResource<E, A>;
export declare const fromTask: MonadTask2<URI>['fromTask'];
export declare const fromTaskEither: <E, A>(fa: TE.TaskEither<E, A>) => ObservableResource<E, A>;
export declare const of: Applicative2<URI>['of'];
export declare const match: <E, A, R>(onInit: () => Observable<R>, onSubmitted: () => Observable<R>, onDone: (r: A) => Observable<R>, onFail: (r: E) => Observable<R>) => (ma: ObservableResource<E, A>) => Observable<R>;
export declare const fetchToMutationEffect: <AX extends (...i: I) => Observable<R>, SS extends S, S, I extends any[] = Parameters<AX>, R = AX extends (...args: any) => Observable<infer RR> ? RR : never>(mapTo: (s: SS) => (i: R) => S) => (ax: AX) => (...a: I) => (s: SS) => Observable<S>;
export declare const URI = "ObservableResource";
export type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind2<E, A> {
        readonly [URI]: ObservableResource<E, A>;
    }
}
export declare const Functor: Functor2<URI>;
export declare const Apply: Apply2<URI>;
export declare const Bifunctor: Bifunctor2<URI>;
export declare const Applicative: Applicative2<URI>;
export declare const Chain: Chain2<URI>;
export declare const Monad: Monad2<URI>;
export declare const MonadObservable: MonadObservable2<URI>;
export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: ObservableResource<E, A>) => ObservableResource<E, B>;
export declare const bimap: <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fa: ObservableResource<E, A>) => ObservableResource<G, B>;
export declare const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: ObservableResource<E, A>) => ObservableResource<G, A>;
export declare const ap: <E, A>(fa: ObservableResource<E, A>) => <B>(fab: ObservableResource<E, (a: A) => B>) => ObservableResource<E, B>;
export declare const chainW: <A, E2, B>(f: (a: A) => ObservableResource<E2, B>) => <E1>(ma: ObservableResource<E1, A>) => ObservableResource<E2 | E1, B>;
export declare const chain: <A, E, B>(f: (a: A) => ObservableResource<E, B>) => (ma: ObservableResource<E, A>) => ObservableResource<E, B>;
export declare const flatten: <E, A>(mma: ObservableResource<E, ObservableResource<E, A>>) => ObservableResource<E, A>;
export declare function swap<E, A>(ma: ObservableResource<E, A>): ObservableResource<A, E>;
export declare const chainFirst: <E, A, B>(f: (a: A) => ObservableResource<E, B>) => (ma: ObservableResource<E, A>) => ObservableResource<E, A>;
export declare const chainFirstW: <E2, A, B>(f: (a: A) => ObservableResource<E2, B>) => <E1>(ma: ObservableResource<E1, A>) => ObservableResource<E1 | E2, A>;
export declare function orElseW<E, M, A, B>(onFail: (e: E) => ObservableResource<M, B>): (ma: ObservableResource<E, A>) => ObservableResource<M, A | B>;
export declare const orElse: <E, A, M>(onFail: (e: E) => ObservableResource<M, A>) => (ma: ObservableResource<E, A>) => ObservableResource<M, A>;
export declare const filterOrElseW: {
    <A, B extends A, E2>(refinement: Refinement<A, B>, onFalse: (a: A) => E2): <E1>(ma: ObservableResource<E1, A>) => ObservableResource<E1 | E2, B>;
    <A, E2>(predicate: Predicate<A>, onFalse: (a: A) => E2): <E1>(ma: ObservableResource<E1, A>) => ObservableResource<E1 | E2, A>;
};
export declare const filterOrElse: {
    <E, A, B extends A>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (ma: ObservableResource<E, A>) => ObservableResource<E, B>;
    <E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): (ma: ObservableResource<E, A>) => ObservableResource<E, A>;
};