@nmtjs/protocol 0.14.4 → 0.15.0-beta.1

package/dist/client/stream.d.ts

@@ -1,28 +0,0 @@
-import type { ProtocolBlobMetadata } from '../common/blob.ts';
-export declare class ProtocolClientBlobStream extends TransformStream<any, ArrayBuffer> {
-    #private;
-    readonly source: ReadableStream;
-    readonly id: number;
-    readonly metadata: ProtocolBlobMetadata;
-    constructor(source: ReadableStream, id: number, metadata: ProtocolBlobMetadata);
-    read(size: number): Promise<ArrayBuffer | null>;
-    abort(error?: Error): void;
-    end(): Promise<void>;
-}
-export interface ProtocolServerStreamInterface<T = any> {
-    [Symbol.asyncIterator](): AsyncGenerator<T>;
-    abort(error?: Error): void;
-}
-export declare class ProtocolServerStream<T = any> extends TransformStream<any, T> implements ProtocolServerStreamInterface<T> {
-    #private;
-    constructor(options?: Transformer<any, T>);
-    [Symbol.asyncIterator](): AsyncGenerator<Awaited<T>, void, unknown>;
-    push(chunk: T): Promise<void>;
-    end(): Promise<void>;
-    abort(error?: Error): Promise<void>;
-}
-export declare class ProtocolServerBlobStream extends ProtocolServerStream<ArrayBuffer> {
-    readonly id: number;
-    readonly metadata: ProtocolBlobMetadata;
-    constructor(id: number, metadata: ProtocolBlobMetadata, options?: Transformer<any, ArrayBuffer>);
-}

package/dist/client/stream.js

@@ -1,95 +0,0 @@
-import { defer } from '@nmtjs/common';
-import { concat, encodeText } from "../common/binary.js";
-export class ProtocolClientBlobStream extends TransformStream {
-    source;
-    id;
-    metadata;
-    #queue;
-    #reader;
-    constructor(source, id, metadata) {
-        super({
-            start: () => {
-                defer(() => source.pipeThrough(this));
-            },
-            transform: (chunk, controller) => {
-                if (chunk instanceof ArrayBuffer) {
-                    controller.enqueue(chunk);
-                }
-                else if (chunk instanceof Uint8Array) {
-                    controller.enqueue(chunk.buffer);
-                }
-                else if (typeof chunk === 'string') {
-                    controller.enqueue(encodeText(chunk));
-                }
-                else {
-                    throw new Error('Invalid chunk data type. Expected ArrayBuffer, Uint8Array, or string.');
-                }
-            },
-        });
-        this.source = source;
-        this.id = id;
-        this.metadata = metadata;
-        this.#queue = new ArrayBuffer(0);
-        this.#reader = this.readable.getReader();
-    }
-    async read(size) {
-        while (this.#queue.byteLength < size) {
-            const { done, value } = await this.#reader.read();
-            if (done) {
-                if (this.#queue.byteLength > 0) {
-                    const chunk = this.#queue;
-                    this.#queue = new ArrayBuffer(0);
-                    return chunk;
-                }
-                return null;
-            }
-            const buffer = value;
-            this.#queue = concat(this.#queue, buffer);
-        }
-        const chunk = this.#queue.slice(0, size);
-        this.#queue = this.#queue.slice(size);
-        return chunk;
-    }
-    abort(error = new Error('Stream aborted')) {
-        this.#reader.cancel(error);
-        this.source.cancel(error);
-    }
-    end() {
-        return this.source.cancel('Stream ended');
-    }
-}
-export class ProtocolServerStream extends TransformStream {
-    #writer;
-    constructor(options) {
-        super(options);
-        this.#writer = this.writable.getWriter();
-    }
-    async *[Symbol.asyncIterator]() {
-        const reader = this.readable.getReader();
-        while (true) {
-            const { done, value } = await reader.read();
-            if (!done)
-                yield value;
-            else
-                break;
-        }
-    }
-    async push(chunk) {
-        await this.#writer.write(chunk);
-    }
-    async end() {
-        await this.#writer.close();
-    }
-    async abort(error = new Error('Stream aborted')) {
-        await this.#writer.abort(error);
-    }
-}
-export class ProtocolServerBlobStream extends ProtocolServerStream {
-    id;
-    metadata;
-    constructor(id, metadata, options) {
-        super(options);
-        this.id = id;
-        this.metadata = metadata;
-    }
-}

package/dist/common/binary.d.ts

@@ -1,19 +0,0 @@
-declare const utf8decoder: TextDecoder;
-export type BinaryTypes = {
-    Int8: number;
-    Int16: number;
-    Int32: number;
-    Uint8: number;
-    Uint16: number;
-    Uint32: number;
-    Float32: number;
-    Float64: number;
-    BigInt64: bigint;
-    BigUint64: bigint;
-};
-export declare const encodeNumber: <T extends keyof BinaryTypes>(value: BinaryTypes[T], type: T, littleEndian?: boolean) => ArrayBuffer;
-export declare const decodeNumber: <T extends keyof BinaryTypes>(buffer: ArrayBuffer, type: T, offset?: number, littleEndian?: boolean) => BinaryTypes[T];
-export declare const encodeText: (text: string) => ArrayBuffer;
-export declare const decodeText: (buffer: Parameters<typeof utf8decoder.decode>[0]) => string;
-export declare const concat: (...buffers: ArrayBuffer[]) => ArrayBuffer;
-export {};

package/dist/common/binary.js

@@ -1,27 +0,0 @@
-// TODO: get rid of lib DOM somehow...
-/// <reference lib="dom" />
-const utf8decoder = new TextDecoder();
-const utf8encoder = new TextEncoder();
-export const encodeNumber = (value, type, littleEndian = false) => {
-    const bytesNeeded = globalThis[`${type}Array`].BYTES_PER_ELEMENT;
-    const ab = new ArrayBuffer(bytesNeeded);
-    const dv = new DataView(ab);
-    dv[`set${type}`](0, value, littleEndian);
-    return ab;
-};
-export const decodeNumber = (buffer, type, offset = 0, littleEndian = false) => {
-    const view = new DataView(buffer);
-    return view[`get${type}`](offset, littleEndian);
-};
-export const encodeText = (text) => new Uint8Array(utf8encoder.encode(text)).buffer;
-export const decodeText = (buffer) => utf8decoder.decode(buffer);
-export const concat = (...buffers) => {
-    const totalLength = buffers.reduce((acc, buffer) => acc + buffer.byteLength, 0);
-    const view = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const buffer of buffers) {
-        view.set(new Uint8Array(buffer), offset);
-        offset += buffer.byteLength;
-    }
-    return view.buffer;
-};

package/dist/common/blob.d.ts

@@ -1,22 +0,0 @@
-export declare const BlobKey: unique symbol;
-export type BlobKey = typeof BlobKey;
-export type ProtocolBlobMetadata = {
-    type: string;
-    size?: number;
-    filename?: string;
-};
-export interface ProtocolBlobInterface {
-    readonly metadata: ProtocolBlobMetadata;
-    readonly [BlobKey]: true;
-}
-export declare class ProtocolBlob implements ProtocolBlobInterface {
-    readonly [BlobKey] = true;
-    readonly metadata: ProtocolBlobMetadata;
-    readonly source: any;
-    constructor(source: any, size?: number, type?: string, filename?: string);
-    static from(source: any, metadata?: {
-        size?: number;
-        type?: string;
-        filename?: string;
-    }): ProtocolBlob;
-}

package/dist/common/blob.js

@@ -1,42 +0,0 @@
-export const BlobKey = Symbol.for('neemata:BlobKey');
-export class ProtocolBlob {
-    [BlobKey] = true;
-    metadata;
-    source;
-    constructor(source, size, type = 'application/octet-stream', filename) {
-        if (typeof size !== 'undefined' && size <= 0)
-            throw new Error('Blob size is invalid');
-        this.source = source;
-        this.metadata = { size, type, filename };
-    }
-    static from(source, metadata = {}) {
-        let _source;
-        if (source instanceof globalThis.ReadableStream) {
-            _source = source;
-        }
-        else if ('File' in globalThis && source instanceof globalThis.File) {
-            _source = source.stream();
-            metadata.size = source.size;
-            metadata.filename = source.name;
-        }
-        else if (source instanceof globalThis.Blob) {
-            _source = source.stream();
-            metadata.size = source.size;
-        }
-        else if (typeof source === 'string') {
-            const blob = new Blob([source]);
-            _source = blob.stream();
-            metadata.size = blob.size;
-            metadata.type = metadata.type || 'text/plain';
-        }
-        else if (source instanceof globalThis.ArrayBuffer) {
-            const blob = new Blob([source]);
-            _source = blob.stream();
-            metadata.size = blob.size;
-        }
-        else {
-            _source = source;
-        }
-        return new ProtocolBlob(_source, metadata.size, metadata.type, metadata.filename);
-    }
-}

package/dist/common/enums.d.ts

@@ -1,41 +0,0 @@
-export declare enum ClientMessageType {
-    Rpc = 10,
-    RpcAbort = 11,
-    RpcStreamAbort = 12,
-    ClientStreamPush = 20,
-    ClientStreamEnd = 21,
-    ClientStreamAbort = 22,
-    ServerStreamAbort = 23,
-    ServerStreamPull = 24
-}
-export declare enum ServerMessageType {
-    Event = 1,
-    RpcResponse = 10,
-    RpcStreamResponse = 11,
-    RpcStreamChunk = 12,
-    RpcStreamEnd = 13,
-    RpcStreamAbort = 14,
-    ServerStreamPush = 20,
-    ServerStreamEnd = 21,
-    ServerStreamAbort = 22,
-    ClientStreamAbort = 23,
-    ClientStreamPull = 24
-}
-export declare enum TransportType {
-    Bidirectional = "Bidirectional",
-    Unidirectional = "Unidirectional"
-}
-export declare enum ErrorCode {
-    ValidationError = "ValidationError",
-    BadRequest = "BadRequest",
-    NotFound = "NotFound",
-    Forbidden = "Forbidden",
-    Unauthorized = "Unauthorized",
-    InternalServerError = "InternalServerError",
-    NotAcceptable = "NotAcceptable",
-    RequestTimeout = "RequestTimeout",
-    GatewayTimeout = "GatewayTimeout",
-    ServiceUnavailable = "ServiceUnavailable",
-    ClientRequestError = "ClientRequestError",
-    ConnectionError = "ConnectionError"
-}

package/dist/common/enums.js

@@ -1,45 +0,0 @@
-export var ClientMessageType;
-(function (ClientMessageType) {
-    ClientMessageType[ClientMessageType["Rpc"] = 10] = "Rpc";
-    ClientMessageType[ClientMessageType["RpcAbort"] = 11] = "RpcAbort";
-    ClientMessageType[ClientMessageType["RpcStreamAbort"] = 12] = "RpcStreamAbort";
-    ClientMessageType[ClientMessageType["ClientStreamPush"] = 20] = "ClientStreamPush";
-    ClientMessageType[ClientMessageType["ClientStreamEnd"] = 21] = "ClientStreamEnd";
-    ClientMessageType[ClientMessageType["ClientStreamAbort"] = 22] = "ClientStreamAbort";
-    ClientMessageType[ClientMessageType["ServerStreamAbort"] = 23] = "ServerStreamAbort";
-    ClientMessageType[ClientMessageType["ServerStreamPull"] = 24] = "ServerStreamPull";
-})(ClientMessageType || (ClientMessageType = {}));
-export var ServerMessageType;
-(function (ServerMessageType) {
-    ServerMessageType[ServerMessageType["Event"] = 1] = "Event";
-    ServerMessageType[ServerMessageType["RpcResponse"] = 10] = "RpcResponse";
-    ServerMessageType[ServerMessageType["RpcStreamResponse"] = 11] = "RpcStreamResponse";
-    ServerMessageType[ServerMessageType["RpcStreamChunk"] = 12] = "RpcStreamChunk";
-    ServerMessageType[ServerMessageType["RpcStreamEnd"] = 13] = "RpcStreamEnd";
-    ServerMessageType[ServerMessageType["RpcStreamAbort"] = 14] = "RpcStreamAbort";
-    ServerMessageType[ServerMessageType["ServerStreamPush"] = 20] = "ServerStreamPush";
-    ServerMessageType[ServerMessageType["ServerStreamEnd"] = 21] = "ServerStreamEnd";
-    ServerMessageType[ServerMessageType["ServerStreamAbort"] = 22] = "ServerStreamAbort";
-    ServerMessageType[ServerMessageType["ClientStreamAbort"] = 23] = "ClientStreamAbort";
-    ServerMessageType[ServerMessageType["ClientStreamPull"] = 24] = "ClientStreamPull";
-})(ServerMessageType || (ServerMessageType = {}));
-export var TransportType;
-(function (TransportType) {
-    TransportType["Bidirectional"] = "Bidirectional";
-    TransportType["Unidirectional"] = "Unidirectional";
-})(TransportType || (TransportType = {}));
-export var ErrorCode;
-(function (ErrorCode) {
-    ErrorCode["ValidationError"] = "ValidationError";
-    ErrorCode["BadRequest"] = "BadRequest";
-    ErrorCode["NotFound"] = "NotFound";
-    ErrorCode["Forbidden"] = "Forbidden";
-    ErrorCode["Unauthorized"] = "Unauthorized";
-    ErrorCode["InternalServerError"] = "InternalServerError";
-    ErrorCode["NotAcceptable"] = "NotAcceptable";
-    ErrorCode["RequestTimeout"] = "RequestTimeout";
-    ErrorCode["GatewayTimeout"] = "GatewayTimeout";
-    ErrorCode["ServiceUnavailable"] = "ServiceUnavailable";
-    ErrorCode["ClientRequestError"] = "ClientRequestError";
-    ErrorCode["ConnectionError"] = "ConnectionError";
-})(ErrorCode || (ErrorCode = {}));

package/dist/common/index.d.ts

@@ -1,4 +0,0 @@
-export * from './binary.ts';
-export * from './blob.ts';
-export * from './enums.ts';
-export * from './types.ts';

package/dist/common/index.js

@@ -1,4 +0,0 @@
-export * from "./binary.js";
-export * from "./blob.js";
-export * from "./enums.js";
-export * from "./types.js";

package/dist/common/types.d.ts

@@ -1,33 +0,0 @@
-import type { OneOf } from '@nmtjs/common';
-import type { ProtocolBlob, ProtocolBlobMetadata } from './blob.ts';
-type Stream = any;
-export interface BaseProtocolError {
-    code: string;
-    message: string;
-    data?: any;
-}
-export type ProtocolRPC = {
-    callId: number;
-    procedure: string;
-    payload: any;
-};
-export type ProtocolRPCResponse<T = Stream> = OneOf<[
-    {
-        callId: number;
-        error: BaseProtocolError;
-    },
-    {
-        callId: number;
-        result: any;
-        streams: Record<number, T>;
-    }
-]>;
-export interface EncodeRPCContext<T = Stream> {
-    getStream: (id: number) => T;
-    addStream: (blob: ProtocolBlob) => T;
-}
-export interface DecodeRPCContext<T = Stream> {
-    getStream: (id: number, callId: number) => T;
-    addStream: (id: number, callId: number, metadata: ProtocolBlobMetadata) => T;
-}
-export {};

package/dist/common/types.js

@@ -1 +0,0 @@
-export {};

package/dist/server/api.d.ts

@@ -1,33 +0,0 @@
-import type { Async } from '@nmtjs/common';
-import type { Container, Hook, MetadataStore } from '@nmtjs/core';
-import type { Connection } from './connection.ts';
-import { kIterableResponse } from './constants.ts';
-export type ProtocolApiCallOptions = {
-    connection: Connection;
-    procedure: string;
-    container: Container;
-    payload: any;
-    signal: AbortSignal;
-    validateMetadata?: (metadata: MetadataStore) => void;
-};
-export type ProtocolAnyIterable<T> = ((signal: AbortSignal) => Async<AsyncIterable<T>>) | AsyncIterable<T>;
-export interface ProtocolApiCallBaseResult<T = unknown> {
-    output: T;
-}
-export interface ProtocolApiCallIterableResult<Y = unknown, O = unknown> extends ProtocolApiCallBaseResult<O> {
-    [kIterableResponse]: true;
-    iterable: ProtocolAnyIterable<Y>;
-    onFinish?: () => void;
-}
-export type ProtocolApiCallResult = ProtocolApiCallBaseResult | ProtocolApiCallIterableResult;
-export interface ProtocolApi {
-    call(options: ProtocolApiCallOptions): Promise<ProtocolApiCallResult>;
-}
-export declare function isIterableResult(value: ProtocolApiCallResult): value is ProtocolApiCallIterableResult;
-export declare function createStreamResponse<Y, O>(iterable: ProtocolAnyIterable<Y>, output?: O, onFinish?: () => void): ProtocolApiCallIterableResult<Y, O>;
-declare module '@nmtjs/core' {
-    interface HookType {
-        [Hook.OnConnect]: (connection: Connection) => any;
-        [Hook.OnDisconnect]: (connection: Connection) => any;
-    }
-}

package/dist/server/api.js

@@ -1,7 +0,0 @@
-import { kIterableResponse } from "./constants.js";
-export function isIterableResult(value) {
-    return value && value[kIterableResponse] === true;
-}
-export function createStreamResponse(iterable, output = undefined, onFinish) {
-    return { [kIterableResponse]: true, iterable, output, onFinish };
-}

package/dist/server/connection.d.ts

@@ -1,25 +0,0 @@
-import type { Container } from '@nmtjs/core';
-import type { BaseServerDecoder, BaseServerEncoder } from './format.ts';
-import type { ProtocolClientStream, ProtocolServerStream } from './stream.ts';
-export type ConnectionOptions<Data = unknown> = {
-    id?: string;
-    data: Data;
-};
-export declare class Connection<Data = unknown> {
-    readonly id: string;
-    readonly data: Data;
-    constructor(options: ConnectionOptions<Data>);
-}
-export declare class ConnectionContext {
-    streamId: number;
-    rpcs: Map<number, AbortController>;
-    clientStreams: Map<number, ProtocolClientStream>;
-    serverStreams: Map<number, ProtocolServerStream>;
-    rpcStreams: Map<number, AbortController>;
-    container: Container;
-    format: {
-        encoder: BaseServerEncoder;
-        decoder: BaseServerDecoder;
-    };
-    constructor(container: ConnectionContext['container'], format: ConnectionContext['format']);
-}

package/dist/server/connection.js

@@ -1,22 +0,0 @@
-import { randomUUID } from 'node:crypto';
-export class Connection {
-    id;
-    data;
-    constructor(options) {
-        this.id = options.id ?? randomUUID();
-        this.data = options.data;
-    }
-}
-export class ConnectionContext {
-    streamId = 1;
-    rpcs = new Map();
-    clientStreams = new Map();
-    serverStreams = new Map();
-    rpcStreams = new Map();
-    container;
-    format;
-    constructor(container, format) {
-        this.container = container;
-        this.format = format;
-    }
-}

package/dist/server/constants.d.ts

@@ -1,4 +0,0 @@
-export declare const kTransportPlugin: unique symbol;
-export type kTransportPlugin = typeof kTransportPlugin;
-export declare const kIterableResponse: unique symbol;
-export type kIterableResponse = typeof kIterableResponse;

package/dist/server/constants.js

@@ -1,2 +0,0 @@
-export const kTransportPlugin = Symbol.for('neemata:TransportPluginKey');
-export const kIterableResponse = Symbol.for('neemata:IterableResponseKey');

package/dist/server/format.d.ts

@@ -1,40 +0,0 @@
-import type { OneOf } from '@nmtjs/common';
-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 {
-    accept: Pattern[];
-    decode(buffer: ArrayBuffer): any;
-    decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolClientStream>): ProtocolRPC;
-}
-export interface BaseServerEncoder {
-    contentType: string;
-    encode(data: any): ArrayBuffer;
-    encodeRPC(rpc: OneOf<[
-        {
-            callId: number;
-            error: any;
-        },
-        {
-            callId: number;
-            result: any;
-        }
-    ]>, context: EncodeRPCContext<ProtocolServerStream>): ArrayBuffer;
-}
-export declare abstract class BaseServerFormat implements BaseServerDecoder, BaseServerEncoder {
-    abstract accept: Pattern[];
-    abstract contentType: string;
-    abstract encode(data: any): ArrayBuffer;
-    abstract encodeRPC(rpc: ProtocolRPCResponse, context: EncodeRPCContext<ProtocolServerStream>): ArrayBuffer;
-    abstract decode(buffer: ArrayBuffer): any;
-    abstract decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolClientStream>): ProtocolRPC;
-}
-export declare const parseContentTypes: (types: string) => string[];
-export declare class Format {
-    decoders: Map<Pattern, BaseServerDecoder>;
-    encoders: Map<Pattern, BaseServerEncoder>;
-    constructor(formats: BaseServerFormat[]);
-    supportsDecoder(contentType: string, throwIfUnsupported?: boolean): BaseServerDecoder | null;
-    supportsEncoder(contentType: string, throwIfUnsupported?: boolean): BaseServerEncoder | null;
-    private supports;
-}

package/dist/server/format.js

@@ -1,60 +0,0 @@
-import { match } from '@nmtjs/core';
-export class BaseServerFormat {
-}
-export const parseContentTypes = (types) => {
-    if (types === '*/*')
-        return ['*/*'];
-    return types
-        .split(',')
-        .map((t) => {
-        const [type, ...rest] = t.split(';');
-        const params = new Map(rest.map((p) => p
-            .trim()
-            .split('=')
-            .slice(0, 2)
-            .map((p) => p.trim())));
-        return {
-            type,
-            q: params.has('q') ? Number.parseFloat(params.get('q')) : 1,
-        };
-    })
-        .sort((a, b) => {
-        if (a.type === '*/*')
-            return 1;
-        if (b.type === '*/*')
-            return -1;
-        return b.q - a.q ? -1 : 1;
-    })
-        .map((t) => t.type);
-};
-export class Format {
-    decoders = new Map();
-    encoders = new Map();
-    constructor(formats) {
-        for (const format of formats) {
-            this.encoders.set(format.contentType, format);
-            for (const acceptType of format.accept) {
-                this.decoders.set(acceptType, format);
-            }
-        }
-    }
-    supportsDecoder(contentType, throwIfUnsupported = false) {
-        return this.supports(this.decoders, contentType, throwIfUnsupported);
-    }
-    supportsEncoder(contentType, throwIfUnsupported = false) {
-        return this.supports(this.encoders, contentType, throwIfUnsupported);
-    }
-    supports(formats, contentType, throwIfUnsupported = false) {
-        // TODO: Use node:utils.MIMEType (not implemented yet in Deno and Bun yet)
-        const types = parseContentTypes(contentType);
-        for (const type of types) {
-            for (const [pattern, format] of formats) {
-                if (type === '*/*' || match(type, pattern))
-                    return format;
-            }
-        }
-        if (throwIfUnsupported)
-            throw new Error(`No supported format found: ${contentType}`);
-        return null;
-    }
-}

package/dist/server/index.d.ts

@@ -1,11 +0,0 @@
-export * from './api.ts';
-export * from './connection.ts';
-export * from './constants.ts';
-export * from './format.ts';
-export * from './injectables.ts';
-export * from './protocol.ts';
-export * from './registry.ts';
-export * from './stream.ts';
-export * from './transport.ts';
-export * from './types.ts';
-export * from './utils.ts';

package/dist/server/index.js

@@ -1,11 +0,0 @@
-export * from "./api.js";
-export * from "./connection.js";
-export * from "./constants.js";
-export * from "./format.js";
-export * from "./injectables.js";
-export * from "./protocol.js";
-export * from "./registry.js";
-export * from "./stream.js";
-export * from "./transport.js";
-export * from "./types.js";
-export * from "./utils.js";

package/dist/server/injectables.d.ts

@@ -1,14 +0,0 @@
-import { Scope } from '@nmtjs/core';
-import type { Connection } from './connection.ts';
-export declare const ProtocolInjectables: {
-    readonly connection: import("@nmtjs/core").LazyInjectable<Connection<unknown>, Scope.Connection>;
-    readonly connectionData: import("@nmtjs/core").LazyInjectable<any, Scope.Connection>;
-    readonly connectionAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Connection>;
-    readonly rpcClientAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
-    readonly rpcTimeoutSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
-    readonly rpcAbortSignal: import("@nmtjs/core").FactoryInjectable<AbortSignal, {
-        rpcTimeoutSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
-        rpcClientAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
-        connectionAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Connection>;
-    }, Scope.Global, AbortSignal>;
-};

package/dist/server/injectables.js

@@ -1,22 +0,0 @@
-import { createFactoryInjectable, createLazyInjectable, Scope, } from '@nmtjs/core';
-const connection = createLazyInjectable(Scope.Connection, 'RPC connection');
-const connectionData = createLazyInjectable(Scope.Connection, "RPC connection's data");
-const connectionAbortSignal = createLazyInjectable(Scope.Connection, 'Connection abort signal');
-const rpcClientAbortSignal = createLazyInjectable(Scope.Call, 'RPC client abort signal');
-const rpcTimeoutSignal = createLazyInjectable(Scope.Call, 'RPC timeout signal');
-const rpcAbortSignal = createFactoryInjectable({
-    dependencies: {
-        rpcTimeoutSignal,
-        rpcClientAbortSignal,
-        connectionAbortSignal,
-    },
-    factory: (ctx) => AbortSignal.any(Object.values(ctx)),
-}, 'Any RPC abort signal');
-export const ProtocolInjectables = {
-    connection,
-    connectionData,
-    connectionAbortSignal,
-    rpcClientAbortSignal,
-    rpcTimeoutSignal,
-    rpcAbortSignal,
-};