@tsed/socketio 6.87.1 → 6.89.0

package/lib/esm/decorators/args.js

@@ -0,0 +1,57 @@
+import { isCollection, Metadata, Store } from "@tsed/core";
+import { SocketFilters } from "../interfaces/SocketFilters";
+/**
+ * Inject the list of arguments in the decorated parameter.
+ *
+ * `@Args` accept an index parameter to pick up directly the item in the arguments list.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   myMethod(@Args() arguments: any[]) {
+ *
+ *   }
+ *
+ *   @Input("event2")
+ *   myMethod2(@Args(0) data: any) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param mapIndex
+ * @param useType
+ */
+export function Args(mapIndex, useType) {
+    return (target, propertyKey, index) => {
+        const store = Store.from(target);
+        const type = Metadata.getParamTypes(target, propertyKey)[index];
+        const param = {
+            filter: SocketFilters.ARGS,
+            useConverter: false
+        };
+        if (mapIndex !== undefined) {
+            Object.assign(param, {
+                mapIndex,
+                useConverter: true,
+                type: useType || type,
+                collectionType: isCollection(type) ? type : undefined
+            });
+        }
+        store.merge("socketIO", {
+            handlers: {
+                [propertyKey]: {
+                    parameters: {
+                        [index]: param
+                    }
+                }
+            }
+        });
+    };
+}
+//# sourceMappingURL=args.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"args.js","sourceRoot":"","sources":["../../../src/decorators/args.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,QAAQ,EAAE,KAAK,EAAC,MAAM,YAAY,CAAC;AACzD,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,IAAI,CAAC,QAAiB,EAAE,OAAa;IACnD,OAAO,CAAC,MAAW,EAAE,WAAmB,EAAE,KAAa,EAAE,EAAE;QACzD,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACjC,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC;QAChE,MAAM,KAAK,GAAG;YACZ,MAAM,EAAE,aAAa,CAAC,IAAI;YAC1B,YAAY,EAAE,KAAK;SACpB,CAAC;QAEF,IAAI,QAAQ,KAAK,SAAS,EAAE;YAC1B,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE;gBACnB,QAAQ;gBACR,YAAY,EAAE,IAAI;gBAClB,IAAI,EAAE,OAAO,IAAI,IAAI;gBACrB,cAAc,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;aACtD,CAAC,CAAC;SACJ;QAED,KAAK,CAAC,KAAK,CAAC,UAAU,EAAE;YACtB,QAAQ,EAAE;gBACR,CAAC,WAAW,CAAC,EAAE;oBACb,UAAU,EAAE;wBACV,CAAC,KAAK,CAAC,EAAE,KAAK;qBACf;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {isCollection, Metadata, Store} from \"@tsed/core\";\nimport {SocketFilters} from \"../interfaces/SocketFilters\";\n\n/**\n * Inject the list of arguments in the decorated parameter.\n *\n * `@Args` accept an index parameter to pick up directly the item in the arguments list.\n *\n * ### Example\n *\n * ```typescript\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *\n *   @Input(\"event\")\n *   myMethod(@Args() arguments: any[]) {\n *\n *   }\n *\n *   @Input(\"event2\")\n *   myMethod2(@Args(0) data: any) {\n *\n *   }\n * }\n * ```\n *\n * @decorator\n * @param mapIndex\n * @param useType\n */\nexport function Args(mapIndex?: number, useType?: any): any {\n  return (target: any, propertyKey: string, index: number) => {\n    const store = Store.from(target);\n    const type = Metadata.getParamTypes(target, propertyKey)[index];\n    const param = {\n      filter: SocketFilters.ARGS,\n      useConverter: false\n    };\n\n    if (mapIndex !== undefined) {\n      Object.assign(param, {\n        mapIndex,\n        useConverter: true,\n        type: useType || type,\n        collectionType: isCollection(type) ? type : undefined\n      });\n    }\n\n    store.merge(\"socketIO\", {\n      handlers: {\n        [propertyKey]: {\n          parameters: {\n            [index]: param\n          }\n        }\n      }\n    });\n  };\n}\n"]}

package/lib/esm/decorators/broadcast.js

@@ -0,0 +1,28 @@
+import { SocketReturnsTypes } from "../interfaces/SocketReturnsTypes";
+import { SocketReturns } from "./socketReturns";
+/**
+ * Broadcast the response for all client registered in the same namespace.
+ *
+ * With the `@Broadcast` decorator, the method will accept a return type (Promise or not).
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   @Broadcast("returnEvent")
+ *   async myMethod(@Args(0) data: any, @Nsp socket): Promise<any> {
+ *      return Promise.resolve({data})
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function Broadcast(eventName) {
+    return SocketReturns(eventName, SocketReturnsTypes.BROADCAST);
+}
+//# sourceMappingURL=broadcast.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"broadcast.js","sourceRoot":"","sources":["../../../src/decorators/broadcast.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAC,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,SAAS,CAAC,SAAiB;IACzC,OAAO,aAAa,CAAC,SAAS,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAChE,CAAC","sourcesContent":["import {SocketReturnsTypes} from \"../interfaces/SocketReturnsTypes\";\nimport {SocketReturns} from \"./socketReturns\";\n\n/**\n * Broadcast the response for all client registered in the same namespace.\n *\n * With the `@Broadcast` decorator, the method will accept a return type (Promise or not).\n *\n * ### Example\n *\n * ```typescript\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *\n *   @Input(\"event\")\n *   @Broadcast(\"returnEvent\")\n *   async myMethod(@Args(0) data: any, @Nsp socket): Promise<any> {\n *      return Promise.resolve({data})\n *   }\n * }\n * ```\n *\n * @decorator\n * @param eventName\n */\nexport function Broadcast(eventName: string) {\n  return SocketReturns(eventName, SocketReturnsTypes.BROADCAST);\n}\n"]}

package/lib/esm/decorators/broadcastOthers.js

@@ -0,0 +1,28 @@
+import { SocketReturnsTypes } from "../interfaces/SocketReturnsTypes";
+import { SocketReturns } from "./socketReturns";
+/**
+ * Broadcast the response for all client registered in the same namespace except to the current client.
+ *
+ * With the `@BroadcastOthers` decorator, the method will accept a return type (Promise or not).
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   @BroadcastOthers("returnEvent")
+ *   async myMethod(@Args(0) data: any, @Nsp socket): Promise<any> {
+ *      return Promise.resolve({data})
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function BroadcastOthers(eventName) {
+    return SocketReturns(eventName, SocketReturnsTypes.BROADCAST_OTHERS);
+}
+//# sourceMappingURL=broadcastOthers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"broadcastOthers.js","sourceRoot":"","sources":["../../../src/decorators/broadcastOthers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAC,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,eAAe,CAAC,SAAiB;IAC/C,OAAO,aAAa,CAAC,SAAS,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;AACvE,CAAC","sourcesContent":["import {SocketReturnsTypes} from \"../interfaces/SocketReturnsTypes\";\nimport {SocketReturns} from \"./socketReturns\";\n\n/**\n * Broadcast the response for all client registered in the same namespace except to the current client.\n *\n * With the `@BroadcastOthers` decorator, the method will accept a return type (Promise or not).\n *\n * ### Example\n *\n * ```typescript\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *\n *   @Input(\"event\")\n *   @BroadcastOthers(\"returnEvent\")\n *   async myMethod(@Args(0) data: any, @Nsp socket): Promise<any> {\n *      return Promise.resolve({data})\n *   }\n * }\n * ```\n *\n * @decorator\n * @param eventName\n */\nexport function BroadcastOthers(eventName: string) {\n  return SocketReturns(eventName, SocketReturnsTypes.BROADCAST_OTHERS);\n}\n"]}

package/lib/esm/decorators/emit.js

@@ -0,0 +1,28 @@
+import { SocketReturnsTypes } from "../interfaces/SocketReturnsTypes";
+import { SocketReturns } from "./socketReturns";
+/**
+ * Emit the response to the client.
+ *
+ * With the `@Emit` decorator, the method will accept a return type (Promise or not).
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   @Emit("returnEvent")
+ *   async myMethod(@Args(0) data: any, @Nsp socket): Promise<any> {
+ *      return Promise.resolve({data})
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function Emit(eventName) {
+    return SocketReturns(eventName, SocketReturnsTypes.EMIT);
+}
+//# sourceMappingURL=emit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emit.js","sourceRoot":"","sources":["../../../src/decorators/emit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAC,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,IAAI,CAAC,SAAiB;IACpC,OAAO,aAAa,CAAC,SAAS,EAAE,kBAAkB,CAAC,IAAI,CAAC,CAAC;AAC3D,CAAC","sourcesContent":["import {SocketReturnsTypes} from \"../interfaces/SocketReturnsTypes\";\nimport {SocketReturns} from \"./socketReturns\";\n\n/**\n * Emit the response to the client.\n *\n * With the `@Emit` decorator, the method will accept a return type (Promise or not).\n *\n * ### Example\n *\n * ```typescript\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *\n *   @Input(\"event\")\n *   @Emit(\"returnEvent\")\n *   async myMethod(@Args(0) data: any, @Nsp socket): Promise<any> {\n *      return Promise.resolve({data})\n *   }\n * }\n * ```\n *\n * @decorator\n * @param eventName\n */\nexport function Emit(eventName: string) {\n  return SocketReturns(eventName, SocketReturnsTypes.EMIT);\n}\n"]}

package/lib/esm/decorators/input.js

@@ -0,0 +1,33 @@
+import { Store } from "@tsed/core";
+/**
+ * Attach the decorated method to the socket event.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   myMethod(@Args(0) data: any, @Nsp socket) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function Input(eventName) {
+    return (target, propertyKey, descriptor) => {
+        Store.from(target).merge("socketIO", {
+            handlers: {
+                [propertyKey]: {
+                    eventName,
+                    methodClassName: propertyKey
+                }
+            }
+        });
+    };
+}
+//# sourceMappingURL=input.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"input.js","sourceRoot":"","sources":["../../../src/decorators/input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AAEjC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,KAAK,CAAC,SAAiB;IACrC,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,SAAS;oBACT,eAAe,EAAE,WAAW;iBAC7B;aACF;SACF,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {Store} from \"@tsed/core\";\n\n/**\n * Attach the decorated method to the socket event.\n *\n * ### Example\n *\n * ```typescript\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *\n *   @Input(\"event\")\n *   myMethod(@Args(0) data: any, @Nsp socket) {\n *\n *   }\n * }\n * ```\n *\n * @decorator\n * @param eventName\n */\nexport function Input(eventName: string) {\n  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {\n    Store.from(target).merge(\"socketIO\", {\n      handlers: {\n        [propertyKey]: {\n          eventName,\n          methodClassName: propertyKey\n        }\n      }\n    });\n  };\n}\n"]}

package/lib/esm/decorators/inputAndBroadcast.js

@@ -0,0 +1,28 @@
+import { Broadcast } from "./broadcast";
+import { Input } from "./input";
+/**
+ * Attach the decorated method to the socket event and broadcast the response to all clients.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @InputAndBroadcast("event")
+ *   async myMethod(@Args(0) data: any, @Nsp socket) {
+ *      return {data: "data"};
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function InputAndBroadcast(eventName) {
+    return (target, propertyKey, descriptor) => {
+        Input(eventName)(target, propertyKey, descriptor);
+        Broadcast(eventName)(target, propertyKey, descriptor);
+    };
+}
+//# sourceMappingURL=inputAndBroadcast.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inputAndBroadcast.js","sourceRoot":"","sources":["../../../src/decorators/inputAndBroadcast.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,KAAK,EAAC,MAAM,SAAS,CAAC;AAE9B;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAAC,SAAiB;IACjD,OAAO,CAAC,MAAW,EAAE,WAAmB,EAAE,UAA8B,EAAE,EAAE;QAC1E,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QAClD,SAAS,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;IACxD,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {Broadcast} from \"./broadcast\";\nimport {Input} from \"./input\";\n\n/**\n * Attach the decorated method to the socket event and broadcast the response to all clients.\n *\n * ### Example\n *\n * ```typescript\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *\n *   @InputAndBroadcast(\"event\")\n *   async myMethod(@Args(0) data: any, @Nsp socket) {\n *      return {data: \"data\"};\n *   }\n * }\n * ```\n *\n * @decorator\n * @param eventName\n */\nexport function InputAndBroadcast(eventName: string) {\n  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {\n    Input(eventName)(target, propertyKey, descriptor);\n    Broadcast(eventName)(target, propertyKey, descriptor);\n  };\n}\n"]}

package/lib/esm/decorators/inputAndBroadcastOthers.js

@@ -0,0 +1,28 @@
+import { BroadcastOthers } from "./broadcastOthers";
+import { Input } from "./input";
+/**
+ * Attach the decorated method to the socket event and broadcast the response to all clients with the exception of the connected customer.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @InputAndBroadcastOthers("event")
+ *   async myMethod(@Args(0) data: any, @Nsp socket) {
+ *      return {data: "data"};
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function InputAndBroadcastOthers(eventName) {
+    return (target, propertyKey, descriptor) => {
+        Input(eventName)(target, propertyKey, descriptor);
+        BroadcastOthers(eventName)(target, propertyKey, descriptor);
+    };
+}
+//# sourceMappingURL=inputAndBroadcastOthers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inputAndBroadcastOthers.js","sourceRoot":"","sources":["../../../src/decorators/inputAndBroadcastOthers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAC,KAAK,EAAC,MAAM,SAAS,CAAC;AAE9B;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,uBAAuB,CAAC,SAAiB;IACvD,OAAO,CAAC,MAAW,EAAE,WAAmB,EAAE,UAA8B,EAAE,EAAE;QAC1E,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QAClD,eAAe,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;IAC9D,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {BroadcastOthers} from \"./broadcastOthers\";\nimport {Input} from \"./input\";\n\n/**\n * Attach the decorated method to the socket event and broadcast the response to all clients with the exception of the connected customer.\n *\n * ### Example\n *\n * ```typescript\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *\n *   @InputAndBroadcastOthers(\"event\")\n *   async myMethod(@Args(0) data: any, @Nsp socket) {\n *      return {data: \"data\"};\n *   }\n * }\n * ```\n *\n * @decorator\n * @param eventName\n */\nexport function InputAndBroadcastOthers(eventName: string) {\n  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {\n    Input(eventName)(target, propertyKey, descriptor);\n    BroadcastOthers(eventName)(target, propertyKey, descriptor);\n  };\n}\n"]}

package/lib/esm/decorators/inputAndEmit.js

@@ -0,0 +1,28 @@
+import { Emit } from "./emit";
+import { Input } from "./input";
+/**
+ * Attach the decorated method to the socket event and emit the response to the client.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @InputAndEmit("event")
+ *   async myMethod(@Args(0) data: any, @Nsp socket) {
+ *      return {data: "data"};
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function InputAndEmit(eventName) {
+    return (target, propertyKey, descriptor) => {
+        Input(eventName)(target, propertyKey, descriptor);
+        Emit(eventName)(target, propertyKey, descriptor);
+    };
+}
+//# sourceMappingURL=inputAndEmit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inputAndEmit.js","sourceRoot":"","sources":["../../../src/decorators/inputAndEmit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAC,KAAK,EAAC,MAAM,SAAS,CAAC;AAE9B;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,YAAY,CAAC,SAAiB;IAC5C,OAAO,CAAC,MAAW,EAAE,WAAmB,EAAE,UAA8B,EAAE,EAAE;QAC1E,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QAClD,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;IACnD,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {Emit} from \"./emit\";\nimport {Input} from \"./input\";\n\n/**\n * Attach the decorated method to the socket event and emit the response to the client.\n *\n * ### Example\n *\n * ```typescript\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *\n *   @InputAndEmit(\"event\")\n *   async myMethod(@Args(0) data: any, @Nsp socket) {\n *      return {data: \"data\"};\n *   }\n * }\n * ```\n *\n * @decorator\n * @param eventName\n */\nexport function InputAndEmit(eventName: string) {\n  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {\n    Input(eventName)(target, propertyKey, descriptor);\n    Emit(eventName)(target, propertyKey, descriptor);\n  };\n}\n"]}

package/lib/esm/decorators/io.js

@@ -0,0 +1,23 @@
+import { Inject } from "@tsed/common";
+import { Server } from "../services/SocketIOServer";
+/**
+ * Inject the [SocketIO.Server](https://socket.io/docs/server-api/) instance in the decorated parameter.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *   constructor(@IO private io: Server) {}
+ * }
+ * ```
+ *
+ * @param target
+ * @param targetKey
+ * @param descriptor
+ * @decorator
+ */
+export function IO(target, targetKey, descriptor) {
+    return Inject(Server)(target, targetKey, descriptor);
+}
+//# sourceMappingURL=io.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"io.js","sourceRoot":"","sources":["../../../src/decorators/io.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,cAAc,CAAC;AAEpC,OAAO,EAAC,MAAM,EAAC,MAAM,4BAA4B,CAAC;AAElD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,EAAE,CAAC,MAAiB,EAAE,SAAiB,EAAE,UAAsD;IAC7G,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;AACvD,CAAC","sourcesContent":["import {Inject} from \"@tsed/common\";\nimport {Type} from \"@tsed/core\";\nimport {Server} from \"../services/SocketIOServer\";\n\n/**\n * Inject the [SocketIO.Server](https://socket.io/docs/server-api/) instance in the decorated parameter.\n *\n * ### Example\n *\n * ```typescript\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *   constructor(@IO private io: Server) {}\n * }\n * ```\n *\n * @param target\n * @param targetKey\n * @param descriptor\n * @decorator\n */\nexport function IO(target: Type<any>, targetKey: string, descriptor: TypedPropertyDescriptor<Function> | number) {\n  return Inject(Server)(target, targetKey, descriptor);\n}\n"]}

package/lib/esm/decorators/nsp.js

@@ -0,0 +1,83 @@
+import { decoratorTypeOf, DecoratorTypes, Store } from "@tsed/core";
+import { SocketFilters } from "../interfaces/SocketFilters";
+import { SocketFilter } from "./socketFilter";
+/**
+ * Inject the [SocketIO.Namespace](https://socket.io/docs/rooms-and-namespaces/#namespaces) instance in the decorated parameter.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * import {Nsp, SocketService, Input} from "@tsed/socketio";
+ *
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Nsp
+ *   nsp: SocketIO.Namespace; // will inject SocketIO.Namespace (not available on constructor)
+ *
+ *   @Nsp("/my-other-namespace")
+ *   nspOther: SocketIO.Namespace; // communication between two namespace
+ *
+ *   @Input("event")
+ *   myMethod(@Nsp namespace: SocketIO.Namespace) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @decorator
+ */
+export function Nsp(target, propertyKey, index) {
+    return Namespace(target, propertyKey, index);
+}
+/**
+ * Inject the [SocketIO.Namespace](https://socket.io/docs/rooms-and-namespaces/#namespaces) instance in the decorated parameter.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * import {Namespace, SocketService, Input} from "@tsed/socketio";
+ *
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Nsp
+ *   nsp: Namespace; // will inject SocketIO.Namespace (not available on constructor)
+ *
+ *   @Nsp("/my-other-namespace")
+ *   nspOther: Namespace; // communication between two namespace
+ *
+ *   @Input("event")
+ *   myMethod(@Namespace namespace: Namespace) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @alias {Nsp}
+ * @decorator
+ */
+export function Namespace(target, propertyKey, index) {
+    if (typeof target === "string") {
+        const nsp = target;
+        return (target, propertyKey) => {
+            Store.from(target).merge("socketIO", {
+                injectNamespaces: [{ propertyKey, nsp }]
+            });
+        };
+    }
+    if (decoratorTypeOf([target, propertyKey, index]) === DecoratorTypes.PROP) {
+        Store.from(target).merge("socketIO", {
+            injectNamespaces: [{ propertyKey }]
+        });
+        return;
+    }
+    return SocketFilter(SocketFilters.NSP)(target, propertyKey, index);
+}
+//# sourceMappingURL=nsp.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nsp.js","sourceRoot":"","sources":["../../../src/decorators/nsp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAE,cAAc,EAAE,KAAK,EAAC,MAAM,YAAY,CAAC;AAElE,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAK5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,GAAG,CAAC,MAAW,EAAE,WAAoB,EAAE,KAAc;IACnE,OAAO,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,SAAS,CAAC,MAAW,EAAE,WAAoB,EAAE,KAAc;IACzE,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;QAC9B,MAAM,GAAG,GAAG,MAAgB,CAAC;QAE7B,OAAO,CAAC,MAAW,EAAE,WAAmB,EAAE,EAAE;YAC1C,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE;gBACnC,gBAAgB,EAAE,CAAC,EAAC,WAAW,EAAE,GAAG,EAAC,CAAC;aACvC,CAAC,CAAC;QACL,CAAC,CAAC;KACH;IAED,IAAI,eAAe,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC,KAAK,cAAc,CAAC,IAAI,EAAE;QACzE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE;YACnC,gBAAgB,EAAE,CAAC,EAAC,WAAW,EAAC,CAAC;SAClC,CAAC,CAAC;QAEH,OAAO;KACR;IAED,OAAO,YAAY,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,WAAY,EAAE,KAAM,CAAC,CAAC;AACvE,CAAC","sourcesContent":["import {decoratorTypeOf, DecoratorTypes, Store} from \"@tsed/core\";\nimport {Namespace as NamespaceType} from \"socket.io\";\nimport {SocketFilters} from \"../interfaces/SocketFilters\";\nimport {SocketFilter} from \"./socketFilter\";\n\nexport type Namespace = NamespaceType;\nexport type Nsp = NamespaceType;\n\n/**\n * Inject the [SocketIO.Namespace](https://socket.io/docs/rooms-and-namespaces/#namespaces) instance in the decorated parameter.\n *\n * ### Example\n *\n * ```typescript\n * import {Nsp, SocketService, Input} from \"@tsed/socketio\";\n *\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *\n *   @Nsp\n *   nsp: SocketIO.Namespace; // will inject SocketIO.Namespace (not available on constructor)\n *\n *   @Nsp(\"/my-other-namespace\")\n *   nspOther: SocketIO.Namespace; // communication between two namespace\n *\n *   @Input(\"event\")\n *   myMethod(@Nsp namespace: SocketIO.Namespace) {\n *\n *   }\n * }\n * ```\n *\n * @param target\n * @param {string} propertyKey\n * @param {number} index\n * @decorator\n */\nexport function Nsp(target: any, propertyKey?: string, index?: number): any {\n  return Namespace(target, propertyKey, index);\n}\n\n/**\n * Inject the [SocketIO.Namespace](https://socket.io/docs/rooms-and-namespaces/#namespaces) instance in the decorated parameter.\n *\n * ### Example\n *\n * ```typescript\n * import {Namespace, SocketService, Input} from \"@tsed/socketio\";\n *\n * @SocketService(\"/nsp\")\n * export class MyWS {\n *\n *   @Nsp\n *   nsp: Namespace; // will inject SocketIO.Namespace (not available on constructor)\n *\n *   @Nsp(\"/my-other-namespace\")\n *   nspOther: Namespace; // communication between two namespace\n *\n *   @Input(\"event\")\n *   myMethod(@Namespace namespace: Namespace) {\n *\n *   }\n * }\n * ```\n *\n * @param target\n * @param {string} propertyKey\n * @param {number} index\n * @alias {Nsp}\n * @decorator\n */\nexport function Namespace(target: any, propertyKey?: string, index?: number): any {\n  if (typeof target === \"string\") {\n    const nsp = target as string;\n\n    return (target: any, propertyKey: string) => {\n      Store.from(target).merge(\"socketIO\", {\n        injectNamespaces: [{propertyKey, nsp}]\n      });\n    };\n  }\n\n  if (decoratorTypeOf([target, propertyKey, index]) === DecoratorTypes.PROP) {\n    Store.from(target).merge(\"socketIO\", {\n      injectNamespaces: [{propertyKey}]\n    });\n\n    return;\n  }\n\n  return SocketFilter(SocketFilters.NSP)(target, propertyKey!, index!);\n}\n"]}

package/lib/esm/decorators/socket.js

@@ -0,0 +1,28 @@
+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(@Socket socket) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @experimental
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @decorator
+ */
+export function Socket(target, propertyKey, index) {
+    return SocketFilter(SocketFilters.SOCKET)(target, propertyKey, index);
+}
+//# sourceMappingURL=socket.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"socket.js","sourceRoot":"","sources":["../../../src/decorators/socket.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,MAAM,CAAC,MAAW,EAAE,WAAmB,EAAE,KAAa;IACpE,OAAO,YAAY,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;AACxE,CAAC","sourcesContent":["import {Socket as SocketType} from \"socket.io\";\nimport {SocketFilters} from \"../interfaces/SocketFilters\";\nimport {SocketFilter} from \"./socketFilter\";\n\nexport type Socket = SocketType;\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(@Socket socket) {\n *\n *   }\n * }\n * ```\n *\n * @experimental\n * @param target\n * @param {string} propertyKey\n * @param {number} index\n * @decorator\n */\nexport function Socket(target: any, propertyKey: string, index: number): any {\n  return SocketFilter(SocketFilters.SOCKET)(target, propertyKey, index);\n}\n"]}

package/lib/esm/decorators/socketErr.js

@@ -0,0 +1,26 @@
+import { SocketFilters } from "../interfaces/SocketFilters";
+import { SocketFilter } from "./socketFilter";
+/**
+ * Inject the error in the parameters
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketMiddlewareError()
+ * export class MyMiddleware {
+ *
+ *   myMethod(@SocketErr err: any, @Args() arguments: any[]) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param target
+ * @param propertyKey
+ * @param index
+ */
+export function SocketErr(target, propertyKey, index) {
+    return SocketFilter(SocketFilters.ERR)(target, propertyKey, index);
+}
+//# sourceMappingURL=socketErr.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"socketErr.js","sourceRoot":"","sources":["../../../src/decorators/socketErr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,SAAS,CAAC,MAAW,EAAE,WAAmB,EAAE,KAAa;IACvE,OAAO,YAAY,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;AACrE,CAAC","sourcesContent":["import {SocketFilters} from \"../interfaces/SocketFilters\";\nimport {SocketFilter} from \"./socketFilter\";\n\n/**\n * Inject the error in the parameters\n *\n * ### Example\n *\n * ```typescript\n * @SocketMiddlewareError()\n * export class MyMiddleware {\n *\n *   myMethod(@SocketErr err: any, @Args() arguments: any[]) {\n *\n *   }\n * }\n * ```\n *\n * @decorator\n * @param target\n * @param propertyKey\n * @param index\n */\nexport function SocketErr(target: any, propertyKey: string, index: number): any {\n  return SocketFilter(SocketFilters.ERR)(target, propertyKey, index);\n}\n"]}

package/lib/esm/decorators/socketEventName.js

@@ -0,0 +1,26 @@
+import { SocketFilters } from "../interfaces/SocketFilters";
+import { SocketFilter } from "./socketFilter";
+/**
+ * Inject the Socket instance in the decorated parameter.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketMiddleware("/nsp")
+ * export class MyMiddleware {
+ *   use(@SocketEventName eventName: string) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @experimental
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @decorator
+ */
+export function SocketEventName(target, propertyKey, index) {
+    return SocketFilter(SocketFilters.EVENT_NAME)(target, propertyKey, index);
+}
+//# sourceMappingURL=socketEventName.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"socketEventName.js","sourceRoot":"","sources":["../../../src/decorators/socketEventName.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,eAAe,CAAC,MAAW,EAAE,WAAmB,EAAE,KAAa;IAC7E,OAAO,YAAY,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;AAC5E,CAAC","sourcesContent":["import {SocketFilters} from \"../interfaces/SocketFilters\";\nimport {SocketFilter} from \"./socketFilter\";\n\n/**\n * Inject the Socket instance in the decorated parameter.\n *\n * ### Example\n *\n * ```typescript\n * @SocketMiddleware(\"/nsp\")\n * export class MyMiddleware {\n *   use(@SocketEventName eventName: string) {\n *\n *   }\n * }\n * ```\n *\n * @experimental\n * @param target\n * @param {string} propertyKey\n * @param {number} index\n * @decorator\n */\nexport function SocketEventName(target: any, propertyKey: string, index: number): any {\n  return SocketFilter(SocketFilters.EVENT_NAME)(target, propertyKey, index);\n}\n"]}

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/common";
+import { Store } from "@tsed/core";
+import { SocketProviderTypes } from "../interfaces";
+/**
+ * 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,cAAc,CAAC;AACxC,OAAO,EAAC,KAAK,EAAO,MAAM,YAAY,CAAC;AACvC,OAAO,EAAC,mBAAmB,EAAC,MAAM,eAAe,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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/common\";\nimport {Store, Type} from \"@tsed/core\";\nimport {SocketProviderTypes} from \"../interfaces\";\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"]}