diff --git "a/classes/types.react-declarative.Source.html" "b/classes/types.react-declarative.Source.html" new file mode 100644--- /dev/null +++ "b/classes/types.react-declarative.Source.html" @@ -0,0 +1,93 @@ +Source | react-declarative

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

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

    • Type Parameters

      • Data = any

        The type of data emitted by the observer.

        +

      Parameters

      • subject: TSubject<Data>

        The subject to create the observer from.

        +

      Returns Observer<Data>

        +
      • The observer created from the subject.
        • +
      +

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

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

    • Type Parameters

      • Data = any

        The type of data the observer handles.

        +

      Parameters

      Returns TObserver<Data> & { isUnicasted: true }

        +
      • A unicast observer instance.
        • +
      +

Settings

Member Visibility

On This Page

Constructors
Properties