a-frame.core — com.github.yapsterapp/a-frame 3.0.18-alpha1

->interceptor clj/s

(->interceptor {_id :id _before :before _after :after})

TODO impl

add-init-coeffects clj/s

(add-init-coeffects event init-coeffects)

add some initial coeffects to an event

assoc-coeffect clj/s

(assoc-coeffect _context _key _value)

TODO impl

assoc-effect clj/s

(assoc-effect _context _key _value)

TODO impl

clear-cofx clj/s

(clear-cofx)

(clear-cofx id)

clear-event clj/s

(clear-event)

(clear-event id)

clear-fx clj/s

(clear-fx)

(clear-fx id)

clear-global-interceptors clj/s

(clear-global-interceptors router)

(clear-global-interceptors router id)

clear all or one global interceptors

create-router clj/s

(create-router app)

(create-router app opts)

create an a-frame router

create-router-dispose-fn clj/s

(create-router-dispose-fn app)

(create-router-dispose-fn app opts)

factory function for an a-frame router and a fn to dispose the router

returns [router dispose-fn]

dispatch clj/s

(dispatch router event)

(dispatch router init-coeffects event)

dispatch a single event

dispatch-n clj/s

(dispatch-n router events)

(dispatch-n router init-coeffects events)

dispatch a vector of events

dispatch-n-sync clj/s

(dispatch-n-sync router events)

(dispatch-n-sync router init-coeffects events)

dispatch-sync a vector of events

dispatch-sync clj/s

(dispatch-sync router event)

(dispatch-sync router init-coeffects event)

dispatch a single event and await the completion of its processing (all cofx, event and fx will complete before the result promise returns)

enqueue clj/s

(enqueue _context _interceptors)

TODO impl

get-coeffect clj/s

(get-coeffect _context)

(get-coeffect _context _key)

(get-coeffect _context _key _not-found)

TODO impl

get-effect clj/s

(get-effect _context)

(get-effect _context _key)

(get-effect _context _key _not-found)

TODO impl

inject-cofx clj/s

(inject-cofx id)

(inject-cofx id value)

reg-cofx clj/s

(reg-cofx id handler)

register a cofx handler (<handler> app) -> Promise<> (<handler> app arg) -> Promise<>

reg-event-ctx clj/s

(reg-event-ctx id handler)

(reg-event-ctx id interceptors handler)

register an event-handler expected to return a (promise of an) updated event-context

(<handler> context) -> Promise<context>

fx from the returned context will be processed as described in reg-event-fx

reg-event-fx clj/s

(reg-event-fx id handler)

(reg-event-fx id interceptors handler)

register an event-handler expected to return a (promise of a) seq of fx

(<handler> cofx event) -> Promise<[{<fx-id> <fx-args>}]>

the seq of fx will be processed sequentially - maps with multiple fx entries may be processed concurrently

note that processing of the partition's queue will be suspended until the handler returns

reg-fx clj/s

(reg-fx id handler)

register an fx handler (<handler> app arg) -> Promise<*>

reg-global-interceptor clj/s

(reg-global-interceptor router interceptor)

register a global interceptor for the router instance - all events dispatched to this router will have global interceptors prepended to the interceptor chain declared with the handler

repl-dispatch-sync->coeffects clj/s

(repl-dispatch-sync->coeffects router event)

(repl-dispatch-sync->coeffects n router event)

return the coeffects for an event

processes all the :enter interceptor fns of the event's chain, but skips the event-handler and any :leave or :error fns

n - the number of handlers to drop from he end of the interceptor chain. default 1