Class Realm

The realm is the actual "engine" that orchestrates any cells and signals that it touches. The realm also stores the state and the dependencies of the nodes that are referred through it.

Constructors

constructor

Methods

cellInstance changeWith combine combineCells connect getValue getValues inContext link pipe pub pubIn register resetSingletonSubs signalInstance singletonSub sub subMultiple transformer

Constructors

constructor

  • new Realm(initialValues?: Record<symbol, unknown>): Realm

  • Creates a new realm.

    Parameters

    • initialValues: Record<symbol, unknown> = {}

      the initial cell values that will populate the realm. Those values will not trigger a recomputation cycle, and will overwrite the initial values specified for each cell.

    Returns Realm

Methods

cellInstance

  • cellInstance<T>(value: T, distinct?: Distinct<T>, node?: symbol): NodeRef<T>

  • Creates or resolves an existing cell instance in the realm. Useful as a joint point when building your own operators.

    Type Parameters

    • T

    Parameters

    • value: T

      the initial value of the cell

    • distinct: Distinct<T> = true

      true by default. Pass false to mark the signal as a non-distinct one, meaning that publishing the same value multiple times will re-trigger a recomputation cycle.

    • node: symbol = ...

      optional, a reference to a cell. If the cell has not been touched in the realm before, the realm will instantiate a reference to it. If it's registered already, the function will return the reference.

    Returns NodeRef<T>

    a reference to the cell.

changeWith

  • changeWith<T, K>(
        cell: NodeRef<T>,
        source: NodeRef<K>,
        map: (cellValue: T, signalValue: K) => T,
    ): void

  • Convenient for mutation of cells that contian non-primitive values (e.g. arrays, or objects). Specifies that the cell value should be changed when source emits, with the result of the map callback parameter. the map parameter gets called with the current value of the cell and the value published through the source.

    Type Parameters

    • T

      the type of the cell value.

    • K

      the type of the value published through the source.

    Parameters

    Returns void

    Example

    const items$ = Cell<string[]([])
    const addItem$ = Signal<string>(false, (r) => {
      r.changeWith(items$, addItem$, (items, item) => [...items, item])
    })
    const r = new Realm()
    r.pub(addItem$, 'foo')
    r.pub(addItem$, 'bar')
    r.getValue(items$) // ['foo', 'bar']

combine

combineCells

connect

  • connect<T extends unknown[] = unknown[]>(
        __namedParameters: {
            map: ProjectionFunc<T>;
            pulls?: NodeRef<unknown>[];
            sink: NodeRef<unknown>;
            sources: NodeRef<unknown>[];
        },
    ): void

  • A low-level utility that connects multiple nodes to a sink node with a map function. Used as a foundation for the higher-level operators. The nodes can be active (sources) or passive (pulls).

    Type Parameters

    • T extends unknown[] = unknown[]

    Parameters

    • __namedParameters: {
          map: ProjectionFunc<T>;
          pulls?: NodeRef<unknown>[];
          sink: NodeRef<unknown>;
          sources: NodeRef<unknown>[];
      }
      • map: ProjectionFunc<T>

        The projection function that will be called when any of the source nodes emits.

      • Optionalpulls?: NodeRef<unknown>[]

        The nodes which values will be pulled. The values will be passed as arguments to the map function.

      • sink: NodeRef<unknown>

        The sink node that will receive the result of the map function.

      • sources: NodeRef<unknown>[]

        The source nodes that emit values to the sink node. The values will be passed as arguments to the map function.

    Returns void

getValue

  • getValue<T>(node: NodeRef<T>): T

  • Gets the current value of a node. The node must be stateful.

    Type Parameters

    • T

    Parameters

    Returns T

    Remark

    if possible, use withLatestFrom or combine, as getValue will not create a dependency to the passed node, which means that if you call it within a computational cycle, you may not get the correct value.

    Example

    const foo$ = Cell('foo')

    const r = new Realm()
    r.getValue(foo$) // 'foo'
    r.pub(foo$, 'bar')
    //...
    r.getValue(foo$) // 'bar'

getValues

inContext

  • inContext<T>(fn: () => T): T

  • Type Parameters

    • T

    Parameters

    • fn: () => T

    Returns T

link

pipe

  • pipe<T>(s: NodeRef<T>): NodeRef<T>

  • Creates a new node that emits the values of the source node transformed through the specified operators.

    Type Parameters

    • T

    Parameters

    Returns NodeRef<T>

    Example

    const signal$ = Signal<number>(true, (r) => {
      const signalPlusOne$ = r.pipe(signal$, map(i => i + 1))
      r.sub(signalPlusOne$, console.log)
    })
    const r = new Realm()
    r.pub(signal$, 1
  • pipe<T, O1>(s: NodeRef<T>, o1: O<T, O1>): NodeRef<O1>

  • Creates a new node that emits the values of the source node transformed through the specified operators.

    Type Parameters

    • T
    • O1

    Parameters

    Returns NodeRef<O1>

    Example

    const signal$ = Signal<number>(true, (r) => {
      const signalPlusOne$ = r.pipe(signal$, map(i => i + 1))
      r.sub(signalPlusOne$, console.log)
    })
    const r = new Realm()
    r.pub(signal$, 1
  • pipe<T, O1, O2>(s: NodeRef<T>, ...o: [O<T, O1>, O<O1, O2>]): NodeRef<O2>

  • Creates a new node that emits the values of the source node transformed through the specified operators.

    Type Parameters

    • T
    • O1
    • O2

    Parameters

    Returns NodeRef<O2>

    Example

    const signal$ = Signal<number>(true, (r) => {
      const signalPlusOne$ = r.pipe(signal$, map(i => i + 1))
      r.sub(signalPlusOne$, console.log)
    })
    const r = new Realm()
    r.pub(signal$, 1
  • pipe<T, O1, O2, O3>(
        s: NodeRef<T>,
        ...o: [O<T, O1>, O<O1, O2>, O<O2, O3>],
    ): NodeRef<O3>

  • Creates a new node that emits the values of the source node transformed through the specified operators.

    Type Parameters

    • T
    • O1
    • O2
    • O3

    Parameters

    Returns NodeRef<O3>

    Example

    const signal$ = Signal<number>(true, (r) => {
      const signalPlusOne$ = r.pipe(signal$, map(i => i + 1))
      r.sub(signalPlusOne$, console.log)
    })
    const r = new Realm()
    r.pub(signal$, 1
  • pipe<T, O1, O2, O3, O4>(
        s: NodeRef<T>,
        ...o: [O<T, O1>, O<O1, O2>, O<O2, O3>, O<O3, O4>],
    ): NodeRef<O4>

  • Creates a new node that emits the values of the source node transformed through the specified operators.

    Type Parameters

    • T
    • O1
    • O2
    • O3
    • O4

    Parameters

    Returns NodeRef<O4>

    Example

    const signal$ = Signal<number>(true, (r) => {
      const signalPlusOne$ = r.pipe(signal$, map(i => i + 1))
      r.sub(signalPlusOne$, console.log)
    })
    const r = new Realm()
    r.pub(signal$, 1
  • pipe<T, O1, O2, O3, O4, O5>(
        s: NodeRef<T>,
        ...o: [O<T, O1>, O<O1, O2>, O<O2, O3>, O<O3, O4>, O<O4, O5>],
    ): NodeRef<O5>

  • Creates a new node that emits the values of the source node transformed through the specified operators.

    Type Parameters

    • T
    • O1
    • O2
    • O3
    • O4
    • O5

    Parameters

    Returns NodeRef<O5>

    Example

    const signal$ = Signal<number>(true, (r) => {
      const signalPlusOne$ = r.pipe(signal$, map(i => i + 1))
      r.sub(signalPlusOne$, console.log)
    })
    const r = new Realm()
    r.pub(signal$, 1
  • pipe<T, O1, O2, O3, O4, O5, O6>(
        s: NodeRef<T>,
        ...o: [O<T, O1>, O<O1, O2>, O<O2, O3>, O<O3, O4>, O<O4, O5>, O<O5, O6>],
    ): NodeRef<O6>

  • Creates a new node that emits the values of the source node transformed through the specified operators.

    Type Parameters

    • T
    • O1
    • O2
    • O3
    • O4
    • O5
    • O6

    Parameters

    Returns NodeRef<O6>

    Example

    const signal$ = Signal<number>(true, (r) => {
      const signalPlusOne$ = r.pipe(signal$, map(i => i + 1))
      r.sub(signalPlusOne$, console.log)
    })
    const r = new Realm()
    r.pub(signal$, 1
  • pipe<T, O1, O2, O3, O4, O5, O6, O7>(
        s: NodeRef<T>,
        ...o: [
            O<T, O1>,
            O<O1, O2>,
            O<O2, O3>,
            O<O3, O4>,
            O<O4, O5>,
            O<O5, O6>,
            O<O6, O7>,
        ],
    ): NodeRef<O7>

  • Creates a new node that emits the values of the source node transformed through the specified operators.

    Type Parameters

    • T
    • O1
    • O2
    • O3
    • O4
    • O5
    • O6
    • O7

    Parameters

    Returns NodeRef<O7>

    Example

    const signal$ = Signal<number>(true, (r) => {
      const signalPlusOne$ = r.pipe(signal$, map(i => i + 1))
      r.sub(signalPlusOne$, console.log)
    })
    const r = new Realm()
    r.pub(signal$, 1
  • pipe<T, O1, O2, O3, O4, O5, O6, O7, O8>(
        s: NodeRef<T>,
        ...o: [
            O<T, O1>,
            O<O1, O2>,
            O<O2, O3>,
            O<O3, O4>,
            O<O4, O5>,
            O<O5, O6>,
            O<O6, O7>,
            O<O7, O8>,
        ],
    ): NodeRef<O8>

  • Creates a new node that emits the values of the source node transformed through the specified operators.

    Type Parameters

    • T
    • O1
    • O2
    • O3
    • O4
    • O5
    • O6
    • O7
    • O8

    Parameters

    Returns NodeRef<O8>

    Example

    const signal$ = Signal<number>(true, (r) => {
      const signalPlusOne$ = r.pipe(signal$, map(i => i + 1))
      r.sub(signalPlusOne$, console.log)
    })
    const r = new Realm()
    r.pub(signal$, 1
  • pipe<T, O1, O2, O3, O4, O5, O6, O7, O8, O9>(
        s: NodeRef<T>,
        ...o: [
            O<T, O1>,
            O<O1, O2>,
            O<O2, O3>,
            O<O3, O4>,
            O<O4, O5>,
            O<O5, O6>,
            O<O6, O7>,
            O<O7, O8>,
            O<O8, O9>,
        ],
    ): NodeRef<O9>

  • Creates a new node that emits the values of the source node transformed through the specified operators.

    Type Parameters

    • T
    • O1
    • O2
    • O3
    • O4
    • O5
    • O6
    • O7
    • O8
    • O9

    Parameters

    Returns NodeRef<O9>

    Example

    const signal$ = Signal<number>(true, (r) => {
      const signalPlusOne$ = r.pipe(signal$, map(i => i + 1))
      r.sub(signalPlusOne$, console.log)
    })
    const r = new Realm()
    r.pub(signal$, 1
  • pipe<T>(
        source: NodeRef<T>,
        ...operators: O<unknown, unknown>[],
    ): NodeRef<unknown>

  • Creates a new node that emits the values of the source node transformed through the specified operators.

    Type Parameters

    • T

    Parameters

    • source: NodeRef<T>
    • ...operators: O<unknown, unknown>[]

    Returns NodeRef<unknown>

    Example

    const signal$ = Signal<number>(true, (r) => {
      const signalPlusOne$ = r.pipe(signal$, map(i => i + 1))
      r.sub(signalPlusOne$, console.log)
    })
    const r = new Realm()
    r.pub(signal$, 1

pub

  • pub<T>(node: NodeRef<T>): void

  • Runs the subscrptions of this node.

    Type Parameters

    • T

    Parameters

    Returns void

    Example

    const foo$ = Action((r) => {
     r.sub(foo$, console.log)
    })

    const r = new Realm()
    r.pub(foo$
  • pub<T>(node: NodeRef<T>, value: T): void

  • Publishes the specified value into a node.

    Type Parameters

    • T

    Parameters

    Returns void

    Example

    const foo$ = Cell('foo')
    const r = new Realm()
    r.pub(foo$, 'bar'

pubIn

  • pubIn(values: Record<symbol, unknown>): void

  • Publishes into multiple nodes simultaneously, triggering a single re-computation cycle.

    Parameters

    • values: Record<symbol, unknown>

      a record of node references and their values.

    Returns void

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')

    const r = new Realm()
    r.pubIn({[foo$]: 'foo1', [bar$]: 'bar1'})

register

  • register(node: NodeRef<unknown>): NodeRef<any>

  • Explicitly includes the specified cell/signal reference in the realm. Most of the time you don't need to do that, since any interaction with the node through a realm will register it. The only exception of that rule should be when the interaction is conditional, and the node definition includes an init function that needs to be eagerly evaluated.

    Parameters

    Returns NodeRef<any>

resetSingletonSubs

  • resetSingletonSubs(): void

  • Clears all exclusive subscriptions.

    Returns void

signalInstance

  • signalInstance<T>(distinct?: Distinct<T>, node?: symbol): NodeRef<T>

  • Creates or resolves an existing signal instance in the realm. Useful as a joint point when building your own operators.

    Type Parameters

    • T

    Parameters

    • distinct: Distinct<T> = true

      true by default. Pass false to mark the signal as a non-distinct one, meaning that publishing the same value multiple times will re-trigger a recomputation cycle.

    • node: symbol = ...

      optional, a reference to a signal. If the signal has not been touched in the realm before, the realm will instantiate a reference to it. If it's registered already, the function will return the reference.

    Returns NodeRef<T>

    a reference to the signal.

singletonSub

  • singletonSub<T>(
        node: NodeRef<T>,
        subscription: undefined | Subscription<T>,
    ): UnsubscribeHandle

  • Subscribes exclusively to values in the referred node. Calling this multiple times on a single node will remove the previous subscription created through singletonSub. Subscriptions created through sub are not affected.

    Type Parameters

    • T

    Parameters

    Returns UnsubscribeHandle

    a function that, when called, will cancel the subscription.

    Example

    const signal$ = Signal<number>()
    const r = new Realm()
    // console.log will run only once.
    r.singletonSub(signal$, console.log)
    r.singletonSub(signal$, console.log)
    r.singletonSub(signal$, console.log)
    r.pub(signal$, 2)

sub

  • sub<T>(node: NodeRef<T>, subscription: Subscription<T>): UnsubscribeHandle

  • Subscribes to the values published in the referred node.

    Type Parameters

    • T

    Parameters

    • node: NodeRef<T>

      the cell/signal to subscribe to.

    • subscription: Subscription<T>

      the callback to execute when the node receives a new value.

    Returns UnsubscribeHandle

    a function that, when called, will cancel the subscription.

    Example

    const signal$ = Signal<number>()
    const r = new Realm()
    const unsub = r.sub(signal$, console.log)
    r.pub(signal$, 2)
    unsub()
    r.pub(signal$, 3)

subMultiple

  • subMultiple<T1>(
        nodes: [NodeRef<T1>],
        subscription: Subscription<[T1]>,
    ): UnsubscribeHandle

  • Subscribes to multiple nodes at once. If any of the nodes emits a value, the subscription will be called with an array of the latest values from each node. If the nodes change within a single execution cycle, the subscription will be called only once with the final node values.

    Type Parameters

    • T1

    Parameters

    Returns UnsubscribeHandle

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')

    const trigger$ = Signal<number>(true, (r) => {
      r.link(r.pipe(trigger$, map(i => `foo${i}`)), foo$)
      r.link(r.pipe(trigger$, map(i => `bar${i}`)), bar$)
    })

    const r = new Realm()
    r.subMultiple([foo$, bar$], ([foo, bar]) => console.log(foo, bar))
    r.pub(trigger$, 2)
  • subMultiple<T1, T2>(
        nodes: [NodeRef<T1>, NodeRef<T2>],
        subscription: Subscription<[T1, T2]>,
    ): UnsubscribeHandle

  • Subscribes to multiple nodes at once. If any of the nodes emits a value, the subscription will be called with an array of the latest values from each node. If the nodes change within a single execution cycle, the subscription will be called only once with the final node values.

    Type Parameters

    • T1
    • T2

    Parameters

    Returns UnsubscribeHandle

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')

    const trigger$ = Signal<number>(true, (r) => {
      r.link(r.pipe(trigger$, map(i => `foo${i}`)), foo$)
      r.link(r.pipe(trigger$, map(i => `bar${i}`)), bar$)
    })

    const r = new Realm()
    r.subMultiple([foo$, bar$], ([foo, bar]) => console.log(foo, bar))
    r.pub(trigger$, 2)
  • subMultiple<T1, T2, T3>(
        nodes: [NodeRef<T1>, NodeRef<T2>, NodeRef<T3>],
        subscription: Subscription<[T1, T2, T3]>,
    ): UnsubscribeHandle

  • Subscribes to multiple nodes at once. If any of the nodes emits a value, the subscription will be called with an array of the latest values from each node. If the nodes change within a single execution cycle, the subscription will be called only once with the final node values.

    Type Parameters

    • T1
    • T2
    • T3

    Parameters

    Returns UnsubscribeHandle

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')

    const trigger$ = Signal<number>(true, (r) => {
      r.link(r.pipe(trigger$, map(i => `foo${i}`)), foo$)
      r.link(r.pipe(trigger$, map(i => `bar${i}`)), bar$)
    })

    const r = new Realm()
    r.subMultiple([foo$, bar$], ([foo, bar]) => console.log(foo, bar))
    r.pub(trigger$, 2)
  • subMultiple<T1, T2, T3, T4>(
        nodes: [NodeRef<T1>, NodeRef<T2>, NodeRef<T3>, NodeRef<T4>],
        subscription: Subscription<[T1, T2, T3, T4]>,
    ): UnsubscribeHandle

  • Subscribes to multiple nodes at once. If any of the nodes emits a value, the subscription will be called with an array of the latest values from each node. If the nodes change within a single execution cycle, the subscription will be called only once with the final node values.

    Type Parameters

    • T1
    • T2
    • T3
    • T4

    Parameters

    Returns UnsubscribeHandle

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')

    const trigger$ = Signal<number>(true, (r) => {
      r.link(r.pipe(trigger$, map(i => `foo${i}`)), foo$)
      r.link(r.pipe(trigger$, map(i => `bar${i}`)), bar$)
    })

    const r = new Realm()
    r.subMultiple([foo$, bar$], ([foo, bar]) => console.log(foo, bar))
    r.pub(trigger$, 2)
  • subMultiple<T1, T2, T3, T4, T5>(
        nodes: [NodeRef<T1>, NodeRef<T2>, NodeRef<T3>, NodeRef<T4>, NodeRef<T5>],
        subscription: Subscription<[T1, T2, T3, T4, T5]>,
    ): UnsubscribeHandle

  • Subscribes to multiple nodes at once. If any of the nodes emits a value, the subscription will be called with an array of the latest values from each node. If the nodes change within a single execution cycle, the subscription will be called only once with the final node values.

    Type Parameters

    • T1
    • T2
    • T3
    • T4
    • T5

    Parameters

    Returns UnsubscribeHandle

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')

    const trigger$ = Signal<number>(true, (r) => {
      r.link(r.pipe(trigger$, map(i => `foo${i}`)), foo$)
      r.link(r.pipe(trigger$, map(i => `bar${i}`)), bar$)
    })

    const r = new Realm()
    r.subMultiple([foo$, bar$], ([foo, bar]) => console.log(foo, bar))
    r.pub(trigger$, 2)
  • subMultiple<T1, T2, T3, T4, T5, T6>(
        nodes: [
            NodeRef<T1>,
            NodeRef<T2>,
            NodeRef<T3>,
            NodeRef<T4>,
            NodeRef<T5>,
            NodeRef<T6>,
        ],
        subscription: Subscription<[T1, T2, T3, T4, T5, T6]>,
    ): UnsubscribeHandle

  • Subscribes to multiple nodes at once. If any of the nodes emits a value, the subscription will be called with an array of the latest values from each node. If the nodes change within a single execution cycle, the subscription will be called only once with the final node values.

    Type Parameters

    • T1
    • T2
    • T3
    • T4
    • T5
    • T6

    Parameters

    Returns UnsubscribeHandle

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')

    const trigger$ = Signal<number>(true, (r) => {
      r.link(r.pipe(trigger$, map(i => `foo${i}`)), foo$)
      r.link(r.pipe(trigger$, map(i => `bar${i}`)), bar$)
    })

    const r = new Realm()
    r.subMultiple([foo$, bar$], ([foo, bar]) => console.log(foo, bar))
    r.pub(trigger$, 2)
  • subMultiple<T1, T2, T3, T4, T5, T6, T7>(
        nodes: [
            NodeRef<T1>,
            NodeRef<T2>,
            NodeRef<T3>,
            NodeRef<T4>,
            NodeRef<T5>,
            NodeRef<T6>,
            NodeRef<T7>,
        ],
        subscription: Subscription<[T1, T2, T3, T4, T5, T6, T7]>,
    ): UnsubscribeHandle

  • Subscribes to multiple nodes at once. If any of the nodes emits a value, the subscription will be called with an array of the latest values from each node. If the nodes change within a single execution cycle, the subscription will be called only once with the final node values.

    Type Parameters

    • T1
    • T2
    • T3
    • T4
    • T5
    • T6
    • T7

    Parameters

    Returns UnsubscribeHandle

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')

    const trigger$ = Signal<number>(true, (r) => {
      r.link(r.pipe(trigger$, map(i => `foo${i}`)), foo$)
      r.link(r.pipe(trigger$, map(i => `bar${i}`)), bar$)
    })

    const r = new Realm()
    r.subMultiple([foo$, bar$], ([foo, bar]) => console.log(foo, bar))
    r.pub(trigger$, 2)
  • subMultiple<T1, T2, T3, T4, T5, T6, T7, T8>(
        nodes: [
            NodeRef<T1>,
            NodeRef<T2>,
            NodeRef<T3>,
            NodeRef<T4>,
            NodeRef<T5>,
            NodeRef<T6>,
            NodeRef<T7>,
            NodeRef<T8>,
        ],
        subscription: Subscription<[T1, T2, T3, T4, T5, T6, T7, T8]>,
    ): UnsubscribeHandle

  • Subscribes to multiple nodes at once. If any of the nodes emits a value, the subscription will be called with an array of the latest values from each node. If the nodes change within a single execution cycle, the subscription will be called only once with the final node values.

    Type Parameters

    • T1
    • T2
    • T3
    • T4
    • T5
    • T6
    • T7
    • T8

    Parameters

    Returns UnsubscribeHandle

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')

    const trigger$ = Signal<number>(true, (r) => {
      r.link(r.pipe(trigger$, map(i => `foo${i}`)), foo$)
      r.link(r.pipe(trigger$, map(i => `bar${i}`)), bar$)
    })

    const r = new Realm()
    r.subMultiple([foo$, bar$], ([foo, bar]) => console.log(foo, bar))
    r.pub(trigger$, 2)
  • subMultiple(
        nodes: NodeRef<unknown>[],
        subscription: Subscription<any>,
    ): UnsubscribeHandle

  • Subscribes to multiple nodes at once. If any of the nodes emits a value, the subscription will be called with an array of the latest values from each node. If the nodes change within a single execution cycle, the subscription will be called only once with the final node values.

    Parameters

    Returns UnsubscribeHandle

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')

    const trigger$ = Signal<number>(true, (r) => {
      r.link(r.pipe(trigger$, map(i => `foo${i}`)), foo$)
      r.link(r.pipe(trigger$, map(i => `bar${i}`)), bar$)
    })

    const r = new Realm()
    r.subMultiple([foo$, bar$], ([foo, bar]) => console.log(foo, bar))
    r.pub(trigger$, 2)

transformer

  • transformer<In>(...o: []): (s: NodeRef<In>) => NodeRef<In>

  • Works as a reverse pipe. Constructs a function, that, when passed a certain node (sink), will create a node that will work as a publisher through the specified pipes into the sink.

    Type Parameters

    • In

    Parameters

    • ...o: []

    Returns (s: NodeRef<In>) => NodeRef<In>

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')
    const entry$ = Signal<number>(true, (r) => {
     const transform = r.transformer(map(x: number => `num${x}`))
     const transformFoo$ = transform(foo$)
     const transformBar$ = transform(bar$)
     r.link(entry$, transformFoo$)
     r.link(entry$, transformBar$)
    })

    const r = new Realm()
    r.pub(entry$, 1) // Both foo$ and bar$ now contain `num1`
  • transformer<In, Out>(...o: [O<In, Out>]): (s: NodeRef<Out>) => NodeRef<In>

  • Works as a reverse pipe. Constructs a function, that, when passed a certain node (sink), will create a node that will work as a publisher through the specified pipes into the sink.

    Type Parameters

    • In
    • Out

    Parameters

    Returns (s: NodeRef<Out>) => NodeRef<In>

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')
    const entry$ = Signal<number>(true, (r) => {
     const transform = r.transformer(map(x: number => `num${x}`))
     const transformFoo$ = transform(foo$)
     const transformBar$ = transform(bar$)
     r.link(entry$, transformFoo$)
     r.link(entry$, transformBar$)
    })

    const r = new Realm()
    r.pub(entry$, 1) // Both foo$ and bar$ now contain `num1`
  • transformer<In, Out, O1>(
        ...o: [O<In, O1>, O<O1, Out>],
    ): (s: NodeRef<Out>) => NodeRef<In>

  • Works as a reverse pipe. Constructs a function, that, when passed a certain node (sink), will create a node that will work as a publisher through the specified pipes into the sink.

    Type Parameters

    • In
    • Out
    • O1

    Parameters

    Returns (s: NodeRef<Out>) => NodeRef<In>

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')
    const entry$ = Signal<number>(true, (r) => {
     const transform = r.transformer(map(x: number => `num${x}`))
     const transformFoo$ = transform(foo$)
     const transformBar$ = transform(bar$)
     r.link(entry$, transformFoo$)
     r.link(entry$, transformBar$)
    })

    const r = new Realm()
    r.pub(entry$, 1) // Both foo$ and bar$ now contain `num1`
  • transformer<In, Out, O1, O2>(
        ...o: [O<In, O1>, O<O1, O2>, O<O2, Out>],
    ): (s: NodeRef<Out>) => NodeRef<In>

  • Works as a reverse pipe. Constructs a function, that, when passed a certain node (sink), will create a node that will work as a publisher through the specified pipes into the sink.

    Type Parameters

    • In
    • Out
    • O1
    • O2

    Parameters

    Returns (s: NodeRef<Out>) => NodeRef<In>

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')
    const entry$ = Signal<number>(true, (r) => {
     const transform = r.transformer(map(x: number => `num${x}`))
     const transformFoo$ = transform(foo$)
     const transformBar$ = transform(bar$)
     r.link(entry$, transformFoo$)
     r.link(entry$, transformBar$)
    })

    const r = new Realm()
    r.pub(entry$, 1) // Both foo$ and bar$ now contain `num1`
  • transformer<In, Out, O1, O2, O3>(
        ...o: [O<In, O1>, O<O1, O2>, O<O2, O3>, O<O3, Out>],
    ): (s: NodeRef<Out>) => NodeRef<In>

  • Works as a reverse pipe. Constructs a function, that, when passed a certain node (sink), will create a node that will work as a publisher through the specified pipes into the sink.

    Type Parameters

    • In
    • Out
    • O1
    • O2
    • O3

    Parameters

    Returns (s: NodeRef<Out>) => NodeRef<In>

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')
    const entry$ = Signal<number>(true, (r) => {
     const transform = r.transformer(map(x: number => `num${x}`))
     const transformFoo$ = transform(foo$)
     const transformBar$ = transform(bar$)
     r.link(entry$, transformFoo$)
     r.link(entry$, transformBar$)
    })

    const r = new Realm()
    r.pub(entry$, 1) // Both foo$ and bar$ now contain `num1`
  • transformer<In, Out, O1, O2, O3, O4>(
        ...o: [O<In, O1>, O<O1, O2>, O<O2, O3>, O<O3, O4>, O<O4, Out>],
    ): (s: NodeRef<Out>) => NodeRef<In>

  • Works as a reverse pipe. Constructs a function, that, when passed a certain node (sink), will create a node that will work as a publisher through the specified pipes into the sink.

    Type Parameters

    • In
    • Out
    • O1
    • O2
    • O3
    • O4

    Parameters

    Returns (s: NodeRef<Out>) => NodeRef<In>

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')
    const entry$ = Signal<number>(true, (r) => {
     const transform = r.transformer(map(x: number => `num${x}`))
     const transformFoo$ = transform(foo$)
     const transformBar$ = transform(bar$)
     r.link(entry$, transformFoo$)
     r.link(entry$, transformBar$)
    })

    const r = new Realm()
    r.pub(entry$, 1) // Both foo$ and bar$ now contain `num1`
  • transformer<In, Out, O1, O2, O3, O4, O5>(
        ...o: [
            O<In, O1>,
            O<O1, O2>,
            O<O2, O3>,
            O<O3, O4>,
            O<O4, O5>,
            O<O5, Out>,
        ],
    ): (s: NodeRef<Out>) => NodeRef<In>

  • Works as a reverse pipe. Constructs a function, that, when passed a certain node (sink), will create a node that will work as a publisher through the specified pipes into the sink.

    Type Parameters

    • In
    • Out
    • O1
    • O2
    • O3
    • O4
    • O5

    Parameters

    Returns (s: NodeRef<Out>) => NodeRef<In>

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')
    const entry$ = Signal<number>(true, (r) => {
     const transform = r.transformer(map(x: number => `num${x}`))
     const transformFoo$ = transform(foo$)
     const transformBar$ = transform(bar$)
     r.link(entry$, transformFoo$)
     r.link(entry$, transformBar$)
    })

    const r = new Realm()
    r.pub(entry$, 1) // Both foo$ and bar$ now contain `num1`
  • transformer<In, Out>(
        ...operators: O<unknown, unknown>[],
    ): (s: NodeRef<Out>) => NodeRef<In>

  • Works as a reverse pipe. Constructs a function, that, when passed a certain node (sink), will create a node that will work as a publisher through the specified pipes into the sink.

    Type Parameters

    • In
    • Out

    Parameters

    • ...operators: O<unknown, unknown>[]

    Returns (s: NodeRef<Out>) => NodeRef<In>

    Example

    const foo$ = Cell('foo')
    const bar$ = Cell('bar')
    const entry$ = Signal<number>(true, (r) => {
     const transform = r.transformer(map(x: number => `num${x}`))
     const transformFoo$ = transform(foo$)
     const transformBar$ = transform(bar$)
     r.link(entry$, transformFoo$)
     r.link(entry$, transformBar$)
    })

    const r = new Realm()
    r.pub(entry$, 1) // Both foo$ and bar$ now contain `num1`

Settings

Member Visibility

On This Page

Constructors
Methods