Emits the given value to the observers.

Emits the given error to the observers.

Completes the bus. All observers will be completed, and any further calls to next or error will be ignored.

Connects the bus to the given signal. Any values emitted by the signal will be forwarded to the bus.

Concatenates the given signals and emits their values. The returned signal will join the signals, waiting for each one to complete before joining the next, and will complete once all of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = Signal.concat(s, t)

u.subscribe(console.log) // 1, 2, 3, 4, 5, 6

Creates a signal that never emits any values and has already completed.

This method is not very useful on its own, but it can be used with other combinators (e.g. fold, scan, etc).

Creates a signal that immediately emits the values from an iterable. The returned signal will complete after the last value in the iterable has been emitted.

import { Signal } from 'bulb'

const s = Signal.from([1, 2, 3])

s.subscribe(console.log) // 1, 2, 3

Creates a signal that wraps a callback.

The executor function f is passed with a callback function when the signal is mounted. The callback is a standard error-first callback, which means that if the callback is called with a non-null first argument, then the returned signal will emit an error. If the callback is called with a null first argument, then the returned signal will emit a value.

import { Signal } from 'bulb'

const s = Signal.fromCallback(callback => {
  callback(null, 'foo')
})

s.subscribe(console.log) // 'foo'

Creates a signal that emits events of type from the EventTarget-compatible target object.

import { Signal } from 'bulb'

Signal.fromEvent('click', document)

Creates a signal that wraps a promise p. The returned signal will complete immediately after the promise is resolved.

import { Signal } from 'bulb'

const p = new Promise((resolve, reject) => {
  resolve('foo')
})
const s = Signal.fromPromise(p)

s.subscribe(console.log) // 'foo'

Merges the given signals and emits their values. The returned signal will complete once all of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = Signal.merge(s, t)

u.subscribe(console.log) // 1, 4, 2, 5, 3, 6

Creates a signal that never emits any values or completes.

This method is not very useful on its own, but it can be used with other combinators (e.g. fold, scan, etc).

Creates a signal that immediately emits the values. The returned signal will complete immediately after the values have been emited.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)

s.subscribe(console.log) // 1, 2, 3

Creates a signal that emits a value every n milliseconds. The value emitted starts at zero and increments indefinitely.

import { Signal } from 'bulb'

const s = Signal.periodic(1000)

s.subscribe(console.log) // 0, 1, 2, ...

Creates a signal that emits an error. The returned signal will complete immediately after the error has been emited.

import { Signal } from 'bulb'

const s = Signal.error('foo')

s.subscribe({ error: console.error }) // 'foo'

Combines the corresponding values emitted by the given signals into tuples. The returned signal will complete when any of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = Signal.zip(s, t)

u.subscribe(console.log) // [1, 4], [2, 5], [3, 6]

Applies the function f to the corresponding values emitted by the given signals. The returned signal will complete when any of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = Signal.zipWith((a, b) => a + b, s, t)

u.subscribe(console.log) // 5, 7, 9

Combines the latest values emitted by the given signals into tuples. The returned signal will complete when any of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = Signal.zipLatest(s, t)

u.subscribe(console.log) // [1, 4], [2, 5], [3, 6]

Applies the function f to the latest values emitted by the given signals. The returned signal will complete when any of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = Signal.zipLatestWith((a, b) => a + b, s, t)

u.subscribe(console.log) // 5, 7, 9

Emits true if all the values emitted by the signal satisfy a predicate function p. The returned signal will complete if the signal emits any value that doesn't satisfy the predictate function.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .all(a => a > 0)

s.subscribe(console.log) // true

Replaces the values of the signal with a constant value

import { Signal } from 'bulb'

const s = Signal
  .periodic(1000)
  .always(1)

s.subscribe(console.log) // 1, 1, 1, ...

Emits true if any of the values emitted by the signal satisfy a predicate function p. The returned signal will complete if the signal emits any value that satisfies the predictate function.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .any(a => a < 0)

s.subscribe(console.log) // false

Emits the given values after the signal has completed.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .append(4, 5, 6)

s.subscribe(console.log) // 1, 2, 3, 4, 5, 6

Applies the latest function emitted by the signal to latest values emitted by the given signals. The returned signal will complete when any of the signals have completed.

The latest function will be called with a number of arguments equal to the number of signals. For example, if the latest function is (a, b) => a + b, then you will need to supply two signals.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = Signal
  .of((a, b) => a + b)
  .apply(s, t)

u.subscribe(console.log) // 5, 7, 9

Buffers values emitted by the signal and emits the buffer contents when it is full. The buffer contents will be emitted when the signal completes, regardless of whether the buffer is full.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3, 4)
  .buffer(2)

s.subscribe(console.log) // [1, 2], [3, 4], ...

Buffers values emitted by the signal and emits the buffer contents whenever there is an event on the given control signal. The buffer contents will be emitted when the signal completes, regardless of whether the buffer is full.

import { Signal } from 'bulb'

const t = Signal.periodic(1000)
const s = Signal
  .of(1, 2, 3, 4)
  .bufferWith(t)

s.subscribe(console.log) // [1, 2], [3, 4], ...

Applies a function f, that returns a Signal, to the first error emitted by the signal. The returned signal will emit values from the signal returned by the function.

import { Signal } from 'bulb'

const s = Signal
  .throwError()
  .catchError(e => Signal.of(1))

s.subscribe(console.log) // 1

Concatenates the given signals and emits their values. The returned signal will join the signals, waiting for each one to complete before joining the next, and will complete once all of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = s.concat(t)

u.subscribe(console.log) // 1, 2, 3, 4, 5, 6

Applies a function f, that returns a Signal, to each value emitted by the signal. The returned signal will join all signals returned by the function, waiting for each one to complete before merging the next.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .concatMap(a => Signal.of(a + 1))

s.subscribe(console.log) // 2, 3, 4

Cycles through the given values as values are emitted by the signal.

import { Signal } from 'bulb'

const s = Signal
  .periodic(1000)
  .cycle(1, 2, 3)

s.subscribe(console.log) // 1, 2, 3, 1, 2, 3, ...

Waits until n milliseconds after the last burst of values before emitting the most recent value from the signal.

import { Mouse } from 'bulb-input'

const s = Mouse
  .position(document)
  .debounce(1000)

s.subscribe(console.log) // [1, 1], [2, 2], ...

Removes duplicate values emitted by the signal.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 2, 3, 3, 3)
  .dedupe()

s.subscribe(console.log) // 1, 2, 3

Removes duplicate values emitted by the signal using a comparator function f.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 2, 3, 3, 3)
  .dedupeWith((a, b) => a === b)

s.subscribe(console.log) // 1, 2, 3

Delays each value emitted by the signal for n milliseconds.

import { Mouse } from 'bulb-input'

const s = Mouse
  .position(document)
  .delay(1000)

s.subscribe(console.log) // [1, 1], [2, 2], ...

Drops the first n values emitted by the signal.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .drop(2)

s.subscribe(console.log) // 3

Drops values emitted by the signal until the given control signal emits a value.

const s = Signal.periodic(1000)
const t = Signal.of().delay(1000)
const u = s.dropUntil(t)

u.subscribe(console.log) // 1, 2

Drops values emitted by the signal while the predicate function p is satisfied. The returned signal will emit values once the predicate function is not satisfied.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .dropWhile(a => a < 2)

s.subscribe(console.log) // 2, 3

Switches between the given signals based on the most recent value emitted by the signal. The values emitted by the signal represent the index of the signal to switch to.

import { Signal } from 'bulb'

const s = Signal.of(1)
const t = Signal.of(2)
const u = Signal
  .periodic(1000)
  .sequential(0, 1)
  .encode(s, t)

u.subscribe(console.log) // 1, 2

Emits a value when the signal has completed.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .endWith(4)

s.subscribe(console.log) // 1, 2, 3, 4

Filters the signal by only emitting values that satisfy a predicate function p.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .filter(a => a > 1)

s.subscribe(console.log) // 2, 3

Emits the first value from the signal, and then completes.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .first()

s.subscribe(console.log) // 1

Applies an accumulator function f to each value emitted by the signal. The accumulated value will be emitted when the signal has completed.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .fold((a, b) => a + b, 0)

s.subscribe(console.log) // 6

Stops emitting values from the signal while the given control signal is truthy.

import { Mouse } from 'bulb-input'

const s = Mouse.position(document)
const t = Mouse.button(document)
const u = s.hold(t)

u.subscribe(console.log) // [1, 1], [2, 2], ...

Emits the last value from the signal, and then completes.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .last()

s.subscribe(console.log) // 3

Applies a function f to each value emitted by the signal.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .map(a => a + 1)

s.subscribe(console.log) // 2, 3, 4

Merges the given signals and emits their values. The returned signal will complete once all of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = s.merge(t)

u.subscribe(console.log) // 1, 4, 2, 5, 3, 6

Emits the given values before any other values are emitted by the signal.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .prepend(4, 5, 6)

s.subscribe(console.log) // 4, 5, 6, 1, 2, 3

Emits the most recent value from the signal whenever there is an event on the given control signal.

import { Mouse } from 'bulb-input'
import { Signal } from 'bulb'

const s = Mouse.position(document)
const t = Signal.periodic(1000)
const u = s.sample(t)

u.subscribe(console.log) // [1, 1], [2, 2], ...

Applies an accumulator function f to each value emitted by the signal. The accumulated value will be emitted for each value emitted by the signal.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .scan((a, b) => a + b, 0)

s.subscribe(console.log) // 1, 3, 6

Emits the next value from the given values for every value emitted by the signal. The returned signal will complete immediately after the last value has been emitted.

import { Signal } from 'bulb'

const s = Signal
  .periodic(1000)
  .sequential(1, 2, 3)

s.subscribe(console.log) // 1, 2, 3

Emits a value before any other values are emitted by the signal.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .startWith(0)

s.subscribe(console.log) // 0, 1, 2, 3

Applies a transform function f to each value emitted by the signal.

The transform function must return a new state, it can also optionally emit values or errors using the emit object.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .stateMachine((a, b, emit) => {
    emit.next(a + b)
    return a * b
  }, 1)

s.subscribe(console.log) // 1, 3, 5

Subscribes an observer to the signal.

The subscribe method returns a subscription handle, which can be used to unsubscribe from the signal.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)

// Subscribe to the signal and log emitted values to the console.
const subscription = s.subscribe(console.log)

// When we are done, we can unsubscribe from the signal.
subscription.unsubscribe()

Subscribes to the most recent signal emitted by the signal (a signal that emits other signals). The returned signal will emit values from the most recent signal.

import { Signal } from 'bulb'

const s = Signal.of(1)
const t = Signal.of(2)
const u = Signal
  .periodic(1000)
  .sequential(s, t)
  .switchLatest()

u.subscribe(console.log) // 1, 2

Applies a function f, that returns a Signal, to each value emitted by the signal. The returned signal will emit values from the most recent signal returned by the function.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .switchMap(a => Signal.of(a + 1))

s.subscribe(console.log) // 2, 3, 4

Takes the first n values emitted by the signal, and then completes.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .take(2)

s.subscribe(console.log) // 1, 2

Emits values from the signal until the given control signal emits a value. The returned signal will complete once the control signal emits a value.

const s = Signal.periodic(1000)
const t = Signal.of().delay(1000)
const u = s.takeUntil(t)

u.subscribe(console.log) // 0

Emits values from the signal while the predicate function p is satisfied. The returned signal will complete once the predicate function is not satisfied.

const s = Signal
  .of(1, 2, 3)
  .takeWhile(a => a < 2)

s.subscribe(console.log) // 1

Performs the side effect function f for each value emitted by the signal. The returned signal contains the same events as the original signal.

import { Signal } from 'bulb'

const s = Signal
  .of(1, 2, 3)
  .tap(console.log)

s.subscribe() // 1, 2, 3

Limits the rate at which values are emitted by the signal to one every n milliseconds. Values will be dropped when the rate limit is exceeded.

import { Mouse } from 'bulb-input'

const s = Mouse
  .position(document)
  .throttle(1000)

s.subscribe(console.log) // [1, 1], [2, 2], ...

Returns a higher-order signal that emits the windowed values of this signal.

import { Signal } from 'bulb'

const t = Signal.periodic(1000)
const s = Signal
  .of(1, 2, 3, 4)
  .window(t)
  .switchLatest()

s.subscribe(console.log) // 1, 2, X, 3, 4, X, ...

Combines the corresponding values emitted by the given signals into tuples. The returned signal will complete when any of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = s.zip(t)

u.subscribe(console.log) // [1, 4], [2, 5], [3, 6]

Applies the function f to the corresponding values emitted by the given signals. The returned signal will complete when any of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = s.zipWith((a, b) => a + b, t)

u.subscribe(console.log) // 5, 7, 9

Combines the latest values emitted by the given signals into tuples. The returned signal will complete when any of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = s.zipLatest(t)

u.subscribe(console.log) // [1, 4], [2, 5], [3, 6]

Applies the function f to the latest values emitted by the given signals. The returned signal will complete when any of the signals have completed.

import { Signal } from 'bulb'

const s = Signal.of(1, 2, 3)
const t = Signal.of(4, 5, 6)
const u = s.zipLatestWith((a, b) => a + b, t)

u.subscribe(console.log) // 5, 7, 9

Unsubscribes the observer from the signal.