bb-fca 2.0.9 → 2.0.11

package/src/deltas/apis/messaging/gcmember.ts

@@ -1,106 +1,71 @@
 import utils = require('../../../utils');
 
-export default function(defaultFuncs: any, api: any, ctx: any) {
+/**
+ * @module gcmember
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+export default function gcmember(
+  defaultFuncs: any,
+  api: any,
+  ctx: any,
+): Function {
   /**
-   * Made by ChoruOfficial
-   * Mqtt
-   * Adds or removes members from a group chat with pre-checking.
-   *
-   * @param {"add" | "remove"} action The action to perform.
-   * @param {string|string[]} userIDs The user ID or array of user IDs.
-   * @param {string} threadID The ID of the group chat.
-   * @param {Function} [callback] Optional callback function.
-   * @returns {Promise<object>} A promise that resolves with information about the action.
+   * Made by ChoruOfficial — Adds or removes members from a group chat via MQTT.
+   * @param {"add" | "remove"} action - The action to perform.
+   * @param {string | string[]} userIDs - The user ID or array of user IDs.
+   * @param {string} threadID - The ID of the group chat.
+   * @returns {Promise<object>}
    */
-  return async function gcmember(action, userIDs, threadID, callback) {
-    let _callback;
-    if (typeof threadID === 'function') {
-      _callback = threadID;
-      threadID = null;
-    } else if (typeof callback === 'function') {
-      _callback = callback;
-    }
-
-    let resolvePromise, rejectPromise;
-    const returnPromise = new Promise<any>((resolve, reject) => {
-      resolvePromise = resolve;
-      rejectPromise = reject;
-    });
+  return async function gcmember(
+    action: 'add' | 'remove',
+    userIDs: string | string[],
+    threadID: string,
+  ): Promise<any> {
+    const validActions = ['add', 'remove'];
+    const normalizedAction = (action || '').toLowerCase() as 'add' | 'remove';
 
-    if (typeof _callback != 'function') {
-      _callback = (err, data) => {
-        // Note: We will now rarely use the 'err' parameter for validation errors
-        if (err) return rejectPromise(err);
-        resolvePromise(data);
-      };
+    if (!validActions.includes(normalizedAction)) {
+      return { type: 'error_gc', error: `Invalid action. Must be one of: ${validActions.join(', ')}` };
+    }
+    if (!userIDs || (Array.isArray(userIDs) && userIDs.length === 0)) {
+      return { type: 'error_gc', error: 'userIDs is required.' };
+    }
+    if (!threadID) {
+      return { type: 'error_gc', error: 'threadID is required.' };
+    }
+    if (!ctx.mqttClient) {
+      return { type: 'error_gc', error: 'Not connected to MQTT' };
     }
 
     try {
-      const validActions = ['add', 'remove'];
-      action = action ? action.toLowerCase() : '';
-
-      // --- ERROR CHECKS NOW RETURN AN OBJECT INSTEAD OF THROWING ---
-      if (!validActions.includes(action)) {
-        return _callback(null, {
-          type: 'error_gc',
-          error: `Invalid action. Must be one of: ${validActions.join(', ')}`,
-        });
-      }
-      if (!userIDs || userIDs.length === 0) {
-        return _callback(null, {
-          type: 'error_gc',
-          error: 'userIDs is required.',
-        });
-      }
-      if (!threadID) {
-        return _callback(null, {
-          type: 'error_gc',
-          error: 'threadID is required.',
-        });
-      }
-      if (!ctx.mqttClient) {
-        return _callback(null, {
-          type: 'error_gc',
-          error: 'Not connected to MQTT',
-        });
-      }
-
       const threadInfo = await api.getThreadInfo(threadID);
       if (!threadInfo) {
-        return _callback(null, {
-          type: 'error_gc',
-          error: 'Could not retrieve thread information.',
-        });
+        return { type: 'error_gc', error: 'Could not retrieve thread information.' };
       }
       if (threadInfo.isGroup === false) {
-        return _callback(null, {
-          type: 'error_gc',
-          error: 'This feature is only for group chats, not private messages.',
-        });
+        return { type: 'error_gc', error: 'This feature is only for group chats, not private messages.' };
       }
 
-      const currentMembers = threadInfo.participantIDs;
+      const currentMembers: string[] = threadInfo.participantIDs;
       const usersToModify = Array.isArray(userIDs) ? userIDs : [userIDs];
-      let queryPayload, query;
-      let finalUsers = usersToModify;
 
       ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1;
       ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
 
-      if (action === 'add') {
-        const usersToAdd = usersToModify.filter(
-          (id) => !currentMembers.includes(id),
-        );
+      let query: any;
+      let finalUsers: string[];
+
+      if (normalizedAction === 'add') {
+        const usersToAdd = usersToModify.filter((id) => !currentMembers.includes(id));
         if (usersToAdd.length === 0) {
-          return _callback(null, {
-            type: 'error_gc',
-            error: 'All specified users are already in the group.',
-          });
+          return { type: 'error_gc', error: 'All specified users are already in the group.' };
         }
         finalUsers = usersToAdd;
-        queryPayload = {
-          thread_key: parseInt(threadID),
-          contact_ids: finalUsers.map((id) => parseInt(id)),
+        const queryPayload = {
+          thread_key: Number.parseInt(threadID),
+          contact_ids: finalUsers.map((id) => Number.parseInt(id)),
           sync_group: 1,
         };
         query = {
@@ -110,16 +75,12 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
           task_id: ctx.wsTaskNumber,
         };
       } else {
-        // action is 'remove'
         const userToRemove = usersToModify[0];
         if (!currentMembers.includes(userToRemove)) {
-          return _callback(null, {
-            type: 'error_gc',
-            error: `User with ID ${userToRemove} is not in this group chat.`,
-          });
+          return { type: 'error_gc', error: `User with ID ${userToRemove} is not in this group chat.` };
         }
         finalUsers = [userToRemove];
-        queryPayload = {
+        const queryPayload = {
           thread_id: threadID,
           contact_id: userToRemove,
           sync_group: 1,
@@ -135,7 +96,7 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
       const context: any = {
         app_id: ctx.appID,
         payload: {
-          epoch_id: parseInt(utils.generateOfflineThreadingID()),
+          epoch_id: Number.parseInt(utils.generateOfflineThreadingID()),
           tasks: [query],
           version_id: '24631415369801570',
         },
@@ -144,32 +105,26 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
       };
       context.payload = JSON.stringify(context.payload);
 
-      ctx.mqttClient.publish(
-        '/ls_req',
-        JSON.stringify(context),
-        { qos: 1, retain: false },
-        (err) => {
-          if (err) return _callback(err); // For network errors, we still reject
-
-          const gcmemberInfo = {
-            type: 'gc_member_update',
-            threadID: threadID,
-            userIDs: finalUsers,
-            action: action,
-            senderID: ctx.userID,
-            BotID: ctx.userID,
-            timestamp: Date.now(),
-          };
-          return _callback(null, gcmemberInfo);
-        },
+      await new Promise<void>((resolve, reject) =>
+        ctx.mqttClient.publish(
+          '/ls_req',
+          JSON.stringify(context),
+          { qos: 1, retain: false },
+          (err) => (err ? reject(err) : resolve()),
+        ),
       );
-    } catch (err) {
-      return _callback(null, {
-        type: 'error_gc',
-        error: err.message || 'An unknown error occurred.',
-      });
-    }
 
-    return returnPromise;
+      return {
+        type: 'gc_member_update',
+        threadID,
+        userIDs: finalUsers,
+        action: normalizedAction,
+        senderID: ctx.userID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+      };
+    } catch (err: any) {
+      return { type: 'error_gc', error: err.message || 'An unknown error occurred.' };
+    }
   };
 }

package/src/deltas/apis/messaging/gcname.ts

@@ -1,87 +1,45 @@
 import utils = require('../../../utils');
 
-export default function(defaultFuncs: any, api: any, ctx: any) {
+/**
+ * Made by Choru Official
+ * Sets the name of a group chat thread via MQTT.
+ *
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+export default function gcname(
+  defaultFuncs: any,
+  api: any,
+  ctx: any,
+): Function {
   /**
-   * Made by Choru Official
-   * Mqtt
    * Sets the name of a group chat thread via MQTT.
-   *
-   * @param {string} newName The new name for the group chat.
-   * @param {string} threadID The ID of the group chat thread.
-   * @param {Function} [callback] Optional callback function to be invoked upon completion.
-   * @param {string} [initiatorID] The ID of the user who initiated the group name change (e.g., from event.senderID).
-   * @returns {Promise<object>} A promise that resolves with a structured event object on success or rejects on error.
+   * @param {string} newName - The new name for the group chat.
+   * @param {string} threadID - The ID of the group chat thread.
+   * @param {string} [initiatorID] - The ID of the user who initiated the change.
+   * @returns {Promise<object>}
    */
-  return function gcname(newName, threadID, callback, initiatorID) {
-    let _callback;
-    let _initiatorID;
-
-    let _resolvePromise;
-    let _rejectPromise;
-    const returnPromise = new Promise<any>((resolve, reject) => {
-      _resolvePromise = resolve;
-      _rejectPromise = reject;
-    });
-
-    if (
-      utils.getType(callback) === 'Function' ||
-      utils.getType(callback) === 'AsyncFunction'
-    ) {
-      _callback = callback;
-      _initiatorID = initiatorID;
-    } else if (
-      utils.getType(threadID) === 'Function' ||
-      utils.getType(threadID) === 'AsyncFunction'
-    ) {
-      _callback = threadID;
-      threadID = null;
-      _initiatorID = callback;
-    } else if (utils.getType(callback) === 'string') {
-      _initiatorID = callback;
-      _callback = undefined;
-    } else {
-      _callback = undefined;
-      _initiatorID = undefined;
-    }
-
-    if (!_callback) {
-      _callback = function(__err, __data) {
-        if (__err) _rejectPromise(__err);
-        else _resolvePromise(__data);
-      };
-    } else {
-      const originalCallback = _callback;
-      _callback = function(__err, __data) {
-        if (__err) {
-          originalCallback(__err);
-          _rejectPromise(__err);
-        } else {
-          originalCallback(null, __data);
-          _resolvePromise(__data);
-        }
-      };
-    }
-
-    _initiatorID = _initiatorID || ctx.userID;
-
-    threadID = threadID || ctx.threadID;
-
+  return async function gcname(
+    newName: string,
+    threadID: string,
+    initiatorID?: string,
+  ): Promise<any> {
     if (!threadID) {
-      return _callback(
-        new Error('threadID is required to change the group chat name.'),
-      );
+      throw new Error('threadID is required to change the group chat name.');
     }
     if (typeof newName !== 'string') {
-      return _callback(new Error('newName must be a string.'));
+      throw new Error('newName must be a string.');
     }
-
     if (!ctx.mqttClient) {
-      return _callback(new Error('Not connected to MQTT'));
+      throw new Error('Not connected to MQTT');
     }
 
     ctx.wsReqNumber += 1;
     ctx.wsTaskNumber += 1;
 
+    const _initiatorID = initiatorID || ctx.userID;
+
     const queryPayload = {
       thread_key: threadID.toString(),
       thread_name: newName,
@@ -108,29 +66,22 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
     };
     context.payload = JSON.stringify(context.payload);
 
-    ctx.mqttClient.publish(
-      '/ls_req',
-      JSON.stringify(context),
-      { qos: 1, retain: false },
-      (err) => {
-        if (err) {
-          return _callback(
-            new Error(`MQTT publish failed for gcname: ${err.message || err}`),
-          );
-        }
-
-        const gcnameChangeEvent = {
-          type: 'thread_name_update',
-          threadID: threadID,
-          newName: newName,
-          senderID: _initiatorID,
-          BotID: ctx.userID,
-          timestamp: Date.now(),
-        };
-        _callback(null, gcnameChangeEvent);
-      },
+    await new Promise<void>((resolve, reject) =>
+      ctx.mqttClient.publish(
+        '/ls_req',
+        JSON.stringify(context),
+        { qos: 1, retain: false },
+        (err) => (err ? reject(new Error(`MQTT publish failed for gcname: ${err.message || err}`)) : resolve()),
+      ),
     );
 
-    return returnPromise;
+    return {
+      type: 'thread_name_update',
+      threadID,
+      newName,
+      senderID: _initiatorID,
+      BotID: ctx.userID,
+      timestamp: Date.now(),
+    };
   };
 }

package/src/deltas/apis/messaging/gcrule.ts

@@ -1,108 +1,62 @@
 import utils = require('../../../utils');
 
-export default function(defaultFuncs: any, api: any, ctx: any) {
+/**
+ * @module gcrule
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+export default function gcrule(
+  defaultFuncs: any,
+  api: any,
+  ctx: any,
+): Function {
   /**
-   * Made by ChoruOfficial
-   * Mqtt
-   * Adds or removes an admin from a group chat with pre-checking.
-   *
-   * @param {"admin" | "unadmin"} action The action to perform.
-   * @param {string} userID The ID of the user to promote or demote.
-   * @param {string} threadID The ID of the group chat.
-   * @param {Function} [callback] Optional callback function.
-   * @returns {Promise<object>} A promise that resolves with information about the action.
+   * Made by ChoruOfficial — Promotes or demotes a group chat member admin status via MQTT.
+   * @param {"admin" | "unadmin"} action - The action to perform.
+   * @param {string} userID - The user ID to promote or demote.
+   * @param {string} threadID - The ID of the group chat.
+   * @returns {Promise<object>}
    */
-  return async function gcrule(action, userID, threadID, callback) {
-    let _callback;
-    if (typeof threadID === 'function') {
-      _callback = threadID;
-      threadID = null;
-    } else if (typeof callback === 'function') {
-      _callback = callback;
-    }
-
-    let resolvePromise, rejectPromise;
-    const returnPromise = new Promise<any>((resolve, reject) => {
-      resolvePromise = resolve;
-      rejectPromise = reject;
-    });
+  return async function gcrule(
+    action: 'admin' | 'unadmin',
+    userID: string,
+    threadID: string,
+  ): Promise<any> {
+    const validActions = ['admin', 'unadmin'];
+    const normalizedAction = (action || '').toLowerCase() as 'admin' | 'unadmin';
 
-    if (typeof _callback != 'function') {
-      _callback = (err, data) => {
-        if (err) return rejectPromise(err);
-        resolvePromise(data);
-      };
+    if (!validActions.includes(normalizedAction)) {
+      return { type: 'error_gc_rule', error: `Invalid action. Must be one of: ${validActions.join(', ')}` };
     }
+    if (!userID) return { type: 'error_gc_rule', error: 'userID is required.' };
+    if (!threadID) return { type: 'error_gc_rule', error: 'threadID is required.' };
+    if (!ctx.mqttClient) return { type: 'error_gc_rule', error: 'Not connected to MQTT' };
 
     try {
-      const validActions = ['admin', 'unadmin'];
-      action = action ? action.toLowerCase() : '';
-
-      if (!validActions.includes(action)) {
-        return _callback(null, {
-          type: 'error_gc_rule',
-          error: `Invalid action. Must be one of: ${validActions.join(', ')}`,
-        });
-      }
-      if (!userID)
-        return _callback(null, {
-          type: 'error_gc_rule',
-          error: 'userID is required.',
-        });
-      if (!threadID)
-        return _callback(null, {
-          type: 'error_gc_rule',
-          error: 'threadID is required.',
-        });
-      if (!ctx.mqttClient)
-        return _callback(null, {
-          type: 'error_gc_rule',
-          error: 'Not connected to MQTT',
-        });
-
       const threadInfo = await api.getThreadInfo(threadID);
-      if (!threadInfo) {
-        return _callback(null, {
-          type: 'error_gc_rule',
-          error: 'Could not retrieve thread information.',
-        });
-      }
-      if (threadInfo.isGroup === false) {
-        return _callback(null, {
-          type: 'error_gc_rule',
-          error: 'This feature is only for group chats.',
-        });
-      }
+      if (!threadInfo) return { type: 'error_gc_rule', error: 'Could not retrieve thread information.' };
+      if (threadInfo.isGroup === false) return { type: 'error_gc_rule', error: 'This feature is only for group chats.' };
 
-      const adminIDs = threadInfo.adminIDs || [];
+      const adminIDs: { id: string }[] = threadInfo.adminIDs || [];
       const isCurrentlyAdmin = adminIDs.some((admin) => admin.id === userID);
 
-      if (action === 'admin') {
-        if (isCurrentlyAdmin) {
-          return _callback(null, {
-            type: 'error_gc_rule',
-            error: `User is already an admin.`,
-          });
-        }
-      } else {
-        // action is 'unadmin'
-        if (!isCurrentlyAdmin) {
-          return _callback(null, {
-            type: 'error_gc_rule',
-            error: `User is not an admin.`,
-          });
-        }
+      if (normalizedAction === 'admin' && isCurrentlyAdmin) {
+        return { type: 'error_gc_rule', error: 'User is already an admin.' };
+      }
+      if (normalizedAction === 'unadmin' && !isCurrentlyAdmin) {
+        return { type: 'error_gc_rule', error: 'User is not an admin.' };
       }
 
-      const isAdminStatus = action === 'admin' ? 1 : 0;
       ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1;
       ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
 
       const queryPayload = {
-        thread_key: parseInt(threadID),
-        contact_id: parseInt(userID),
-        is_admin: isAdminStatus,
+        thread_key: Number.parseInt(threadID),
+        contact_id: Number.parseInt(userID),
+        is_admin: normalizedAction === 'admin' ? 1 : 0,
       };
+
       const query = {
         failure_count: null,
         label: '25',
@@ -110,10 +64,11 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         queue_name: 'admin_status',
         task_id: ctx.wsTaskNumber,
       };
+
       const context: any = {
         app_id: ctx.appID,
         payload: {
-          epoch_id: parseInt(utils.generateOfflineThreadingID()),
+          epoch_id: Number.parseInt(utils.generateOfflineThreadingID()),
           tasks: [query],
           version_id: '24631415369801570',
         },
@@ -122,31 +77,26 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
       };
       context.payload = JSON.stringify(context.payload);
 
-      ctx.mqttClient.publish(
-        '/ls_req',
-        JSON.stringify(context),
-        { qos: 1, retain: false },
-        (err) => {
-          if (err) return _callback(err);
-          const gcruleInfo = {
-            type: 'gc_rule_update',
-            threadID: threadID,
-            userID: userID,
-            action: action,
-            senderID: ctx.userID,
-            BotID: ctx.userID,
-            timestamp: Date.now(),
-          };
-          return _callback(null, gcruleInfo);
-        },
+      await new Promise<void>((resolve, reject) =>
+        ctx.mqttClient.publish(
+          '/ls_req',
+          JSON.stringify(context),
+          { qos: 1, retain: false },
+          (err) => (err ? reject(err) : resolve()),
+        ),
       );
-    } catch (err) {
-      return _callback(null, {
-        type: 'error_gc_rule',
-        error: err.message || 'An unknown error occurred.',
-      });
-    }
 
-    return returnPromise;
+      return {
+        type: 'gc_rule_update',
+        threadID,
+        userID,
+        action: normalizedAction,
+        senderID: ctx.userID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+      };
+    } catch (err: any) {
+      return { type: 'error_gc_rule', error: err.message || 'An unknown error occurred.' };
+    }
   };
 }

package/src/deltas/apis/messaging/markAsDelivered.ts

@@ -1,35 +1,40 @@
 // @ChoruOfficial
-"use strict";
+import utils = require('../../../utils');
 
-import utils = require("../../../utils");
 /**
  * @param {Object} defaultFuncs
  * @param {Object} api
  * @param {Object} ctx
- * @returns {function(threadID: string, messageID: string): Promise<void>}
  */
-export default function(defaultFuncs: any, api: any, ctx: any) {
+export default function markAsDelivered(
+  defaultFuncs: any,
+  api: any,
+  ctx: any,
+): Function {
   /**
    * Marks a message as delivered.
    * @param {string} threadID - The ID of the thread.
    * @param {string} messageID - The ID of the message to mark as delivered.
-   * @returns {Promise<void>} A promise that resolves on success or rejects on error.
+   * @returns {Promise<void>}
    */
-  return async function markAsDelivered(threadID, messageID) {
+  return async function markAsDelivered(
+    threadID: string,
+    messageID: string,
+  ): Promise<void> {
     if (!threadID || !messageID) {
-      const err = "Error: messageID or threadID is not defined";
-      utils.error("markAsDelivered", err);
+      const err = 'Error: messageID or threadID is not defined';
+      utils.error('markAsDelivered', err);
       throw new Error(err);
     }
 
-    const form = {};
-    form["message_ids[0]"] = messageID;
-    form["thread_ids[" + threadID + "][0]"] = messageID;
+    const form: Record<string, any> = {};
+    form['message_ids[0]'] = messageID;
+    form['thread_ids[' + threadID + '][0]'] = messageID;
 
     try {
       const resData = await defaultFuncs
         .post(
-          "https://www.facebook.com/ajax/mercury/delivery_receipts.php",
+          'https://www.facebook.com/ajax/mercury/delivery_receipts.php',
           ctx.jar,
           form,
         )
@@ -40,8 +45,8 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
         throw resData;
       }
     } catch (err) {
-      utils.error("markAsDelivered", err);
+      utils.error('markAsDelivered', err);
       throw err;
     }
   };
-};
+}