@tsed/socketio 7.0.0-alpha.1 → 7.0.0-beta.10

package/lib/esm/decorators/socketFilter.js

@@ -0,0 +1,25 @@
+import { Store } from "@tsed/core";
+/**
+ *
+ * @param {SocketFilters} filter
+ * @param {number} mapIndex
+ * @returns {(target: any, propertyKey: string, index: number) => Store}
+ * @decorator
+ */
+export function SocketFilter(filter, mapIndex) {
+    return (target, propertyKey, index) => {
+        Store.from(target).merge("socketIO", {
+            handlers: {
+                [propertyKey]: {
+                    parameters: {
+                        [index]: {
+                            filter,
+                            mapIndex
+                        }
+                    }
+                }
+            }
+        });
+    };
+}
+//# sourceMappingURL=socketFilter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"socketFilter.js","sourceRoot":"","sources":["../../../src/decorators/socketFilter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AAGjC;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,MAAqB,EAAE,QAAiB;IACnE,OAAO,CAAC,MAAW,EAAE,WAAmB,EAAE,KAAa,EAAE,EAAE;QACzD,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE;YACnC,QAAQ,EAAE;gBACR,CAAC,WAAW,CAAC,EAAE;oBACb,UAAU,EAAE;wBACV,CAAC,KAAK,CAAC,EAAE;4BACP,MAAM;4BACN,QAAQ;yBACT;qBACF;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {Store} from \"@tsed/core\";\nimport {SocketFilters} from \"../interfaces/SocketFilters\";\n\n/**\n *\n * @param {SocketFilters} filter\n * @param {number} mapIndex\n * @returns {(target: any, propertyKey: string, index: number) => Store}\n * @decorator\n */\nexport function SocketFilter(filter: SocketFilters, mapIndex?: number) {\n  return (target: any, propertyKey: string, index: number) => {\n    Store.from(target).merge(\"socketIO\", {\n      handlers: {\n        [propertyKey]: {\n          parameters: {\n            [index]: {\n              filter,\n              mapIndex\n            }\n          }\n        }\n      }\n    });\n  };\n}\n"]}

package/lib/esm/decorators/socketMiddleware.js

@@ -0,0 +1,70 @@
+import { Middleware } from "@tsed/platform-middlewares";
+import { Store } from "@tsed/core";
+import { SocketProviderTypes } from "../interfaces/SocketProviderTypes.js";
+/**
+ * Declare a new SocketMiddleware.
+ *
+ * ### 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 = this.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 {Function}
+ * @decorator
+ * @experimental
+ */
+export function SocketMiddleware() {
+    return (target) => {
+        Store.from(target).merge("socketIO", {
+            type: SocketProviderTypes.MIDDLEWARE,
+            handlers: {
+                use: {
+                    methodClassName: "use"
+                }
+            }
+        });
+        return Middleware()(target);
+    };
+}
+//# sourceMappingURL=socketMiddleware.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"socketMiddleware.js","sourceRoot":"","sources":["../../../src/decorators/socketMiddleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,4BAA4B,CAAC;AACtD,OAAO,EAAC,KAAK,EAAO,MAAM,YAAY,CAAC;AACvC,OAAO,EAAC,mBAAmB,EAAC,MAAM,mCAAmC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,CAAC,MAAiB,EAAE,EAAE;QAC3B,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE;YACnC,IAAI,EAAE,mBAAmB,CAAC,UAAU;YACpC,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/platform-middlewares\";\nimport {Store, Type} from \"@tsed/core\";\nimport {SocketProviderTypes} from \"../interfaces/SocketProviderTypes\";\n\n/**\n * Declare a new SocketMiddleware.\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 = this.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 {Function}\n * @decorator\n * @experimental\n */\nexport function SocketMiddleware(): Function {\n  return (target: Type<any>) => {\n    Store.from(target).merge(\"socketIO\", {\n      type: SocketProviderTypes.MIDDLEWARE,\n      handlers: {\n        use: {\n          methodClassName: \"use\"\n        }\n      }\n    });\n\n    return Middleware()(target);\n  };\n}\n"]}

package/lib/esm/decorators/socketMiddlewareError.js

@@ -0,0 +1,67 @@
+import { Middleware } from "@tsed/platform-middlewares";
+import { Store } from "@tsed/core";
+import { SocketProviderTypes } from "../interfaces/SocketProviderTypes.js";
+/**
+ * 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,4BAA4B,CAAC;AACtD,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/platform-middlewares\";\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.js";
+import { PROVIDER_TYPE_SOCKET_SERVICE } from "../constants/constants.js";
+/**
+ * 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,wBAAwB,CAAC;AAEpE;;;;;;;;;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/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.js";
+import { SocketFilter } from "./socketFilter.js";
+/**
+ * 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,40 @@
+/**
+ * @file Automatically generated by barrelsby.
+ */
+export * from "./SocketIOModule.js";
+export * from "./class/SocketHandlersBuilder.js";
+export * from "./class/SocketProviderMetadata.js";
+export * from "./constants/constants.js";
+export * from "./decorators/args.js";
+export * from "./decorators/broadcast.js";
+export * from "./decorators/broadcastOthers.js";
+export * from "./decorators/emit.js";
+export * from "./decorators/input.js";
+export * from "./decorators/inputAndBroadcast.js";
+export * from "./decorators/inputAndBroadcastOthers.js";
+export * from "./decorators/inputAndEmit.js";
+export * from "./decorators/io.js";
+export * from "./decorators/nsp.js";
+export * from "./decorators/socket.js";
+export * from "./decorators/socketErr.js";
+export * from "./decorators/socketEventName.js";
+export * from "./decorators/socketFilter.js";
+export * from "./decorators/socketMiddleware.js";
+export * from "./decorators/socketMiddlewareError.js";
+export * from "./decorators/socketReturns.js";
+export * from "./decorators/socketService.js";
+export * from "./decorators/socketSession.js";
+export * from "./decorators/socketUseAfter.js";
+export * from "./decorators/socketUseBefore.js";
+export * from "./interfaces/OnNamespaceInit.js";
+export * from "./interfaces/SocketFilters.js";
+export * from "./interfaces/SocketHandlerMetadata.js";
+export * from "./interfaces/SocketInjectableNsp.js";
+export * from "./interfaces/SocketParamMetadata.js";
+export * from "./interfaces/SocketProviderTypes.js";
+export * from "./interfaces/SocketReturnsTypes.js";
+export * from "./interfaces/interfaces.js";
+export * from "./registries/NspSessionRegistry.js";
+export * from "./services/SocketIOServer.js";
+export * from "./services/SocketIOService.js";
+//# 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;;GAEG;AAEH,cAAc,kBAAkB,CAAC;AACjC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oCAAoC,CAAC;AACnD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC","sourcesContent":["/**\n * @file Automatically generated by barrelsby.\n */\n\nexport * from \"./SocketIOModule\";\nexport * from \"./class/SocketHandlersBuilder\";\nexport * from \"./class/SocketProviderMetadata\";\nexport * from \"./constants/constants\";\nexport * from \"./decorators/args\";\nexport * from \"./decorators/broadcast\";\nexport * from \"./decorators/broadcastOthers\";\nexport * from \"./decorators/emit\";\nexport * from \"./decorators/input\";\nexport * from \"./decorators/inputAndBroadcast\";\nexport * from \"./decorators/inputAndBroadcastOthers\";\nexport * from \"./decorators/inputAndEmit\";\nexport * from \"./decorators/io\";\nexport * from \"./decorators/nsp\";\nexport * from \"./decorators/socket\";\nexport * from \"./decorators/socketErr\";\nexport * from \"./decorators/socketEventName\";\nexport * from \"./decorators/socketFilter\";\nexport * from \"./decorators/socketMiddleware\";\nexport * from \"./decorators/socketMiddlewareError\";\nexport * from \"./decorators/socketReturns\";\nexport * from \"./decorators/socketService\";\nexport * from \"./decorators/socketSession\";\nexport * from \"./decorators/socketUseAfter\";\nexport * from \"./decorators/socketUseBefore\";\nexport * from \"./interfaces/OnNamespaceInit\";\nexport * from \"./interfaces/SocketFilters\";\nexport * from \"./interfaces/SocketHandlerMetadata\";\nexport * from \"./interfaces/SocketInjectableNsp\";\nexport * from \"./interfaces/SocketParamMetadata\";\nexport * from \"./interfaces/SocketProviderTypes\";\nexport * from \"./interfaces/SocketReturnsTypes\";\nexport * from \"./interfaces/interfaces\";\nexport * from \"./registries/NspSessionRegistry\";\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/interfaces.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../src/interfaces/interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import SocketIO from \"socket.io\";\n\ndeclare global {\n  namespace TsED {\n    interface Configuration {\n      socketIO: Partial<SocketIO.ServerOptions>;\n    }\n  }\n}\n"]}

package/lib/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

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/di";
+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,UAAU,CAAC;AAC1C,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/di\";\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"]}