Have ideas to improve npm?Join in the discussion! »

    rxify

    0.9.2 • Public • Published

    rxify

    An RxJS library wrapper that lets you execute Rx operators directly using marble-diagram ASCII string arguments.

    rxify was mainly created as an educational tool to guide those ramping up on Reactive Extensions for the first time by presenting an alternative way to visualize and experiment on its asynchronous features. However, some folks may find it useful for other purposes such as general problem-solving or simplifying unit tests.

    Installation
    npm install rxify
    
    Marble Notation / Terminology

    Each string argument is basically an observable sequence expressed in ASCII marble diagram notation. For example, the string 'A...B' represents a stream of two events separated by some passage of time. In rxify the actual unit of time is not important, so it may be easier to just imagine each '.' as one tick of time. Also, to simplify things further, the end of a string is automatically interpreted as an onCompleted action. Technically you can represent that with '|' but it's purely optional.

    Sequence Character Meaning
    . One tick of elapsed time
    | onCompleted() event
    ! onError() event
    ( ) A grouped set of coinciding events
    A-Z, 0-9 onNext() event
    Basic Examples

    The easiest way to convert a marble string directly to an observable is to call rxify.of, rxify.just, or rxify.from:

    var rxify = require('rxify');
    var obs = rxify.of('A...B...');
    obs = rxify.just('A...B...');
    obs = rxify.from('A...B...');
    console.log(obs.toString());
    // Output: 'A...B...'

    You can also pass these strings directly in as normal arguments:

    obs = rxify.concat('A...','B...','C...');
    console.log(obs.toString());
    // Output: 'A...B...C...'
    Chaining Operators
    obs = rxify.of('A...B...').concat('C...')
    console.log(obs.toString());
    // Output: 'A...B...C...'
    obs = rxify.zip('A...B...C...','123').take(2);
    console.log(obs.toString());
    // Output: '(A1)...(B2)'
    Visualizing Output

    If you'd like to see a verbose colorized step-by-step breakdown on a chained set of operations, you can call the extended display() method.

    obs = rxify.zip('A...B...C...','123').take(2);
    obs.display();
    // Outputs:
    // OPERATION ARGUMENTS              OUTPUT
    // zip       ["A...B...C...","123"] (A1)...(B2)...(C3)...|
    // take      [2]                    (A1)...(B2)|

    Dealing with Time

    Note: When calling a RxJS operator that normally expects a time-based argument in milliseconds, with rxify you should instead pass in the desired number of ticks. For example:

    rxify.delay(3) // Interpreted as '...'

    Note: You can also represent the argument as a sequence string:

    rxify.delay('...')
    More Examples
    var seqa = 'A...B.....C';
    var seqb = '..1...2.3..';
    var seqc = 'x....y....z';
    var obs = rxify.combineLatest(seqa, seqb, seqc );
    console.log(obs.toString());
    // Output: '..(A1x).(B1x)(B1y)(B2y).(B3y).(C3z)'
    var i = 0;
    console.log('doWhile example: ' + rxify.from('Aa.').
                doWhile(function() {
                    return ++<= 4;
                })
    );
    // Output: 'doWhile example: Aa.Aa.Aa.Aa.Aa.'
    var seq = '123456789';
    console.log('filter example: ' + rxify.from(seq).
        filter(function(elem) {
            return elem % 2 == 0;
        })
    );
    // Output: 'filter example: .2.4.6.8.'
    console.log('bufferWithTime example: ' + rxify.interval(1).
        bufferWithTime(5,1).
        take(3)
    );
    // Output: 'bufferWithTime: ....(0,1,2,3,4)(0,1,2,3,4,5)(2,3,4,5,6)'
    var input = 'AA..BBB..CCCC...DDDD...EEEEEE..FFFFF..GGGGG';
    console.log('debounce example: ' + rxify.of(input).debounce(1).toString());
    // Output: '..A....B.....C......D........E......F.....G'

    If you'd like more examples on how to use rxify, please refer to these unit tests

    Supported Observable Methods

    • amb
    • catch
    • combineLatest
    • concat
    • empty
    • for
    • forkJoin
    • from
    • generate
    • if
    • interval
    • just
    • merge
    • mergeDelayError
    • of
    • onErrorResumeNext
    • pairs
    • range
    • repeat
    • return
    • start
    • timer
    • while
    • zip

    Supported Observable Instance Methods

    • average
    • bufferWithCount
    • bufferWithTime
    • catch
    • combineLatest
    • concat
    • count
    • debounce
    • defaultIfEmpty
    • delay
    • distinct
    • distinctUntilChanged
    • do
    • doOnCompleted
    • doOnError
    • doOnNext
    • doWhile
    • elementAt
    • every
    • filter
    • finally
    • find
    • findIndex
    • first
    • flatMap
    • flatMapLatest
    • forEach
    • forkJoin
    • ignoreElements
    • isEmpty
    • last
    • let
    • map
    • max
    • maxBy
    • merge
    • min
    • minBy
    • onErrorResumeNext
    • pairwise
    • pluck
    • reduce
    • retry
    • sample
    • scan
    • select**
    • selectMany
    • sequenceEqual
    • skip
    • skipLast
    • skipLastWithTime
    • skipUntil
    • skipUntilWithTime
    • skipWhile
    • some
    • startWith
    • subscribe
    • subscribeOnCompleted
    • subscribeOnError
    • subscribeOnNext
    • sum
    • take
    • takeLast
    • takeLastBuffer
    • takeLastBufferWithTime
    • takeLastWithTime
    • takeUntil
    • takeUntilWithTime
    • takeWhile
    • tap
    • tapOnCompleted
    • tapOnError
    • tapOnNext
    • throttle
    • timeout
    • timeInterval
    • timestamp
    • toArray
    • where
    • zip

    Install

    npm i rxify

    DownloadsWeekly Downloads

    3

    Version

    0.9.2

    License

    ISC

    Last publish

    Collaborators

    • avatar