gifted-baileys 1.5.4 → 1.5.6

package/{lib → src}/Socket/groups.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractGroupMetadata = exports.makeGroupsSocket = void 0;
 const WAProto_1 = require("../../WAProto");
@@ -9,21 +18,23 @@ const chats_1 = require("./chats");
 const makeGroupsSocket = (config) => {
     const sock = (0, chats_1.makeChatsSocket)(config);
     const { authState, ev, query, upsertMessage } = sock;
-    const groupQuery = async (jid, type, content) => (query({
-        tag: 'iq',
-        attrs: {
-            type,
-            xmlns: 'w:g2',
-            to: jid,
-        },
-        content
-    }));
-    const groupMetadata = async (jid) => {
-        const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
+    const groupQuery = (jid, type, content) => __awaiter(void 0, void 0, void 0, function* () {
+        return (query({
+            tag: 'iq',
+            attrs: {
+                type,
+                xmlns: 'w:g2',
+                to: jid,
+            },
+            content
+        }));
+    });
+    const groupMetadata = (jid) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
         return (0, exports.extractGroupMetadata)(result);
-    };
-    const groupFetchAllParticipating = async () => {
-        const result = await query({
+    });
+    const groupFetchAllParticipating = () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield query({
             tag: 'iq',
             attrs: {
                 to: '@g.us',
@@ -56,22 +67,18 @@ const makeGroupsSocket = (config) => {
         }
         sock.ev.emit('groups.update', Object.values(data));
         return data;
-    };
-    sock.ws.on('CB:ib,,dirty', async (node) => {
+    });
+    sock.ws.on('CB:ib,,dirty', (node) => __awaiter(void 0, void 0, void 0, function* () {
         const { attrs } = (0, WABinary_1.getBinaryNodeChild)(node, 'dirty');
         if (attrs.type !== 'groups') {
             return;
         }
-        await groupFetchAllParticipating();
-        await sock.cleanDirtyBits('groups');
-    });
-    return {
-        ...sock,
-        groupQuery,
-        groupMetadata,
-        groupCreate: async (subject, participants) => {
+        yield groupFetchAllParticipating();
+        yield sock.cleanDirtyBits('groups');
+    }));
+    return Object.assign(Object.assign({}, sock), { groupMetadata, groupCreate: (subject, participants) => __awaiter(void 0, void 0, void 0, function* () {
             const key = (0, Utils_1.generateMessageID)();
-            const result = await groupQuery('@g.us', 'set', [
+            const result = yield groupQuery('@g.us', 'set', [
                 {
                     tag: 'create',
                     attrs: {
@@ -85,9 +92,8 @@ const makeGroupsSocket = (config) => {
                 }
             ]);
             return (0, exports.extractGroupMetadata)(result);
-        },
-        groupLeave: async (id) => {
-            await groupQuery('@g.us', 'set', [
+        }), groupLeave: (id) => __awaiter(void 0, void 0, void 0, function* () {
+            yield groupQuery('@g.us', 'set', [
                 {
                     tag: 'leave',
                     attrs: {},
@@ -96,18 +102,16 @@ const makeGroupsSocket = (config) => {
                     ]
                 }
             ]);
-        },
-        groupUpdateSubject: async (jid, subject) => {
-            await groupQuery(jid, 'set', [
+        }), groupUpdateSubject: (jid, subject) => __awaiter(void 0, void 0, void 0, function* () {
+            yield groupQuery(jid, 'set', [
                 {
                     tag: 'subject',
                     attrs: {},
                     content: Buffer.from(subject, 'utf-8')
                 }
             ]);
-        },
-        groupRequestParticipantsList: async (jid) => {
-            const result = await groupQuery(jid, 'get', [
+        }), groupRequestParticipantsList: (jid) => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield groupQuery(jid, 'get', [
                 {
                     tag: 'membership_approval_requests',
                     attrs: {}
@@ -116,9 +120,8 @@ const makeGroupsSocket = (config) => {
             const node = (0, WABinary_1.getBinaryNodeChild)(result, 'membership_approval_requests');
             const participants = (0, WABinary_1.getBinaryNodeChildren)(node, 'membership_approval_request');
             return participants.map(v => v.attrs);
-        },
-        groupRequestParticipantsUpdate: async (jid, participants, action) => {
-            const result = await groupQuery(jid, 'set', [{
+        }), groupRequestParticipantsUpdate: (jid, participants, action) => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield groupQuery(jid, 'set', [{
                     tag: 'membership_requests_action',
                     attrs: {},
                     content: [
@@ -138,9 +141,8 @@ const makeGroupsSocket = (config) => {
             return participantsAffected.map(p => {
                 return { status: p.attrs.error || '200', jid: p.attrs.jid };
             });
-        },
-        groupParticipantsUpdate: async (jid, participants, action) => {
-            const result = await groupQuery(jid, 'set', [
+        }), groupParticipantsUpdate: (jid, participants, action) => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield groupQuery(jid, 'set', [
                 {
                     tag: action,
                     attrs: {},
@@ -155,47 +157,40 @@ const makeGroupsSocket = (config) => {
             return participantsAffected.map(p => {
                 return { status: p.attrs.error || '200', jid: p.attrs.jid, content: p };
             });
-        },
-        groupUpdateDescription: async (jid, description) => {
+        }), groupUpdateDescription: (jid, description) => __awaiter(void 0, void 0, void 0, function* () {
             var _a;
-            const metadata = await groupMetadata(jid);
+            const metadata = yield groupMetadata(jid);
             const prev = (_a = metadata.descId) !== null && _a !== void 0 ? _a : null;
-            await groupQuery(jid, 'set', [
+            yield groupQuery(jid, 'set', [
                 {
                     tag: 'description',
-                    attrs: {
-                        ...(description ? { id: (0, Utils_1.generateMessageID)() } : { delete: 'true' }),
-                        ...(prev ? { prev } : {})
-                    },
+                    attrs: Object.assign(Object.assign({}, (description ? { id: (0, Utils_1.generateMessageID)() } : { delete: 'true' })), (prev ? { prev } : {})),
                     content: description ? [
                         { tag: 'body', attrs: {}, content: Buffer.from(description, 'utf-8') }
                     ] : undefined
                 }
             ]);
-        },
-        groupInviteCode: async (jid) => {
-            const result = await groupQuery(jid, 'get', [{ tag: 'invite', attrs: {} }]);
+        }), groupInviteCode: (jid) => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield groupQuery(jid, 'get', [{ tag: 'invite', attrs: {} }]);
             const inviteNode = (0, WABinary_1.getBinaryNodeChild)(result, 'invite');
             return inviteNode === null || inviteNode === void 0 ? void 0 : inviteNode.attrs.code;
-        },
-        groupRevokeInvite: async (jid) => {
-            const result = await groupQuery(jid, 'set', [{ tag: 'invite', attrs: {} }]);
+        }), groupRevokeInvite: (jid) => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield groupQuery(jid, 'set', [{ tag: 'invite', attrs: {} }]);
             const inviteNode = (0, WABinary_1.getBinaryNodeChild)(result, 'invite');
             return inviteNode === null || inviteNode === void 0 ? void 0 : inviteNode.attrs.code;
-        },
-        groupAcceptInvite: async (code) => {
-            const results = await groupQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }]);
+        }), groupAcceptInvite: (code) => __awaiter(void 0, void 0, void 0, function* () {
+            const results = yield groupQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }]);
             const result = (0, WABinary_1.getBinaryNodeChild)(results, 'group');
             return result === null || result === void 0 ? void 0 : result.attrs.jid;
-        },
+        }), 
         /**
          * accept a GroupInviteMessage
          * @param key the key of the invite message, or optionally only provide the jid of the person who sent the invite
          * @param inviteMessage the message to accept
          */
-        groupAcceptInviteV4: ev.createBufferedFunction(async (key, inviteMessage) => {
+        groupAcceptInviteV4: ev.createBufferedFunction((key, inviteMessage) => __awaiter(void 0, void 0, void 0, function* () {
             key = typeof key === 'string' ? { remoteJid: key } : key;
-            const results = await groupQuery(inviteMessage.groupJid, 'set', [{
+            const results = yield groupQuery(inviteMessage.groupJid, 'set', [{
                     tag: 'accept',
                     attrs: {
                         code: inviteMessage.inviteCode,
@@ -222,7 +217,7 @@ const makeGroupsSocket = (config) => {
                 ]);
             }
             // generate the group add message
-            await upsertMessage({
+            yield upsertMessage({
                 key: {
                     remoteJid: inviteMessage.groupJid,
                     id: (0, Utils_1.generateMessageID)(),
@@ -237,28 +232,21 @@ const makeGroupsSocket = (config) => {
                 messageTimestamp: (0, Utils_1.unixTimestampSeconds)()
             }, 'notify');
             return results.attrs.from;
-        }),
-        groupGetInviteInfo: async (code) => {
-            const results = await groupQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }]);
+        })), groupGetInviteInfo: (code) => __awaiter(void 0, void 0, void 0, function* () {
+            const results = yield groupQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }]);
             return (0, exports.extractGroupMetadata)(results);
-        },
-        groupToggleEphemeral: async (jid, ephemeralExpiration) => {
+        }), groupToggleEphemeral: (jid, ephemeralExpiration) => __awaiter(void 0, void 0, void 0, function* () {
             const content = ephemeralExpiration ?
                 { tag: 'ephemeral', attrs: { expiration: ephemeralExpiration.toString() } } :
                 { tag: 'not_ephemeral', attrs: {} };
-            await groupQuery(jid, 'set', [content]);
-        },
-        groupSettingUpdate: async (jid, setting) => {
-            await groupQuery(jid, 'set', [{ tag: setting, attrs: {} }]);
-        },
-        groupMemberAddMode: async (jid, mode) => {
-            await groupQuery(jid, 'set', [{ tag: 'member_add_mode', attrs: {}, content: mode }]);
-        },
-        groupJoinApprovalMode: async (jid, mode) => {
-            await groupQuery(jid, 'set', [{ tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state: mode } }] }]);
-        },
-        groupFetchAllParticipating
-    };
+            yield groupQuery(jid, 'set', [content]);
+        }), groupSettingUpdate: (jid, setting) => __awaiter(void 0, void 0, void 0, function* () {
+            yield groupQuery(jid, 'set', [{ tag: setting, attrs: {} }]);
+        }), groupMemberAddMode: (jid, mode) => __awaiter(void 0, void 0, void 0, function* () {
+            yield groupQuery(jid, 'set', [{ tag: 'member_add_mode', attrs: {}, content: mode }]);
+        }), groupJoinApprovalMode: (jid, mode) => __awaiter(void 0, void 0, void 0, function* () {
+            yield groupQuery(jid, 'set', [{ tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state: mode } }] }]);
+        }), groupFetchAllParticipating });
 };
 exports.makeGroupsSocket = makeGroupsSocket;
 const extractGroupMetadata = (result) => {
@@ -297,7 +285,7 @@ const extractGroupMetadata = (result) => {
                 admin: (attrs.type || null),
             };
         }),
-        ephemeralDuration: eph ? +eph : 0
+        ephemeralDuration: eph ? +eph : undefined
     };
     return metadata;
 };

package/src/Socket/groups.ts

@@ -0,0 +1,356 @@
+import { proto } from '../../WAProto'
+import { GroupMetadata, GroupParticipant, ParticipantAction, SocketConfig, WAMessageKey, WAMessageStubType } from '../Types'
+import { generateMessageID, unixTimestampSeconds } from '../Utils'
+import { BinaryNode, getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, jidEncode, jidNormalizedUser } from '../WABinary'
+import { makeChatsSocket } from './chats'
+
+export const makeGroupsSocket = (config: SocketConfig) => {
+	const sock = makeChatsSocket(config)
+	const { authState, ev, query, upsertMessage } = sock
+
+	const groupQuery = async(jid: string, type: 'get' | 'set', content: BinaryNode[]) => (
+		query({
+			tag: 'iq',
+			attrs: {
+				type,
+				xmlns: 'w:g2',
+				to: jid,
+			},
+			content
+		})
+	)
+
+	const groupMetadata = async(jid: string) => {
+		const result = await groupQuery(
+			jid,
+			'get',
+			[ { tag: 'query', attrs: { request: 'interactive' } } ]
+		)
+		return extractGroupMetadata(result)
+	}
+
+
+	const groupFetchAllParticipating = async() => {
+		const result = await query({
+			tag: 'iq',
+			attrs: {
+				to: '@g.us',
+				xmlns: 'w:g2',
+				type: 'get',
+			},
+			content: [
+				{
+					tag: 'participating',
+					attrs: { },
+					content: [
+						{ tag: 'participants', attrs: { } },
+						{ tag: 'description', attrs: { } }
+					]
+				}
+			]
+		})
+		const data: { [_: string]: GroupMetadata } = { }
+		const groupsChild = getBinaryNodeChild(result, 'groups')
+		if(groupsChild) {
+			const groups = getBinaryNodeChildren(groupsChild, 'group')
+			for(const groupNode of groups) {
+				const meta = extractGroupMetadata({
+					tag: 'result',
+					attrs: { },
+					content: [groupNode]
+				})
+				data[meta.id] = meta
+			}
+		}
+
+		sock.ev.emit('groups.update', Object.values(data))
+
+		return data
+	}
+
+	sock.ws.on('CB:ib,,dirty', async(node: BinaryNode) => {
+		const { attrs } = getBinaryNodeChild(node, 'dirty')!
+		if(attrs.type !== 'groups') {
+			return
+		}
+
+		await groupFetchAllParticipating()
+		await sock.cleanDirtyBits('groups')
+	})
+
+	return {
+		...sock,
+		groupMetadata,
+		groupCreate: async(subject: string, participants: string[]) => {
+			const key = generateMessageID()
+			const result = await groupQuery(
+				'@g.us',
+				'set',
+				[
+					{
+						tag: 'create',
+						attrs: {
+							subject,
+							key
+						},
+						content: participants.map(jid => ({
+							tag: 'participant',
+							attrs: { jid }
+						}))
+					}
+				]
+			)
+			return extractGroupMetadata(result)
+		},
+		groupLeave: async(id: string) => {
+			await groupQuery(
+				'@g.us',
+				'set',
+				[
+					{
+						tag: 'leave',
+						attrs: { },
+						content: [
+							{ tag: 'group', attrs: { id } }
+						]
+					}
+				]
+			)
+		},
+		groupUpdateSubject: async(jid: string, subject: string) => {
+			await groupQuery(
+				jid,
+				'set',
+				[
+					{
+						tag: 'subject',
+						attrs: { },
+						content: Buffer.from(subject, 'utf-8')
+					}
+				]
+			)
+		},
+		groupRequestParticipantsList: async(jid: string) => {
+			const result = await groupQuery(
+				jid,
+				'get',
+				[
+					{
+						tag: 'membership_approval_requests',
+						attrs: {}
+					}
+				]
+			)
+			const node = getBinaryNodeChild(result, 'membership_approval_requests')
+			const participants = getBinaryNodeChildren(node, 'membership_approval_request')
+			return participants.map(v => v.attrs)
+		},
+		groupRequestParticipantsUpdate: async(jid: string, participants: string[], action: 'approve' | 'reject') => {
+			const result = await groupQuery(
+				jid,
+				'set',
+				[{
+					tag: 'membership_requests_action',
+					attrs: {},
+					content: 				[
+						{
+							tag: action,
+							attrs: { },
+							content: participants.map(jid => ({
+								tag: 'participant',
+								attrs: { jid }
+							}))
+						}
+					]
+				}]
+			)
+			const node = getBinaryNodeChild(result, 'membership_requests_action')
+			const nodeAction = getBinaryNodeChild(node, action)
+			const participantsAffected = getBinaryNodeChildren(nodeAction, 'participant')
+			return participantsAffected.map(p => {
+				return { status: p.attrs.error || '200', jid: p.attrs.jid }
+			})
+		},
+		groupParticipantsUpdate: async(
+			jid: string,
+			participants: string[],
+			action: ParticipantAction
+		) => {
+			const result = await groupQuery(
+				jid,
+				'set',
+				[
+					{
+						tag: action,
+						attrs: { },
+						content: participants.map(jid => ({
+							tag: 'participant',
+							attrs: { jid }
+						}))
+					}
+				]
+			)
+			const node = getBinaryNodeChild(result, action)
+			const participantsAffected = getBinaryNodeChildren(node!, 'participant')
+			return participantsAffected.map(p => {
+				return { status: p.attrs.error || '200', jid: p.attrs.jid, content: p }
+			})
+		},
+		groupUpdateDescription: async(jid: string, description?: string) => {
+			const metadata = await groupMetadata(jid)
+			const prev = metadata.descId ?? null
+
+			await groupQuery(
+				jid,
+				'set',
+				[
+					{
+						tag: 'description',
+						attrs: {
+							...(description ? { id: generateMessageID() } : { delete: 'true' }),
+							...(prev ? { prev } : {})
+						},
+						content: description ? [
+							{ tag: 'body', attrs: {}, content: Buffer.from(description, 'utf-8') }
+						] : undefined
+					}
+				]
+			)
+		},
+		groupInviteCode: async(jid: string) => {
+			const result = await groupQuery(jid, 'get', [{ tag: 'invite', attrs: {} }])
+			const inviteNode = getBinaryNodeChild(result, 'invite')
+			return inviteNode?.attrs.code
+		},
+		groupRevokeInvite: async(jid: string) => {
+			const result = await groupQuery(jid, 'set', [{ tag: 'invite', attrs: {} }])
+			const inviteNode = getBinaryNodeChild(result, 'invite')
+			return inviteNode?.attrs.code
+		},
+		groupAcceptInvite: async(code: string) => {
+			const results = await groupQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }])
+			const result = getBinaryNodeChild(results, 'group')
+			return result?.attrs.jid
+		},
+		/**
+		 * accept a GroupInviteMessage
+		 * @param key the key of the invite message, or optionally only provide the jid of the person who sent the invite
+		 * @param inviteMessage the message to accept
+		 */
+		groupAcceptInviteV4: ev.createBufferedFunction(async(key: string | WAMessageKey, inviteMessage: proto.Message.IGroupInviteMessage) => {
+			key = typeof key === 'string' ? { remoteJid: key } : key
+			const results = await groupQuery(inviteMessage.groupJid!, 'set', [{
+				tag: 'accept',
+				attrs: {
+					code: inviteMessage.inviteCode!,
+					expiration: inviteMessage.inviteExpiration!.toString(),
+					admin: key.remoteJid!
+				}
+			}])
+
+			// if we have the full message key
+			// update the invite message to be expired
+			if(key.id) {
+				// create new invite message that is expired
+				inviteMessage = proto.Message.GroupInviteMessage.fromObject(inviteMessage)
+				inviteMessage.inviteExpiration = 0
+				inviteMessage.inviteCode = ''
+				ev.emit('messages.update', [
+					{
+						key,
+						update: {
+							message: {
+								groupInviteMessage: inviteMessage
+							}
+						}
+					}
+				])
+			}
+
+			// generate the group add message
+			await upsertMessage(
+				{
+					key: {
+						remoteJid: inviteMessage.groupJid,
+						id: generateMessageID(),
+						fromMe: false,
+						participant: key.remoteJid,
+					},
+					messageStubType: WAMessageStubType.GROUP_PARTICIPANT_ADD,
+					messageStubParameters: [
+						authState.creds.me!.id
+					],
+					participant: key.remoteJid,
+					messageTimestamp: unixTimestampSeconds()
+				},
+				'notify'
+			)
+
+			return results.attrs.from
+		}),
+		groupGetInviteInfo: async(code: string) => {
+			const results = await groupQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }])
+			return extractGroupMetadata(results)
+		},
+		groupToggleEphemeral: async(jid: string, ephemeralExpiration: number) => {
+			const content: BinaryNode = ephemeralExpiration ?
+				{ tag: 'ephemeral', attrs: { expiration: ephemeralExpiration.toString() } } :
+				{ tag: 'not_ephemeral', attrs: { } }
+			await groupQuery(jid, 'set', [content])
+		},
+		groupSettingUpdate: async(jid: string, setting: 'announcement' | 'not_announcement' | 'locked' | 'unlocked') => {
+			await groupQuery(jid, 'set', [ { tag: setting, attrs: { } } ])
+		},
+		groupMemberAddMode: async(jid: string, mode: 'admin_add' | 'all_member_add') => {
+			await groupQuery(jid, 'set', [ { tag: 'member_add_mode', attrs: { }, content: mode } ])
+		},
+		groupJoinApprovalMode: async(jid: string, mode: 'on' | 'off') => {
+			await groupQuery(jid, 'set', [ { tag: 'membership_approval_mode', attrs: { }, content: [ { tag: 'group_join', attrs: { state: mode } } ] } ])
+		},
+		groupFetchAllParticipating
+	}
+}
+
+
+export const extractGroupMetadata = (result: BinaryNode) => {
+	const group = getBinaryNodeChild(result, 'group')!
+	const descChild = getBinaryNodeChild(group, 'description')
+	let desc: string | undefined
+	let descId: string | undefined
+	if(descChild) {
+		desc = getBinaryNodeChildString(descChild, 'body')
+		descId = descChild.attrs.id
+	}
+
+	const groupId = group.attrs.id.includes('@') ? group.attrs.id : jidEncode(group.attrs.id, 'g.us')
+	const eph = getBinaryNodeChild(group, 'ephemeral')?.attrs.expiration
+	const memberAddMode = getBinaryNodeChildString(group, 'member_add_mode') === 'all_member_add'
+	const metadata: GroupMetadata = {
+		id: groupId,
+		subject: group.attrs.subject,
+		subjectOwner: group.attrs.s_o,
+		subjectTime: +group.attrs.s_t,
+		size: getBinaryNodeChildren(group, 'participant').length,
+		creation: +group.attrs.creation,
+		owner: group.attrs.creator ? jidNormalizedUser(group.attrs.creator) : undefined,
+		desc,
+		descId,
+		linkedParent: getBinaryNodeChild(group, 'linked_parent')?.attrs.jid || undefined,
+		restrict: !!getBinaryNodeChild(group, 'locked'),
+		announce: !!getBinaryNodeChild(group, 'announcement'),
+		isCommunity: !!getBinaryNodeChild(group, 'parent'),
+		isCommunityAnnounce: !!getBinaryNodeChild(group, 'default_sub_group'),
+		joinApprovalMode: !!getBinaryNodeChild(group, 'membership_approval_mode'),
+		memberAddMode,
+		participants: getBinaryNodeChildren(group, 'participant').map(
+			({ attrs }) => {
+				return {
+					id: attrs.jid,
+					admin: (attrs.type || null) as GroupParticipant['admin'],
+				}
+			}
+		),
+		ephemeralDuration: eph ? +eph : undefined
+	}
+	return metadata
+}

package/{lib → src}/Socket/index.js

@@ -3,8 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Defaults_1 = require("../Defaults");
 const registration_1 = require("./registration");
 // export the last socket layer
-const makeWASocket = (config) => ((0, registration_1.makeRegistrationSocket)({
-    ...Defaults_1.DEFAULT_CONNECTION_CONFIG,
-    ...config
-}));
+const makeWASocket = (config) => ((0, registration_1.makeRegistrationSocket)(Object.assign(Object.assign({}, Defaults_1.DEFAULT_CONNECTION_CONFIG), config)));
 exports.default = makeWASocket;

package/src/Socket/index.ts

@@ -0,0 +1,13 @@
+import { DEFAULT_CONNECTION_CONFIG } from '../Defaults'
+import { UserFacingSocketConfig } from '../Types'
+import { makeRegistrationSocket as _makeSocket } from './registration'
+
+// export the last socket layer
+const makeWASocket = (config: UserFacingSocketConfig) => (
+	_makeSocket({
+		...DEFAULT_CONNECTION_CONFIG,
+		...config
+	})
+)
+
+export default makeWASocket