@rokt/dcui-orchestrator 0.0.2-rc.0

package/node_modules/@rokt/kit/stream/error-middleware/send-error.js

@@ -0,0 +1,13 @@
+export const ERROR_SENT_KEY = 'ERROR_SENT';
+export const setErrorSent = (ctx, value) => ctx.setContext(ERROR_SENT_KEY, value);
+export const getErrorSent = (ctx) => ctx.getContext(ERROR_SENT_KEY);
+/**
+ * Handler to automatically respond with the error if handlers throw.
+ */
+export const sendError = (ctx, err) => {
+    if (ctx.hasSent() || !err) {
+        return;
+    }
+    ctx.sendError(err);
+    setErrorSent(ctx, true);
+};

package/node_modules/@rokt/kit/stream/errors/contextual-error.d.ts

@@ -0,0 +1,8 @@
+import { ErrorDetails } from '../interfaces';
+import { ErrorCode } from './error-code';
+export declare class ContextualError extends Error implements ErrorDetails {
+    code?: ErrorCode;
+    additionalInformation?: Record<string, any>;
+    handled?: boolean;
+    constructor(message: string, context?: Partial<Omit<ErrorDetails, 'stack'>>);
+}

package/node_modules/@rokt/kit/stream/errors/contextual-error.js

@@ -0,0 +1,10 @@
+export class ContextualError extends Error {
+    constructor(message, context) {
+        var _a, _b;
+        super(message);
+        this.name = (_a = context === null || context === void 0 ? void 0 : context.name) !== null && _a !== void 0 ? _a : this.name;
+        this.code = context === null || context === void 0 ? void 0 : context.code;
+        this.additionalInformation = context === null || context === void 0 ? void 0 : context.additionalInformation;
+        this.handled = (_b = context === null || context === void 0 ? void 0 : context.handled) !== null && _b !== void 0 ? _b : false;
+    }
+}

package/node_modules/@rokt/kit/stream/errors/error-code.d.ts

@@ -0,0 +1,22 @@
+import { stream } from '../index';
+import { ErrorCodes } from './error-codes';
+export type ControllerErrorCodes = (typeof ControllerErrorCodes)[keyof typeof ControllerErrorCodes];
+export declare const ControllerErrorCodes: {
+    /**
+     * Raised when /select-placements call failed. It could be due to failed connection to server or server error.
+     */
+    readonly PLACEMENTS_RESPONSE: "PLACEMENTS_RESPONSE";
+    /**
+     * Raised when /session call failed. It could be due to failed connection to server or server error.
+     */
+    readonly SESSION_ERROR: "SESSION_RESPONSE";
+    /**
+     * Raised when creating a child plugin and invalid parent instance information is passed.
+     */
+    readonly CREATE_CHILD_PLUGIN: "CREATE_CHILD_PLUGIN";
+    /**
+     * Raised when a plugin container frame has been created by Launcher but no response was received within the timeout.
+     */
+    readonly PLUGIN_CONTAINER_LOAD: "PLUGIN_CONTAINER_LOAD";
+};
+export type ErrorCode = ErrorCodes | ControllerErrorCodes | stream.ErrorCodes | string;

package/node_modules/@rokt/kit/stream/errors/error-code.js

@@ -0,0 +1,18 @@
+export const ControllerErrorCodes = {
+    /**
+     * Raised when /select-placements call failed. It could be due to failed connection to server or server error.
+     */
+    PLACEMENTS_RESPONSE: 'PLACEMENTS_RESPONSE',
+    /**
+     * Raised when /session call failed. It could be due to failed connection to server or server error.
+     */
+    SESSION_ERROR: 'SESSION_RESPONSE',
+    /**
+     * Raised when creating a child plugin and invalid parent instance information is passed.
+     */
+    CREATE_CHILD_PLUGIN: 'CREATE_CHILD_PLUGIN',
+    /**
+     * Raised when a plugin container frame has been created by Launcher but no response was received within the timeout.
+     */
+    PLUGIN_CONTAINER_LOAD: 'PLUGIN_CONTAINER_LOAD',
+};

package/node_modules/@rokt/kit/stream/errors/error-codes.d.ts

@@ -0,0 +1,6 @@
+export type ErrorCodes = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+export declare const ErrorCodes: {
+    readonly UNHANDLED_EXCEPTION: "UNHANDLED_EXCEPTION";
+    readonly ERROR_LIMIT_EXCEEDED: "ERROR_LIMIT_EXCEEDED";
+    readonly WARNING_LIMIT_EXCEEDED: "WARNING_LIMIT_EXCEEDED";
+};

package/node_modules/@rokt/kit/stream/errors/error-codes.js

@@ -0,0 +1,5 @@
+export const ErrorCodes = {
+    UNHANDLED_EXCEPTION: 'UNHANDLED_EXCEPTION',
+    ERROR_LIMIT_EXCEEDED: 'ERROR_LIMIT_EXCEEDED',
+    WARNING_LIMIT_EXCEEDED: 'WARNING_LIMIT_EXCEEDED',
+};

package/node_modules/@rokt/kit/stream/errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './contextual-error';
+export * from './error-code';
+export * from './error-codes';

package/node_modules/@rokt/kit/stream/errors/index.js

@@ -0,0 +1,3 @@
+export * from './contextual-error';
+export * from './error-code';
+export * from './error-codes';

package/node_modules/@rokt/kit/stream/group.d.ts

@@ -0,0 +1,13 @@
+import { HandlerFunc } from './interfaces';
+export declare class Group implements IGroup {
+    private middleware;
+    private handlers;
+    getHandlers(): Record<string, Array<HandlerFunc>>;
+    use(handler: HandlerFunc): void;
+    on(eventType: string, ...handlers: Array<HandlerFunc>): void;
+}
+export interface IGroup {
+    getHandlers(): Record<string, Array<HandlerFunc>>;
+    use(middleware: HandlerFunc | Group): void;
+    on(event: string, ...handlers: Array<HandlerFunc>): void;
+}

package/node_modules/@rokt/kit/stream/group.js

@@ -0,0 +1,19 @@
+export class Group {
+    constructor() {
+        this.middleware = [];
+        this.handlers = {};
+    }
+    getHandlers() {
+        const result = {};
+        for (const [event, handlers] of Object.entries(this.handlers)) {
+            result[event] = [...this.middleware, ...handlers];
+        }
+        return result;
+    }
+    use(handler) {
+        this.middleware.push(handler);
+    }
+    on(eventType, ...handlers) {
+        this.handlers[eventType] = handlers;
+    }
+}

package/node_modules/@rokt/kit/stream/handler-context.d.ts

@@ -0,0 +1,22 @@
+import { Context, EventSender, ErrorDetails } from './interfaces';
+import { StreamEvent } from './stream-event';
+export declare class HandlerContext<Body = any, Response = any> implements Context {
+    private connection;
+    private event;
+    private data;
+    private isSent;
+    private responseHeaders;
+    constructor(connection: EventSender<StreamEvent>, event: StreamEvent);
+    getHeaders(): Record<string, string>;
+    getEvent(): string;
+    getContext<T>(key: string): T;
+    setResponseHeader(key: string, value: string): void;
+    setContext<T = any>(key: string, value: T): void;
+    getBody<T = Body>(): T;
+    setBody(body: Body): void;
+    sendError(body?: ErrorDetails): void;
+    send<T = Response>(body?: T): void;
+    hasSent(): boolean;
+    private validate;
+    private convertErrorToObject;
+}

package/node_modules/@rokt/kit/stream/handler-context.js

@@ -0,0 +1,86 @@
+import { StreamEvent } from './stream-event';
+import { ErrorCodes } from './error-codes';
+export class HandlerContext {
+    constructor(connection, event) {
+        this.connection = connection;
+        this.event = event;
+        this.data = {};
+        this.isSent = false;
+        this.responseHeaders = {};
+    }
+    getHeaders() {
+        return this.event.headers;
+    }
+    getEvent() {
+        return this.event.eventType;
+    }
+    getContext(key) {
+        return this.data[key];
+    }
+    setResponseHeader(key, value) {
+        this.responseHeaders[key] = value;
+    }
+    setContext(key, value) {
+        this.data[key] = value;
+    }
+    getBody() {
+        return this.event.body;
+    }
+    setBody(body) {
+        this.event.body = body;
+    }
+    sendError(body) {
+        this.validate(body);
+        if (body instanceof Error) {
+            body = this.convertErrorToObject(body);
+        }
+        const response = new StreamEvent({
+            ID: this.event.ID,
+            eventType: this.event.eventType,
+            body,
+            headers: this.responseHeaders,
+            hasError: true,
+            isResponse: true,
+        });
+        this.connection.send(response);
+        this.isSent = true;
+    }
+    send(body) {
+        this.validate(body);
+        const response = new StreamEvent({
+            ID: this.event.ID,
+            eventType: this.event.eventType,
+            body,
+            headers: this.responseHeaders,
+            isResponse: true,
+        });
+        this.connection.send(response);
+        this.isSent = true;
+    }
+    hasSent() {
+        return this.isSent;
+    }
+    validate(body) {
+        if (this.isSent === true) {
+            const error = {
+                name: 'HandlerContext.RESPONSE_ALREADY_SENT',
+                message: 'HandlerContext: Response already sent.',
+                code: ErrorCodes.RESPONSE_ALREADY_SENT,
+                additionalInformation: {
+                    response: body,
+                },
+            };
+            throw error;
+        }
+    }
+    convertErrorToObject(err) {
+        return {
+            message: err.message,
+            name: err.name,
+            stack: err.stack,
+            code: err.code,
+            handled: err.handled,
+            additionalInformation: err.additionalInformation,
+        };
+    }
+}

package/node_modules/@rokt/kit/stream/index.barrel.d.ts

@@ -0,0 +1,12 @@
+export * from './interfaces';
+export * from './transmitter';
+export * from './router';
+export * from './create';
+export * from './group';
+export * from './run-handlers';
+export * from './stream-event';
+export * from './engine';
+export * from './async-engine';
+export * from './error-codes';
+export * from './error-middleware';
+export * from './default-headers';

package/node_modules/@rokt/kit/stream/index.barrel.js

@@ -0,0 +1,12 @@
+export * from './interfaces';
+export * from './transmitter';
+export * from './router';
+export * from './create';
+export * from './group';
+export * from './run-handlers';
+export * from './stream-event';
+export * from './engine';
+export * from './async-engine';
+export * from './error-codes';
+export * from './error-middleware';
+export * from './default-headers';

package/node_modules/@rokt/kit/stream/index.d.ts

@@ -0,0 +1,2 @@
+import * as stream from './index.barrel';
+export { stream };

package/node_modules/@rokt/kit/stream/index.js

@@ -0,0 +1,2 @@
+import * as stream from './index.barrel';
+export { stream };

package/node_modules/@rokt/kit/stream/interceptors/index.barrel.d.ts

@@ -0,0 +1 @@
+export * from './location';

package/node_modules/@rokt/kit/stream/interceptors/index.barrel.js

@@ -0,0 +1 @@
+export * from './location';

package/node_modules/@rokt/kit/stream/interceptors/index.d.ts

@@ -0,0 +1,2 @@
+import * as streamInterceptors from './index.barrel';
+export { streamInterceptors };

package/node_modules/@rokt/kit/stream/interceptors/index.js

@@ -0,0 +1,2 @@
+import * as streamInterceptors from './index.barrel';
+export { streamInterceptors };

package/node_modules/@rokt/kit/stream/interceptors/location.d.ts

@@ -0,0 +1,2 @@
+import { stream } from '../index';
+export declare const location: (window: Window) => stream.Interceptor;

package/node_modules/@rokt/kit/stream/interceptors/location.js

@@ -0,0 +1,6 @@
+export const location = (window) => (req) => {
+    if (req.isResponse) {
+        return;
+    }
+    req.headers = Object.assign(Object.assign({}, req.headers), { host: window.location.host, origin: window.location.origin, href: window.location.href, pathname: window.location.pathname });
+};

package/node_modules/@rokt/kit/stream/interfaces.d.ts

@@ -0,0 +1,32 @@
+import { Subscriber } from '../reactive';
+export type ErrorDetails = {
+    name: string;
+    message: string;
+    stack?: string;
+    code?: string;
+    additionalInformation?: Record<string, any>;
+    handled?: boolean;
+};
+export declare const DEFAULT_ALIAS = "No Alias";
+export interface EventSenderReceiver<T = any> extends EventReceiver<T>, EventSender<T> {
+}
+export interface EventReceiver<T = any> {
+    onMessage: Subscriber<T>;
+}
+export interface EventSender<T = any> {
+    send(data: T): void;
+}
+export interface Context<Body = any, Response = any> {
+    getBody<T = Body>(): T;
+    getHeaders(): Record<string, string>;
+    getEvent(): string;
+    getContext<T = any>(key: string): T;
+    setBody(body: Body): void;
+    setContext<T = any>(key: string, value: T): void;
+    setResponseHeader(key: string, value: string): void;
+    send<T = Response>(payload?: T): void;
+    sendError(payload?: ErrorDetails): void;
+    hasSent(): boolean;
+}
+export type HandlerFunc<Body = any, Response = any> = (ctx: Context<Body, Response>, err?: ErrorDetails) => any | Promise<any>;
+export type ErrorHandlerFunc<Body = any, Response = any> = (ctx: Context<Body, Response>, err: ErrorDetails) => any | Promise<any>;

package/node_modules/@rokt/kit/stream/interfaces.js

@@ -0,0 +1 @@
+export const DEFAULT_ALIAS = 'No Alias';

package/node_modules/@rokt/kit/stream/middleware/auto-send.d.ts

@@ -0,0 +1,2 @@
+import { stream } from '../index';
+export declare const autoSend: stream.HandlerFunc;

package/node_modules/@rokt/kit/stream/middleware/auto-send.js

@@ -0,0 +1 @@
+export const autoSend = (ctx) => ctx.send();

package/node_modules/@rokt/kit/stream/middleware/forward-event.d.ts

@@ -0,0 +1,11 @@
+import { stream } from '../index';
+export type ForwardEventHeaders = (typeof ForwardEventHeaders)[keyof typeof ForwardEventHeaders];
+export declare const ForwardEventHeaders: {
+    IsForwarded: string;
+};
+export type IsForwardedHeaderType = (typeof IsForwardedHeaderType)[keyof typeof IsForwardedHeaderType];
+export declare const IsForwardedHeaderType: {
+    True: string;
+    False: string;
+};
+export declare const forwardEvent: (transmitter: stream.ITransmitter, event?: string) => stream.HandlerFunc;

package/node_modules/@rokt/kit/stream/middleware/forward-event.js

@@ -0,0 +1,40 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { DefaultEventHeaders } from '../default-headers';
+import { MiddlewareEventHeaders } from './headers';
+export const ForwardEventHeaders = {
+    IsForwarded: 'is-forwarded',
+};
+export const IsForwardedHeaderType = {
+    True: 'true',
+    False: 'false',
+};
+export const forwardEvent = (transmitter, event) => (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const _a = ctx.getHeaders(), _b = DefaultEventHeaders.SenderAlias, senderAlias = _a[_b], _c = DefaultEventHeaders.SenderId, senderId = _a[_c], headers = __rest(_a, [typeof _b === "symbol" ? _b : _b + "", typeof _c === "symbol" ? _c : _c + ""]);
+    const forwardedFor = {
+        [MiddlewareEventHeaders.OriginalSenderAlias]: senderAlias,
+        [MiddlewareEventHeaders.OriginalSenderId]: senderId,
+    };
+    transmitter.send(event || ctx.getEvent(), {
+        body: ctx.getBody(),
+        headers: Object.assign(Object.assign({ [ForwardEventHeaders.IsForwarded]: IsForwardedHeaderType.True }, forwardedFor), headers),
+    });
+});

package/node_modules/@rokt/kit/stream/middleware/headers.d.ts

@@ -0,0 +1,5 @@
+export type MiddlewareEventHeaders = (typeof MiddlewareEventHeaders)[keyof typeof MiddlewareEventHeaders];
+export declare const MiddlewareEventHeaders: {
+    OriginalSenderAlias: string;
+    OriginalSenderId: string;
+};

package/node_modules/@rokt/kit/stream/middleware/headers.js

@@ -0,0 +1,4 @@
+export const MiddlewareEventHeaders = {
+    OriginalSenderAlias: 'original-sender-alias',
+    OriginalSenderId: 'original-sender-id',
+};

package/node_modules/@rokt/kit/stream/middleware/index.barrel.d.ts

@@ -0,0 +1,5 @@
+export * from './auto-send';
+export * from './forward-event';
+export * from './location';
+export * from './proxy-event';
+export * from './headers';

package/node_modules/@rokt/kit/stream/middleware/index.barrel.js

@@ -0,0 +1,5 @@
+export * from './auto-send';
+export * from './forward-event';
+export * from './location';
+export * from './proxy-event';
+export * from './headers';

package/node_modules/@rokt/kit/stream/middleware/index.d.ts

@@ -0,0 +1,3 @@
+import * as streamMiddleware from './index.barrel';
+export * from './index.barrel';
+export { streamMiddleware };

package/node_modules/@rokt/kit/stream/middleware/index.js

@@ -0,0 +1,3 @@
+import * as streamMiddleware from './index.barrel';
+export * from './index.barrel';
+export { streamMiddleware };

package/node_modules/@rokt/kit/stream/middleware/location.d.ts

@@ -0,0 +1,2 @@
+import { stream } from '../index';
+export declare const location: (window: Window) => stream.HandlerFunc;

package/node_modules/@rokt/kit/stream/middleware/location.js

@@ -0,0 +1,6 @@
+export const location = (window) => (ctx) => {
+    ctx.setResponseHeader('origin', window.location.origin);
+    ctx.setResponseHeader('host', window.location.host);
+    ctx.setResponseHeader('href', window.location.href);
+    ctx.setResponseHeader('pathname', window.location.pathname);
+};

package/node_modules/@rokt/kit/stream/middleware/proxy-event.d.ts

@@ -0,0 +1,11 @@
+import { stream } from '../index';
+export type ProxyEventHeaders = (typeof ProxyEventHeaders)[keyof typeof ProxyEventHeaders];
+export declare const ProxyEventHeaders: {
+    IsProxied: string;
+};
+export type IsProxiedHeaderType = (typeof IsProxiedHeaderType)[keyof typeof IsProxiedHeaderType];
+export declare const IsProxiedHeaderType: {
+    True: string;
+    False: string;
+};
+export declare const proxyEvent: (transmitter: stream.ITransmitter, event?: string) => stream.HandlerFunc;

package/node_modules/@rokt/kit/stream/middleware/proxy-event.js

@@ -0,0 +1,49 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { DefaultEventHeaders } from '../default-headers';
+import { MiddlewareEventHeaders } from './headers';
+export const ProxyEventHeaders = {
+    IsProxied: 'is-proxied',
+};
+export const IsProxiedHeaderType = {
+    True: 'true',
+    False: 'false',
+};
+export const proxyEvent = (transmitter, event) => (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const _a = ctx.getHeaders(), _b = DefaultEventHeaders.SenderAlias, senderAlias = _a[_b], _c = DefaultEventHeaders.SenderId, senderId = _a[_c], headers = __rest(_a, [typeof _b === "symbol" ? _b : _b + "", typeof _c === "symbol" ? _c : _c + ""]);
+        const forwardedFor = {
+            [MiddlewareEventHeaders.OriginalSenderAlias]: senderAlias,
+            [MiddlewareEventHeaders.OriginalSenderId]: senderId,
+        };
+        const result = yield transmitter.send(event || ctx.getEvent(), {
+            body: ctx.getBody(),
+            headers: Object.assign(Object.assign({ [ProxyEventHeaders.IsProxied]: IsProxiedHeaderType.True }, forwardedFor), headers),
+        });
+        for (const [name, value] of Object.entries(result.headers)) {
+            ctx.setResponseHeader(name, value);
+        }
+        ctx.send(result.body);
+    }
+    catch (error) {
+        ctx.sendError(error);
+    }
+});

package/node_modules/@rokt/kit/stream/router.d.ts

@@ -0,0 +1,31 @@
+import { Group } from './group';
+import { Context, EventSenderReceiver, HandlerFunc } from './interfaces';
+import { StreamEvent } from './stream-event';
+export declare const getRouterName: (ctx: Context) => any;
+export type RouterError = (typeof RouterError)[keyof typeof RouterError];
+export declare const RouterError: {
+    readonly HandlerExists: "HandlerExists";
+};
+type RouterOptions = {
+    connection: EventSenderReceiver<StreamEvent>;
+    alias?: string;
+    id?: string;
+};
+export declare class Router implements IRouter {
+    private options;
+    private connection;
+    private subscription;
+    private handlers;
+    private middleware;
+    constructor(options: RouterOptions);
+    use(middleware: HandlerFunc | Group): void;
+    on(event: string, ...handlers: Array<HandlerFunc>): void;
+    close(): void;
+    private onMessage;
+}
+export interface IRouter {
+    use(middleware: HandlerFunc | Group): void;
+    on(event: string, ...handlers: Array<HandlerFunc>): void;
+    close(): void;
+}
+export {};

package/node_modules/@rokt/kit/stream/router.js

@@ -0,0 +1,44 @@
+import { Subscription } from '../reactive';
+import { pipe, filter } from '../reactive/operators';
+import { Group } from './group';
+import { HandlerContext } from './handler-context';
+import { runHandlers } from './run-handlers';
+const ROUTER_NAME_KEY = 'router-name';
+export const getRouterName = (ctx) => ctx.getContext(ROUTER_NAME_KEY);
+export const RouterError = {
+    HandlerExists: 'HandlerExists',
+};
+export class Router {
+    constructor(options) {
+        this.options = options;
+        this.onMessage = (handlers) => (msg) => {
+            const ctx = new HandlerContext(this.connection, msg);
+            return runHandlers(ctx, ...this.middleware, ...handlers);
+        };
+        this.connection = this.options.connection;
+        this.subscription = new Subscription();
+        this.handlers = [];
+        this.middleware = [];
+    }
+    use(middleware) {
+        if (middleware instanceof Group) {
+            const routerHandlers = middleware.getHandlers();
+            for (const [event, handlers] of Object.entries(routerHandlers)) {
+                this.on(event, ...handlers);
+            }
+            return;
+        }
+        this.middleware.push(middleware);
+    }
+    on(event, ...handlers) {
+        if (this.handlers.includes(event)) {
+            throw new Error(RouterError.HandlerExists);
+        }
+        this.handlers.push(event);
+        const onEvent = pipe(this.connection.onMessage)(filter((e) => e.eventType === event));
+        this.subscription.add(onEvent.subscribe(this.onMessage(handlers)));
+    }
+    close() {
+        this.subscription.unsubscribe();
+    }
+}

package/node_modules/@rokt/kit/stream/run-handlers.d.ts

@@ -0,0 +1,2 @@
+import { Context, HandlerFunc } from './interfaces';
+export declare const runHandlers: (initialContext: Context, ...handlers: Array<HandlerFunc>) => Promise<void>;