@tsed/socketio 6.87.2 → 6.90.0

package/lib/esm/decorators/socketMiddlewareError.js

@@ -0,0 +1,67 @@
+import { Middleware } from "@tsed/common";
+import { Store } from "@tsed/core";
+import { SocketProviderTypes } from "../interfaces/SocketProviderTypes";
+/**
+ * Declare a new SocketMiddlewareError.
+ *
+ * ### Example
+ *
+ * A middleware can be also used on a `SocketService` either on a class or on a method.
+ *
+ * Here an example of a middleware:
+ *
+ * ```typescript
+ * import {SocketMiddlewareError, SocketErr, Socket, Args} from "@tsed/socketio";
+ *
+ * @SocketMiddlewareError()
+ * export class ErrorHandlerSocketMiddleware {
+ *    async use(@SocketEventName, @SocketErr err: any, @Socket socket: SocketIO.Socket) {
+ *        console.error(err);
+ *        socket.emit("error", {message: "An error has occured"})
+ *    }
+ * }
+ * ```
+ *
+ * Then:
+ *
+ * ```typescript
+ * import {SocketService, SocketUseAfter, SocketUseBefore, Emit, Input, Args} from "@tsed/socketio";
+ * import {ErrorHandlerSocketMiddleware} from "../middlewares";
+ * import {User} from "../models/User";
+ *
+ * @SocketService("/my-namespace")
+ * @SocketUseAfter(ErrorHandlerSocketMiddleware) // global version
+ * export class MySocketService {
+ *
+ *    @Input("eventName")
+ *    @Emit("responseEventName") // or Broadcast or BroadcastOthers
+ *    @SocketUseAfter(ErrorHandlerSocketMiddleware)
+ *    async myMethod(@Args(0) userName: User) {
+ *
+ *        console.log(user);
+ *        throw new Error("Error");
+ *
+ *        return user;
+ *    }
+ * }
+ * ```
+ *
+ * @returns {Function}
+ * @decorator
+ * @experimental
+ */
+export function SocketMiddlewareError() {
+    return (target) => {
+        Store.from(target).merge("socketIO", {
+            type: SocketProviderTypes.MIDDLEWARE,
+            error: true,
+            handlers: {
+                use: {
+                    methodClassName: "use"
+                }
+            }
+        });
+        return Middleware()(target);
+    };
+}
+//# sourceMappingURL=socketMiddlewareError.js.map

package/lib/esm/decorators/socketMiddlewareError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socketMiddlewareError.js","sourceRoot":"","sources":["../../../src/decorators/socketMiddlewareError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EAAC,KAAK,EAAO,MAAM,YAAY,CAAC;AACvC,OAAO,EAAC,mBAAmB,EAAC,MAAM,mCAAmC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO,CAAC,MAAiB,EAAE,EAAE;QAC3B,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE;YACnC,IAAI,EAAE,mBAAmB,CAAC,UAAU;YACpC,KAAK,EAAE,IAAI;YAEX,QAAQ,EAAE;gBACR,GAAG,EAAE;oBACH,eAAe,EAAE,KAAK;iBACvB;aACF;SACF,CAAC,CAAC;QAEH,OAAO,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {Middleware} from \"@tsed/common\";\nimport {Store, Type} from \"@tsed/core\";\nimport {SocketProviderTypes} from \"../interfaces/SocketProviderTypes\";\n\n/**\n * Declare a new SocketMiddlewareError.\n *\n * ### Example\n *\n * A middleware can be also used on a `SocketService` either on a class or on a method.\n *\n * Here an example of a middleware:\n *\n * ```typescript\n * import {SocketMiddlewareError, SocketErr, Socket, Args} from \"@tsed/socketio\";\n *\n * @SocketMiddlewareError()\n * export class ErrorHandlerSocketMiddleware {\n *    async use(@SocketEventName, @SocketErr err: any, @Socket socket: SocketIO.Socket) {\n *        console.error(err);\n *        socket.emit(\"error\", {message: \"An error has occured\"})\n *    }\n * }\n * ```\n *\n * Then:\n *\n * ```typescript\n * import {SocketService, SocketUseAfter, SocketUseBefore, Emit, Input, Args} from \"@tsed/socketio\";\n * import {ErrorHandlerSocketMiddleware} from \"../middlewares\";\n * import {User} from \"../models/User\";\n *\n * @SocketService(\"/my-namespace\")\n * @SocketUseAfter(ErrorHandlerSocketMiddleware) // global version\n * export class MySocketService {\n *\n *    @Input(\"eventName\")\n *    @Emit(\"responseEventName\") // or Broadcast or BroadcastOthers\n *    @SocketUseAfter(ErrorHandlerSocketMiddleware)\n *    async myMethod(@Args(0) userName: User) {\n *\n *        console.log(user);\n *        throw new Error(\"Error\");\n *\n *        return user;\n *    }\n * }\n * ```\n *\n * @returns {Function}\n * @decorator\n * @experimental\n */\nexport function SocketMiddlewareError(): Function {\n  return (target: Type<any>) => {\n    Store.from(target).merge(\"socketIO\", {\n      type: SocketProviderTypes.MIDDLEWARE,\n      error: true,\n\n      handlers: {\n        use: {\n          methodClassName: \"use\"\n        }\n      }\n    });\n\n    return Middleware()(target);\n  };\n}\n"]}

package/lib/esm/decorators/socketReturns.js

@@ -0,0 +1,23 @@
+import { Store } from "@tsed/core";
+/**
+ *
+ * @param {string} eventName
+ * @param {SocketReturnsTypes} type
+ * @returns {(target: any, propertyKey: string, descriptor: PropertyDescriptor) => void}
+ * @decorator
+ */
+export function SocketReturns(eventName, type) {
+    return (target, propertyKey, descriptor) => {
+        Store.from(target).merge("socketIO", {
+            handlers: {
+                [propertyKey]: {
+                    returns: {
+                        eventName,
+                        type
+                    }
+                }
+            }
+        });
+    };
+}
+//# sourceMappingURL=socketReturns.js.map

package/lib/esm/decorators/socketReturns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socketReturns.js","sourceRoot":"","sources":["../../../src/decorators/socketReturns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AAGjC;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,SAAiB,EAAE,IAAwB;IACvE,OAAO,CAAC,MAAW,EAAE,WAAmB,EAAE,UAA8B,EAAE,EAAE;QAC1E,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE;YACnC,QAAQ,EAAE;gBACR,CAAC,WAAW,CAAC,EAAE;oBACb,OAAO,EAAE;wBACP,SAAS;wBACT,IAAI;qBACL;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {Store} from \"@tsed/core\";\nimport {SocketReturnsTypes} from \"../interfaces/SocketReturnsTypes\";\n\n/**\n *\n * @param {string} eventName\n * @param {SocketReturnsTypes} type\n * @returns {(target: any, propertyKey: string, descriptor: PropertyDescriptor) => void}\n * @decorator\n */\nexport function SocketReturns(eventName: string, type: SocketReturnsTypes) {\n  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {\n    Store.from(target).merge(\"socketIO\", {\n      handlers: {\n        [propertyKey]: {\n          returns: {\n            eventName,\n            type\n          }\n        }\n      }\n    });\n  };\n}\n"]}

package/lib/esm/decorators/socketService.js

@@ -0,0 +1,20 @@
+import { StoreMerge, useDecorators } from "@tsed/core";
+import { Injectable } from "@tsed/di";
+import { SocketProviderTypes } from "../interfaces/SocketProviderTypes";
+import { PROVIDER_TYPE_SOCKET_SERVICE } from "../constants";
+/**
+ * The decorators `@SocketService()` declare a new socket service (and service) can be injected in other service or controller on there `constructor`.
+ * All services annotated with `@SocketService()` are constructed one time.
+ *
+ * > `@SocketService()` use the `reflect-metadata` to collect and inject service on controllers or other services.
+ *
+ * @param {string} namespace
+ * @returns {Function}
+ * @decorator
+ */
+export function SocketService(namespace = "/") {
+    return useDecorators(StoreMerge("socketIO", { namespace, type: SocketProviderTypes.SERVICE }), Injectable({
+        type: PROVIDER_TYPE_SOCKET_SERVICE
+    }));
+}
+//# sourceMappingURL=socketService.js.map

package/lib/esm/decorators/socketService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socketService.js","sourceRoot":"","sources":["../../../src/decorators/socketService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,aAAa,EAAC,MAAM,YAAY,CAAC;AACrD,OAAO,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACpC,OAAO,EAAC,mBAAmB,EAAC,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAC,4BAA4B,EAAC,MAAM,cAAc,CAAC;AAE1D;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,SAAS,GAAG,GAAG;IAC3C,OAAO,aAAa,CAClB,UAAU,CAAC,UAAU,EAAE,EAAC,SAAS,EAAE,IAAI,EAAE,mBAAmB,CAAC,OAAO,EAAC,CAAC,EACtE,UAAU,CAAC;QACT,IAAI,EAAE,4BAA4B;KACnC,CAAC,CACH,CAAC;AACJ,CAAC","sourcesContent":["import {StoreMerge, useDecorators} from \"@tsed/core\";\nimport {Injectable} from \"@tsed/di\";\nimport {SocketProviderTypes} from \"../interfaces/SocketProviderTypes\";\nimport {PROVIDER_TYPE_SOCKET_SERVICE} from \"../constants\";\n\n/**\n * The decorators `@SocketService()` declare a new socket service (and service) can be injected in other service or controller on there `constructor`.\n * All services annotated with `@SocketService()` are constructed one time.\n *\n * > `@SocketService()` use the `reflect-metadata` to collect and inject service on controllers or other services.\n *\n * @param {string} namespace\n * @returns {Function}\n * @decorator\n */\nexport function SocketService(namespace = \"/\") {\n  return useDecorators(\n    StoreMerge(\"socketIO\", {namespace, type: SocketProviderTypes.SERVICE}),\n    Injectable({\n      type: PROVIDER_TYPE_SOCKET_SERVICE\n    })\n  );\n}\n"]}

package/lib/esm/decorators/socketSession.js

@@ -0,0 +1,27 @@
+import { SocketFilters } from "../interfaces/SocketFilters";
+import { SocketFilter } from "./socketFilter";
+/**
+ * Inject the Socket instance in the decorated parameter.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   myMethod(@SocketSession session: Map) {
+ *     console.log(session);
+ *   }
+ * }
+ * ```
+ *
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @decorator
+ */
+export function SocketSession(target, propertyKey, index) {
+    return SocketFilter(SocketFilters.SESSION)(target, propertyKey, index);
+}
+//# sourceMappingURL=socketSession.js.map

package/lib/esm/decorators/socketSession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socketSession.js","sourceRoot":"","sources":["../../../src/decorators/socketSession.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,aAAa,CAAC,MAAW,EAAE,WAAmB,EAAE,KAAa;IAC3E,OAAO,YAAY,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;AACzE,CAAC","sourcesContent":["import {SocketFilters} from \"../interfaces/SocketFilters\";\nimport {SocketFilter} from \"./socketFilter\";\n\nexport type SocketSession = Map<string, any>;\n\n/**\n * Inject the Socket instance in the decorated parameter.\n *\n * ### Example\n *\n * ```typescript\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *\n *   @Input(\"event\")\n *   myMethod(@SocketSession session: Map) {\n *     console.log(session);\n *   }\n * }\n * ```\n *\n * @param target\n * @param {string} propertyKey\n * @param {number} index\n * @decorator\n */\nexport function SocketSession(target: any, propertyKey: string, index: number): any {\n  return SocketFilter(SocketFilters.SESSION)(target, propertyKey, index);\n}\n"]}

package/lib/esm/decorators/socketUseAfter.js

@@ -0,0 +1,70 @@
+import { Store } from "@tsed/core";
+/**
+ * Attach a Socket Middleware to a method or a class.
+ *
+ * ### Example
+ *
+ * A middleware can be also used on a `SocketService` either on a class or on a method.
+ *
+ * Here an example of a middleware:
+ *
+ * ```typescript
+ * import {SocketMiddlewareError, SocketErr, Socket, Args} from "@tsed/socketio";
+ *
+ * @SocketMiddlewareError()
+ * export class ErrorHandlerSocketMiddleware {
+ *    async use(@SocketErr() err: any, @Socket socket: SocketIO.Socket) {
+ *        console.error(err);
+ *        socket.emit("error", {message: "An error has occured"})
+ *    }
+ * }
+ * ```
+ *
+ * Then:
+ *
+ * ```typescript
+ * import {SocketService, SocketUseAfter, SocketUseBefore, Emit, Input, Args} from "@tsed/socketio";
+ * import {ErrorHandlerSocketMiddleware} from "../middlewares";
+ * import {User} from "../models/User";
+ *
+ * @SocketService("/my-namespace")
+ * @SocketUseAfter(ErrorHandlerSocketMiddleware) // global version
+ * export class MySocketService {
+ *
+ *    @Input("eventName")
+ *    @Emit("responseEventName") // or Broadcast or BroadcastOthers
+ *    @SocketUseAfter(ErrorHandlerSocketMiddleware)
+ *    async myMethod(@Args(0) userName: User) {
+ *
+ *        console.log(user);
+ *        throw new Error("Error");
+ *
+ *        return user;
+ *    }
+ * }
+ * ```
+ *
+ * @returns {(target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void}
+ * @decorator
+ * @experimental
+ * @param middlewares
+ */
+export function SocketUseAfter(...middlewares) {
+    return (target, propertyKey, descriptor) => {
+        if (propertyKey) {
+            Store.from(target).merge("socketIO", {
+                handlers: {
+                    [propertyKey]: {
+                        useAfter: middlewares
+                    }
+                }
+            });
+        }
+        else {
+            Store.from(target).merge("socketIO", {
+                useAfter: middlewares
+            });
+        }
+    };
+}
+//# sourceMappingURL=socketUseAfter.js.map

package/lib/esm/decorators/socketUseAfter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socketUseAfter.js","sourceRoot":"","sources":["../../../src/decorators/socketUseAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAO,MAAM,YAAY,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,UAAU,cAAc,CAAC,GAAG,WAAwB;IACxD,OAAO,CAAC,MAAW,EAAE,WAAoB,EAAE,UAA+B,EAAE,EAAE;QAC5E,IAAI,WAAW,EAAE;YACf,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE;gBACnC,QAAQ,EAAE;oBACR,CAAC,WAAW,CAAC,EAAE;wBACb,QAAQ,EAAE,WAAW;qBACtB;iBACF;aACF,CAAC,CAAC;SACJ;aAAM;YACL,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE;gBACnC,QAAQ,EAAE,WAAW;aACtB,CAAC,CAAC;SACJ;IACH,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {Store, Type} from \"@tsed/core\";\n\n/**\n * Attach a Socket Middleware to a method or a class.\n *\n * ### Example\n *\n * A middleware can be also used on a `SocketService` either on a class or on a method.\n *\n * Here an example of a middleware:\n *\n * ```typescript\n * import {SocketMiddlewareError, SocketErr, Socket, Args} from \"@tsed/socketio\";\n *\n * @SocketMiddlewareError()\n * export class ErrorHandlerSocketMiddleware {\n *    async use(@SocketErr() err: any, @Socket socket: SocketIO.Socket) {\n *        console.error(err);\n *        socket.emit(\"error\", {message: \"An error has occured\"})\n *    }\n * }\n * ```\n *\n * Then:\n *\n * ```typescript\n * import {SocketService, SocketUseAfter, SocketUseBefore, Emit, Input, Args} from \"@tsed/socketio\";\n * import {ErrorHandlerSocketMiddleware} from \"../middlewares\";\n * import {User} from \"../models/User\";\n *\n * @SocketService(\"/my-namespace\")\n * @SocketUseAfter(ErrorHandlerSocketMiddleware) // global version\n * export class MySocketService {\n *\n *    @Input(\"eventName\")\n *    @Emit(\"responseEventName\") // or Broadcast or BroadcastOthers\n *    @SocketUseAfter(ErrorHandlerSocketMiddleware)\n *    async myMethod(@Args(0) userName: User) {\n *\n *        console.log(user);\n *        throw new Error(\"Error\");\n *\n *        return user;\n *    }\n * }\n * ```\n *\n * @returns {(target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void}\n * @decorator\n * @experimental\n * @param middlewares\n */\nexport function SocketUseAfter(...middlewares: Type<any>[]) {\n  return (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => {\n    if (propertyKey) {\n      Store.from(target).merge(\"socketIO\", {\n        handlers: {\n          [propertyKey]: {\n            useAfter: middlewares\n          }\n        }\n      });\n    } else {\n      Store.from(target).merge(\"socketIO\", {\n        useAfter: middlewares\n      });\n    }\n  };\n}\n"]}

package/lib/esm/decorators/socketUseBefore.js

@@ -0,0 +1,74 @@
+import { Store } from "@tsed/core";
+/**
+ * Attach a Socket Middleware to a method or a class.
+ *
+ * ### Example
+ *
+ * A middleware can be also used on a `SocketService` either on a class or on a method.
+ *
+ * Here an example of a middleware:
+ *
+ * ```typescript
+ * @SocketMiddleware()
+ * export class UserConverterSocketMiddleware {
+ *     constructor(private converterService: ConverterService) {
+ *     }
+ *     async use(@Args() args: any[]) {
+ *
+ *         let [user] = args;
+ *         // update Arguments
+ *         user = ConverterService.deserialize(user, User);
+ *
+ *         return [user];
+ *     }
+ * }
+ * ```
+ * > The user instance will be forwarded to the next middleware and to your decorated method.
+ *
+ * Then:
+ *
+ * ```typescript
+ * import {SocketService, SocketUseAfter, SocketUseBefore, Emit, Input, Args} from "@tsed/socketio";
+ * import {UserConverterSocketMiddleware} from "../middlewares";
+ * import {User} from "../models/User";
+ *
+ * @SocketService("/my-namespace")
+ * @SocketUseBefore(UserConverterSocketMiddleware) // global version
+ * export class MySocketService {
+ *
+ *    @Input("eventName")
+ *    @Emit("responseEventName") // or Broadcast or BroadcastOthers
+ *    @SocketUseBefore(UserConverterSocketMiddleware)
+ *    async myMethod(@Args(0) user: User) {
+ *
+ *        console.log(user);
+ *
+ *        return user;
+ *    }
+ * }
+ * ```
+ *
+ * @returns {(target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void}
+ * @decorator
+ * @experimental
+ * @param middlewares
+ */
+export function SocketUseBefore(...middlewares) {
+    return (target, propertyKey, descriptor) => {
+        if (propertyKey) {
+            Store.from(target).merge("socketIO", {
+                handlers: {
+                    [propertyKey]: {
+                        useBefore: middlewares
+                    }
+                }
+            });
+        }
+        else {
+            Store.from(target).merge("socketIO", {
+                useBefore: middlewares
+            });
+        }
+    };
+}
+//# sourceMappingURL=socketUseBefore.js.map

package/lib/esm/decorators/socketUseBefore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socketUseBefore.js","sourceRoot":"","sources":["../../../src/decorators/socketUseBefore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAO,MAAM,YAAY,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,UAAU,eAAe,CAAC,GAAG,WAAwB;IACzD,OAAO,CAAC,MAAW,EAAE,WAAoB,EAAE,UAA+B,EAAE,EAAE;QAC5E,IAAI,WAAW,EAAE;YACf,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE;gBACnC,QAAQ,EAAE;oBACR,CAAC,WAAW,CAAC,EAAE;wBACb,SAAS,EAAE,WAAW;qBACvB;iBACF;aACF,CAAC,CAAC;SACJ;aAAM;YACL,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE;gBACnC,SAAS,EAAE,WAAW;aACvB,CAAC,CAAC;SACJ;IACH,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {Store, Type} from \"@tsed/core\";\n\n/**\n * Attach a Socket Middleware to a method or a class.\n *\n * ### Example\n *\n * A middleware can be also used on a `SocketService` either on a class or on a method.\n *\n * Here an example of a middleware:\n *\n * ```typescript\n * @SocketMiddleware()\n * export class UserConverterSocketMiddleware {\n *     constructor(private converterService: ConverterService) {\n *     }\n *     async use(@Args() args: any[]) {\n *\n *         let [user] = args;\n *         // update Arguments\n *         user = ConverterService.deserialize(user, User);\n *\n *         return [user];\n *     }\n * }\n * ```\n * > The user instance will be forwarded to the next middleware and to your decorated method.\n *\n * Then:\n *\n * ```typescript\n * import {SocketService, SocketUseAfter, SocketUseBefore, Emit, Input, Args} from \"@tsed/socketio\";\n * import {UserConverterSocketMiddleware} from \"../middlewares\";\n * import {User} from \"../models/User\";\n *\n * @SocketService(\"/my-namespace\")\n * @SocketUseBefore(UserConverterSocketMiddleware) // global version\n * export class MySocketService {\n *\n *    @Input(\"eventName\")\n *    @Emit(\"responseEventName\") // or Broadcast or BroadcastOthers\n *    @SocketUseBefore(UserConverterSocketMiddleware)\n *    async myMethod(@Args(0) user: User) {\n *\n *        console.log(user);\n *\n *        return user;\n *    }\n * }\n * ```\n *\n * @returns {(target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void}\n * @decorator\n * @experimental\n * @param middlewares\n */\nexport function SocketUseBefore(...middlewares: Type<any>[]) {\n  return (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => {\n    if (propertyKey) {\n      Store.from(target).merge(\"socketIO\", {\n        handlers: {\n          [propertyKey]: {\n            useBefore: middlewares\n          }\n        }\n      });\n    } else {\n      Store.from(target).merge(\"socketIO\", {\n        useBefore: middlewares\n      });\n    }\n  };\n}\n"]}

package/lib/esm/index.js

@@ -0,0 +1,29 @@
+export * from "./SocketIOModule";
+// interfaces
+export * from "./interfaces";
+export * from "./class/SocketProviderMetadata";
+// decorators
+export * from "./decorators/input";
+export * from "./decorators/args";
+export * from "./decorators/io";
+export * from "./decorators/nsp";
+export * from "./decorators/emit";
+export * from "./decorators/broadcast";
+export * from "./decorators/broadcastOthers";
+export * from "./decorators/inputAndEmit";
+export * from "./decorators/inputAndBroadcast";
+export * from "./decorators/inputAndBroadcastOthers";
+export * from "./decorators/socket";
+export * from "./decorators/socketErr";
+export * from "./decorators/socketFilter";
+export * from "./decorators/socketMiddleware";
+export * from "./decorators/socketMiddlewareError";
+export * from "./decorators/socketService";
+export * from "./decorators/socketSession";
+export * from "./decorators/socketUseAfter";
+export * from "./decorators/socketUseBefore";
+export * from "./decorators/socketEventName";
+// service
+export * from "./services/SocketIOServer";
+export * from "./services/SocketIOService";
+//# sourceMappingURL=index.js.map

package/lib/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AAEjC,aAAa;AACb,cAAc,cAAc,CAAC;AAC7B,cAAc,gCAAgC,CAAC;AAE/C,aAAa;AACb,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAE7C,UAAU;AACV,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC","sourcesContent":["export * from \"./SocketIOModule\";\n\n// interfaces\nexport * from \"./interfaces\";\nexport * from \"./class/SocketProviderMetadata\";\n\n// decorators\nexport * from \"./decorators/input\";\nexport * from \"./decorators/args\";\nexport * from \"./decorators/io\";\nexport * from \"./decorators/nsp\";\nexport * from \"./decorators/emit\";\nexport * from \"./decorators/broadcast\";\nexport * from \"./decorators/broadcastOthers\";\nexport * from \"./decorators/inputAndEmit\";\nexport * from \"./decorators/inputAndBroadcast\";\nexport * from \"./decorators/inputAndBroadcastOthers\";\nexport * from \"./decorators/socket\";\nexport * from \"./decorators/socketErr\";\nexport * from \"./decorators/socketFilter\";\nexport * from \"./decorators/socketMiddleware\";\nexport * from \"./decorators/socketMiddlewareError\";\nexport * from \"./decorators/socketService\";\nexport * from \"./decorators/socketSession\";\nexport * from \"./decorators/socketUseAfter\";\nexport * from \"./decorators/socketUseBefore\";\nexport * from \"./decorators/socketEventName\";\n\n// service\nexport * from \"./services/SocketIOServer\";\nexport * from \"./services/SocketIOService\";\n"]}

package/lib/esm/interfaces/OnNamespaceInit.js

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

package/lib/esm/interfaces/OnNamespaceInit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OnNamespaceInit.js","sourceRoot":"","sources":["../../../src/interfaces/OnNamespaceInit.ts"],"names":[],"mappings":"","sourcesContent":["import {Namespace} from \"socket.io\";\n\n/**\n *\n */\nexport interface OnNamespaceInit {\n  $onNamespaceInit(nsp: Namespace): void;\n}\n"]}

package/lib/esm/interfaces/SocketFilters.js

@@ -0,0 +1,13 @@
+/**
+ * @ignore
+ */
+export var SocketFilters;
+(function (SocketFilters) {
+    SocketFilters["ARGS"] = "args";
+    SocketFilters["SOCKET"] = "socket";
+    SocketFilters["EVENT_NAME"] = "eventName";
+    SocketFilters["NSP"] = "nsp";
+    SocketFilters["SESSION"] = "session";
+    SocketFilters["ERR"] = "error";
+})(SocketFilters || (SocketFilters = {}));
+//# sourceMappingURL=SocketFilters.js.map

package/lib/esm/interfaces/SocketFilters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SocketFilters.js","sourceRoot":"","sources":["../../../src/interfaces/SocketFilters.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAN,IAAY,aAOX;AAPD,WAAY,aAAa;IACvB,8BAAa,CAAA;IACb,kCAAiB,CAAA;IACjB,yCAAwB,CAAA;IACxB,4BAAW,CAAA;IACX,oCAAmB,CAAA;IACnB,8BAAa,CAAA;AACf,CAAC,EAPW,aAAa,KAAb,aAAa,QAOxB","sourcesContent":["/**\n * @ignore\n */\nexport enum SocketFilters {\n  ARGS = \"args\",\n  SOCKET = \"socket\",\n  EVENT_NAME = \"eventName\",\n  NSP = \"nsp\",\n  SESSION = \"session\",\n  ERR = \"error\"\n}\n"]}

package/lib/esm/interfaces/SocketHandlerMetadata.js

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

package/lib/esm/interfaces/SocketHandlerMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SocketHandlerMetadata.js","sourceRoot":"","sources":["../../../src/interfaces/SocketHandlerMetadata.ts"],"names":[],"mappings":"","sourcesContent":["import {SocketParamMetadata} from \"./SocketParamMetadata\";\nimport {SocketReturnsTypes} from \"./SocketReturnsTypes\";\n\n/**\n *\n */\nexport interface SocketHandlerMetadata {\n  eventName?: string;\n  methodClassName: string;\n  useBefore?: any[];\n  useAfter?: any[];\n  parameters?: {[key: number]: SocketParamMetadata};\n  returns?: {\n    type: SocketReturnsTypes;\n    eventName: string;\n  };\n}\n"]}

package/lib/esm/interfaces/SocketInjectableNsp.js

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

package/lib/esm/interfaces/SocketInjectableNsp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SocketInjectableNsp.js","sourceRoot":"","sources":["../../../src/interfaces/SocketInjectableNsp.ts"],"names":[],"mappings":"","sourcesContent":["export interface SocketInjectableNsp {\n  propertyKey: string;\n  nsp?: string;\n}\n"]}

package/lib/esm/interfaces/SocketParamMetadata.js

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

package/lib/esm/interfaces/SocketParamMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SocketParamMetadata.js","sourceRoot":"","sources":["../../../src/interfaces/SocketParamMetadata.ts"],"names":[],"mappings":"","sourcesContent":["import {MetadataTypes} from \"@tsed/core\";\nimport {SocketFilters} from \"./SocketFilters\";\n\nexport interface SocketParamMetadata extends Partial<MetadataTypes> {\n  filter: SocketFilters;\n  mapIndex?: number;\n  useConverter?: boolean;\n}\n"]}

package/lib/esm/interfaces/SocketProviderTypes.js

@@ -0,0 +1,9 @@
+/**
+ *
+ */
+export var SocketProviderTypes;
+(function (SocketProviderTypes) {
+    SocketProviderTypes["SERVICE"] = "service";
+    SocketProviderTypes["MIDDLEWARE"] = "middleware";
+})(SocketProviderTypes || (SocketProviderTypes = {}));
+//# sourceMappingURL=SocketProviderTypes.js.map

package/lib/esm/interfaces/SocketProviderTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SocketProviderTypes.js","sourceRoot":"","sources":["../../../src/interfaces/SocketProviderTypes.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAN,IAAY,mBAGX;AAHD,WAAY,mBAAmB;IAC7B,0CAAmB,CAAA;IACnB,gDAAyB,CAAA;AAC3B,CAAC,EAHW,mBAAmB,KAAnB,mBAAmB,QAG9B","sourcesContent":["/**\n *\n */\nexport enum SocketProviderTypes {\n  SERVICE = \"service\",\n  MIDDLEWARE = \"middleware\"\n}\n"]}

package/lib/esm/interfaces/SocketReturnsTypes.js

@@ -0,0 +1,10 @@
+/**
+ * @ignore
+ */
+export var SocketReturnsTypes;
+(function (SocketReturnsTypes) {
+    SocketReturnsTypes["BROADCAST"] = "broadcast";
+    SocketReturnsTypes["BROADCAST_OTHERS"] = "broadcastOthers";
+    SocketReturnsTypes["EMIT"] = "emit";
+})(SocketReturnsTypes || (SocketReturnsTypes = {}));
+//# sourceMappingURL=SocketReturnsTypes.js.map

package/lib/esm/interfaces/SocketReturnsTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SocketReturnsTypes.js","sourceRoot":"","sources":["../../../src/interfaces/SocketReturnsTypes.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAN,IAAY,kBAIX;AAJD,WAAY,kBAAkB;IAC5B,6CAAuB,CAAA;IACvB,0DAAoC,CAAA;IACpC,mCAAa,CAAA;AACf,CAAC,EAJW,kBAAkB,KAAlB,kBAAkB,QAI7B","sourcesContent":["/**\n * @ignore\n */\nexport enum SocketReturnsTypes {\n  BROADCAST = \"broadcast\",\n  BROADCAST_OTHERS = \"broadcastOthers\",\n  EMIT = \"emit\"\n}\n"]}

package/lib/esm/interfaces/index.js

@@ -0,0 +1,8 @@
+export * from "./SocketHandlerMetadata";
+export * from "./SocketParamMetadata";
+export * from "./SocketProviderTypes";
+export * from "./OnNamespaceInit";
+export * from "./SocketFilters";
+export * from "./SocketReturnsTypes";
+export * from "./SocketInjectableNsp";
+//# sourceMappingURL=index.js.map

package/lib/esm/interfaces/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interfaces/index.ts"],"names":[],"mappings":"AAUA,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC","sourcesContent":["import SocketIO from \"socket.io\";\n\ndeclare global {\n  namespace TsED {\n    interface Configuration {\n      socketIO: Partial<SocketIO.ServerOptions>;\n    }\n  }\n}\n\nexport * from \"./SocketHandlerMetadata\";\nexport * from \"./SocketParamMetadata\";\nexport * from \"./SocketProviderTypes\";\nexport * from \"./OnNamespaceInit\";\nexport * from \"./SocketFilters\";\nexport * from \"./SocketReturnsTypes\";\nexport * from \"./SocketInjectableNsp\";\n"]}

package/lib/esm/registries/NspSessionRegistry.js

@@ -0,0 +1,12 @@
+/**
+ *
+ * @type {Map<any, any>}
+ */
+const SESSIONS = new Map();
+export function getNspSession(namespace = "/") {
+    if (!SESSIONS.has(namespace)) {
+        SESSIONS.set(namespace, new Map());
+    }
+    return SESSIONS.get(namespace);
+}
+//# sourceMappingURL=NspSessionRegistry.js.map

package/lib/esm/registries/NspSessionRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NspSessionRegistry.js","sourceRoot":"","sources":["../../../src/registries/NspSessionRegistry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,QAAQ,GAAkC,IAAI,GAAG,EAAE,CAAC;AAE1D,MAAM,UAAU,aAAa,CAAC,YAAoB,GAAG;IACnD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;QAC5B,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;KACpC;IAED,OAAO,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AACjC,CAAC","sourcesContent":["/**\n *\n * @type {Map<any, any>}\n */\nconst SESSIONS: Map<string, Map<string, any>> = new Map();\n\nexport function getNspSession(namespace: string = \"/\") {\n  if (!SESSIONS.has(namespace)) {\n    SESSIONS.set(namespace, new Map());\n  }\n\n  return SESSIONS.get(namespace);\n}\n"]}

package/lib/esm/services/SocketIOServer.js

@@ -0,0 +1,12 @@
+import { registerProvider } from "@tsed/common";
+import { Server } from "socket.io";
+// tslint:disable-next-line: variable-name
+export const SocketIOServer = Server;
+export { Server };
+registerProvider({
+    provide: Server,
+    useFactory() {
+        return new Server();
+    }
+});
+//# sourceMappingURL=SocketIOServer.js.map

package/lib/esm/services/SocketIOServer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SocketIOServer.js","sourceRoot":"","sources":["../../../src/services/SocketIOServer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAC,MAAM,EAAC,MAAM,WAAW,CAAC;AAIjC,0CAA0C;AAC1C,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC;AAErC,OAAO,EAAC,MAAM,EAAC,CAAC;AAEhB,gBAAgB,CAAC;IACf,OAAO,EAAE,MAAM;IACf,UAAU;QACR,OAAO,IAAI,MAAM,EAAE,CAAC;IACtB,CAAC;CACF,CAAC,CAAC","sourcesContent":["import {registerProvider} from \"@tsed/common\";\nimport {Server} from \"socket.io\";\n\nexport type SocketIOServer = Server;\n\n// tslint:disable-next-line: variable-name\nexport const SocketIOServer = Server;\n\nexport {Server};\n\nregisterProvider({\n  provide: Server,\n  useFactory() {\n    return new Server();\n  }\n});\n"]}

package/lib/esm/services/SocketIOService.js

@@ -0,0 +1,64 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { ConverterService, InjectorService, Service } from "@tsed/common";
+import SocketIO from "socket.io"; // tslint:disable-line: no-unused-variable
+import { SocketHandlersBuilder } from "../class/SocketHandlersBuilder";
+import { SocketProviderMetadata } from "../class/SocketProviderMetadata";
+import { IO } from "../decorators/io";
+/**
+ *
+ */
+let SocketIOService = class SocketIOService {
+    constructor(injector, io, converterService) {
+        this.injector = injector;
+        this.io = io;
+        this.converterService = converterService;
+        /**
+         *
+         * @type {Map<any, any>}
+         */
+        this.namespaces = new Map();
+    }
+    /**
+     *
+     * @param {string} namespace
+     * @returns {SocketIO.Namespace}
+     */
+    getNsp(namespace = "/") {
+        if (!this.namespaces.has(namespace)) {
+            const conf = { nsp: this.io.of(namespace), instances: [] };
+            this.namespaces.set(namespace, conf);
+            conf.nsp.on("connection", (socket) => {
+                conf.instances.forEach((builder) => {
+                    builder.onConnection(socket, conf.nsp);
+                });
+                socket.on("disconnect", () => {
+                    conf.instances.forEach((builder) => {
+                        builder.onDisconnect(socket, conf.nsp);
+                    });
+                });
+            });
+        }
+        return this.namespaces.get(namespace);
+    }
+    /**
+     *
+     * @param {Provider<any>} provider
+     */
+    addSocketProvider(provider) {
+        const wsConfig = new SocketProviderMetadata(provider.store.get("socketIO"));
+        const nspConfig = this.getNsp(wsConfig.namespace);
+        const nsps = new Map();
+        this.namespaces.forEach((value, nsp) => {
+            nsps.set(nsp, value.nsp);
+        });
+        const builder = new SocketHandlersBuilder(provider, this.converterService, this.injector).build(nsps);
+        nspConfig.instances.push(builder);
+    }
+};
+SocketIOService = __decorate([
+    Service(),
+    __param(1, IO),
+    __metadata("design:paramtypes", [InjectorService, SocketIO.Server, ConverterService])
+], SocketIOService);
+export { SocketIOService };
+//# sourceMappingURL=SocketIOService.js.map

package/lib/esm/services/SocketIOService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SocketIOService.js","sourceRoot":"","sources":["../../../src/services/SocketIOService.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,gBAAgB,EAAE,eAAe,EAAY,OAAO,EAAC,MAAM,cAAc,CAAC;AAClF,OAAO,QAAQ,MAAM,WAAW,CAAC,CAAC,0CAA0C;AAC5E,OAAO,EAAC,qBAAqB,EAAC,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAC,sBAAsB,EAAC,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAC,EAAE,EAAC,MAAM,kBAAkB,CAAC;AAEpC;;GAEG;AAEH,IAAa,eAAe,GAA5B,MAAa,eAAe;IAO1B,YAAoB,QAAyB,EAAc,EAAmB,EAAU,gBAAkC;QAAtG,aAAQ,GAAR,QAAQ,CAAiB;QAAc,OAAE,GAAF,EAAE,CAAiB;QAAU,qBAAgB,GAAhB,gBAAgB,CAAkB;QAN1H;;;WAGG;QACK,eAAU,GAA2D,IAAI,GAAG,EAAE,CAAC;IAEsC,CAAC;IAE9H;;;;OAIG;IACI,MAAM,CAAC,YAAoB,GAAG;QACnC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;YACnC,MAAM,IAAI,GAAG,EAAC,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,EAAC,CAAC;YAEzD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;YAErC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC,MAAM,EAAE,EAAE;gBACnC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,OAA8B,EAAE,EAAE;oBACxD,OAAO,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;gBACzC,CAAC,CAAC,CAAC;gBAEH,MAAM,CAAC,EAAE,CAAC,YAAY,EAAE,GAAG,EAAE;oBAC3B,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,OAA8B,EAAE,EAAE;wBACxD,OAAO,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;oBACzC,CAAC,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;SACJ;QAED,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAE,CAAC;IACzC,CAAC;IAED;;;OAGG;IACI,iBAAiB,CAAC,QAAuB;QAC9C,MAAM,QAAQ,GAA2B,IAAI,sBAAsB,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC;QAEpG,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAClD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAE,CAAC;QAEvB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;YACrC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;QAEH,MAAM,OAAO,GAAG,IAAI,qBAAqB,CAAC,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAEtG,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;CACF,CAAA;AAtDY,eAAe;IAD3B,OAAO,EAAE;IAQwC,WAAA,EAAE,CAAA;qCAApB,eAAe,EAAkB,QAAQ,CAAC,MAAM,EAA4B,gBAAgB;GAP/G,eAAe,CAsD3B;SAtDY,eAAe","sourcesContent":["import {ConverterService, InjectorService, Provider, Service} from \"@tsed/common\";\nimport SocketIO from \"socket.io\"; // tslint:disable-line: no-unused-variable\nimport {SocketHandlersBuilder} from \"../class/SocketHandlersBuilder\";\nimport {SocketProviderMetadata} from \"../class/SocketProviderMetadata\";\nimport {IO} from \"../decorators/io\";\n\n/**\n *\n */\n@Service()\nexport class SocketIOService {\n  /**\n   *\n   * @type {Map<any, any>}\n   */\n  private namespaces: Map<string, {nsp: SocketIO.Namespace; instances: any}> = new Map();\n\n  constructor(private injector: InjectorService, @IO private io: SocketIO.Server, private converterService: ConverterService) {}\n\n  /**\n   *\n   * @param {string} namespace\n   * @returns {SocketIO.Namespace}\n   */\n  public getNsp(namespace: string = \"/\"): {nsp: SocketIO.Namespace; instances: any[]} {\n    if (!this.namespaces.has(namespace)) {\n      const conf = {nsp: this.io.of(namespace), instances: []};\n\n      this.namespaces.set(namespace, conf);\n\n      conf.nsp.on(\"connection\", (socket) => {\n        conf.instances.forEach((builder: SocketHandlersBuilder) => {\n          builder.onConnection(socket, conf.nsp);\n        });\n\n        socket.on(\"disconnect\", () => {\n          conf.instances.forEach((builder: SocketHandlersBuilder) => {\n            builder.onDisconnect(socket, conf.nsp);\n          });\n        });\n      });\n    }\n\n    return this.namespaces.get(namespace)!;\n  }\n\n  /**\n   *\n   * @param {Provider<any>} provider\n   */\n  public addSocketProvider(provider: Provider<any>) {\n    const wsConfig: SocketProviderMetadata = new SocketProviderMetadata(provider.store.get(\"socketIO\"));\n\n    const nspConfig = this.getNsp(wsConfig.namespace);\n    const nsps = new Map();\n\n    this.namespaces.forEach((value, nsp) => {\n      nsps.set(nsp, value.nsp);\n    });\n\n    const builder = new SocketHandlersBuilder(provider, this.converterService, this.injector).build(nsps);\n\n    nspConfig.instances.push(builder);\n  }\n}\n"]}

package/lib/types/SocketIOModule.d.ts

@@ -0,0 +1,29 @@
+import { AfterListen, HttpServer, HttpsServer, InjectorService, OnDestroy, Provider } from "@tsed/common";
+import { Server, ServerOptions } from "socket.io";
+import { SocketIOService } from "./services/SocketIOService";
+/**
+ * @ignore
+ */
+export declare class SocketIOModule implements AfterListen, OnDestroy {
+    private injector;
+    private httpServer;
+    private httpsServer;
+    private io;
+    private socketIOService;
+    disableRoutesSummary: boolean;
+    settings: Partial<ServerOptions>;
+    httpPort: string | number;
+    httpsPort: string | number;
+    constructor(injector: InjectorService, httpServer: HttpServer, httpsServer: HttpsServer, io: Server, socketIOService: SocketIOService);
+    $afterListen(): Promise<void>;
+    $onDestroy(): void;
+    /**
+     *
+     * @returns {Provider<any>[]}
+     */
+    protected getWebsocketServices(): Provider<any>[];
+    /**
+     *
+     */
+    protected printSocketEvents(): void;
+}