@nmtjs/protocol 0.13.1 → 0.14.0

package/dist/client/protocol.d.ts

@@ -1,9 +1,9 @@
-import { type InteractivePromise, type OneOf } from '@nmtjs/common';
+import type { InteractivePromise, OneOf } from '@nmtjs/common';
 import type { ProtocolBlobMetadata } from '../common/blob.ts';
+import type { BaseProtocolError, ProtocolRPCResponse } from '../common/types.ts';
+import type { BaseClientFormat } from './format.ts';
 import { ClientMessageType, ServerMessageType } from '../common/enums.ts';
-import type { BaseProtocolError, ProtocolRPC, ProtocolRPCResponse } from '../common/types.ts';
 import { EventEmitter } from './events.ts';
-import type { BaseClientFormat } from './format.ts';
 import { ProtocolClientBlobStream, ProtocolServerBlobStream, ProtocolServerStream } from './stream.ts';
 export declare class ProtocolError extends Error implements BaseProtocolError {
     code: string;
@@ -55,16 +55,17 @@ export declare abstract class ProtocolTransport extends EventEmitter<ProtocolTra
     status: ProtocolTransportStatus;
     abstract connect(auth: any, transformer: ProtocolBaseTransformer): Promise<void>;
     abstract disconnect(): Promise<void>;
-    abstract call(namespace: string, procedure: string, payload: any, options: ProtocolBaseClientCallOptions, transformer: ProtocolBaseTransformer): Promise<ProtocolClientCall>;
+    abstract call(procedure: string, payload: any, options: ProtocolBaseClientCallOptions, transformer: ProtocolBaseTransformer): Promise<ProtocolClientCall>;
     abstract send(messageType: ClientMessageType, buffer: ArrayBuffer, metadata: ProtocolSendMetadata): Promise<void>;
 }
 export declare class ProtocolBaseTransformer {
-    encodeRPC(namespace: string, procedure: string, payload: any): any;
-    decodeRPC(namespace: string, procedure: string, payload: any): any;
-    decodeRPCChunk(namespace: string, procedure: string, payload: any): any;
-    decodeEvent(namespace: string, event: string, payload: any): any;
+    encodeRPC(_procedure: string, payload: any): any;
+    decodeRPC(_procedure: string, payload: any): any;
+    decodeRPCChunk(_procedure: string, payload: any): any;
+    decodeEvent(_event: string, payload: any): any;
 }
-export type ProtocolClientCall = InteractivePromise<any> & Pick<ProtocolRPC, 'namespace' | 'procedure'> & {
+export type ProtocolClientCall = InteractivePromise<any> & {
+    procedure: string;
     signal: AbortSignal;
 };
 export type ProtocolBaseClientOptions = {
@@ -104,15 +105,13 @@ export declare class BaseProtocol<T extends Record<string, Record<string, any>>
     ]>, transformer: ProtocolBaseTransformer): void;
     handleRpcResponse({ callId, error, result, streams }: ProtocolRPCResponse, transformer: ProtocolBaseTransformer, stream?: ProtocolServerStream): ProtocolClientCall;
     handleRpcStreamResponse(response: ProtocolRPCResponse, stream: ProtocolServerStream, transformer: ProtocolBaseTransformer): ProtocolClientCall;
-    createCall(namespace: string, procedure: string, options: ProtocolBaseClientCallOptions): InteractivePromise<unknown> & {
-        namespace: string;
+    createCall(procedure: string, options: ProtocolBaseClientCallOptions): InteractivePromise<unknown> & {
         procedure: string;
         signal: AbortSignal;
     };
-    createRpc(namespace: string, procedure: string, payload: any, options: ProtocolBaseClientCallOptions, transformer: ProtocolBaseTransformer): {
+    createRpc(procedure: string, payload: any, options: ProtocolBaseClientCallOptions, transformer: ProtocolBaseTransformer): {
         callId: number;
         call: InteractivePromise<unknown> & {
-            namespace: string;
             procedure: string;
             signal: AbortSignal;
         };
@@ -130,20 +129,20 @@ export declare class BaseProtocol<T extends Record<string, Record<string, any>>
     removeServerStream(streamId: number): void;
     pushServerStream(streamId: number, chunk: ArrayBuffer): Promise<void>;
     endServerStream(streamId: number): void;
-    abortServerStream(streamId: number, error?: Error): void;
-    emitEvent(namespace: string, event: string, payload: string, transformer: ProtocolBaseTransformer): void;
+    abortServerStream(streamId: number, _error?: Error): void;
+    emitEvent(event: string, payload: string, transformer: ProtocolBaseTransformer): void;
 }
 export declare class Protocol<T extends Record<string, Record<string, any>> = Record<string, Record<string, any>>> extends BaseProtocol<T> {
     handleServerMessage(buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.Event](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.Event](buffer: ArrayBuffer, _transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
     protected [ServerMessageType.RpcResponse](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
     protected [ServerMessageType.RpcStreamResponse](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.RpcStreamChunk](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.RpcStreamEnd](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.RpcStreamAbort](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.ServerStreamPush](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.ServerStreamEnd](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.ServerStreamAbort](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.ClientStreamPull](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
-    protected [ServerMessageType.ClientStreamAbort](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.RpcStreamChunk](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.RpcStreamEnd](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.RpcStreamAbort](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.ServerStreamPush](buffer: ArrayBuffer, transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.ServerStreamEnd](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.ServerStreamAbort](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.ClientStreamPull](buffer: ArrayBuffer, transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.ClientStreamAbort](buffer: ArrayBuffer, _transport: ProtocolTransport, _transformer: ProtocolBaseTransformer): void;
 }

package/dist/client/protocol.js

@@ -1,4 +1,4 @@
-import { createPromise, } from '@nmtjs/common';
+import { createPromise } from '@nmtjs/common';
 import { concat, decodeNumber, encodeNumber } from "../common/binary.js";
 import { ClientMessageType, ErrorCode, ServerMessageType, } from "../common/enums.js";
 import { EventEmitter } from "./events.js";
@@ -18,11 +18,7 @@ export class ProtocolError extends Error {
         return `${this.code} ${this.message}`;
     }
     toJSON() {
-        return {
-            code: this.code,
-            message: this.message,
-            data: this.data,
-        };
+        return { code: this.code, message: this.message, data: this.data };
     }
 }
 export class ProtocolClientStreams {
@@ -116,16 +112,16 @@ export class ProtocolTransport extends EventEmitter {
     status = ProtocolTransportStatus.DISCONNECTED;
 }
 export class ProtocolBaseTransformer {
-    encodeRPC(namespace, procedure, payload) {
+    encodeRPC(_procedure, payload) {
         return payload;
     }
-    decodeRPC(namespace, procedure, payload) {
+    decodeRPC(_procedure, payload) {
         return payload;
     }
-    decodeRPCChunk(namespace, procedure, payload) {
+    decodeRPCChunk(_procedure, payload) {
         return payload;
     }
-    decodeEvent(namespace, event, payload) {
+    decodeEvent(_event, payload) {
         return payload;
     }
 }
@@ -150,7 +146,7 @@ export class BaseProtocol extends EventEmitter {
         }
         else {
             try {
-                const transformed = transformer.decodeRPC(call.namespace, call.procedure, response.result);
+                const transformed = transformer.decodeRPC(call.procedure, response.result);
                 if (response.stream)
                     call.resolve({ result: transformed, stream: response.stream });
                 else
@@ -178,31 +174,22 @@ export class BaseProtocol extends EventEmitter {
         this.rpcStreams.add(response.callId, stream);
         return call;
     }
-    createCall(namespace, procedure, options) {
+    createCall(procedure, options) {
         const timeoutSignal = AbortSignal.timeout(options.timeout);
         const signal = options.signal
             ? AbortSignal.any([options.signal, timeoutSignal])
             : timeoutSignal;
-        const call = Object.assign(createPromise(), {
-            namespace,
-            procedure,
-            signal,
-        });
+        const call = Object.assign(createPromise(), { procedure, signal });
         timeoutSignal.addEventListener('abort', () => {
             const error = new ProtocolError(ErrorCode.RequestTimeout, 'Request timeout');
             call.reject(error);
         }, { once: true });
         return call;
     }
-    createRpc(namespace, procedure, payload, options, transformer) {
+    createRpc(procedure, payload, options, transformer) {
         const callId = ++this.callId;
-        const call = this.createCall(namespace, procedure, options);
-        const { buffer, streams } = this.format.encodeRPC({
-            callId,
-            namespace,
-            procedure,
-            payload: transformer.encodeRPC(namespace, procedure, payload),
-        }, {
+        const call = this.createCall(procedure, options);
+        const { buffer, streams } = this.format.encodeRPC({ callId, procedure, payload: transformer.encodeRPC(procedure, payload) }, {
             addStream: (blob) => {
                 const streamId = ++this.streamId;
                 return this.clientStreams.add(blob.source, streamId, blob.metadata);
@@ -248,12 +235,12 @@ export class BaseProtocol extends EventEmitter {
     endServerStream(streamId) {
         this.serverStreams.end(streamId);
     }
-    abortServerStream(streamId, error) {
+    abortServerStream(streamId, _error) {
         this.serverStreams.abort(streamId);
     }
-    emitEvent(namespace, event, payload, transformer) {
-        const transformed = transformer.decodeEvent(namespace, event, payload);
-        this.emit(`${namespace}/${event}`, 
+    emitEvent(event, payload, transformer) {
+        const transformed = transformer.decodeEvent(event, payload);
+        this.emit(event, 
         //@ts-expect-error
         transformed);
     }
@@ -272,9 +259,9 @@ export class Protocol extends BaseProtocol {
             }
         }
     }
-    [ServerMessageType.Event](buffer, transport, transformer) {
-        const [namespace, event, payload] = this.format.decode(buffer);
-        this.emitEvent(namespace, event, payload, transformer);
+    [ServerMessageType.Event](buffer, _transport, transformer) {
+        const [event, payload] = this.format.decode(buffer);
+        this.emitEvent(event, payload, transformer);
     }
     [ServerMessageType.RpcResponse](buffer, transport, transformer) {
         const response = this.format.decodeRPC(buffer, {
@@ -306,41 +293,41 @@ export class Protocol extends BaseProtocol {
         });
         const stream = new ProtocolServerStream({
             transform: (chunk, controller) => {
-                const transformed = transformer.decodeRPCChunk(call.namespace, call.procedure, chunk);
+                const transformed = transformer.decodeRPCChunk(call.procedure, chunk);
                 controller.enqueue(transformed);
             },
         });
         const call = this.handleRpcStreamResponse(response, stream, transformer);
     }
-    [ServerMessageType.RpcStreamChunk](buffer, transport, transformer) {
+    [ServerMessageType.RpcStreamChunk](buffer, _transport, _transformer) {
         const callId = decodeNumber(buffer, 'Uint32');
         const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
         const payload = this.format.decode(chunk);
         this.pushRpcStream(callId, payload);
     }
-    [ServerMessageType.RpcStreamEnd](buffer, transport, transformer) {
+    [ServerMessageType.RpcStreamEnd](buffer, _transport, _transformer) {
         const callId = decodeNumber(buffer, 'Uint32');
         this.endRpcStream(callId);
     }
-    [ServerMessageType.RpcStreamAbort](buffer, transport, transformer) {
+    [ServerMessageType.RpcStreamAbort](buffer, _transport, _transformer) {
         const callId = decodeNumber(buffer, 'Uint32');
         this.abortRpcStream(callId);
     }
-    [ServerMessageType.ServerStreamPush](buffer, transport, transformer) {
+    [ServerMessageType.ServerStreamPush](buffer, transport, _transformer) {
         const streamId = decodeNumber(buffer, 'Uint32');
         const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
         this.pushServerStream(streamId, chunk);
         transport.send(ClientMessageType.ServerStreamPull, encodeNumber(streamId, 'Uint32'), { streamId });
     }
-    [ServerMessageType.ServerStreamEnd](buffer, transport, transformer) {
+    [ServerMessageType.ServerStreamEnd](buffer, _transport, _transformer) {
         const streamId = decodeNumber(buffer, 'Uint32');
         this.endServerStream(streamId);
     }
-    [ServerMessageType.ServerStreamAbort](buffer, transport, transformer) {
+    [ServerMessageType.ServerStreamAbort](buffer, _transport, _transformer) {
         const streamId = decodeNumber(buffer, 'Uint32');
         this.abortServerStream(streamId);
     }
-    [ServerMessageType.ClientStreamPull](buffer, transport, transformer) {
+    [ServerMessageType.ClientStreamPull](buffer, transport, _transformer) {
         const streamId = decodeNumber(buffer, 'Uint32');
         const size = decodeNumber(buffer, 'Uint32', Uint32Array.BYTES_PER_ELEMENT);
         this.pullClientStream(streamId, size).then((chunk) => {
@@ -355,7 +342,7 @@ export class Protocol extends BaseProtocol {
             transport.send(ClientMessageType.ClientStreamAbort, encodeNumber(streamId, 'Uint32'), { streamId });
         });
     }
-    [ServerMessageType.ClientStreamAbort](buffer, transport, transformer) {
+    [ServerMessageType.ClientStreamAbort](buffer, _transport, _transformer) {
         const streamId = decodeNumber(buffer, 'Uint32');
         this.abortClientStream(streamId);
     }

package/dist/common/blob.js

@@ -7,11 +7,7 @@ export class ProtocolBlob {
         if (typeof size !== 'undefined' && size <= 0)
             throw new Error('Blob size is invalid');
         this.source = source;
-        this.metadata = {
-            size,
-            type,
-            filename,
-        };
+        this.metadata = { size, type, filename };
     }
     static from(source, metadata = {}) {
         let _source;

package/dist/common/types.d.ts

@@ -8,7 +8,6 @@ export interface BaseProtocolError {
 }
 export type ProtocolRPC = {
     callId: number;
-    namespace: string;
     procedure: string;
     payload: any;
 };

package/dist/server/api.d.ts

@@ -4,12 +4,11 @@ import type { Connection } from './connection.ts';
 import { kIterableResponse } from './constants.ts';
 export type ProtocolApiCallOptions = {
     connection: Connection;
-    namespace: string;
     procedure: string;
     container: Container;
     payload: any;
     signal: AbortSignal;
-    metadata?: (metadata: MetadataStore) => void;
+    validateMetadata?: (metadata: MetadataStore) => void;
 };
 export type ProtocolAnyIterable<T> = ((signal: AbortSignal) => Async<AsyncIterable<T>>) | AsyncIterable<T>;
 export interface ProtocolApiCallBaseResult<T = unknown> {

package/dist/server/api.js

@@ -3,10 +3,5 @@ export function isIterableResult(value) {
     return value && value[kIterableResponse] === true;
 }
 export function createStreamResponse(iterable, output = undefined, onFinish) {
-    return {
-        [kIterableResponse]: true,
-        iterable,
-        output,
-        onFinish,
-    };
+    return { [kIterableResponse]: true, iterable, output, onFinish };
 }

package/dist/server/format.d.ts

@@ -1,5 +1,5 @@
 import type { OneOf } from '@nmtjs/common';
-import { type Pattern } from '@nmtjs/core';
+import type { Pattern } from '@nmtjs/core';
 import type { DecodeRPCContext, EncodeRPCContext, ProtocolRPC, ProtocolRPCResponse } from '../common/types.ts';
 import type { ProtocolClientStream, ProtocolServerStream } from './stream.ts';
 export interface BaseServerDecoder {

package/dist/server/protocol.d.ts

@@ -1,14 +1,15 @@
-import { type Callback } from '@nmtjs/common';
-import { type AnyInjectable, type Container, type Logger } from '@nmtjs/core';
+import type { Callback } from '@nmtjs/common';
+import type { AnyInjectable, Container, Logger } from '@nmtjs/core';
 import type { ProtocolBlob, ProtocolBlobMetadata } from '../common/blob.ts';
 import type { ProtocolRPC } from '../common/types.ts';
-import { type ProtocolApi, type ProtocolApiCallOptions } from './api.ts';
-import { Connection, ConnectionContext, type ConnectionOptions } from './connection.ts';
+import type { ProtocolApi, ProtocolApiCallOptions } from './api.ts';
+import type { ConnectionOptions } from './connection.ts';
 import type { Format } from './format.ts';
 import type { ProtocolRegistry } from './registry.ts';
-import { ProtocolClientStream, ProtocolServerStream } from './stream.ts';
 import type { Transport } from './transport.ts';
-import { type ResolveFormatParams } from './utils.ts';
+import type { ResolveFormatParams } from './utils.ts';
+import { Connection, ConnectionContext } from './connection.ts';
+import { ProtocolClientStream, ProtocolServerStream } from './stream.ts';
 export declare class ProtocolError extends Error {
     code: string;
     data?: any;
@@ -67,7 +68,7 @@ export declare class ProtocolServerStreams {
 export type ProtocolRPCOptions = {
     signal?: AbortSignal;
     provides?: [AnyInjectable, any][];
-    metadata?: ProtocolApiCallOptions['metadata'];
+    validateMetadata?: ProtocolApiCallOptions['validateMetadata'];
 };
 export declare class Protocol {
     #private;
@@ -92,7 +93,7 @@ export declare class Protocol {
     rpcAbortRaw(connectionId: string, buffer: ArrayBuffer): void;
     rpcStreamAbort(connectionId: string, callId: number): void;
     rpcStreamAbortRaw(connectionId: string, buffer: ArrayBuffer): void;
-    notify(connectionId: string, event: any, payload: any): void;
+    notify(): void;
     addConnection(transport: ProtocolConnectionTransport, options: ConnectionOptions, params: ResolveFormatParams): Promise<{
         connection: Connection<unknown>;
         context: ConnectionContext;

package/dist/server/protocol.js

@@ -1,9 +1,9 @@
 import { defer, isAbortError, throwError } from '@nmtjs/common';
-import { Hook, Scope, } from '@nmtjs/core';
+import { Hook, Scope } from '@nmtjs/core';
 import { concat, decodeNumber, encodeNumber } from "../common/binary.js";
 import { ErrorCode, ServerMessageType } from "../common/enums.js";
-import { isIterableResult, } from "./api.js";
-import { Connection, ConnectionContext, } from "./connection.js";
+import { isIterableResult } from "./api.js";
+import { Connection, ConnectionContext } from "./connection.js";
 import { ProtocolInjectables } from "./injectables.js";
 import { ProtocolClientStream, ProtocolServerStream } from "./stream.js";
 import { getFormat } from "./utils.js";
@@ -22,11 +22,7 @@ export class ProtocolError extends Error {
         return `${this.code} ${this.message}`;
     }
     toJSON() {
-        return {
-            code: this.code,
-            message: this.message,
-            data: this.data,
-        };
+        return { code: this.code, message: this.message, data: this.data };
     }
 }
 export class ProtocolConnections {
@@ -192,7 +188,7 @@ export class Protocol {
     async rpc(connectionId, rpc, params = {}) {
         const { connection, context, transport } = this.#connections.get(connectionId);
         const { rpcs, format } = context;
-        const { callId, namespace, procedure, payload } = rpc;
+        const { callId, procedure, payload } = rpc;
         const abortController = new AbortController();
         const signal = params.signal
             ? AbortSignal.any([params.signal, abortController.signal])
@@ -209,16 +205,12 @@ export class Protocol {
             const response = await this.call({
                 connection,
                 container,
-                namespace,
                 payload,
                 procedure,
                 signal,
-                metadata: params.metadata,
+                validateMetadata: params.validateMetadata,
             });
-            const responseEncoded = format.encoder.encodeRPC({
-                callId,
-                result: response.output,
-            }, {
+            const responseEncoded = format.encoder.encodeRPC({ callId, result: response.output }, {
                 addStream: (blob) => {
                     const streamId = context.streamId++;
                     const stream = this.#serverStreams.add(connectionId, streamId, blob);
@@ -227,7 +219,7 @@ export class Protocol {
                         const buf = Buffer.from(chunk);
                         transport.send(connection, ServerMessageType.ServerStreamPush, concat(encodeNumber(streamId, 'Uint32'), buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)), { callId, streamId });
                     });
-                    stream.on('error', (err) => {
+                    stream.on('error', () => {
                         transport.send(connection, ServerMessageType.ServerStreamAbort, encodeNumber(streamId, 'Uint32'), { callId, streamId });
                     });
                     stream.on('end', () => {
@@ -277,10 +269,10 @@ export class Protocol {
         }
         catch (error) {
             const payload = format.encoder.encodeRPC({ callId, error }, {
-                addStream(blob) {
+                addStream() {
                     throwError('Cannot handle stream for error response');
                 },
-                getStream(id) {
+                getStream() {
                     throwError('Cannot handle stream for error response');
                 },
             });
@@ -329,7 +321,7 @@ export class Protocol {
         const callId = decodeNumber(buffer, 'Uint32');
         return this.rpcStreamAbort(connectionId, callId);
     }
-    notify(connectionId, event, payload) {
+    notify() {
         throw Error('Unimplemented');
     }
     addConnection(transport, options, params) {

package/dist/server/stream.d.ts

@@ -1,4 +1,5 @@
-import { PassThrough, type ReadableOptions } from 'node:stream';
+import type { ReadableOptions } from 'node:stream';
+import { PassThrough } from 'node:stream';
 import type { ProtocolBlob, ProtocolBlobMetadata } from '../common/blob.ts';
 export declare class ProtocolClientStream extends PassThrough {
     readonly id: number;

package/dist/server/transport.d.ts

@@ -1,11 +1,11 @@
 import type { BasePlugin, PluginContext } from '@nmtjs/core';
 import type { ServerMessageType } from '../common/enums.ts';
 import type { Connection } from './connection.ts';
-import { kTransportPlugin } from './constants.ts';
 import type { Format } from './format.ts';
 import type { Protocol } from './protocol.ts';
 import type { ProtocolRegistry } from './registry.ts';
 import type { ProtocolSendMetadata } from './types.ts';
+import { kTransportPlugin } from './constants.ts';
 export interface Transport<T = unknown> {
     start: () => Promise<void>;
     stop: () => Promise<void>;

package/dist/server/utils.js

@@ -11,8 +11,5 @@ export const getFormat = (format, { acceptType, contentType }) => {
     const decoder = acceptType ? format.supportsDecoder(acceptType) : undefined;
     if (!decoder)
         throw new UnsupportedAcceptTypeError('Unsupported Accept-Type');
-    return {
-        encoder,
-        decoder,
-    };
+    return { encoder, decoder };
 };

package/package.json

@@ -19,21 +19,21 @@
     }
   },
   "dependencies": {
-    "@nmtjs/core": "0.13.1",
-    "@nmtjs/type": "0.13.1",
-    "@nmtjs/common": "0.13.1"
+    "@nmtjs/core": "0.14.0",
+    "@nmtjs/common": "0.14.0",
+    "@nmtjs/type": "0.14.0"
   },
   "peerDependencies": {
-    "@nmtjs/common": "0.13.1",
-    "@nmtjs/core": "0.13.1",
-    "@nmtjs/type": "0.13.1"
+    "@nmtjs/common": "0.14.0",
+    "@nmtjs/type": "0.14.0",
+    "@nmtjs/core": "0.14.0"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.13.1",
+  "version": "0.14.0",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"