@cspell/cspell-service-bus 6.19.1 → 6.20.0

package/dist/{Dispatcher.d.ts → cjs/Dispatcher.d.ts}

@@ -1,4 +1,4 @@
-import type { RequestResponseType, ServiceRequest } from './request';
+import type { RequestResponseType, ServiceRequest } from './request.js';
 export interface Dispatcher {
     dispatch<R extends ServiceRequest>(request: R): RequestResponseType<R>;
 }

package/dist/{ServiceRequestFactory.d.ts → cjs/ServiceRequestFactory.d.ts}

@@ -1,5 +1,5 @@
-import type { Handler, HandleRequestFn } from './handlers';
-import type { ServiceRequest } from './request';
+import type { Handler, HandleRequestFn } from './handlers.js';
+import type { ServiceRequest } from './request.js';
 export interface ServiceRequestFactory<R extends ServiceRequest, P = R['params'], T extends string = R['type']> {
     type: T;
     is: (r: ServiceRequest | R) => r is R;

package/dist/{SystemServiceBus.d.ts → cjs/SystemServiceBus.d.ts}

@@ -1,7 +1,7 @@
-import type { Dispatcher } from './Dispatcher';
-import type { Handler, HandleRequestFn } from './handlers';
-import type { ServiceRequest } from './request';
-import type { ServiceRequestFactory } from './ServiceRequestFactory';
+import type { Dispatcher } from './Dispatcher.js';
+import type { Handler, HandleRequestFn } from './handlers.js';
+import type { ServiceRequest } from './request.js';
+import type { ServiceRequestFactory } from './ServiceRequestFactory.js';
 export interface SystemServiceBus extends Dispatcher {
     registerHandler(requestPrefix: string, handler: Handler): this;
     registerRequestHandler<T extends ServiceRequest>(requestDef: ServiceRequestFactory<T>, fn: HandleRequestFn<T>, name?: string | undefined, description?: string | undefined): this;

package/dist/{bus.d.ts → cjs/bus.d.ts}

@@ -1,13 +1,13 @@
-import type { Dispatcher } from './Dispatcher';
-import type { Handler, HandleRequest, HandlerFn } from './handlers';
-import type { RequestResponseType, ServiceRequest } from './request';
+import type { Dispatcher } from './Dispatcher.js';
+import type { Handler, HandleRequest, HandlerFn } from './handlers.js';
+import type { RequestResponseType, ServiceRequest } from './request.js';
 export declare class ServiceBus implements Dispatcher {
     readonly handlers: Handler[];
     constructor(handlers?: Handler[]);
     addHandler(handler: HandlerFn, name: string, description?: string): this;
     addHandler(handler: Handler): this;
     dispatch<R extends ServiceRequest>(request: R): RequestResponseType<R>;
-    defaultHandler<T extends ServiceRequest>(request: T): import("./request").ServiceResponseFailure<RequestResponseType<T> extends infer T_1 ? T_1 extends RequestResponseType<T> ? T_1 extends {
+    defaultHandler<T extends ServiceRequest>(request: T): import("./request.js").ServiceResponseFailure<RequestResponseType<T> extends infer T_1 ? T_1 extends RequestResponseType<T> ? T_1 extends {
         ___T?: infer R;
     } ? R : never : never : never>;
     protected reduceHandlers<R extends ServiceRequest>(handlers: readonly Handler[], request: R, dispatcher: Dispatcher, defaultHandler: HandleRequest): HandleRequest;

package/dist/{createRequestHandler.d.ts → cjs/createRequestHandler.d.ts}

@@ -1,6 +1,6 @@
-import type { Handler, HandleRequestFn, HandlerFn } from './handlers';
-import type { IsARequest, ServiceRequest } from './request';
-import type { ServiceRequestFactory } from './ServiceRequestFactory';
+import type { Handler, HandleRequestFn, HandlerFn } from './handlers.js';
+import type { IsARequest, ServiceRequest } from './request.js';
+import type { ServiceRequestFactory } from './ServiceRequestFactory.js';
 export declare function createRequestHandler<T extends ServiceRequest>(requestDef: ServiceRequestFactory<T>, fn: HandleRequestFn<T>, name?: string, description?: string): Handler;
 export declare function createIsRequestHandlerFn<T extends ServiceRequest>(isA: IsARequest<T>, fn: HandleRequestFn<T>): HandlerFn;
 export declare function createIsRequestHandler<T extends ServiceRequest>(isA: IsARequest<T>, fn: HandleRequestFn<T>, name: string, description?: string): Handler;

package/dist/{errors.d.ts → cjs/errors.d.ts}

@@ -1,4 +1,4 @@
-import type { ServiceRequest } from './request';
+import type { ServiceRequest } from './request.js';
 export declare class ErrorUnhandledRequest extends Error {
     readonly request: ServiceRequest;
     constructor(request: ServiceRequest);

package/dist/{handlers.d.ts → cjs/handlers.d.ts}

@@ -1,6 +1,6 @@
-import type { Dispatcher } from './Dispatcher';
-import type { RequestResponseType, ServiceRequest } from './request';
-import type { ServiceRequestFactory, ServiceRequestFactoryRequestType } from './ServiceRequestFactory';
+import type { Dispatcher } from './Dispatcher.js';
+import type { RequestResponseType, ServiceRequest } from './request.js';
+import type { ServiceRequestFactory, ServiceRequestFactoryRequestType } from './ServiceRequestFactory.js';
 export type HandleRequestFn<R extends ServiceRequest> = (request: R, next: HandleRequest, dispatch: Dispatcher) => RequestResponseType<R>;
 export interface HandleRequest {
     <R extends ServiceRequest>(request: R): any;

package/dist/cjs/index.cjs

@@ -0,0 +1,142 @@
+'use strict';
+
+class ErrorUnhandledRequest extends Error {
+    constructor(request) {
+        super(`Unhandled Request: ${request.type}`);
+        this.request = request;
+    }
+}
+class ErrorServiceRequestDepthExceeded extends Error {
+    constructor(request, depth) {
+        super(`Service Request Depth ${depth} Exceeded: ${request.type}`);
+        this.request = request;
+        this.depth = depth;
+    }
+}
+class UnhandledHandlerError extends Error {
+    constructor(handlerName, handlerDescription, cause) {
+        super(`Unhandled Error in Handler: ${handlerName}`);
+        this.handlerName = handlerName;
+        this.handlerDescription = handlerDescription;
+        this.cause = cause;
+    }
+}
+
+class BaseServiceRequest {
+    constructor(type, params) {
+        this.type = type;
+        this.params = params;
+    }
+}
+class ServiceRequestCls extends BaseServiceRequest {
+    constructor(type, params) {
+        super(type, params);
+    }
+}
+function createResponse(value, _req) {
+    return { value };
+}
+function createResponseFail(_request, error) {
+    return { error };
+}
+function isServiceResponseSuccess(res) {
+    return 'value' in res && res.error === undefined;
+}
+function isServiceResponseFailure(res) {
+    return res.error !== undefined;
+}
+
+const MAX_DEPTH = 10;
+class ServiceBus {
+    constructor(handlers = []) {
+        this.handlers = [];
+        handlers.forEach((h) => this.addHandler(h));
+    }
+    addHandler(handler, name = 'anonymous', description) {
+        const h = typeof handler === 'function' ? { fn: handler, name, description } : handler;
+        const { fn, name: _name, description: _description } = h;
+        this.handlers.push({ fn, name: _name, description: _description });
+        return this;
+    }
+    dispatch(request) {
+        let depth = 0;
+        const dispatcher = { dispatch };
+        const handler = this.reduceHandlers(this.handlers, request, dispatcher, this.defaultHandler);
+        function dispatch(request) {
+            ++depth;
+            if (depth >= MAX_DEPTH) {
+                return createResponseFail(request, new ErrorServiceRequestDepthExceeded(request, depth));
+            }
+            const response = handler(request);
+            --depth;
+            return response;
+        }
+        return dispatch(request);
+    }
+    defaultHandler(request) {
+        return createResponseFail(request, new ErrorUnhandledRequest(request));
+    }
+    reduceHandlers(handlers, request, dispatcher, defaultHandler) {
+        const _handlers = handlers.map((m) => ({ ...m, fn: m.fn(dispatcher) }));
+        const handler = _handlers.reduce((next, h) => {
+            const fn = h.fn(next);
+            return (req) => {
+                try {
+                    return fn(req);
+                }
+                catch (e) {
+                    return createResponseFail(request, new UnhandledHandlerError(h.name, h.description, e));
+                }
+            };
+        }, defaultHandler);
+        return handler;
+    }
+}
+function createServiceBus(handlers = []) {
+    return new ServiceBus(handlers);
+}
+
+function createRequestHandler(requestDef, fn, name, description) {
+    return createIsRequestHandler(requestDef.is, fn, name ?? requestDef.type, description);
+}
+function createIsRequestHandlerFn(isA, fn) {
+    return (dispatcher) => (next) => (request) => isA(request) ? fn(request, next, dispatcher) : next(request);
+}
+function createIsRequestHandler(isA, fn, name, description) {
+    return {
+        fn: createIsRequestHandlerFn(isA, fn),
+        name,
+        description,
+    };
+}
+
+function requestFactory(requestType) {
+    class RequestClass extends ServiceRequestCls {
+        constructor(params) {
+            super(requestType, params);
+        }
+        static is(req) {
+            return req instanceof RequestClass && req.type === requestType;
+        }
+        static create(params) {
+            return new RequestClass(params);
+        }
+        static createRequestHandler(fn, name, description) {
+            return createRequestHandler(RequestClass, fn, name, description);
+        }
+    }
+    RequestClass.type = requestType;
+    return RequestClass;
+}
+
+exports.ServiceBus = ServiceBus;
+exports.ServiceRequestCls = ServiceRequestCls;
+exports.createIsRequestHandler = createIsRequestHandler;
+exports.createRequestHandler = createRequestHandler;
+exports.createResponse = createResponse;
+exports.createResponseFail = createResponseFail;
+exports.createServiceBus = createServiceBus;
+exports.isServiceResponseFailure = isServiceResponseFailure;
+exports.isServiceResponseSuccess = isServiceResponseSuccess;
+exports.requestFactory = requestFactory;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.d.ts

@@ -0,0 +1,9 @@
+export { createServiceBus, ServiceBus } from './bus.js';
+export { createIsRequestHandler, createRequestHandler } from './createRequestHandler.js';
+export { Dispatcher } from './Dispatcher.js';
+export type { Handler } from './handlers.js';
+export type { ServiceRequest } from './request.js';
+export { createResponse, createResponseFail, isServiceResponseFailure, isServiceResponseSuccess, ServiceRequestCls, ServiceResponse, } from './request.js';
+export { requestFactory } from './requestFactory.js';
+export type { ServiceRequestFactory, ServiceRequestFactoryRequestType } from './ServiceRequestFactory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/{request.d.ts → cjs/request.d.ts}

@@ -9,7 +9,7 @@ declare class BaseServiceRequest<T extends string, P, R> implements ServiceReque
     readonly __r?: ServiceResponseBase<R>;
     constructor(type: T, params: P);
 }
-export declare class ServiceRequest<T extends string, P, R> extends BaseServiceRequest<T, P, R> {
+export declare class ServiceRequestCls<T extends string, P, R> extends BaseServiceRequest<T, P, R> {
     constructor(type: T, params: P);
 }
 interface ServiceResponseBase<T> {

package/dist/{requestFactory.d.ts → cjs/requestFactory.d.ts}

@@ -1,4 +1,4 @@
-import { ServiceRequest } from './request';
-import type { ServiceRequestFactory } from './ServiceRequestFactory';
+import type { ServiceRequest } from './request.js';
+import type { ServiceRequestFactory } from './ServiceRequestFactory.js';
 export declare function requestFactory<T extends string, P, R>(requestType: T): ServiceRequestFactory<ServiceRequest<T, P, R>>;
 //# sourceMappingURL=requestFactory.d.ts.map

package/dist/esm/Dispatcher.d.ts

@@ -0,0 +1,5 @@
+import type { RequestResponseType, ServiceRequest } from './request.js';
+export interface Dispatcher {
+    dispatch<R extends ServiceRequest>(request: R): RequestResponseType<R>;
+}
+//# sourceMappingURL=Dispatcher.d.ts.map

package/dist/esm/Dispatcher.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Dispatcher.js.map

package/dist/esm/ServiceRequestFactory.d.ts

@@ -0,0 +1,16 @@
+import type { Handler, HandleRequestFn } from './handlers.js';
+import type { ServiceRequest } from './request.js';
+export interface ServiceRequestFactory<R extends ServiceRequest, P = R['params'], T extends string = R['type']> {
+    type: T;
+    is: (r: ServiceRequest | R) => r is R;
+    create(params: P): R;
+    createRequestHandler(fn: HandleRequestFn<R>, name?: string, description?: string): Handler;
+    /**
+     * Place holder property used to determine the request type. It is NEVER set.
+     */
+    __request?: R;
+}
+export type ServiceRequestFactoryRequestType<T> = T extends {
+    __request?: infer R;
+} ? R : never;
+//# sourceMappingURL=ServiceRequestFactory.d.ts.map

package/dist/esm/ServiceRequestFactory.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ServiceRequestFactory.js.map

package/dist/esm/SystemServiceBus.d.ts

@@ -0,0 +1,33 @@
+import type { Dispatcher } from './Dispatcher.js';
+import type { Handler, HandleRequestFn } from './handlers.js';
+import type { ServiceRequest } from './request.js';
+import type { ServiceRequestFactory } from './ServiceRequestFactory.js';
+export interface SystemServiceBus extends Dispatcher {
+    registerHandler(requestPrefix: string, handler: Handler): this;
+    registerRequestHandler<T extends ServiceRequest>(requestDef: ServiceRequestFactory<T>, fn: HandleRequestFn<T>, name?: string | undefined, description?: string | undefined): this;
+    createSubsystem(name: string, requestPattern: string | RegExp): SubsystemServiceBus;
+    readonly subsystems: Map<string, SubsystemServiceBus>;
+}
+export declare function createSystemServiceBus(): SystemServiceBus;
+export declare const RequestRegisterHandlerFactory: ServiceRequestFactory<ServiceRequest<"System:RegisterHandler", {
+    readonly requestPrefix: string;
+    readonly handler: Handler;
+}, SubsystemServiceBus>, {
+    readonly requestPrefix: string;
+    readonly handler: Handler;
+}, "System:RegisterHandler">;
+export declare const RequestCreateSubsystemFactory: ServiceRequestFactory<ServiceRequest<"System:CreateSubsystem", {
+    readonly name: string;
+    readonly requestPattern: string | RegExp;
+}, SubsystemServiceBus>, {
+    readonly name: string;
+    readonly requestPattern: string | RegExp;
+}, "System:CreateSubsystem">;
+interface SubsystemServiceBus extends Dispatcher {
+    readonly name: string;
+    readonly requestPattern: string | RegExp;
+    readonly handler: Handler;
+}
+export declare function createSubsystemServiceBus(name: string, requestPattern: string | RegExp): SubsystemServiceBus;
+export {};
+//# sourceMappingURL=SystemServiceBus.d.ts.map

package/dist/{SystemServiceBus.js → esm/SystemServiceBus.js}

@@ -1,61 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSubsystemServiceBus = exports.RequestCreateSubsystemFactory = exports.RequestRegisterHandlerFactory = exports.createSystemServiceBus = void 0;
-const assert_1 = require("./assert");
-const bus_1 = require("./bus");
-const createRequestHandler_1 = require("./createRequestHandler");
-const errors_1 = require("./errors");
-const request_1 = require("./request");
-const requestFactory_1 = require("./requestFactory");
+import { assert } from './assert.js';
+import { createServiceBus, ServiceBus } from './bus.js';
+import { createRequestHandler } from './createRequestHandler.js';
+import { ErrorDuplicateSubsystem } from './errors.js';
+import { createResponse } from './request.js';
+import { requestFactory } from './requestFactory.js';
 class SystemServiceBusImpl {
     constructor() {
-        this.serviceBus = (0, bus_1.createServiceBus)();
+        this.serviceBus = createServiceBus();
         this._subsystems = new Map();
         this.bindDefaultHandlers();
         this.createSubsystem('Default Subsystem', '' /* match everything */);
     }
     bindDefaultHandlers() {
-        this.serviceBus.addHandler((0, createRequestHandler_1.createRequestHandler)(exports.RequestCreateSubsystemFactory, (req) => {
+        this.serviceBus.addHandler(createRequestHandler(RequestCreateSubsystemFactory, (req) => {
             const { name, requestPattern } = req.params;
             if (this._subsystems.has(name)) {
-                throw new errors_1.ErrorDuplicateSubsystem(name);
+                throw new ErrorDuplicateSubsystem(name);
             }
             const sub = createSubsystemServiceBus(name, requestPattern);
             this._subsystems.set(name, sub);
             this.serviceBus.addHandler(sub.handler);
-            return (0, request_1.createResponse)(sub);
+            return createResponse(sub);
         }));
     }
     dispatch(request) {
         return this.serviceBus.dispatch(request);
     }
     createSubsystem(name, requestPattern) {
-        const res = this.dispatch(exports.RequestCreateSubsystemFactory.create({ name, requestPattern }));
-        (0, assert_1.assert)(res?.value);
+        const res = this.dispatch(RequestCreateSubsystemFactory.create({ name, requestPattern }));
+        assert(res?.value);
         return res.value;
     }
     registerHandler(requestPrefix, handler) {
-        const request = exports.RequestRegisterHandlerFactory.create({ requestPrefix, handler });
+        const request = RequestRegisterHandlerFactory.create({ requestPrefix, handler });
         this.serviceBus.dispatch(request);
         return this;
     }
     registerRequestHandler(requestDef, fn, name, description) {
-        this.registerHandler(requestDef.type, (0, createRequestHandler_1.createRequestHandler)(requestDef, fn, name, description));
+        this.registerHandler(requestDef.type, createRequestHandler(requestDef, fn, name, description));
         return this;
     }
     get subsystems() {
         return new Map(this._subsystems);
     }
 }
-function createSystemServiceBus() {
+export function createSystemServiceBus() {
     return new SystemServiceBusImpl();
 }
-exports.createSystemServiceBus = createSystemServiceBus;
 const TypeRequestRegisterHandler = 'System:RegisterHandler';
-exports.RequestRegisterHandlerFactory = (0, requestFactory_1.requestFactory)(TypeRequestRegisterHandler);
+export const RequestRegisterHandlerFactory = requestFactory(TypeRequestRegisterHandler);
 const TypeRequestCreateSubsystem = 'System:CreateSubsystem';
-exports.RequestCreateSubsystemFactory = (0, requestFactory_1.requestFactory)(TypeRequestCreateSubsystem);
-class SubsystemServiceBusImpl extends bus_1.ServiceBus {
+export const RequestCreateSubsystemFactory = requestFactory(TypeRequestCreateSubsystem);
+class SubsystemServiceBusImpl extends ServiceBus {
     constructor(name, requestPattern) {
         super();
         this.name = name;
@@ -64,7 +60,7 @@ class SubsystemServiceBusImpl extends bus_1.ServiceBus {
             typeof requestPattern === 'string'
                 ? (reqType) => reqType.startsWith(requestPattern)
                 : (reqType) => requestPattern.test(reqType);
-        const handleRegistration = (0, createRequestHandler_1.createRequestHandler)(exports.RequestRegisterHandlerFactory, (req, next) => this.handleRegistrationReq(req, next), 'Subsystem Register Handlers for ' + name, `Matches against: <${requestPattern.toString()}>`);
+        const handleRegistration = createRequestHandler(RequestRegisterHandlerFactory, (req, next) => this.handleRegistrationReq(req, next), 'Subsystem Register Handlers for ' + name, `Matches against: <${requestPattern.toString()}>`);
         this.addHandler(handleRegistration);
         this.handler = {
             name: 'Subsystem: ' + name,
@@ -80,19 +76,18 @@ class SubsystemServiceBusImpl extends bus_1.ServiceBus {
         }
         // console.log(`${this.name}.handleRegistrationReq add ***`);
         this.addHandler(request.params.handler);
-        return (0, request_1.createResponse)(this);
+        return createResponse(this);
     }
     _handler(dispatcher) {
         return (next) => (req) => {
-            if (!this.canHandleType(req.type) && !exports.RequestRegisterHandlerFactory.is(req))
+            if (!this.canHandleType(req.type) && !RequestRegisterHandlerFactory.is(req))
                 return next(req);
             const dispatch = this.reduceHandlers(this.handlers, req, dispatcher, next);
             return dispatch(req);
         };
     }
 }
-function createSubsystemServiceBus(name, requestPattern) {
+export function createSubsystemServiceBus(name, requestPattern) {
     return new SubsystemServiceBusImpl(name, requestPattern);
 }
-exports.createSubsystemServiceBus = createSubsystemServiceBus;
 //# sourceMappingURL=SystemServiceBus.js.map

package/dist/esm/assert.d.ts

@@ -0,0 +1,2 @@
+export declare function assert(value: unknown, message?: string | Error): asserts value;
+//# sourceMappingURL=assert.d.ts.map

package/dist/esm/assert.js

@@ -0,0 +1,7 @@
+export function assert(value, message) {
+    if (!value) {
+        const err = message instanceof Error ? message : Error(message ?? 'AssertionError');
+        throw err;
+    }
+}
+//# sourceMappingURL=assert.js.map

package/dist/esm/bus.d.ts

@@ -0,0 +1,16 @@
+import type { Dispatcher } from './Dispatcher.js';
+import type { Handler, HandleRequest, HandlerFn } from './handlers.js';
+import type { RequestResponseType, ServiceRequest } from './request.js';
+export declare class ServiceBus implements Dispatcher {
+    readonly handlers: Handler[];
+    constructor(handlers?: Handler[]);
+    addHandler(handler: HandlerFn, name: string, description?: string): this;
+    addHandler(handler: Handler): this;
+    dispatch<R extends ServiceRequest>(request: R): RequestResponseType<R>;
+    defaultHandler<T extends ServiceRequest>(request: T): import("./request.js").ServiceResponseFailure<RequestResponseType<T> extends infer T_1 ? T_1 extends RequestResponseType<T> ? T_1 extends {
+        ___T?: infer R;
+    } ? R : never : never : never>;
+    protected reduceHandlers<R extends ServiceRequest>(handlers: readonly Handler[], request: R, dispatcher: Dispatcher, defaultHandler: HandleRequest): HandleRequest;
+}
+export declare function createServiceBus(handlers?: Handler[]): ServiceBus;
+//# sourceMappingURL=bus.d.ts.map

package/dist/{bus.js → esm/bus.js}

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createServiceBus = exports.ServiceBus = void 0;
-const errors_1 = require("./errors");
-const request_1 = require("./request");
+import { ErrorServiceRequestDepthExceeded, ErrorUnhandledRequest, UnhandledHandlerError } from './errors.js';
+import { createResponseFail } from './request.js';
 const MAX_DEPTH = 10;
-class ServiceBus {
+export class ServiceBus {
     constructor(handlers = []) {
         this.handlers = [];
         handlers.forEach((h) => this.addHandler(h));
@@ -22,7 +19,7 @@ class ServiceBus {
         function dispatch(request) {
             ++depth;
             if (depth >= MAX_DEPTH) {
-                return (0, request_1.createResponseFail)(request, new errors_1.ErrorServiceRequestDepthExceeded(request, depth));
+                return createResponseFail(request, new ErrorServiceRequestDepthExceeded(request, depth));
             }
             const response = handler(request);
             --depth;
@@ -31,7 +28,7 @@ class ServiceBus {
         return dispatch(request);
     }
     defaultHandler(request) {
-        return (0, request_1.createResponseFail)(request, new errors_1.ErrorUnhandledRequest(request));
+        return createResponseFail(request, new ErrorUnhandledRequest(request));
     }
     reduceHandlers(handlers, request, dispatcher, defaultHandler) {
         const _handlers = handlers.map((m) => ({ ...m, fn: m.fn(dispatcher) }));
@@ -42,16 +39,14 @@ class ServiceBus {
                     return fn(req);
                 }
                 catch (e) {
-                    return (0, request_1.createResponseFail)(request, new errors_1.UnhandledHandlerError(h.name, h.description, e));
+                    return createResponseFail(request, new UnhandledHandlerError(h.name, h.description, e));
                 }
             };
         }, defaultHandler);
         return handler;
     }
 }
-exports.ServiceBus = ServiceBus;
-function createServiceBus(handlers = []) {
+export function createServiceBus(handlers = []) {
     return new ServiceBus(handlers);
 }
-exports.createServiceBus = createServiceBus;
 //# sourceMappingURL=bus.js.map

package/dist/esm/createRequestHandler.d.ts

@@ -0,0 +1,7 @@
+import type { Handler, HandleRequestFn, HandlerFn } from './handlers.js';
+import type { IsARequest, ServiceRequest } from './request.js';
+import type { ServiceRequestFactory } from './ServiceRequestFactory.js';
+export declare function createRequestHandler<T extends ServiceRequest>(requestDef: ServiceRequestFactory<T>, fn: HandleRequestFn<T>, name?: string, description?: string): Handler;
+export declare function createIsRequestHandlerFn<T extends ServiceRequest>(isA: IsARequest<T>, fn: HandleRequestFn<T>): HandlerFn;
+export declare function createIsRequestHandler<T extends ServiceRequest>(isA: IsARequest<T>, fn: HandleRequestFn<T>, name: string, description?: string): Handler;
+//# sourceMappingURL=createRequestHandler.d.ts.map

package/dist/esm/createRequestHandler.js

@@ -0,0 +1,14 @@
+export function createRequestHandler(requestDef, fn, name, description) {
+    return createIsRequestHandler(requestDef.is, fn, name ?? requestDef.type, description);
+}
+export function createIsRequestHandlerFn(isA, fn) {
+    return (dispatcher) => (next) => (request) => isA(request) ? fn(request, next, dispatcher) : next(request);
+}
+export function createIsRequestHandler(isA, fn, name, description) {
+    return {
+        fn: createIsRequestHandlerFn(isA, fn),
+        name,
+        description,
+    };
+}
+//# sourceMappingURL=createRequestHandler.js.map

package/dist/esm/errors.d.ts

@@ -0,0 +1,21 @@
+import type { ServiceRequest } from './request.js';
+export declare class ErrorUnhandledRequest extends Error {
+    readonly request: ServiceRequest;
+    constructor(request: ServiceRequest);
+}
+export declare class ErrorServiceRequestDepthExceeded extends Error {
+    readonly request: ServiceRequest;
+    readonly depth: number;
+    constructor(request: ServiceRequest, depth: number);
+}
+export declare class UnhandledHandlerError extends Error {
+    readonly handlerName: string;
+    readonly handlerDescription: string | undefined;
+    readonly cause: unknown;
+    constructor(handlerName: string, handlerDescription: string | undefined, cause: unknown);
+}
+export declare class ErrorDuplicateSubsystem extends Error {
+    readonly subsystemName: string;
+    constructor(subsystemName: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/esm/errors.js

@@ -0,0 +1,28 @@
+export class ErrorUnhandledRequest extends Error {
+    constructor(request) {
+        super(`Unhandled Request: ${request.type}`);
+        this.request = request;
+    }
+}
+export class ErrorServiceRequestDepthExceeded extends Error {
+    constructor(request, depth) {
+        super(`Service Request Depth ${depth} Exceeded: ${request.type}`);
+        this.request = request;
+        this.depth = depth;
+    }
+}
+export class UnhandledHandlerError extends Error {
+    constructor(handlerName, handlerDescription, cause) {
+        super(`Unhandled Error in Handler: ${handlerName}`);
+        this.handlerName = handlerName;
+        this.handlerDescription = handlerDescription;
+        this.cause = cause;
+    }
+}
+export class ErrorDuplicateSubsystem extends Error {
+    constructor(subsystemName) {
+        super(`Duplicate subsystem: ${subsystemName}`);
+        this.subsystemName = subsystemName;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/esm/handlers.d.ts

@@ -0,0 +1,30 @@
+import type { Dispatcher } from './Dispatcher.js';
+import type { RequestResponseType, ServiceRequest } from './request.js';
+import type { ServiceRequestFactory, ServiceRequestFactoryRequestType } from './ServiceRequestFactory.js';
+export type HandleRequestFn<R extends ServiceRequest> = (request: R, next: HandleRequest, dispatch: Dispatcher) => RequestResponseType<R>;
+export interface HandleRequest {
+    <R extends ServiceRequest>(request: R): any;
+}
+export interface HandleRequestKnown<R extends ServiceRequest> {
+    (request: R): RequestResponseType<R>;
+}
+export type FactoryRequestHandler<T extends ServiceRequestFactory<ServiceRequest>, R extends ServiceRequest = ServiceRequestFactoryRequestType<T>> = HandleRequestKnown<R>;
+export interface HandlerNext {
+    (next: HandleRequest): HandleRequest;
+}
+export interface HandlerFn {
+    (dispatcher: Dispatcher): HandlerNext;
+}
+export interface Handler {
+    /**
+     * Name of the Handler.
+     * Useful for debugging and uncaught exceptions.
+     */
+    readonly name: string;
+    /**
+     * Optional description of the Handler.
+     */
+    readonly description?: string | undefined;
+    readonly fn: HandlerFn;
+}
+//# sourceMappingURL=handlers.d.ts.map

package/dist/esm/handlers.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=handlers.js.map

package/dist/esm/index.d.ts

@@ -0,0 +1,9 @@
+export { createServiceBus, ServiceBus } from './bus.js';
+export { createIsRequestHandler, createRequestHandler } from './createRequestHandler.js';
+export { Dispatcher } from './Dispatcher.js';
+export type { Handler } from './handlers.js';
+export type { ServiceRequest } from './request.js';
+export { createResponse, createResponseFail, isServiceResponseFailure, isServiceResponseSuccess, ServiceRequestCls, ServiceResponse, } from './request.js';
+export { requestFactory } from './requestFactory.js';
+export type { ServiceRequestFactory, ServiceRequestFactoryRequestType } from './ServiceRequestFactory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export { createServiceBus, ServiceBus } from './bus.js';
+export { createIsRequestHandler, createRequestHandler } from './createRequestHandler.js';
+export { createResponse, createResponseFail, isServiceResponseFailure, isServiceResponseSuccess, ServiceRequestCls, } from './request.js';
+export { requestFactory } from './requestFactory.js';
+//# sourceMappingURL=index.js.map