noblox.ts-fetch 4.6.8

package/lib/groups/shout.js

@@ -0,0 +1,65 @@
+// Includes
+const http = require('../util/http.js').func
+const getGeneralToken = require('../util/getGeneralToken.js').func
+
+// Args
+exports.required = ['group']
+exports.optional = ['message', 'jar']
+
+// Docs
+/**
+ * 🔐 Change a group's shout.
+ * @category Group
+ * @alias shout
+ * @param {number} group - The id of the group.
+ * @param {string=} [message=""] - The message to shout
+ * @returns {Promise<GroupShout>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * noblox.shout(1, "Hello world!")
+**/
+
+function shoutOnGroup (group, message = '', jar, xcsrf) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: `https://groups.roblox.com/v1/groups/${group}/status`,
+      options: {
+        method: 'PATCH',
+        resolveWithFullResponse: true,
+        json: {
+          message
+        },
+        jar: jar,
+        headers: {
+          'X-CSRF-TOKEN': xcsrf
+        }
+      }
+    }
+
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 200) {
+          resolve(res.body)
+        } else {
+          const body = res.body || {}
+          if (body.errors && body.errors.length > 0) {
+            const errors = body.errors.map((e) => {
+              return e.message
+            })
+            reject(new Error(`${res.statusCode} ${errors.join(', ')}`))
+          } else {
+            reject(new Error(`${res.statusCode} ${res.body}`))
+          }
+        }
+      }).catch(error => reject(error))
+  })
+}
+
+// Define
+exports.func = function (args) {
+  const jar = args.jar
+  return getGeneralToken({ jar: jar })
+    .then(function (xcsrf) {
+      return shoutOnGroup(args.group, args.message, args.jar, xcsrf)
+    })
+}

package/lib/index.js

@@ -0,0 +1,30 @@
+const path = require('path')
+const fs = require('fs')
+const include = ['cache']
+
+const noblox = {}
+
+function search (dir) {
+  require('fs').readdirSync(dir).forEach(function (file) {
+    const stat = fs.statSync(path.join(dir, file))
+    if (stat.isFile() || include.indexOf(file) !== -1) {
+      noblox[file.replace('.js', '')] = require(dir + '/' + file)
+    } else if (stat.isDirectory()) {
+      search(path.join(dir, file))
+    }
+  })
+}
+
+search(__dirname)
+
+for (const name in noblox) {
+  const exporter = noblox[name]
+  if (Object.prototype.hasOwnProperty.call(exporter, 'func')) {
+    module.exports[name] = noblox.wrap.wrapExport(exporter.func, exporter.required || [], exporter.optional || [])
+  } else {
+    module.exports[name] = noblox[name]
+  }
+}
+
+exports.options = require('./options.js')
+exports.settings = require('../settings.json')

package/lib/internal/levelOneCopy.js

@@ -0,0 +1,16 @@
+// Define
+function shallowCopy (obj) {
+  return Object.assign(obj instanceof Array ? [] : {}, obj)
+}
+
+module.exports = function (obj) {
+  const newObj = shallowCopy(obj)
+  for (const index in obj) {
+    let value = obj[index]
+    if (value instanceof Object) {
+      value = shallowCopy(value)
+    }
+    newObj[index] = value
+  }
+  return newObj
+}

package/lib/internal/queue.js

@@ -0,0 +1,61 @@
+// Includes
+const options = require('../options.js')
+
+// Define
+module.exports = function (type, index, func, handler) {
+  const group = options.queue[type]
+  if (!group[index]) {
+    group[index] = {
+      jobs: []
+    }
+  }
+  const home = group[index]
+  function run (time) {
+    return function (resolve, reject) {
+      setTimeout(function () {
+        func().then(resolve).catch(reject)
+      }, time)
+    }
+  }
+  const jobs = home.jobs
+  function deactivate (err) {
+    jobs.shift()
+    if (!handler(err)) {
+      home.last = Date.now()
+    }
+  }
+  function next () {
+    jobs.shift()
+    home.last = Date.now()
+  }
+  if (group.delay > 0) {
+    const delay = group.delay
+    const last = home.last
+    if (jobs.length === 0) {
+      let item
+      const diff = Date.now() - last
+      if (!last || diff > delay) {
+        item = func()
+      } else {
+        item = new Promise(run(delay - diff))
+      }
+      jobs.push(item)
+      item.then(next).catch(deactivate)
+      return item
+    } else {
+      const job = jobs[jobs.length - 1].then(function () {
+        const item = new Promise(run(delay))
+        item.then(next).catch(deactivate)
+        return item
+      }).catch(function (err) {
+        const item = handler && handler(err) ? func() : new Promise(run(delay))
+        item.then(next).catch(deactivate)
+        return item
+      })
+      jobs.push(job)
+      return job
+    }
+  } else {
+    return func()
+  }
+}

package/lib/internal/timeout.js

@@ -0,0 +1,30 @@
+class TimeoutError extends Error {
+}
+
+/**
+ * A basic replacement for the Bluebird 'timeout' method. Returns a Promise which will resolve or reject with the result of the given
+ * promise once it resolves, or reject if the promise should fail to resolve within the supplied timeout. An optional reason
+ * can also be supplied.
+ * @param promise - The Promise to apply a timeout to.
+ * @param timeoutTime - The timeout to apply to the Promise.
+ * @param reason - Optional String reason for the timeout.
+ * @returns {Promise<unknown>}
+ */
+function timeout (promise, timeoutTime, reason = 'operation timed out') {
+  let timer
+
+  const timeoutPromise = new Promise(function (resolve, reject) {
+    timer = setTimeout(function () {
+      return reject(new TimeoutError(reason))
+    }, timeoutTime)
+  })
+
+  // We return the first promise to complete. If it resolves normally, the normal promise completed - so we cancel the timer
+  // to prevent any unnecessary hanging waiting for timeout timers.
+  return Promise.race([promise, timeoutPromise])
+    .finally(function () {
+      clearTimeout(timer)
+    })
+}
+
+module.exports = timeout

package/lib/internal/wrap.js

@@ -0,0 +1,78 @@
+/*
+const args = ['jar', 'username', 'password']
+
+raw function login (jar, username, password)
+
+exported function login ()
+  check number of arguments if necessary
+    options object: login(arguments[0])
+    individual arguments:
+      for each argument add to an options array corresponding with argument order
+      login(options)
+*/
+// Define
+exports.wrapExport = function (wrapFunction, required, optional) {
+  const reqLength = required.length
+  if ((reqLength + optional.length) > 0) {
+    return function () {
+      let options = {}
+      const length = arguments.length
+      let assume = false
+      if (length > 0) {
+        const first = arguments[0]
+        let collectOptions = true
+        if (length === 1 && (first instanceof Object)) {
+          assume = true
+          const firstArg = required[0] || optional
+          if (firstArg && firstArg instanceof Object) {
+            for (let i = 0; i < firstArg.length; i++) {
+              if (first[firstArg[i]]) {
+                options = first
+                collectOptions = false
+                break
+              }
+            }
+          } else if (firstArg && first[firstArg]) {
+            options = first
+            collectOptions = false
+          }
+        }
+        if (collectOptions) {
+          for (let i = 0; i <= length; i++) {
+            const list = (i >= reqLength ? optional : required)
+            const index = list[(i >= reqLength ? (i - reqLength) : i)]
+            if (index instanceof Object) {
+              options[index[0]] = arguments[i]
+            } else {
+              options[index] = arguments[i]
+            }
+          }
+        }
+      }
+      for (let i = 0; i < reqLength; i++) {
+        const arg = required[i]
+        let found = false
+        if (arg instanceof Object) {
+          for (let k = 0; k <= arg.length; k++) {
+            if (options[arg[k]] != null) {
+              found = true
+              break
+            }
+          }
+        } else if (options[arg] != null) {
+          found = true
+        }
+        if (!found) {
+          if (assume) {
+            throw new Error('A required argument is missing')
+          } else {
+            throw new Error('Required argument "' + (arg instanceof Object ? arg.join('/') : arg) + '" is missing')
+          }
+        }
+      }
+      return wrapFunction(options)
+    }
+  } else {
+    return wrapFunction
+  }
+}

package/lib/inventory/getCollectibles.js

@@ -0,0 +1,31 @@
+// Includes
+const getPageResults = require('../util/getPageResults.js').func
+
+// Args
+exports.required = ['userId']
+exports.optional = ['assetType', 'sortOrder', 'limit', 'jar']
+
+// Docs
+/**
+ * 🔓 Get a user's collectibles.
+ * @category User
+ * @alias getCollectibles
+ * @param {number} userId - The id of the user whose collectibles are being retrieved.
+ * @param {SortOrder=} [sortOrder=Asc] - The order that the collectibles will bee sorted by (Asc or Desc)
+ * @param {string=} assetType - The asset type for the collectibles you're trying to get.
+ * @param {number} [limit=10] - The amount of results per request.
+ * @returns {Promise<CollectibleEntry[]>}
+ * @example const noblox = require("noblox.js")
+ * let collectibles = await noblox.getCollectibles({userId: 123456, sortOrder: "Asc", limit: 100})
+**/
+
+// Define
+exports.func = function (args) {
+  return getPageResults({
+    jar: args.jar,
+    url: `//inventory.roblox.com/v1/users/${args.userId}/assets/collectibles`,
+    query: { assetType: args.assetType },
+    sortOrder: args.sortOrder,
+    limit: args.limit
+  })
+}

package/lib/inventory/getInventory.js

@@ -0,0 +1,32 @@
+// Includes
+const getPageResults = require('../util/getPageResults.js').func
+
+// Args
+exports.required = ['userId', 'assetTypes']
+exports.optional = ['sortOrder', 'limit', 'jar']
+
+// Docs
+/**
+ * 🔓 Get a user's inventory.
+ * NOTE: Badges must use [getPlayerBadges()]{@link https://noblox.js.org/global.html#getPlayerBadges} due to an issue with Roblox's API.
+ * @category User
+ * @alias getInventory
+ * @param {number} userId - The id of user whose inventory is being returned.
+ * @param {Array<string>} assetTypes - The types of assets being retrieved: [("Shirt", "Pants")]{@link https://developer.roblox.com/en-us/api-reference/enum/AssetType}.
+ * @param {SortOrder=} [sortOrder=Asc] - The order that the data will be returned in (Asc or Desc)
+ * @param {Limit=} [limit=10] - The number of assets returned in each request (10, 25, 50, or 100)
+ * @returns {Promise<InventoryEntry[]>}
+ * @example const noblox = require("noblox.js")
+ * let inventory = await noblox.getInventory({userId: 123456, assetTypes: ["Shirt"], sortOrder: "Asc", limit: 100})
+**/
+
+// Define
+exports.func = function (args) {
+  return getPageResults({
+    jar: args.jar,
+    url: `//inventory.roblox.com/v2/users/${args.userId}/inventory`,
+    query: { assetTypes: args.assetTypes.join(',') },
+    sortOrder: args.sortOrder,
+    limit: args.limit
+  })
+}

package/lib/inventory/getInventoryById.js

@@ -0,0 +1,31 @@
+// Includes
+const getPageResults = require('../util/getPageResults.js').func
+
+// Args
+exports.required = ['userId', 'assetTypeId']
+exports.optional = ['sortOrder', 'limit', 'jar']
+
+// Docs
+/**
+ * 🔓 Get a user's inventory.
+ * @category User
+ * @alias getInventoryById
+ * @param {number} userId - The id of user whose inventory is being returned.
+ * @param {Array<number>} assetTypeId - The types of assets being retrieved: [(11, 12)]{@link https://developer.roblox.com/en-us/api-reference/enum/AssetType}.
+ * @param {SortOrder=} [sortOrder=Asc] - The order that the data will be returned in (Asc or Desc)
+ * @param {Limit=} [limit=10] - The number of assets returned in each request (10, 25, 50, or 100)
+ * @returns {Promise<InventoryEntry[]>}
+ * @example const noblox = require("noblox.js")
+ * let inventory = await noblox.getInventoryById({userId: 123456, assetTypeId: 2, sortOrder: "Asc", limit: 100})
+**/
+
+// Define
+exports.func = function (args) {
+  return getPageResults({
+    jar: args.jar,
+    url: `//inventory.roblox.com/v2/users/${args.userId}/inventory/${args.assetTypeId}`,
+    query: {},
+    sortOrder: args.sortOrder,
+    limit: args.limit
+  })
+}

package/lib/inventory/getOwnership.js

@@ -0,0 +1,54 @@
+// Includes
+const http = require('../util/http.js').func
+
+// Args
+exports.required = ['userId', 'itemTargetId']
+exports.optional = ['itemType']
+
+// Docs
+/**
+ * ✅ Check if the user owns the asset.
+ * @category User
+ * @alias getOwnership
+ * @param {number} userId - The id of the user whose ownership is being checked.
+ * @param {number} itemTargetId - The id of the item.
+ * @param {("Asset" | "GamePass" | "Badge" | "Bundle")=} [itemType=Asset] - The type of item in question (Asset, GamePass, Badge, Bundle)
+ * @returns {Promise<boolean>}
+ * @example const noblox = require("noblox.js")
+ * let ownership = await noblox.getOwnership(123456, 234567, "GamePass")
+**/
+
+// Define
+function getOwnership (userId, itemTargetId, itemType) {
+  return new Promise((resolve, reject) => {
+    const httpOpt = {
+      url: `//inventory.roblox.com/v1/users/${userId}/items/${itemType}/${itemTargetId}`,
+      options: {
+        method: 'GET',
+        resolveWithFullResponse: true
+      }
+    }
+    return http(httpOpt)
+      .then(function (res) {
+        if (res.statusCode === 200) {
+          const body = JSON.parse(res.body)
+          resolve(body.data.length > 0)
+        } else {
+          const body = JSON.parse(res.body) || {}
+          if (body.errors && body.errors.length > 0) {
+            const errors = body.errors.map((e) => {
+              return e.message
+            })
+            reject(new Error(`${res.statusCode} ${errors.join(', ')}`))
+          } else {
+            reject(new Error(`${res.statusCode} ${res.body}`))
+          }
+        }
+      })
+  })
+}
+
+exports.func = function (args) {
+  const itemType = args.itemType || 'Asset'
+  return getOwnership(args.userId, args.itemTargetId, itemType)
+}

package/lib/inventory/getUAIDs.js

@@ -0,0 +1,47 @@
+// Includes
+const getCollectibles = require('./getCollectibles.js').func
+
+// Args
+exports.required = ['userId', 'assetIds']
+exports.optional = ['exclusionList', 'jar']
+
+// Docs
+/**
+ * ✅ Get a UserAssetID for a specific asset.
+ * @category User
+ * @alias getUAIDs
+ * @param {number} userId - The id of the user to search.
+ * @param {Array<number>} assetIds - The ids of the assets to retrieve.
+ * @param {Array<number>=} exclusionList - The UAIDs to exclude from the search.
+ * @returns {Promise<UAIDResponse>}
+ * @example const noblox = require("noblox.js")
+ * const UAIDInfo = await noblox.getUAIDs(80231025, [1974901902, 4255053867, 2705893733, 1532395])
+**/
+
+// Define
+function getUAIDs (userId, requestedIds, excludedIds) {
+  return new Promise((resolve) => {
+    getCollectibles({ userId: userId }).then(function (collectibles) {
+      const retrievedIds = []
+
+      for (let index = 0; index < collectibles.length; index++) {
+        const collectible = collectibles[index]
+        const requestIndex = requestedIds.indexOf(collectible.assetId)
+
+        if (requestIndex > -1 && excludedIds.indexOf(collectible.userAssetId) === -1) {
+          requestedIds.splice(requestIndex, 1)
+          retrievedIds.push(collectible.userAssetId)
+        }
+      }
+
+      resolve({
+        uaids: retrievedIds,
+        failedIds: requestedIds
+      })
+    })
+  })
+}
+
+exports.func = function (args) {
+  return getUAIDs(args.userId, args.assetIds, args.exclusionList || [])
+}

package/lib/itemconfiguration/getGroupAssets.js

@@ -0,0 +1,32 @@
+// Includes
+const getPageResults = require('../util/getPageResults.js').func
+
+// Args
+exports.required = ['groupId', 'assetType']
+exports.optional = ['sortOrder', 'limit', 'jar']
+
+// Docs
+/**
+ * 🔐 Get assets for a group.
+ * @category Group
+ * @alias getGroupAssets
+ * @param {number} groupId - The id of the group.
+ * @param {String} assetType - The type of asset being retrieved: [("Shirt", "Pants")]{@link https://developer.roblox.com/en-us/api-reference/enum/AssetType}.
+ * @param {SortOrder=} [sortOrder=Asc] - The order results are sorted in.
+ * @param {Limit=} [limit=∞] - The maximum number of assets to return
+ * @returns {Promise<GroupAssetInfo[]>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * const groupModels = await noblox.getGroupAssets({groupId: 1, assetType: 'Model', sortOrder: 'Asc', limit: '100'})
+**/
+
+// Define
+exports.func = function (args) {
+  return getPageResults({
+    jar: args.jar,
+    url: '//itemconfiguration.roblox.com/v1/creations/get-assets',
+    query: { assetType: args.assetType, groupId: args.groupId },
+    sortOrder: args.sortOrder || 'Asc',
+    limit: args.limit
+  })
+}

package/lib/options.js

@@ -0,0 +1,26 @@
+// Includes
+const settings = require('../settings.json')
+const jar = require('./util/jar.js').func
+const newCache = require('./cache/new.js')
+
+// Define
+exports.init = function () {
+  exports.jar = jar()
+
+  const cacheList = []
+  const cache = settings.cache
+  for (const name of Object.keys(cache)) {
+    const item = cache[name]
+    const cacheObj = {
+      name: name,
+      refresh: item.refresh,
+      expire: item.expire
+    }
+    cacheList.push(cacheObj)
+  }
+  exports.cache = newCache(cacheList)
+
+  exports.queue = settings.queue
+}
+
+exports.init()

package/lib/party/onPartyDeleted.js

@@ -0,0 +1,53 @@
+const events = require('events')
+
+const onNotification = require('../client/onNotification.js').func
+
+exports.optional = ['jar']
+
+// Docs
+/**
+ * 🔐 An event for when a party is deleted.
+ * @category Party
+ * @alias onPartyDeleted
+ * @returns An EventEmitter that emits when a party is deleted.
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * const partyDeleted = noblox.onPartyDeleted()
+ * partyDeleted.on("data", function(data) {
+ *  console.log("Party deleted! ", data)
+ * })
+ * partyDeleted.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: jar })
+
+  notifications.on('data', (name, message) => {
+    if (name === 'PartyNotifications' && message.Type === 'PartyDeleted') {
+      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/onPartyInvite.js

@@ -0,0 +1,53 @@
+const events = require('events')
+
+const onNotification = require('../client/onNotification.js').func
+
+exports.optional = ['jar']
+
+// Docs
+/**
+ * 🔐 An event for when you're invited to a party.
+ * @category Party
+ * @alias onPartyInvite
+ * @returns An EventEmitter that emits when you're invited to a party.
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * const partyInvite = noblox.onPartyInvite()
+ * partyInvite.on("data", function(data) {
+ *  console.log("Invited to party! ", data)
+ * })
+ * partyInvite.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: jar })
+
+  notifications.on('data', (name, message) => {
+    if (name === 'PartyNotifications' && message.Type === 'InvitedToParty') {
+      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
+}