bb-fca 2.0.9 → 2.0.10

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;
     }
   };
-};
+}

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

@@ -1,94 +1,67 @@
 // @ChoruOfficial
-import utils = require("../../../utils");
+import utils = require('../../../utils');
 
 /**
  * @param {Object} defaultFuncs
  * @param {Object} api
  * @param {Object} ctx
  */
-export default function(defaultFuncs: any, api: any, ctx: any) {
+export default function markAsRead(
+  defaultFuncs: any,
+  api: any,
+  ctx: any,
+): Function {
   /**
-   * Marks a thread as read.
+   * Marks a thread as read or unread.
    * @param {string} threadID - The ID of the thread to mark as read.
-   * @param {boolean} [read=true] - Whether to mark as read (true) or unread (false). Defaults to true.
-   * @param {Function} [callback] - The callback function.
-   * @returns {Promise<null|Error>} A Promise that resolves with null on success, or rejects with an Error.
+   * @param {boolean} [read=true] - Whether to mark as read (true) or unread (false).
+   * @returns {Promise<null>}
    */
-  return async function markAsRead(threadID, read, callback) {
-    if (
-      utils.getType(read) === "Function" ||
-      utils.getType(read) === "AsyncFunction"
-    ) {
-      callback = read;
-      read = true;
-    }
-    if (read == undefined) {
-      read = true;
-    }
-
-    if (!callback) {
-      callback = () => {};
-    }
-
-    const form = {};
+  return async function markAsRead(
+    threadID: string,
+    read: boolean = true,
+  ): Promise<null> {
+    const form: Record<string, any> = {};
 
-    if (typeof ctx.globalOptions.pageID !== "undefined") {
-      form["source"] = "PagesManagerMessagesInterface";
-      form["request_user_id"] = ctx.globalOptions.pageID;
-      form["ids[" + threadID + "]"] = read;
-      form["watermarkTimestamp"] = new Date().getTime();
-      form["shouldSendReadReceipt"] = true;
-      form["commerce_last_message_type"] = "";
+    if (typeof ctx.globalOptions.pageID !== 'undefined') {
+      form['source'] = 'PagesManagerMessagesInterface';
+      form['request_user_id'] = ctx.globalOptions.pageID;
+      form['ids[' + threadID + ']'] = read;
+      form['watermarkTimestamp'] = new Date().getTime();
+      form['shouldSendReadReceipt'] = true;
+      form['commerce_last_message_type'] = '';
 
-      let resData;
-      try {
-        resData = await defaultFuncs
-          .post(
-            "https://www.facebook.com/ajax/mercury/change_read_status.php",
-            ctx.jar,
-            form,
-          )
-          .then(utils.saveCookies(ctx.jar))
-          .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
-      } catch (e) {
-        callback(e);
-        return e;
-      }
+      const resData = await defaultFuncs
+        .post(
+          'https://www.facebook.com/ajax/mercury/change_read_status.php',
+          ctx.jar,
+          form,
+        )
+        .then(utils.saveCookies(ctx.jar))
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
 
       if (resData.error) {
         const err = resData.error;
-        utils.error("markAsRead", err);
-        callback(err);
-        return err;
+        utils.error('markAsRead', err);
+        throw new Error(err);
       }
 
-      callback();
       return null;
     } else {
-      try {
-        if (ctx.mqttClient) {
-          const err = await new Promise((r) =>
-            ctx.mqttClient.publish(
-              "/mark_thread",
-              JSON.stringify({
-                threadID,
-                mark: "read",
-                state: read,
-              }),
-              { qos: 1, retain: false },
-              r,
-            ),
-          );
-          if (err) throw err;
-        } else {
-          throw {
-            error: "You can only use this function after you start listening.",
-          };
-        }
-      } catch (e) {
-        callback(e);
-        return e;
+      if (!ctx.mqttClient) {
+        throw {
+          error: 'You can only use this function after you start listening.',
+        };
       }
+      await new Promise<void>((resolve, reject) =>
+        ctx.mqttClient.publish(
+          '/mark_thread',
+          JSON.stringify({ threadID, mark: 'read', state: read }),
+          { qos: 1, retain: false },
+          (err) => (err ? reject(err) : resolve()),
+        ),
+      );
     }
+    return null;
   };
-};
+}

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

@@ -5,31 +5,31 @@ import utils = require('../../../utils');
  * @param {Object} defaultFuncs
  * @param {Object} api
  * @param {Object} ctx
- * @returns {function(): Promise<void>}
  */
-export default function(defaultFuncs: any, api: any, ctx: any) {
+export default function markAsReadAll(
+  defaultFuncs: any,
+  api: any,
+  ctx: any,
+): Function {
   /**
+   * Marks all messages in the inbox as read.
    * @returns {Promise<void>}
    */
-  return async function markAsReadAll() {
-    const form = {
-      folder: 'inbox',
-    };
+  return async function markAsReadAll(): Promise<void> {
+    const form = { folder: 'inbox' };
 
     try {
-      const resData = await defaultFuncs.post(
-        'https://www.facebook.com/ajax/mercury/mark_folder_as_read.php',
-        ctx.jar,
-        form,
-      );
+      const resData = await defaultFuncs
+        .post(
+          'https://www.facebook.com/ajax/mercury/mark_folder_as_read.php',
+          ctx.jar,
+          form,
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
 
-      const parsedData = utils.parseAndCheckLogin(resData, defaultFuncs) as any;
-
-      if (parsedData.error) {
-        throw parsedData;
+      if (resData.error) {
+        throw resData;
       }
-
-      return;
     } catch (err) {
       utils.error('markAsReadAll', err);
       throw err;