Class Source

The Source class provides utility functions for creating and manipulating Observers.

Constructors

constructor

Properties

create createCold createHot fromArray fromBehaviorSubject fromDelay fromEvent fromInterval fromPromise fromSubject fromValue join merge multicast pipe unicast

Constructors

constructor

Properties

Staticcreate

create: <Data = any>(
    emitter: (next: (data: Data) => void) => void | () => void,
) => Observer<Data>

Creates a new instance of the Cold object.

StaticcreateCold

createCold: <Data = any>(
    emitter: (next: (data: Data) => void) => void | () => void,
) => Observer<Data>

Creates a cold observable.

Type declaration

    • <Data = any>(
          emitter: (next: (data: Data) => void) => void | () => void,
      ): Observer<Data>

    • Type Parameters

      • Data = any

      Parameters

      • emitter: (next: (data: Data) => void) => void | () => void

        The emitter function which is called when a subscriber is added. It should return a function that is called when the subscription is unsubscribed, or return undefined if no cleanup is needed.

      Returns Observer<Data>

      • The created observer.

StaticcreateHot

createHot: <Data = any>(
    emitter: (next: (data: Data) => void) => void | () => void,
) => Observer<Data>

Creates a hot observable that emits data as it is received from the given emitter.

Type declaration

    • <Data = any>(
          emitter: (next: (data: Data) => void) => void | () => void,
      ): Observer<Data>

    • Type Parameters

      • Data = any

        The type of data emitted by the observable.

      Parameters

      • emitter: (next: (data: Data) => void) => void | () => void

        The function that receives a callback to emit data. It should return a cleanup function or undefined.

      Returns Observer<Data>

      The observer that allows subscribing to and unsubscribing from the emitted data.

StaticfromArray

fromArray: <Data = any>(
    data: Data,
) => TObserver<
    readonly (
        Data extends readonly InnerArr[]
            ? InnerArr extends readonly InnerArr[]
                ? InnerArr extends readonly InnerArr[]
                    ? InnerArr extends readonly InnerArr[]
                        ? InnerArr extends readonly InnerArr[]
                            ? InnerArr extends readonly InnerArr[]
                                ? InnerArr extends readonly (...)[]
                                    ? (...) extends (...) ? (...) : (...)
                                    : InnerArr
                                : InnerArr
                            : InnerArr
                        : InnerArr
                    : InnerArr
                : InnerArr
            : Data
    )[],
>

StaticfromBehaviorSubject

fromBehaviorSubject: <Data = any>(
    subject: TBehaviorSubject<Data>,
) => Observer<Data>

Creates an observer from a BehaviorSubject.

Type declaration

StaticfromDelay

fromDelay: (delay: number) => TObserver<void>

StaticfromEvent

fromEvent: (
    event: keyof DocumentEventMap,
) => TObserver<
    | Event
    | FocusEvent
    | UIEvent
    | MouseEvent
    | ProgressEvent<EventTarget>
    | AnimationEvent
    | InputEvent
    | CompositionEvent
    | ClipboardEvent
    | DragEvent
    | ErrorEvent
    | FormDataEvent
    | PointerEvent
    | KeyboardEvent
    | SecurityPolicyViolationEvent
    | SubmitEvent
    | TouchEvent
    | TransitionEvent
    | WheelEvent,
>

StaticfromInterval

fromInterval: (delay: number) => TObserver<number>

StaticfromPromise

fromPromise: <Data = any>(
    callbackfn: () => Promise<Data>,
    fallbackfn?: (e: Error) => void,
) => TObserver<Data>

StaticfromSubject

fromSubject: <Data = any>(subject: TSubject<Data>) => Observer<Data>

Creates an observer from the given subject and returns it.

Type declaration

StaticfromValue

fromValue: <Data = any>(data: Data | () => Data) => TObserver<Data>

Creates a new observer that emits a value from the given data or function.

Type declaration

Staticjoin

join: <
    A = never,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
>(
    observers: [
        TObserver<A>,
        TObserver<B>?,
        TObserver<C>?,
        TObserver<D>?,
        TObserver<E>?,
        TObserver<F>?,
        TObserver<G>?,
    ],
    options?: {
        buffer?: [A, B?, C?, D?, E?, F?, G?, H?, I?, J?];
        race?: boolean;
    },
) => TObserver<[A, B, C, D, E, F, G, H, I, J]>

Creates a join observer that combines the values emitted by multiple Observers into a single Observable.

Type declaration

    • <
          A = never,
          B = never,
          C = never,
          D = never,
          E = never,
          F = never,
          G = never,
          H = never,
          I = never,
          J = never,
      >(
          observers: [
              TObserver<A>,
              TObserver<B>?,
              TObserver<C>?,
              TObserver<D>?,
              TObserver<E>?,
              TObserver<F>?,
              TObserver<G>?,
          ],
          options?: {
              buffer?: [A, B?, C?, D?, E?, F?, G?, H?, I?, J?];
              race?: boolean;
          },
      ): TObserver<[A, B, C, D, E, F, G, H, I, J]>

    • Type Parameters

      • A = never

        The type of the value emitted by the first Observer.

      • B = never

        The type of the value emitted by the second Observer.

      • C = never

        The type of the value emitted by the third Observer.

      • D = never

        The type of the value emitted by the fourth Observer.

      • E = never

        The type of the value emitted by the fifth Observer.

      • F = never

        The type of the value emitted by the sixth Observer.

      • G = never

        The type of the value emitted by the seventh Observer.

      • H = never

        The type of the value emitted by the eighth Observer.

      • I = never

        The type of the value emitted by the ninth Observer.

      • J = never

        The type of the value emitted by the tenth Observer.

      Parameters

      • observers: [
            TObserver<A>,
            TObserver<B>?,
            TObserver<C>?,
            TObserver<D>?,
            TObserver<E>?,
            TObserver<F>?,
            TObserver<G>?,
        ]

        An array of Observers to join.

      • Optionaloptions: { buffer?: [A, B?, C?, D?, E?, F?, G?, H?, I?, J?]; race?: boolean }

        Optional parameters for the join operation, including a buffer and a race flag.

        • Optionalbuffer?: [A, B?, C?, D?, E?, F?, G?, H?, I?, J?]

          An array to store the latest emitted values from each Observer. Defaults to an empty array.

        • Optionalrace?: boolean

          A boolean flag indicating whether to emit the combined values immediately or wait for all Observers to emit a value. Defaults to false.

      Returns TObserver<[A, B, C, D, E, F, G, H, I, J]>

      An Observer that emits an array of values, each value being the latest emitted value from the corresponding Observer.

Staticmerge

merge: <
    A = never,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
>(
    observers: [
        TObserver<A>,
        TObserver<B>?,
        TObserver<C>?,
        TObserver<D>?,
        TObserver<E>?,
        TObserver<F>?,
        TObserver<G>?,
    ],
) => TObserver<A | B | C | D | E | F | G | H | I | J>

Merges multiple observers into a single observer.

Type declaration

    • <
          A = never,
          B = never,
          C = never,
          D = never,
          E = never,
          F = never,
          G = never,
          H = never,
          I = never,
          J = never,
      >(
          observers: [
              TObserver<A>,
              TObserver<B>?,
              TObserver<C>?,
              TObserver<D>?,
              TObserver<E>?,
              TObserver<F>?,
              TObserver<G>?,
          ],
      ): TObserver<A | B | C | D | E | F | G | H | I | J>

    • Type Parameters

      • A = never

        The type of observer A.

      • B = never

        The type of observer B.

      • C = never

        The type of observer C.

      • D = never

        The type of observer D.

      • E = never

        The type of observer E.

      • F = never

        The type of observer F.

      • G = never

        The type of observer G.

      • H = never

        The type of observer H.

      • I = never

        The type of observer I.

      • J = never

        The type of observer J.

      Parameters

      Returns TObserver<A | B | C | D | E | F | G | H | I | J>

      • The merged observer.

Staticmulticast

multicast: <Data = any>(
    factory: () => TObserver<Data>,
) => TObserver<Data> & { getRef: any; isMulticasted: true }

Creates a multicast observer.

Type declaration

    • <Data = any>(
          factory: () => TObserver<Data>,
      ): TObserver<Data> & { getRef: any; isMulticasted: true }

    • Type Parameters

      • Data = any

        The type of data being observed.

      Parameters

      • factory: () => TObserver<Data>

        A factory function that creates the observer.

      Returns TObserver<Data> & { getRef: any; isMulticasted: true }

      • The multicast observer.

Staticpipe

pipe: <Data = any, Output = any>(
    target: TObserver<Data>,
    emitter: (
        subject: TSubject<Data>,
        next: (output: Output) => void,
    ) => void | () => void,
) => Observer<Output>

Creates a pipe that connects an observer to a subject and emits output values based on a given emitter function.

Type declaration

    • <Data = any, Output = any>(
          target: TObserver<Data>,
          emitter: (
              subject: TSubject<Data>,
              next: (output: Output) => void,
          ) => void | () => void,
      ): Observer<Output>

    • Type Parameters

      • Data = any

        The type of data that will be observed.

      • Output = any

        The type of output that will be emitted.

      Parameters

      • target: TObserver<Data>

        The observer that will receive output values.

      • emitter: (subject: TSubject<Data>, next: (output: Output) => void) => void | () => void

        A function that takes a subject and a next function and returns an unsubscribe function.

      Returns Observer<Output>

      The observer that is connected to the subject and emits output values.

Staticunicast

unicast: <Data = any>(
    factory: () => TObserver<Data>,
) => TObserver<Data> & { isUnicasted: true }

Type declaration

Settings

Member Visibility

On This Page

Constructors
Properties