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

Class Observer<Data>

A class representing an Observer.

+

Type Parameters

  • Data = any

    The type of data to observe.

    +

Implements

Constructors

constructor +

Properties

connect +debounce +delay +emit +filter +flatMap +map +mapAsync +merge +once +operator +reduce +repeat +share +split +tap +toIteratorContext +toPromise +unsubscribe +

Accessors

hasListeners +isShared +

Methods

[LISTEN_CONNECT] +[LISTEN_DISCONNECT] +

Constructors

constructor

Properties

connect

connect: (callbackfn: (value: Data) => void) => any

Subscribes to the OBSERVER_EVENT and invokes the provided callback function. +Emits the CONNECT_EVENT. +Returns a composed function that will try to dispose and unsubscribe the callback.

+

Type declaration

    • (callbackfn: (value: Data) => void): any

    • Parameters

      • callbackfn: (value: Data) => void

        The callback function to be invoked when OBSERVER_EVENT is emitted.

        +

      Returns any

        +
      • The composed function that will try to dispose and unsubscribe the callback.
        • +
      +

debounce

debounce: (delay?: number) => Observer<Data>

Creates a debounced observer that emits values at a specified delay.

+

Type declaration

    • (delay?: number): Observer<Data>

    • Parameters

      • Optionaldelay: number

        The delay (in milliseconds) between value emissions.

        +

      Returns Observer<Data>

      The debounced observer.

      +

delay

delay: (delay?: number) => Observer<Data>

Creates a delayed observer that emits values at a specified delay.

+

Type declaration

    • (delay?: number): Observer<Data>

    • Parameters

      • Optionaldelay: number

        The delay (in milliseconds) between value emissions.

        +

      Returns Observer<Data>

      The debounced observer.

      +

emit

emit: (data: Data) => Promise<void>

Emits the specified data to all observers.

+

Type declaration

    • (data: Data): Promise<void>

    • Parameters

      • data: Data

        The data to be emitted.

        +

      Returns Promise<void>

filter

filter: (callbackfn: (value: Data) => boolean) => Observer<Data>

Creates a filtered observer.

+

Type declaration

    • (callbackfn: (value: Data) => boolean): Observer<Data>

    • Parameters

      • callbackfn: (value: Data) => boolean

        The filter callback function.

        +

      Returns Observer<Data>

      The filtered observer.

      +

flatMap

flatMap: <T = any>(callbackfn: (value: Data) => T[]) => Observer<T>

Applies a callback function to each value emitted by the Observable and flattens the resulting values into a new Observable.

+

Type declaration

    • <T = any>(callbackfn: (value: Data) => T[]): Observer<T>

    • Type Parameters

      • T = any

        The type of values emitted by the Observable.

        +

      Parameters

      • callbackfn: (value: Data) => T[]

        A callback function that accepts a value emitted by the Observable and returns an array of values or a single value.

        +

      Returns Observer<T>

        +
      • A new Observer that emits the flattened values.
        • +
      +

map

map: <T = any>(callbackfn: (value: Data) => T) => Observer<T>

Creates a new Observer.

+

Type declaration

    • <T = any>(callbackfn: (value: Data) => T): Observer<T>

    • Type Parameters

      • T = any

        The type of the value emitted by the observer.

        +

      Parameters

      • callbackfn: (value: Data) => T

        A function to apply to each value emitted by the observer.

        +

      Returns Observer<T>

        +
      • The created Observer.
        • +
      +

mapAsync

mapAsync: <T = any>(
    callbackfn: (value: Data) => Promise<T>,
    fallbackfn?: (e: Error) => void,
) => Observer<T>

Creates an Observer with asynchronous mapping functionality.

+

Type declaration

    • <T = any>(
          callbackfn: (value: Data) => Promise<T>,
          fallbackfn?: (e: Error) => void,
      ): Observer<T>

    • Type Parameters

      • T = any

        The type of the result of the mapping function.

        +

      Parameters

      • callbackfn: (value: Data) => Promise<T>

        The function used to map the incoming data.

        +
      • Optionalfallbackfn: (e: Error) => void

        An optional fallback function to handle error cases. If not provided, the error will be rethrown.

        +

      Returns Observer<T>

        +
      • The created Observer.
        • +
      +

merge

merge: <T = any>(observer: TObserver<T>) => Observer<Data | T>

Merges an observer with the given observer, returning a new observer that emits values from both observers.

+

Type declaration

once

once: (callbackfn: (value: Data) => void) => Fn

Executes a callback function once and provides a way to unsubscribe from further executions.

+

Type declaration

    • (callbackfn: (value: Data) => void): Fn

    • Parameters

      • callbackfn: (value: Data) => void

        The callback function to be executed once.

        +

      Returns Fn

        +
      • A function that can be called to unsubscribe from further executions of the callback.
        • +
      +

operator

operator: <T = any>(
    callbackfn: (target: TObserver<Data>) => TObserver<T>,
) => TObserver<T>

Operator function to create a new observer with a transformed data type.

+

Type declaration

    • <T = any>(callbackfn: (target: TObserver<Data>) => TObserver<T>): TObserver<T>

    • Type Parameters

      • T = any

        The type of the transformed data.

        +

      Parameters

      • callbackfn: (target: TObserver<Data>) => TObserver<T>

        A callback function that takes the target observer and returns a new observer with transformed data.

        +

      Returns TObserver<T>

        +
      • A new observer with the transformed data type.
        • +
      +

reduce

reduce: <T = any>(callbackfn: (acm: T, cur: Data) => T, begin: T) => Observer<T>

Reduces the data emitted by an Observer using a callback function and an initial value.

+

Type declaration

    • <T = any>(callbackfn: (acm: T, cur: Data) => T, begin: T): Observer<T>

    • Type Parameters

      • T = any

        The type of the accumulator and the return value.

        +

      Parameters

      • callbackfn: (acm: T, cur: Data) => T

        The callback function to execute on each emitted value. +It takes an accumulator value and the current value being emitted, and returns the new accumulator value.

        +
      • begin: T

        The initial value of the accumulator.

        +

      Returns Observer<T>

        +
      • An Observer that emits the accumulated value after each emission.
        • +
      +

repeat

repeat: (interval?: number) => Observer<Data>

Creates an observable sequence that emits values at specified intervals.

+

Type declaration

    • (interval?: number): Observer<Data>

    • Parameters

      • Optionalinterval: number

        The time interval between emissions in milliseconds.

        +

      Returns Observer<Data>

      The observer object to subscribe to.

      +

share

share: () => this

Marks a variable as shared.

+

Type declaration

    • (): this

    • Returns this

      The shared variable object.

      +

split

split: () => Observer<
    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
    )[],
>

Creates and returns an observer function that splits an array of data +into a nested array of a specified length.

+

Type declaration

    • (): Observer<
          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
          )[],
      >

    • Returns Observer<
          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
          )[],
      >

      The split observer function.

      +

tap

tap: (callbackfn: (value: Data) => void) => Observer<Data>

Attaches a callback function to the tap observer. The callback function will be called with a value of type Data when the tap observer is triggered.

+

Type declaration

    • (callbackfn: (value: Data) => void): Observer<Data>

    • Parameters

      • callbackfn: (value: Data) => void

        A callback function that takes a value of type Data as an argument.

        +

      Returns Observer<Data>

        +
      • An observer object that can be used to manage the tap subscription.
        • +
      +

toIteratorContext

toIteratorContext: () => {
    done(): void;
    iterate: () => AsyncGenerator<Awaited<Data>, void, unknown>;
}

Creates a context for iterating asynchronously using a generator function.

+

Type declaration

    • (): {
          done(): void;
          iterate: () => AsyncGenerator<Awaited<Data>, void, unknown>;
      }

    • Returns { done(): void; iterate: () => AsyncGenerator<Awaited<Data>, void, unknown> }

      The iterator context object.

      +

toPromise

toPromise: () => Promise<Data>

Converts the current instance to a Promise that resolves with the data.

+

Type declaration

    • (): Promise<Data>

    • Returns Promise<Data>

      A Promise that resolves with the data.

      +

unsubscribe

unsubscribe: () => void

Unsubscribes from all events and performs cleanup.

+

Type declaration

    • (): void

    • Returns void

Function

Name

unsubscribe

+

Member Of

undefined

+

Accessors

hasListeners

  • get hasListeners(): boolean

    Returns whether the given event has any listeners.

    +

    Returns boolean

    True if there are listeners for the event, otherwise false.

    +

isShared

  • get isShared(): boolean

    Returns the current value of the 'isShared' property.

    +

    Returns boolean

      +
    • The value of the 'isShared' property.
      • +
    +

Methods

[LISTEN_CONNECT]

  • "[LISTEN_CONNECT]"(fn: () => void): void

    Sets up a listener for the connect event on the broadcast channel.

    +

    Parameters

    • fn: () => void

      The callback function to be executed once the connect event is triggered.

      +

    Returns void

[LISTEN_DISCONNECT]

  • "[LISTEN_DISCONNECT]"(fn: () => void): void

    Adds a listener for the DISCONNECT_EVENT.

    +

    Parameters

    • fn: () => void

      The function to be executed when the event occurs.

      +

    Returns void

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods