add gs

RCCService2020/ExtraContent/LuaPackages/Packages/_Index/roblox_genericpagination/genericpagination/LinkedList.lua

@@ -0,0 +1,51 @@
+local LinkedList = {}
+LinkedList.__index = LinkedList
+
+LinkedList.createNode = function(value)
+	local node =  {
+		previous = nil,
+		next = nil,
+		value = value,
+	}
+
+	setmetatable(node, LinkedList)
+
+	return node
+end
+
+-- Inserts a new node between the 'self' node and its 'next' node. Can also be used to append a node to the end
+function LinkedList:CreateNext(value)
+	local nextNode = {
+		previous = self,
+		next = self.next,
+		value = value or {},
+	}
+
+	if self.next then
+		self.next.previous = nextNode
+	end
+
+	setmetatable(nextNode, LinkedList)
+	self.next = nextNode
+	return nextNode
+end
+
+
+-- Inserts a new node between the 'self' node and its 'previous' node. Can also prepend a node to the beginning
+function LinkedList:CreatePrevious(value)
+	local previousNode = {
+		previous = self.previous,
+		next = self,
+		value = value or {},
+	}
+
+	if self.previous then
+		self.previous.next = previousNode
+	end
+
+	setmetatable(previousNode, LinkedList)
+	self.previous = previousNode
+	return previousNode
+end
+
+return LinkedList

RCCService2020/ExtraContent/LuaPackages/Packages/_Index/roblox_genericpagination/genericpagination/LinkedList.spec.lua

@@ -0,0 +1,66 @@
+return function()
+	local LinkedList = require(script.Parent.LinkedList)
+
+	describe("it should initialize properly", function()
+		local node = LinkedList.createNode(456)
+		local emptyNode = LinkedList.createNode()
+
+		it("given a value", function()
+			expect(node.value).to.equal(456)
+		end)
+
+		it("given nothing", function()
+			expect(emptyNode.value).to.equal(nil)
+		end)
+	end)
+
+	describe("it should properly link nodes", function()
+		it("when calling createNext on the end of a list", function()
+			local nodeA = LinkedList.createNode("a")
+			local nodeB = nodeA:CreateNext("b")
+
+			expect(nodeA.next).to.equal(nodeB)
+			expect(nodeA.next.value).to.equal(nodeB.value)
+
+			expect(nodeB.previous).to.equal(nodeA)
+			expect(nodeB.previous.value).to.equal(nodeA.value)
+		end)
+
+		it("when calling createNext inbetween Nodes", function()
+			local nodeA = LinkedList.createNode("a")
+			local nodeC = nodeA:CreateNext("c")
+			local nodeB = nodeA:CreateNext("b")
+
+			expect(nodeA.next).to.equal(nodeB)
+			expect(nodeB.previous).to.equal(nodeA)
+			expect(nodeB.next).to.equal(nodeC)
+			expect(nodeC.previous).to.equal(nodeB)
+		end)
+
+		it("when calling createPrevious on the beginning of a list", function()
+			local nodeA = LinkedList.createNode("a")
+			local nodeZ = nodeA:CreatePrevious("z")
+
+			expect(nodeA.previous).to.equal(nodeZ)
+			expect(nodeA.previous.value).to.equal(nodeZ.value)
+
+			expect(nodeZ.next).to.equal(nodeA)
+			expect(nodeZ.next.value).to.equal(nodeA.value)
+		end)
+
+		it("when calling createPrevious inbetween Nodes", function()
+			local nodeA = LinkedList.createNode("a")
+			local nodeY = nodeA:CreatePrevious("y")
+			local nodeZ = nodeA:CreatePrevious("z")
+
+			expect(nodeA.previous).to.equal(nodeZ)
+			expect(nodeZ.previous).to.equal(nodeY)
+			expect(nodeZ.next).to.equal(nodeA)
+			expect(nodeY.next).to.equal(nodeZ)
+		end)
+
+
+
+	end)
+
+end

RCCService2020/ExtraContent/LuaPackages/Packages/_Index/roblox_genericpagination/genericpagination/Paginator.lua

@@ -0,0 +1,106 @@
+--[[
+		Make sure to read api-reference.md for how to use.
+--]]
+
+local dependencies = require(script.Parent.dependencies)
+local t = dependencies.t
+local LinkedList = dependencies.LinkedList
+local Promise = dependencies.Promise
+
+local Paginator = {
+	llRoot = nil,
+	llIndex = nil,
+	_isFetching = false,
+}
+Paginator.__index = Paginator
+
+local requiredProps = t.strictInterface({
+	pageSize = t.number,
+	fetchWithCursor = t.callback,
+	fetchInit = t.callback,
+})
+
+Paginator.new = function(props)
+	assert(requiredProps(props))
+	local self = {}
+	for k, v in pairs(props) do
+		self[k] = v
+	end
+	setmetatable(self, Paginator)
+
+	self:_init()
+	return self
+end
+
+function Paginator:_init()
+	-- we don't know our currentCursor... just our previous and next
+	self._isFetching = true
+	return self.fetchInit():andThen(function(previousCursor, nextCursor)
+		self.llRoot = LinkedList.createNode()
+		self.llIndex = self.llRoot
+		self.llIndex:CreatePrevious(previousCursor)
+		self.llIndex:CreateNext(nextCursor)
+		self._isFetching = false
+	end)
+
+end
+
+function Paginator:getCurrent()
+	return self.llIndex.value or {}
+end
+
+function Paginator:getNext()
+	if self._isFetching then
+		return Promise.reject("Paginator is currently busy. Please wait.")
+	end
+
+	local cursor = self.llIndex.next.value or ""
+
+	if cursor == "" then
+		return Promise.reject("Next cursor is invalid")
+	end
+
+	self.llIndex = self.llIndex.next
+	self._isFetching = true
+
+	return self.fetchWithCursor(cursor):andThen(function(previousCursor, nextCursor)
+		self.llIndex.previous.value = previousCursor
+		if self.llIndex.next then
+			self.llIndex.next.value = nextCursor
+		else
+			self.llIndex:CreateNext(nextCursor)
+		end
+		self._isFetching = false
+	end)
+end
+
+function Paginator:getPrevious()
+	if self._isFetching then
+		return Promise.reject("Paginator is currently busy. Please wait.")
+	end
+
+	local cursor = self.llIndex.previous.value or ""
+
+	if cursor == "" then
+		return Promise.reject("Previous cursor is invalid")
+	end
+
+	self.llIndex = self.llIndex.previous
+	self._isFetching = true
+
+	return self.fetchWithCursor(cursor, true):andThen(function(previousCursor, nextCursor)
+		self.llIndex.next.value = nextCursor
+		if self.llIndex.previous then
+			self.llIndex.previous.value = previousCursor
+		else
+			self.llIndex:CreatePrevious(previousCursor)
+		end
+		self._isFetching = false
+	end)
+end
+
+function Paginator:isFetching()
+	return self._isFetching
+end
+
+return Paginator

RCCService2020/ExtraContent/LuaPackages/Packages/_Index/roblox_genericpagination/genericpagination/Paginator.spec.lua

@@ -0,0 +1,200 @@
+local dependencies = require(script.Parent.dependencies)
+local Promise = dependencies.Promise
+
+return function()
+	local Paginator = require(script.Parent.Paginator)
+
+	describe("it should initialize properly", function()
+		local mockFetchInit = function(params)
+			return function()
+				return Promise.resolve():andThen(function()
+					return params-1, params+1
+				end)
+			end
+		end
+
+		local mockFetchWithCursor = function(cursor)
+			return Promise.resolve():andThen(function()
+				local newPrevCursor = cursor - 1
+				local newNextCursor = cursor + 1
+				return newPrevCursor, newNextCursor
+			end)
+		end
+
+		local startCursor = 4
+
+		local paginator = Paginator.new({
+			pageSize = 10,
+			fetchInit = mockFetchInit(startCursor),
+			fetchWithCursor = mockFetchWithCursor,
+		})
+
+		it("given proper values", function()
+			expect(paginator).to.be.ok()
+		end)
+	end)
+
+	describe("it should return the correct cursors", function()
+		local mockFetchInit = function(params)
+			return function()
+				return Promise.resolve():andThen(function()
+					return params-1, params+1
+				end)
+			end
+		end
+
+		local mockFetchWithCursor = function(cursor)
+			return Promise.resolve():andThen(function()
+				local newPrevCursor = cursor - 1
+				local newNextCursor = cursor + 1
+				return newPrevCursor, newNextCursor
+			end)
+		end
+
+		local startCursor = 4
+
+		it("when fetching next", function()
+			local paginator = Paginator.new({
+				pageSize = 10,
+				fetchInit = mockFetchInit(startCursor),
+				fetchWithCursor = mockFetchWithCursor,
+			})
+
+			paginator:getNext()
+			local newCursor = paginator:getCurrent()
+
+			expect(newCursor).to.equal(startCursor + 1)
+		end)
+
+		it("when fetching previous", function()
+			local paginator = Paginator.new({
+				pageSize = 10,
+				fetchInit = mockFetchInit(startCursor),
+				fetchWithCursor = mockFetchWithCursor,
+			})
+
+			paginator:getPrevious()
+			local newCursor = paginator:getCurrent()
+
+			expect(newCursor).to.equal(startCursor - 1)
+		end)
+
+		it("when fetching next then previous", function()
+			local paginator = Paginator.new({
+				pageSize = 10,
+				fetchInit = mockFetchInit(startCursor),
+				fetchWithCursor = mockFetchWithCursor,
+			})
+
+			paginator:getNext()
+			paginator:getPrevious()
+			local newCursor = paginator:getCurrent()
+
+			expect(newCursor).to.equal(startCursor)
+		end)
+
+		it("when fetching previous then next", function()
+			local paginator = Paginator.new({
+				pageSize = 10,
+				fetchInit = mockFetchInit(startCursor),
+				fetchWithCursor = mockFetchWithCursor,
+			})
+
+			paginator:getPrevious()
+			paginator:getNext()
+			local newCursor = paginator:getCurrent()
+
+			expect(newCursor).to.equal(startCursor)
+		end)
+
+		it("when fetching next next previous", function()
+			local paginator = Paginator.new({
+				pageSize = 10,
+				fetchInit = mockFetchInit(startCursor),
+				fetchWithCursor = mockFetchWithCursor,
+			})
+
+			paginator:getPrevious()
+			paginator:getNext()
+			paginator:getNext()
+			local newCursor = paginator:getCurrent()
+
+			expect(newCursor).to.equal(startCursor + 1)
+		end)
+
+		it("when fetching previous previous next", function()
+			local paginator = Paginator.new({
+				pageSize = 10,
+				fetchInit = mockFetchInit(startCursor),
+				fetchWithCursor = mockFetchWithCursor,
+			})
+
+			paginator:getPrevious()
+			paginator:getPrevious()
+			paginator:getNext()
+			local newCursor = paginator:getCurrent()
+
+			expect(newCursor).to.equal(startCursor - 1)
+		end)
+
+		it("when fetching previous next next", function()
+			local paginator = Paginator.new({
+				pageSize = 10,
+				fetchInit = mockFetchInit(startCursor),
+				fetchWithCursor = mockFetchWithCursor,
+			})
+
+			paginator:getPrevious()
+			paginator:getNext()
+			paginator:getNext()
+			local newCursor = paginator:getCurrent()
+
+			expect(newCursor).to.equal(startCursor + 1)
+		end)
+
+		it("when fetching next previous previous", function()
+			local paginator = Paginator.new({
+				pageSize = 10,
+				fetchInit = mockFetchInit(startCursor),
+				fetchWithCursor = mockFetchWithCursor,
+			})
+
+			paginator:getNext()
+			paginator:getPrevious()
+			paginator:getPrevious()
+			local newCursor = paginator:getCurrent()
+
+			expect(newCursor).to.equal(startCursor - 1)
+		end)
+
+		it("when fetching next next next", function()
+			local paginator = Paginator.new({
+				pageSize = 10,
+				fetchInit = mockFetchInit(startCursor),
+				fetchWithCursor = mockFetchWithCursor,
+			})
+
+			paginator:getNext()
+			paginator:getNext()
+			paginator:getNext()
+			local newCursor = paginator:getCurrent()
+
+			expect(newCursor).to.equal(startCursor + 3)
+		end)
+
+		it("when fetching previous previous previous", function()
+			local paginator = Paginator.new({
+				pageSize = 10,
+				fetchInit = mockFetchInit(startCursor),
+				fetchWithCursor = mockFetchWithCursor,
+			})
+
+			paginator:getPrevious()
+			paginator:getPrevious()
+			paginator:getPrevious()
+			local newCursor = paginator:getCurrent()
+
+			expect(newCursor).to.equal(startCursor - 3)
+		end)
+	end)
+end

RCCService2020/ExtraContent/LuaPackages/Packages/_Index/roblox_genericpagination/genericpagination/dependencies.lua

@@ -0,0 +1,8 @@
+local ROOT = script.Parent
+local Packages = script:FindFirstAncestor("Packages")
+
+return {
+	t = require(Packages.t),
+	LinkedList = require(ROOT.LinkedList),
+	Promise = require(Packages.Promise),
+}

RCCService2020/ExtraContent/LuaPackages/Packages/_Index/roblox_genericpagination/genericpagination/init.lua

@@ -0,0 +1,8 @@
+-- Generator information:
+-- Human name: GenericPagination
+-- Variable name: GenericPagination
+-- Repo name: genericpagination
+
+local Paginator = require(script.Paginator)
+
+return Paginator

RCCService2020/ExtraContent/LuaPackages/Packages/_Index/roblox_genericpagination/genericpagination/inspect.lua

@@ -0,0 +1,333 @@
+local inspect ={
+	_VERSION = 'inspect.lua 3.1.0',
+	_URL     = 'http://github.com/kikito/inspect.lua',
+	_DESCRIPTION = 'human-readable representations of tables',
+	_LICENSE = [[
+	  MIT LICENSE
+
+	  Copyright (c) 2013 Enrique García Cota
+
+	  Permission is hereby granted, free of charge, to any person obtaining a
+	  copy of this software and associated documentation files (the
+	  "Software"), to deal in the Software without restriction, including
+	  without limitation the rights to use, copy, modify, merge, publish,
+	  distribute, sublicense, and/or sell copies of the Software, and to
+	  permit persons to whom the Software is furnished to do so, subject to
+	  the following conditions:
+
+	  The above copyright notice and this permission notice shall be included
+	  in all copies or substantial portions of the Software.
+
+	  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+	  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+	  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+	  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+	  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+	  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+	  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+	]]
+  }
+
+  local tostring = tostring
+
+  inspect.KEY       = setmetatable({}, {__tostring = function() return 'inspect.KEY' end})
+  inspect.METATABLE = setmetatable({}, {__tostring = function() return 'inspect.METATABLE' end})
+
+  local function rawpairs(t)
+	return next, t, nil
+  end
+
+  -- Apostrophizes the string if it has quotes, but not aphostrophes
+  -- Otherwise, it returns a regular quoted string
+  local function smartQuote(str)
+	if str:match('"') and not str:match("'") then
+	  return "'" .. str .. "'"
+	end
+	return '"' .. str:gsub('"', '\\"') .. '"'
+  end
+
+  -- \a => '\\a', \0 => '\\0', 31 => '\31'
+  local shortControlCharEscapes = {
+	["\a"] = "\\a",  ["\b"] = "\\b", ["\f"] = "\\f", ["\n"] = "\\n",
+	["\r"] = "\\r",  ["\t"] = "\\t", ["\v"] = "\\v"
+  }
+  local longControlCharEscapes = {} -- \a => nil, \0 => \000, 31 => \031
+  for i=0, 31 do
+	local ch = string.char(i)
+	if not shortControlCharEscapes[ch] then
+	  shortControlCharEscapes[ch] = "\\"..i
+	  longControlCharEscapes[ch]  = string.format("\\%03d", i)
+	end
+  end
+
+  local function escape(str)
+	return (str:gsub("\\", "\\\\")
+			   :gsub("(%c)%f[0-9]", longControlCharEscapes)
+			   :gsub("%c", shortControlCharEscapes))
+  end
+
+  local function isIdentifier(str)
+	return type(str) == 'string' and str:match( "^[_%a][_%a%d]*$" )
+  end
+
+  local function isSequenceKey(k, sequenceLength)
+	return type(k) == 'number'
+	   and 1 <= k
+	   and k <= sequenceLength
+	   and math.floor(k) == k
+  end
+
+  local defaultTypeOrders = {
+	['number']   = 1, ['boolean']  = 2, ['string'] = 3, ['table'] = 4,
+	['function'] = 5, ['userdata'] = 6, ['thread'] = 7
+  }
+
+  local function sortKeys(a, b)
+	local ta, tb = type(a), type(b)
+
+	-- strings and numbers are sorted numerically/alphabetically
+	if ta == tb and (ta == 'string' or ta == 'number') then return a < b end
+
+	local dta, dtb = defaultTypeOrders[ta], defaultTypeOrders[tb]
+	-- Two default types are compared according to the defaultTypeOrders table
+	if dta and dtb then return defaultTypeOrders[ta] < defaultTypeOrders[tb]
+	elseif dta     then return true  -- default types before custom ones
+	elseif dtb     then return false -- custom types after default ones
+	end
+
+	-- custom types are sorted out alphabetically
+	return ta < tb
+  end
+
+  -- For implementation reasons, the behavior of rawlen & # is "undefined" when
+  -- tables aren't pure sequences. So we implement our own # operator.
+  local function getSequenceLength(t)
+	local len = 1
+	local v = rawget(t,len)
+	while v ~= nil do
+	  len = len + 1
+	  v = rawget(t,len)
+	end
+	return len - 1
+  end
+
+  local function getNonSequentialKeys(t)
+	local keys, keysLength = {}, 0
+	local sequenceLength = getSequenceLength(t)
+	for k,_ in rawpairs(t) do
+	  if not isSequenceKey(k, sequenceLength) then
+		keysLength = keysLength + 1
+		keys[keysLength] = k
+	  end
+	end
+	table.sort(keys, sortKeys)
+	return keys, keysLength, sequenceLength
+  end
+
+  local function countTableAppearances(t, tableAppearances)
+	tableAppearances = tableAppearances or {}
+
+	if type(t) == 'table' then
+	  if not tableAppearances[t] then
+		tableAppearances[t] = 1
+		for k,v in rawpairs(t) do
+		  countTableAppearances(k, tableAppearances)
+		  countTableAppearances(v, tableAppearances)
+		end
+		countTableAppearances(getmetatable(t), tableAppearances)
+	  else
+		tableAppearances[t] = tableAppearances[t] + 1
+	  end
+	end
+
+	return tableAppearances
+  end
+
+  local copySequence = function(s)
+	local copy, len = {}, #s
+	for i=1, len do copy[i] = s[i] end
+	return copy, len
+  end
+
+  local function makePath(path, ...)
+	local keys = {...}
+	local newPath, len = copySequence(path)
+	for i=1, #keys do
+	  newPath[len + i] = keys[i]
+	end
+	return newPath
+  end
+
+  local function processRecursive(process, item, path, visited)
+	if item == nil then return nil end
+	if visited[item] then return visited[item] end
+
+	local processed = process(item, path)
+	if type(processed) == 'table' then
+	  local processedCopy = {}
+	  visited[item] = processedCopy
+	  local processedKey
+
+	  for k,v in rawpairs(processed) do
+		processedKey = processRecursive(process, k, makePath(path, k, inspect.KEY), visited)
+		if processedKey ~= nil then
+		  processedCopy[processedKey] = processRecursive(process, v, makePath(path, processedKey), visited)
+		end
+	  end
+
+	  local mt  = processRecursive(process, getmetatable(processed), makePath(path, inspect.METATABLE), visited)
+	  if type(mt) ~= 'table' then mt = nil end -- ignore not nil/table __metatable field
+	  setmetatable(processedCopy, mt)
+	  processed = processedCopy
+	end
+	return processed
+  end
+
+
+
+  -------------------------------------------------------------------
+
+  local Inspector = {}
+  local Inspector_mt = {__index = Inspector}
+
+  function Inspector:puts(...)
+	local args   = {...}
+	local buffer = self.buffer
+	local len    = #buffer
+	for i=1, #args do
+	  len = len + 1
+	  buffer[len] = args[i]
+	end
+  end
+
+  function Inspector:down(f)
+	self.level = self.level + 1
+	f()
+	self.level = self.level - 1
+  end
+
+  function Inspector:tabify()
+	self:puts(self.newline, string.rep(self.indent, self.level))
+  end
+
+  function Inspector:alreadyVisited(v)
+	return self.ids[v] ~= nil
+  end
+
+  function Inspector:getId(v)
+	local id = self.ids[v]
+	if not id then
+	  local tv = type(v)
+	  id              = (self.maxIds[tv] or 0) + 1
+	  self.maxIds[tv] = id
+	  self.ids[v]     = id
+	end
+	return tostring(id)
+  end
+
+  function Inspector:putKey(k)
+	if isIdentifier(k) then return self:puts(k) end
+	self:puts("[")
+	self:putValue(k)
+	self:puts("]")
+  end
+
+  function Inspector:putTable(t)
+	if t == inspect.KEY or t == inspect.METATABLE then
+	  self:puts(tostring(t))
+	elseif self:alreadyVisited(t) then
+	  self:puts('<table ', self:getId(t), '>')
+	elseif self.level >= self.depth then
+	  self:puts('{...}')
+	else
+	  if self.tableAppearances[t] > 1 then self:puts('<', self:getId(t), '>') end
+
+	  local nonSequentialKeys, nonSequentialKeysLength, sequenceLength = getNonSequentialKeys(t)
+	  local mt                = getmetatable(t)
+
+	  self:puts('{')
+	  self:down(function()
+		local count = 0
+		for i=1, sequenceLength do
+		  if count > 0 then self:puts(',') end
+		  self:puts(' ')
+		  self:putValue(t[i])
+		  count = count + 1
+		end
+
+		for i=1, nonSequentialKeysLength do
+		  local k = nonSequentialKeys[i]
+		  if count > 0 then self:puts(',') end
+		  self:tabify()
+		  self:putKey(k)
+		  self:puts(' = ')
+		  self:putValue(t[k])
+		  count = count + 1
+		end
+
+		if type(mt) == 'table' then
+		  if count > 0 then self:puts(',') end
+		  self:tabify()
+		  self:puts('<metatable> = ')
+		  self:putValue(mt)
+		end
+	  end)
+
+	  if nonSequentialKeysLength > 0 or type(mt) == 'table' then -- result is multi-lined. Justify closing }
+		self:tabify()
+	  elseif sequenceLength > 0 then -- array tables have one extra space before closing }
+		self:puts(' ')
+	  end
+
+	  self:puts('}')
+	end
+  end
+
+  function Inspector:putValue(v)
+	local tv = type(v)
+
+	if tv == 'string' then
+	  self:puts(smartQuote(escape(v)))
+	elseif tv == 'number' or tv == 'boolean' or tv == 'nil' or
+		   tv == 'cdata' or tv == 'ctype' then
+	  self:puts(tostring(v))
+	elseif tv == 'table' then
+	  self:putTable(v)
+	else
+	  self:puts('<', tv, ' ', self:getId(v), '>')
+	end
+  end
+
+  -------------------------------------------------------------------
+
+  function inspect.inspect(root, options)
+	options       = options or {}
+
+	local depth   = options.depth   or math.huge
+	local newline = options.newline or '\n'
+	local indent  = options.indent  or '  '
+	local process = options.process
+
+	if process then
+	  root = processRecursive(process, root, {}, {})
+	end
+
+	local inspector = setmetatable({
+	  depth            = depth,
+	  level            = 0,
+	  buffer           = {},
+	  ids              = {},
+	  maxIds           = {},
+	  newline          = newline,
+	  indent           = indent,
+	  tableAppearances = countTableAppearances(root)
+	}, Inspector_mt)
+
+	inspector:putValue(root)
+
+	return table.concat(inspector.buffer)
+  end
+
+  setmetatable(inspect, { __call = function(_, ...) return inspect.inspect(...) end })
+
+  return inspect

RCCService2020/ExtraContent/LuaPackages/Packages/_Index/roblox_genericpagination/genericpagination/publicApi.spec.lua

@@ -0,0 +1,7 @@
+return function()
+	it("SHOULD return a valid, constructable object", function()
+		local api = require(script.Parent)
+		expect(api).to.be.ok()
+		expect(api.new).to.be.ok()
+	end)
+end