Simple observer pattern

Install

``
npm install obseriot
`

Usage

Define event

Object with a handler.name and handler.action .

- handler.name => Event name
- handler.action => Return the parameters to be provided to the listener
- Array is provided as a variadic argument
- Can be provide a variety of types. String, Object, Function, whatever

`js
const urlChange = {
handler: {
name: 'url_change',
action ( collection, id, action ) {
// Some processing and formatting
return [ collection, id, action ]
}
}
}
`

Listen and Notify

`js
// obseriot.listen( event object , callback function )
obseriot.listen( urlChange, ( ...arg ) => {
console.log( arg ) // => 'shop', 1, 'detail'
} )

// obseriot.notify( event object , parameters )
obseriot.notify( urlChange, 'shop', 1, 'detail' )
`

One time listener

`js
// obseriot.once( event object , callback function )
obseriot.once( urlChange, ( ...arg ) => {
console.log( arg )
} )
`

Remove listeners

Remove all registered listeners.

`js
// obseriot.remove( event object )
obseriot.remove( urlChange )
`

Remove one registered listener.

`js
// obseriot.remove( event object, callback function )
const callback = ( ...arg ) => {
console.log( arg )
}
obseriot.listen( urlChange, callback ) // Listen to the named function.
obseriot.remove( urlChange, callback ) // Remove!
`

How to use like Flux

Define Action

`js
export const increment = {
handler: {
name: 'action_increment',
action ( num = 1 ) {
return [ num ]
}
}
}
`

Define Store

`js
import {increment} from './action/increment'
import obseriot from 'obseriot'

export const count = {
state: 0,
handler: {
name: 'store_count',
action () {
return [ count.state ]
}
}
}

obseriot.listen( increment, num => {
count.state = count.state + num
obseriot.notify( count )
} )
`

Your Component

`js
import {increment} from './action/increment'
import {count} from './store/count'
import obseriot from 'obseriot'

// Action in somewhere components
obseriot.notify( increment, 1 )

// Listen to Store update
obseriot.listen( count, newCount => {
console.log( newCount ) // => 1
} )
``