TypeScript icon, indicating that this package has built-in type declarations

    3.1.3 • Public • Published


    npm version npm downloads Twitter Follow

    This project is part of the @thi.ng/umbrella monorepo.


    Interceptor based event bus, side effect & immutable state handling.

    Event bus, interceptors, side effects

    Interceptors: Event and Effect primitives


    The idea of interceptors is quite similar to functional composition and AOP (aspect oriented programming). You want to reuse some functionality across components within your app. For example, if you have multiple actions which should be undoable, you can compose your main event handlers with the snapShot() interceptor, which requires a @thi.ng/atom/History-like instance and records a snapshot of the current app state, but else is completely invisible.

    [UNDOABLE_EVENT]: [snapshot(), valueSetter("foo")]

    Event Handlers

    The idea of event handlers is being responsible to assign parameters to side effects, rather than executing effects themselves, is again mainly to do with the DRY-principle, instrumentation potential and performance. Most composed event handler chains are setup so that your "actual" main handler is last in line in the pre processing phase. If e.g. your event handlers would directly update the state atom, then any attached watches (derived views, cursors, other subscriptions) would be re-run each time. By assigning the updated state to, e.g., an FX_STATE event, we can avoid these interim updates and only apply the new state once all events in the current frame have been processed. Furthermore, a post interceptor might cancel the event due to validation errors etc.

    Events vs Effects:

    To briefly summarize the differences between event handlers & effects:

    Event handlers are triggered by events, but each event handler is technically a chain of interceptors (even though many are just a single item). Even if you just specify a single function, it's internally translated into an array of interceptor objects like:

    valueSetter("route") -> [{ pre: (...) => {[FX_STATE]: ...}, post: undefined }]

    When processing an event, these interceptors are then executed first in ascending order for any pre functions and then backwards again for any post functions (only if there are any in the chain). So if you had defined an handler with this chain: [{pre: f1, post: f2}, {pre: f3}, {pre: f4, post: f5}], then the functions would be called in this order: f1, f3, f4, f5, f2. The post phase is largely intended for state/effect validation & logging post-update. I.e., interceptors commonly need pre only.

    Like with trace() some interceptors DO have side effects, but they're really the exception to the rule. For example, snapshot() is idempotent since it only records a new snapshot if it's different from the last and trace(), but is typically used during development only - its side effect is outside the scope of your app (i.e. the console).

    Great, but why?

    In most apps there're far more event types/handlers than possible actions any component can take. So assigning them to registered side effects enables better code reuse. Another use-case is debugging. With a break point set at the beginning of processEffects() (in event-bus.ts) you can see exactly which side effects have occurred at each frame. This can be very helpful for debugging and avoid having to "keep everything in your head" or - as Rich Hickey would say - make your app "Easier to reason about".

    More comprehensive description forthcoming. Please check the detailed commented source code and examples for now:


    DEPRECATED - no further development planned

    Search or submit any issues for this package

    Related packages

    • @thi.ng/atom - Mutable wrappers for nested immutable values with optional undo/redo history and transaction support
    • @thi.ng/hdom - Lightweight vanilla ES6 UI component trees with customizable branch-local behaviors
    • @thi.ng/rdom - Lightweight, reactive, VDOM-less UI/DOM components with async lifecycle and @thi.ng/hiccup compatible


    yarn add @thi.ng/interceptors

    ES module import:

    <script type="module" src="https://cdn.skypack.dev/@thi.ng/interceptors"></script>

    Skypack documentation

    For Node.js REPL:

    # with flag only for < v16
    node --experimental-repl-await
    > const interceptors = await import("@thi.ng/interceptors");

    Package sizes (gzipped, pre-treeshake): ESM: 2.23 KB


    Usage examples

    Several demos in this repo's /examples directory are using this package.

    A selection:

    Screenshot Description Live demo Source
    Minimal demo using interceptors with an async side effect Demo Source
    Custom dropdown UI component for hdom Demo Source
    Custom dropdown UI component w/ fuzzy search Demo Source
    Event handling w/ interceptors and side effects Demo Source
    Event handling w/ interceptors and side effects Demo Source
    Complete mini SPA app w/ router & async content loading Demo Source
    Interactive grid generator, SVG generation & export, undo/redo support Demo Source
    Additive waveform synthesis & SVG visualization with undo/redo Demo Source


    Generated API docs





    If this project contributes to an academic publication, please cite it as:

      title = "@thi.ng/interceptors",
      author = "Karsten Schmidt and others",
      note = "https://thi.ng/interceptors",
      year = 2016


    © 2016 - 2021 Karsten Schmidt // Apache Software License 2.0


    npm i @thi.ng/interceptors

    DownloadsWeekly Downloads






    Unpacked Size

    95.6 kB

    Total Files


    Last publish


    • thi.ng