bb-fca 2.0.8 → 2.0.10

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;

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

@@ -1,50 +1,30 @@
 // @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 markAsSeen(
+  defaultFuncs: any,
+  api: any,
+  ctx: any,
+): Function {
   /**
    * Marks all messages as "seen" up to a specific timestamp.
-   * @param {number} [seen_timestamp=Date.now()] - The timestamp (in milliseconds) up to which messages should be marked as seen. If a function is provided, it's treated as the callback and the timestamp defaults to the current time.
-   * @param {Function} [callback] - The callback function.
-   * @returns {Promise<void>} A Promise that resolves on success or rejects with an error.
+   * @param {number} [seen_timestamp=Date.now()] - The timestamp (in ms) up to which messages should be marked as seen.
+   * @returns {Promise<void>}
    */
-  return async function markAsRead(seen_timestamp, callback) {
-    let resolveFunc: Function = function () {};
-    let rejectFunc: Function = function () {};
-    const returnPromise = new Promise<any>(function (resolve, reject) {
-      resolveFunc = resolve;
-      rejectFunc = reject;
-    });
-
-    if (utils.getType(seen_timestamp) == "Function" || utils.getType(seen_timestamp) == "AsyncFunction") {
-      callback = seen_timestamp;
-      seen_timestamp = Date.now();
-    } else if (seen_timestamp === undefined) {
-      seen_timestamp = Date.now();
-    }
-
-    if (!callback) {
-      callback = function (err, friendList) {
-        if (err) {
-          return rejectFunc(err);
-        }
-        resolveFunc(friendList);
-      };
-    }
-
-    const form = {
-      seen_timestamp: seen_timestamp,
-    };
+  return async function markAsSeen(
+    seen_timestamp: number = Date.now(),
+  ): Promise<void> {
+    const form = { seen_timestamp };
 
     try {
       const resData = await defaultFuncs
         .post(
-          "https://www.facebook.com/ajax/mercury/mark_seen.php",
+          'https://www.facebook.com/ajax/mercury/mark_seen.php',
           ctx.jar,
           form,
         )
@@ -54,16 +34,12 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
       if (resData.error) {
         throw resData;
       }
-
-      return callback();
     } catch (err) {
-      utils.error("markAsSeen", err);
-      if (utils.getType(err) == "Object" && err.error === "Not logged in.") {
+      utils.error('markAsSeen', err);
+      if (utils.getType(err) === 'Object' && (err as any).error === 'Not logged in.') {
         ctx.loggedIn = false;
       }
-      return callback(err);
+      throw err;
     }
-
-    return returnPromise;
   };
-};
+}

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

@@ -1,104 +1,44 @@
 import utils = require('../../../utils');
 
-export default function(defaultFuncs: any, api: any, ctx: any) {
+/**
+ * @module nickname
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ */
+export default function nickname(
+  defaultFuncs: any,
+  api: any,
+  ctx: any,
+): Function {
   /**
-   * Made by Choru Official
-   * Mqtt
-   * Sets a nickname for a participant in a Facebook thread via MQTT.
-   *
-   * @param {string} nickname The new nickname to set.
-   * @param {string} threadID The ID of the thread.
-   * @param {string} participantID The ID of the participant whose nickname will be changed. Defaults to the current user's ID if not provided or a function.
-   * @param {Function} [callback] Optional callback function to be invoked upon completion.
-   * @param {string} [initiatorID] The ID of the user who initiated the nickname change (e.g., from event.senderID).
-   * @returns {Promise<object>} A promise that resolves with a structured event object on success or rejects on error.
+   * Made by Choru Official — Sets a nickname for a participant in a thread via MQTT.
+   * @param {string} nickname - The new nickname to set.
+   * @param {string} threadID - The ID of the thread.
+   * @param {string} [participantID] - The ID of the participant. Defaults to the bot's own ID.
+   * @param {string} [initiatorID] - The ID of the user initiating the change.
+   * @returns {Promise<object>}
    */
-  return function setNickname(
-    nickname,
-    threadID,
-    participantID,
-    callback,
-    initiatorID,
-  ) {
-    let _callback;
-    let _initiatorID;
+  return async function setNickname(
+    nicknameStr: string,
+    threadID: string,
+    participantID?: string,
+    initiatorID?: string,
+  ): Promise<any> {
+    const _initiatorID = initiatorID || ctx.userID;
+    const _participantID = participantID || ctx.userID;
 
-    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(participantID) === 'Function' ||
-      utils.getType(participantID) === 'AsyncFunction'
-    ) {
-      _callback = participantID;
-      participantID = ctx.userID;
-      _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;
-    participantID = participantID || ctx.userID;
-
-    if (!threadID) {
-      return _callback(new Error('threadID is required to set a nickname.'));
-    }
-    if (typeof nickname !== 'string') {
-      return _callback(new Error('nickname must be a string.'));
-    }
-
-    if (!ctx.mqttClient) {
-      return _callback(new Error('Not connected to MQTT'));
-    }
+    if (!threadID) throw new TypeError('threadID is required to set a nickname.');
+    if (typeof nicknameStr !== 'string') throw new TypeError('nickname must be a string.');
+    if (!ctx.mqttClient) throw new Error('Not connected to MQTT');
 
     ctx.wsReqNumber += 1;
     ctx.wsTaskNumber += 1;
 
     const queryPayload = {
       thread_key: threadID.toString(),
-      contact_id: participantID.toString(),
-      nickname: nickname,
+      contact_id: _participantID.toString(),
+      nickname: nicknameStr,
       sync_group: 1,
     };
 
@@ -113,7 +53,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',
       },
@@ -122,32 +62,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(
-            new Error(
-              `MQTT publish failed for setNickname: ${err.message || err}`,
-            ),
-          );
-        }
-
-        const nicknameChangeEvent = {
-          type: 'thread_nickname_update',
-          threadID: threadID,
-          participantID: participantID,
-          newNickname: nickname,
-          senderID: _initiatorID,
-          BotID: ctx.userID,
-          timestamp: Date.now(),
-        };
-        _callback(null, nicknameChangeEvent);
-      },
+    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 setNickname: ${err.message || err}`))
+            : resolve(),
+      ),
     );
 
-    return returnPromise;
+    return {
+      type: 'thread_nickname_update',
+      threadID,
+      participantID: _participantID,
+      newNickname: nicknameStr,
+      senderID: _initiatorID,
+      BotID: ctx.userID,
+      timestamp: Date.now(),
+    };
   };
 }

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

@@ -1,29 +1,22 @@
 import utils = require('../../../utils');
 
 /**
- * @ChoruOfficial
- * @description A module for interacting with Facebook Messenger Notes. This is not for creating notes on a user's profile page, but rather the temporary status-like notes in Messenger.
- * @param {Object} defaultFuncs The default functions provided by the API wrapper.
- * @param {Object} api The full API object.
- * @param {Object} ctx The context object containing the user's session state (e.g., userID, jar).
- * @returns {Object} An object containing methods to create, delete, recreate, and check notes.
+ * @module notes
+ * @description Interacts with Facebook Messenger Notes (temporary status-like notes).
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
  */
-export default function(defaultFuncs: any, api: any, ctx: any) {
-  /**
-   * @callback notesCallback
-   * @param {Error|null} error An error object if the request fails, otherwise null.
-   * @param {Object} [data] The data returned from the API.
-   */
-
+export default function notes(
+  defaultFuncs: any,
+  api: any,
+  ctx: any,
+) {
   /**
    * Checks for the currently active note for the logged-in user.
-   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object representing the current note.
+   * @returns {Promise<object|null>}
    */
-  function checkNote(callback) {
-    if (typeof callback !== 'function') {
-      callback = () => {};
-    }
-
+  async function checkNote(): Promise<any> {
     const form = {
       fb_api_caller_class: 'RelayModern',
       fb_api_req_friendly_name: 'MWInboxTrayNoteCreationDialogQuery',
@@ -31,30 +24,24 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
       doc_id: '30899655739648624',
     };
 
-    defaultFuncs
+    const resData = await defaultFuncs
       .post('https://www.facebook.com/api/graphql/', ctx.jar, form)
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then((resData) => {
-        if (resData && resData.errors) throw resData.errors[0];
-        const currentNote = resData?.data?.viewer?.actor?.msgr_user_rich_status;
-        callback(null, currentNote);
-      })
-      .catch((err) => {
-        utils.error('notes.checkNote', err);
-        callback(err);
-      });
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+    if (resData?.errors) {
+      utils.error('notes.checkNote', resData.errors[0]);
+      throw resData.errors[0];
+    }
+    return resData?.data?.viewer?.actor?.msgr_user_rich_status ?? null;
   }
 
   /**
-   * Creates a new note with the provided text. The note lasts for 24 hours (86400 seconds).
-   * @param {string} text The content of the note.
-   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object confirming the note's creation status.
+   * Creates a new note with the provided text. The note lasts for 24 hours.
+   * @param {string} text - The content of the note.
+   * @param {string} [privacy="EVERYONE"] - Privacy setting.
+   * @returns {Promise<object>}
    */
-  function createNote(text, privacy = 'EVERYONE', callback?) {
-    if (typeof callback !== 'function') {
-      callback = () => {};
-    }
-
+  async function createNote(text: string, privacy = 'EVERYONE'): Promise<any> {
     const variables = {
       input: {
         client_mutation_id: Math.round(Math.random() * 10).toString(),
@@ -68,38 +55,31 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
     };
     const form = {
       fb_api_caller_class: 'RelayModern',
-      fb_api_req_friendly_name:
-        'MWInboxTrayNoteCreationDialogCreationStepContentMutation',
+      fb_api_req_friendly_name: 'MWInboxTrayNoteCreationDialogCreationStepContentMutation',
       variables: JSON.stringify(variables),
       doc_id: '24060573783603122',
     };
 
-    defaultFuncs
+    const resData = await defaultFuncs
       .post('https://www.facebook.com/api/graphql/', ctx.jar, form)
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then((resData) => {
-        if (resData && resData.errors) throw resData.errors[0];
-        const status = resData?.data?.xfb_rich_status_create?.status;
-        if (!status)
-          throw new Error('Could not find note status in the server response.');
-        callback(null, status);
-      })
-      .catch((err) => {
-        utils.error('notes.createNote', err);
-        callback(err);
-      });
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+    if (resData?.errors) {
+      utils.error('notes.createNote', resData.errors[0]);
+      throw resData.errors[0];
+    }
+
+    const status = resData?.data?.xfb_rich_status_create?.status;
+    if (!status) throw new Error('Could not find note status in the server response.');
+    return status;
   }
 
   /**
    * Deletes a specific note by its ID.
-   * @param {string} noteID The ID of the note to be deleted.
-   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object confirming the deletion.
+   * @param {string} noteID - The ID of the note to delete.
+   * @returns {Promise<object>}
    */
-  function deleteNote(noteID, callback) {
-    if (typeof callback !== 'function') {
-      callback = () => {};
-    }
-
+  async function deleteNote(noteID: string): Promise<any> {
     const variables = {
       input: {
         client_mutation_id: Math.round(Math.random() * 10).toString(),
@@ -114,46 +94,30 @@ export default function(defaultFuncs: any, api: any, ctx: any) {
       doc_id: '9532619970198958',
     };
 
-    defaultFuncs
+    const resData = await defaultFuncs
       .post('https://www.facebook.com/api/graphql/', ctx.jar, form)
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then((resData) => {
-        if (resData && resData.errors) throw resData.errors[0];
-        const deletedStatus = resData?.data?.xfb_rich_status_delete;
-        if (!deletedStatus)
-          throw new Error(
-            'Could not find deletion status in the server response.',
-          );
-        callback(null, deletedStatus);
-      })
-      .catch((err) => {
-        utils.error('notes.deleteNote', err);
-        callback(err);
-      });
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+    if (resData?.errors) {
+      utils.error('notes.deleteNote', resData.errors[0]);
+      throw resData.errors[0];
+    }
+
+    const deletedStatus = resData?.data?.xfb_rich_status_delete;
+    if (!deletedStatus) throw new Error('Could not find deletion status in the server response.');
+    return deletedStatus;
   }
 
   /**
-   * A convenience function that first deletes an old note and then creates a new one.
-   * @param {string} oldNoteID The ID of the note to delete.
-   * @param {string} newText The text for the new note.
-   * @param {notesCallback} callback A callback function that is executed after the request. It receives an error object (if any) and an object containing the deletion and creation statuses.
+   * Deletes an old note and creates a new one.
+   * @param {string} oldNoteID - The ID of the note to delete.
+   * @param {string} newText - The text for the new note.
+   * @returns {Promise<{ deleted: object, created: object }>}
    */
-  function recreateNote(oldNoteID, newText, callback) {
-    if (typeof callback !== 'function') {
-      callback = () => {};
-    }
-
-    deleteNote(oldNoteID, (err, deleted) => {
-      if (err) {
-        return callback(err);
-      }
-      createNote(newText, undefined, (err, created) => {
-        if (err) {
-          return callback(err);
-        }
-        callback(null, { deleted, created });
-      });
-    });
+  async function recreateNote(oldNoteID: string, newText: string): Promise<{ deleted: any; created: any }> {
+    const deleted = await deleteNote(oldNoteID);
+    const created = await createNote(newText);
+    return { deleted, created };
   }
 
   return {