noblox-asset.js 7.4.0

package/lib/party/onPartyUserJoined.js

@@ -0,0 +1,53 @@
+const events = require('events')
+
+const onNotification = require('../client/onNotification.js').func
+
+exports.optional = ['jar']
+
+// Docs
+/**
+ * 🔐 An event for when someone joins a party.
+ * @category Party
+ * @alias onPartyUserJoined
+ * @returns An EventEmitter that emits when someone joins a party.
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * const partyJoined = noblox.onPartyUserJoined()
+ * partyJoined.on("data", function(data) {
+ *  console.log("Someone joined a party! ", data)
+ * })
+ * partyJoined.on("error", function(err) {
+ *  console.error("Something went wrong: ", err)
+ *  // Handle error as needed
+ * })
+**/
+
+exports.func = (args) => {
+  const jar = args.jar
+  const newEvent = new events.EventEmitter()
+  const notifications = onNotification({ jar })
+
+  notifications.on('data', (name, message) => {
+    if (name === 'PartyNotifications' && message.Type === 'PartyUserJoined') {
+      newEvent.emit('data', {
+        PartyId: message.PartyId,
+        PartyType: message.PartyType
+      })
+    }
+  })
+
+  notifications.on('error', (err) => {
+    newEvent.emit('error', err)
+  })
+
+  notifications.on('connect', () => {
+    newEvent.emit('connect')
+  })
+
+  notifications.on('close', (internal) => {
+    if (internal) return
+    notifications.emit('close', true)
+  })
+
+  return newEvent
+}

package/lib/party/onPartyUserLeft.js

@@ -0,0 +1,53 @@
+const events = require('events')
+
+const onNotification = require('../client/onNotification.js').func
+
+exports.optional = ['jar']
+
+// Docs
+/**
+ * 🔐 An event for when someone leaves a party.
+ * @category Party
+ * @alias onPartyUserLeft
+ * @returns An EventEmitter that emits when someone leaves a party.
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * const partyLeft = noblox.onPartyUserLeft()
+ * partyLeft.on("data", function(data) {
+ *  console.log("Someone left party! ", data)
+ * })
+ * partyLeft.on("error", function(err) {
+ *  console.error("Something went wrong: ", err)
+ *  // Handle error as needed
+ * })
+**/
+
+exports.func = (args) => {
+  const jar = args.jar
+  const newEvent = new events.EventEmitter()
+  const notifications = onNotification({ jar })
+
+  notifications.on('data', (name, message) => {
+    if (name === 'PartyNotifications' && message.Type === 'PartyUserLeft') {
+      newEvent.emit('data', {
+        PartyId: message.PartyId,
+        PartyType: message.PartyType
+      })
+    }
+  })
+
+  notifications.on('error', (err) => {
+    newEvent.emit('error', err)
+  })
+
+  notifications.on('connect', () => {
+    newEvent.emit('connect')
+  })
+
+  notifications.on('close', (internal) => {
+    if (internal) return
+    notifications.emit('close', true)
+  })
+
+  return newEvent
+}

package/lib/premiumfeatures/getPremium.js

@@ -0,0 +1,46 @@
+// Includes
+const http = require('../util/http.js').func
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['userId']
+exports.optional = ['jar']
+
+// Docs
+/**
+ * 🔐 Gets whether or not a user has premium.
+ * @category User
+ * @alias getPremium
+ * @param {number} userId - The id of the user.
+ * @returns {Promise<boolean>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * const hasPremium = await noblox.getPremium(123456)
+ **/
+
+// Define
+function getPremium (jar, userId) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: `https://premiumfeatures.roblox.com/v1/users/${userId}/validate-membership`,
+      options: {
+        method: 'GET',
+        jar,
+        resolveWithFullResponse: true
+      }
+    }
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 200) {
+          resolve(res.body === 'true')
+        } else {
+          reject(new RobloxAPIError(res))
+        }
+      })
+  })
+}
+
+exports.func = function (args) {
+  const jar = args.jar
+  return getPremium(jar, args.userId)
+}

package/lib/presence/getPresences.js

@@ -0,0 +1,60 @@
+// Includes
+const http = require('../util/http.js').func
+const getGeneralToken = require('../util/getGeneralToken.js').func
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['userIds']
+exports.optional = []
+
+// Docs
+/**
+ * 🔐 Get the presence status of users.
+ * @category Presence
+ * @alias getPresences
+ * @param {Array<number>} userIds - An array of userIds.
+ * @returns {Promise<Presences>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * const presences = await noblox.getPresences([1, 2, 3])
+**/
+
+// Define
+function getPresences (userIds, jar, xcsrf) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: '//presence.roblox.com/v1/presence/users',
+      options: {
+        method: 'POST',
+        resolveWithFullResponse: true,
+        jar,
+        headers: {
+          'X-CSRF-TOKEN': xcsrf,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          userIds
+        })
+      }
+    }
+
+    return http(httpOpt)
+      .then(function (res) {
+        const responseData = JSON.parse(res.body)
+        if (res.statusCode !== 200) {
+          reject(new RobloxAPIError(res))
+        } else {
+          resolve(responseData)
+        }
+      })
+      .catch(error => reject(error))
+  })
+}
+
+exports.func = function (args) {
+  const jar = args.jar
+  return getGeneralToken({ jar })
+    .then(function (xcsrf) {
+      return getPresences(args.userIds, args.jar, xcsrf)
+    })
+}

package/lib/privatemessages/getMessages.js

@@ -0,0 +1,55 @@
+// Includes
+const http = require('../util/http.js').func
+const RobloxAPIError = require('../util/apiError.js')
+// Args
+exports.required = []
+exports.optional = ['pageNumber', 'pageSize', 'messageTab', 'jar']
+
+// Docs
+/**
+ * 🔐 Get the messages of the authenticated user.
+ * @category User
+ * @alias getMessages
+ * @param {number=} [pageNumber=0] - The number of the current page.
+ * @param {number=} [pageSize=25] - The size of the current page.
+ * @param {("Inbox" | "Sent" | "Archive")=} [messageTab=Inbox] - The tab of the messages being fetched (Inbox, Sent, Archive)
+ * @returns {Promise<PrivateMessagesPage>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * let messages = await noblox.getMessages(1, 10, "Inbox"))
+**/
+
+// Define
+function getMessages (jar, pageNumber, pageSize, messageTab) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: `//privatemessages.roblox.com/v1/messages?pageNumber=${pageNumber}&pageSize=${pageSize}&messageTab=${messageTab}`,
+      options: {
+        method: 'GET',
+        jar,
+        resolveWithFullResponse: true
+      }
+    }
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 200) {
+          resolve(JSON.parse(res.body))
+        } else {
+          reject(new RobloxAPIError(res))
+        }
+      })
+  })
+}
+
+exports.func = function (args) {
+  const jar = args.jar
+  const pageNumber = (args.pageNumber && args.pageNumber.toString()) || '0'
+  const pageSize = (args.pageSize && args.pageSize.toString()) || '25'
+  const messageTab = args.messageTab || 'Inbox'
+  if (!['Inbox', 'Sent', 'Archive'].includes(messageTab)) {
+    return new Promise((resolve, reject) => {
+      reject(new Error('messageTab must be Inbox, Sent, or Archive'))
+    })
+  }
+  return getMessages(jar, pageNumber, pageSize, messageTab)
+}

package/lib/privatemessages/message.js

@@ -0,0 +1,75 @@
+// Includes
+const http = require('../util/http.js').func
+const queue = require('../internal/queue.js')
+const getGeneralToken = require('../util/getGeneralToken.js').func
+const getHash = require('../util/getHash.js').func
+const getSenderId = require('../util/getSenderUserId.js').func
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['recipient', 'subject', 'body']
+exports.optional = ['replyMessageId', 'includePreviousMessage', 'jar']
+
+// Docs
+/**
+ * 🔐 Send a message. NOTE: Roblox blocks web servers and proxies from sending messages.
+ * @category User
+ * @alias message
+ * @param {number} recipient - The id of the user.
+ * @param {string} subject - The subject of the message.
+ * @param {string} body - The body of the message.
+ * @param {number=} replyMessageId - The messageId to reply to.
+ * @param {boolean=} [includePreviousMessage=false] - The previous or next page cursor.
+ * @returns {Promise<void>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * noblox.message(1, "A subject", "A body", 1234, true)
+**/
+
+// Define
+function message (jar, token, senderId, recipient, subject, body, replyMessageId, includePreviousMessage) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: '//privatemessages.roblox.com/v1/messages/send',
+      options: {
+        method: 'POST',
+        jar,
+        headers: {
+          'X-CSRF-TOKEN': token,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          userId: senderId,
+          recipientId: recipient,
+          subject,
+          body,
+          replyMessageId,
+          includePreviousMessage
+        }),
+        resolveWithFullResponse: true
+      }
+    }
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 200) {
+          resolve(JSON.parse(res.body))
+        } else {
+          reject(new RobloxAPIError(res))
+        }
+      })
+  })
+}
+
+exports.func = function (args) {
+  const jar = args.jar
+  return queue('Message', getHash({ jar }), function () {
+    return getGeneralToken({ jar })
+      .then(function (xcsrf) {
+        return getSenderId({ jar }).then((senderId) => {
+          return message(jar, xcsrf, senderId, args.recipient, args.subject, args.body, args.replyMessageId, args.includePreviousMessage)
+        })
+      })
+  }, function () {
+    return true
+  })
+}

package/lib/privatemessages/onMessage.js

@@ -0,0 +1,89 @@
+// Dependencies
+const events = require('events')
+
+// Includes
+const onNotification = require('../client/onNotification.js').func
+const getMessages = require('./getMessages.js').func
+
+// Args
+exports.optional = ['jar']
+
+// Docs
+/**
+ * 🔐 An event for when a user sends you a message via. the older 'email-like' message system. To receive chat messages,
+ * see the `onNewMessage` method.
+ * @see [onNewMessage()](global.html#onNewMessage).
+ * @category User
+ * @alias onMessage
+ * @returns An EventEmitter that emits when a user sends you a message.
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * const messageEvent = noblox.onMessage()
+ * messageEvent.on("data", function(data) {
+ *  console.log("New message! ", data)
+ * })
+ * messageEvent.on("error", function(err) {
+ *  console.error("Something went wrong: ", err)
+ *  // Handle error as needed
+ * })
+**/
+
+// Define
+exports.func = function (args) {
+  const jar = args.jar
+  const onMessage = new events.EventEmitter()
+  let waitingForRequest = false
+  let latest
+  getMessages({ jar, messageTab: 'Inbox', pageNumber: 0, pageSize: 1 })
+    .then(function (initial) {
+      latest = initial.collection[0] ? initial.collection[0].id : 0
+      const notifications = onNotification({ jar })
+      notifications.on('data', function (name, message) {
+        if (name === 'MessageNotification' && message.Type === 'Created') {
+          if (waitingForRequest) {
+            waitingForRequest = false
+          } else {
+            getMessages({
+              jar,
+              messageTab: 'Inbox',
+              pageNumber: 0,
+              pageSize: 1
+            })
+              .then(function (inbox) {
+                const messages = inbox.collection
+                for (let i = messages.length - 1; i >= 0; i--) {
+                  const message = messages[i]
+                  const id = message.id
+                  if (id > latest) {
+                    latest = id
+                    onMessage.emit('data', message)
+                  }
+                }
+              })
+          }
+        } else if (name === 'FriendshipNotifications' && message.Type === 'FriendshipRequested') {
+          waitingForRequest = true
+        }
+      })
+      notifications.on('error', function (err) {
+        onMessage.emit('error', err)
+      })
+      notifications.on('connect', function () {
+        onMessage.emit('connect')
+      })
+      notifications.on('close', function (internal) {
+        if (internal) {
+          return
+        }
+        onMessage.emit('close', true)
+      })
+      onMessage.on('close', function (internal) {
+        if (internal) {
+          return
+        }
+        notifications.emit('close', true)
+      })
+    })
+
+  return onMessage
+}

package/lib/thumbnails/getLogo.js

@@ -0,0 +1,56 @@
+// Includes
+const http = require('../util/http.js').func
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['group']
+exports.optional = ['size', 'circular', 'format']
+
+// Docs
+/**
+ * ✅ Get the group's logo.
+ * @category Group
+ * @alias getLogo
+ * @param {number} group - The id of the group.
+ * @param {GroupIconSize=} [size=150x150] - The size of the logo.
+ * @param {boolean=} [circular=false] - Get the circular version of the logo.
+ * @param {GroupIconFormat=} [format=Png] - The file format of the logo.
+ * @returns {Promise<string>}
+ * @example const noblox = require("noblox.js")
+ * const logo = await noblox.getLogo(1)
+**/
+
+// Define
+function getLogo (group, size, circular, format) {
+  const httpOpt = {
+    url: '//thumbnails.roblox.com/v1/groups/icons',
+    options: {
+      qs: {
+        groupIds: group,
+        size: size || '150x150',
+        format: format || 'Png',
+        isCircular: circular
+      },
+      json: true,
+      resolveWithFullResponse: true
+    }
+  }
+  return http(httpOpt)
+    .then(function (res) {
+      if (res.statusCode !== 200) {
+        throw new RobloxAPIError(res)
+      }
+
+      const thumbnailData = res.body.data[0]
+
+      if (thumbnailData.state !== 'Completed') {
+        throw new Error('The requested image has not been approved. Status: ' + thumbnailData.state)
+      }
+
+      return thumbnailData.imageUrl
+    })
+}
+
+exports.func = function (args) {
+  return getLogo(args.group)
+}

package/lib/thumbnails/getPlayerThumbnail.js

@@ -0,0 +1,120 @@
+// Includes
+const http = require('../util/http.js').func
+const { thumbnail: settings } = require('../../settings.json')
+const RobloxAPIError = require('../util/apiError.js')
+
+// Args
+exports.required = ['userIds']
+exports.optional = ['size', 'format', 'isCircular', 'cropType', 'retryCount']
+
+// Variables
+const eligibleSizes = {
+  body: {
+    sizes: ['30x30', '48x48', '60x60', '75x75', '100x100', '110x110', '140x140', '150x150', '150x200', '180x180', '250x250', '352x352', '420x420', '720x720'],
+    endpoint: 'avatar'
+  },
+  bust: {
+    sizes: ['48x48', '50x50', '60x60', '75x75', '100x100', '150x150', '180x180', '352x352', '420x420'],
+    endpoint: 'avatar-bust'
+  },
+  headshot: {
+    sizes: ['48x48', '50x50', '60x60', '75x75', '100x100', '110x110', '150x150', '180x180', '352x352', '420x420', '720x720'],
+    endpoint: 'avatar-headshot'
+  }
+}
+
+// Docs
+/**
+ * ✅ Get a user's thumbnail.
+ * @category User
+ * @alias getPlayerThumbnail
+ * @param {number | Array<number>} userIds - The id or an array ids of thumbnails to be retrieved; 100
+ * @param {number | string=} [size=720x720] - The [size of the image to be returned]{@link https://noblox.js.org/thumbnailSizes.png}; defaults highest resolution
+ * @param {'png' | 'jpeg'=} [format=png] - The file format of the returned thumbnails
+ * @param {boolean=} [isCircular=false] - Return the circular version of the thumbnails
+ * @param {'Body' | 'Bust' | 'Headshot'=} [cropType=Body] - The style of thumbnail that will be returned
+ * @returns {Promise<PlayerThumbnailData[]>}
+ * @example const noblox = require("noblox.js")
+ * let thumbnail_default = await noblox.getPlayerThumbnail(2416399685)
+ * let thumbnail_circHeadshot = await noblox.getPlayerThumbnail(2416399685, 420, "png", true, "Headshot")
+ * let thumbnails_body = await noblox.getPlayerThumbnail([2416399685, 234567, 345678], "150x200", "jpeg", false, "Body")
+**/
+
+// Define
+function getPlayerThumbnail (userIds, size, format = 'png', isCircular = false, cropType = 'body', retryCount = settings.maxRetries) {
+  // Validate userIds
+  if (Array.isArray(userIds)) {
+    if (userIds.some(isNaN)) {
+      throw new Error('userIds must be a number or an array of numbers')
+    }
+    userIds = [...new Set(userIds)] // get rid of duplicates, endpoint response does this anyway
+    if (userIds.length > 100) {
+      throw new Error(`too many userIds provided (${userIds.length}); maximum 100`)
+    }
+  } else {
+    if (isNaN(userIds)) {
+      throw new Error('userId is not a number')
+    }
+    userIds = [userIds]
+  }
+
+  // Validate cropType
+  cropType = cropType.toLowerCase()
+  if (!Object.keys(eligibleSizes).includes(cropType)) {
+    throw new Error(`Invalid cropping type provided: ${cropType} | Use: ${Object.keys(eligibleSizes).join(', ')}`)
+  }
+  const { sizes, endpoint } = eligibleSizes[cropType]
+
+  // Validate size
+  size = size || sizes[sizes.length - 1]
+  if (typeof size === 'number') {
+    size = `${size}x${size}`
+  }
+  if (!sizes.includes(size)) {
+    throw new Error(`Invalid size parameter provided: ${size} | [${cropType.toUpperCase()}] Use: ${sizes.join(', ')}`)
+  }
+
+  // Validate format
+  if (format.toLowerCase() !== 'png' && format.toLowerCase() !== 'jpeg') {
+    throw new Error(`Invalid image type provided: ${format} | Use: png, jpeg`)
+  }
+
+  return http({
+    url: `https://thumbnails.roblox.com/v1/users/${endpoint}?userIds=${userIds.join(',')}&size=${size}&format=${format}&isCircular=${!!isCircular}`,
+    options: {
+      resolveWithFullResponse: true,
+      followRedirect: true
+    }
+  })
+    .then(async (res) => {
+      let { data } = JSON.parse(res.body)
+      if (res.statusCode === 200) {
+        if (retryCount > 0) {
+          const pendingThumbnails = data.filter(obj => { return obj.state === 'Pending' }).map(obj => obj.targetId) // Get 'Pending' thumbnails as array of userIds
+          if (pendingThumbnails.length > 0) {
+            await timeout(settings.retryDelay) // small delay helps cache populate on Roblox's end; default 500ms
+            const updatedPending = await getPlayerThumbnail(pendingThumbnails, size, format, isCircular, cropType, --retryCount) // Recursively retry for # of maxRetries attempts; default 2
+            data = data.map(obj => updatedPending.find(o => o.targetId === obj.targetId) || obj) // Update primary array's values
+          }
+        }
+        data = data.map(obj => {
+          if (obj.state !== 'Completed') {
+            const settingsUrl = settings.failedUrl[obj.state.toLowerCase()] // user defined settings.json default image URL for blocked or pending thumbnails; default ""
+            obj.imageUrl = settingsUrl || `https://noblox.js.org/moderatedThumbnails/moderatedThumbnail_${size}.png`
+          }
+          return obj
+        })
+        return data
+      } else {
+        throw new RobloxAPIError(res)
+      }
+    })
+}
+
+function timeout (ms) {
+  return new Promise(resolve => { setTimeout(resolve, ms) })
+}
+
+exports.func = function ({ userIds, size, format, isCircular, cropType, retryCount }) {
+  return getPlayerThumbnail(userIds, size, format, isCircular, cropType, retryCount)
+}