roblox-opencode 1.0.0

package/vendor/rbxutil/comm/Client/ClientComm.luau

@@ -0,0 +1,232 @@
+-- ClientComm
+-- Stephen Leitnick
+-- December 20, 2021
+
+local Comm = require(script.Parent)
+local Types = require(script.Parent.Parent.Types)
+local Util = require(script.Parent.Parent.Util)
+
+--[=[
+	@class ClientComm
+	@client
+]=]
+local ClientComm = {}
+ClientComm.__index = ClientComm
+
+--[=[
+	@within ClientComm
+	@type ClientMiddlewareFn (args: {any}) -> (shouldContinue: boolean, ...: any)
+	The middleware function takes the arguments (as a table array), and should
+	return `true|false` to indicate if the process should continue.
+
+	If returning `false`, the optional varargs after the `false` are used as the new return values
+	to whatever was calling the middleware.
+]=]
+--[=[
+	@within ClientComm
+	@type ClientMiddleware {ClientMiddlewareFn}
+	Array of middleware functions.
+]=]
+
+--[=[
+	@return ClientComm
+	Constructs a ClientComm object.
+
+	If `usePromise` is set to `true`, then `GetFunction` will generate a function that returns a Promise
+	that resolves with the server response. If set to `false`, the function will act like a normal
+	call to a RemoteFunction and yield until the function responds.
+
+	```lua
+	local clientComm = ClientComm.new(game:GetService("ReplicatedStorage"), true)
+
+	-- If using a unique namespace with ServerComm, include it as second argument:
+	local clientComm = ClientComm.new(game:GetService("ReplicatedStorage"), true, "MyNamespace")
+	```
+]=]
+function ClientComm.new(parent: Instance, usePromise: boolean, namespace: string?)
+	assert(not Util.IsServer, "ClientComm must be constructed from the client")
+	assert(typeof(parent) == "Instance", "Parent must be of type Instance")
+	local ns = Util.DefaultCommFolderName
+	if namespace then
+		ns = namespace
+	end
+	local folder: Instance? = parent:WaitForChild(ns, Util.WaitForChildTimeout)
+	assert(folder ~= nil, "Could not find namespace for ClientComm in parent: " .. ns)
+	local self = setmetatable({}, ClientComm)
+	self._instancesFolder = folder
+	self._usePromise = usePromise
+	return self
+end
+
+--[=[
+	@param name string
+	@param inboundMiddleware ClientMiddleware?
+	@param outboundMiddleware ClientMiddleware?
+	@return (...: any) -> any
+
+	Generates a function on the matching RemoteFunction generated with ServerComm. The function
+	can then be called to invoke the server. If this `ClientComm` object was created with
+	the `usePromise` parameter set to `true`, then this generated function will return
+	a Promise when called.
+
+	```lua
+	-- Server-side:
+	local serverComm = ServerComm.new(someParent)
+	serverComm:BindFunction("MyFunction", function(player, msg)
+		return msg:upper()
+	end)
+
+	-- Client-side:
+	local clientComm = ClientComm.new(someParent)
+	local myFunc = clientComm:GetFunction("MyFunction")
+	local uppercase = myFunc("hello world")
+	print(uppercase) --> HELLO WORLD
+
+	-- Client-side, using promises:
+	local clientComm = ClientComm.new(someParent, true)
+	local myFunc = clientComm:GetFunction("MyFunction")
+	myFunc("hi there"):andThen(function(msg)
+		print(msg) --> HI THERE
+	end):catch(function(err)
+		print("Error:", err)
+	end)
+	```
+]=]
+function ClientComm:GetFunction(
+	name: string,
+	inboundMiddleware: Types.ClientMiddleware?,
+	outboundMiddleware: Types.ClientMiddleware?
+)
+	return Comm.GetFunction(self._instancesFolder, name, self._usePromise, inboundMiddleware, outboundMiddleware)
+end
+
+--[=[
+	@param name string
+	@param inboundMiddleware ClientMiddleware?
+	@param outboundMiddleware ClientMiddleware?
+	@return ClientRemoteSignal
+	Returns a new ClientRemoteSignal that mirrors the matching RemoteSignal created by
+	ServerComm with the same matching `name`.
+
+	```lua
+	local mySignal = clientComm:GetSignal("MySignal")
+
+	-- Listen for data from the server:
+	mySignal:Connect(function(message)
+		print("Received message from server:", message)
+	end)
+
+	-- Send data to the server:
+	mySignal:Fire("Hello!")
+	```
+]=]
+function ClientComm:GetSignal(
+	name: string,
+	inboundMiddleware: Types.ClientMiddleware?,
+	outboundMiddleware: Types.ClientMiddleware?
+)
+	return Comm.GetSignal(self._instancesFolder, name, inboundMiddleware, outboundMiddleware)
+end
+
+--[=[
+	@param name string
+	@param inboundMiddleware ClientMiddleware?
+	@param outboundMiddleware ClientMiddleware?
+	@return ClientRemoteProperty
+	Returns a new ClientRemoteProperty that mirrors the matching RemoteProperty created by
+	ServerComm with the same matching `name`.
+
+	Take a look at the ClientRemoteProperty documentation for more info, such as
+	understanding how to wait for data to be ready.
+
+	```lua
+	local mapInfo = clientComm:GetProperty("MapInfo")
+
+	-- Observe the initial value of mapInfo, and all subsequent changes:
+	mapInfo:Observe(function(info)
+		print("Current map info", info)
+	end)
+
+	-- Check to see if data is initially ready:
+	if mapInfo:IsReady() then
+		-- Get the data:
+		local info = mapInfo:Get()
+	end
+
+	-- Get a promise that resolves once the data is ready (resolves immediately if already ready):
+	mapInfo:OnReady():andThen(function(info)
+		print("Map info is ready with info", info)
+	end)
+
+	-- Same as above, but yields thread:
+	local success, info = mapInfo:OnReady():await()
+	```
+]=]
+function ClientComm:GetProperty(
+	name: string,
+	inboundMiddleware: Types.ClientMiddleware?,
+	outboundMiddleware: Types.ClientMiddleware?
+)
+	return Comm.GetProperty(self._instancesFolder, name, inboundMiddleware, outboundMiddleware)
+end
+
+--[=[
+	@param inboundMiddleware ClientMiddleware?
+	@param outboundMiddleware ClientMiddleware?
+	@return table
+	Returns an object which maps RemoteFunctions as methods
+	and RemoteEvents as fields.
+	```lua
+	-- Server-side:
+	serverComm:BindFunction("Test", function(player) end)
+	serverComm:CreateSignal("MySignal")
+	serverComm:CreateProperty("MyProperty", 10)
+
+	-- Client-side
+	local obj = clientComm:BuildObject()
+	obj:Test()
+	obj.MySignal:Connect(function(data) end)
+	obj.MyProperty:Observe(function(value) end)
+	```
+]=]
+function ClientComm:BuildObject(inboundMiddleware: Types.ClientMiddleware?, outboundMiddleware: Types.ClientMiddleware?)
+	local obj = {}
+	local rfFolder = self._instancesFolder:FindFirstChild("RF")
+	local reFolder = self._instancesFolder:FindFirstChild("RE")
+	local rpFolder = self._instancesFolder:FindFirstChild("RP")
+	if rfFolder then
+		for _, rf in rfFolder:GetChildren() do
+			if not rf:IsA("RemoteFunction") then
+				continue
+			end
+			local f = self:GetFunction(rf.Name, inboundMiddleware, outboundMiddleware)
+			obj[rf.Name] = function(_self, ...)
+				return f(...)
+			end
+		end
+	end
+	if reFolder then
+		for _, re in reFolder:GetChildren() do
+			if (not re:IsA("RemoteEvent")) and (not re:IsA("UnreliableRemoteEvent")) then
+				continue
+			end
+			obj[re.Name] = self:GetSignal(re.Name, inboundMiddleware, outboundMiddleware)
+		end
+	end
+	if rpFolder then
+		for _, re in rpFolder:GetChildren() do
+			if not re:IsA("RemoteEvent") then
+				continue
+			end
+			obj[re.Name] = self:GetProperty(re.Name, inboundMiddleware, outboundMiddleware)
+		end
+	end
+	return obj
+end
+
+--[=[
+	Destroys the ClientComm object.
+]=]
+function ClientComm:Destroy() end
+
+return ClientComm

package/vendor/rbxutil/comm/Client/ClientRemoteProperty.luau

@@ -0,0 +1,156 @@
+-- ClientRemoteProperty
+-- Stephen Leitnick
+-- December 20, 2021
+
+local Promise = require(script.Parent.Parent.Parent.Promise)
+local Signal = require(script.Parent.Parent.Parent.Signal)
+local ClientRemoteSignal = require(script.Parent.ClientRemoteSignal)
+local Types = require(script.Parent.Parent.Types)
+
+--[=[
+	@within ClientRemoteProperty
+	@prop Changed Signal<any>
+
+	Fires when the property receives an updated value
+	from the server.
+
+	```lua
+	clientRemoteProperty.Changed:Connect(function(value)
+		print("New value", value)
+	end)
+	```
+]=]
+
+--[=[
+	@class ClientRemoteProperty
+	@client
+	Created via `ClientComm:GetProperty()`.
+]=]
+local ClientRemoteProperty = {}
+ClientRemoteProperty.__index = ClientRemoteProperty
+
+function ClientRemoteProperty.new(
+	re: RemoteEvent,
+	inboundMiddleware: Types.ClientMiddleware?,
+	outboudMiddleware: Types.ClientMiddleware?
+)
+	local self = setmetatable({}, ClientRemoteProperty)
+	self._rs = ClientRemoteSignal.new(re, inboundMiddleware, outboudMiddleware)
+	self._ready = false
+	self._value = nil
+	self.Changed = Signal.new()
+	self._rs:Fire()
+
+	local resolveOnReadyPromise
+	self._readyPromise = Promise.new(function(resolve)
+		resolveOnReadyPromise = resolve
+	end)
+	self._changed = self._rs:Connect(function(value)
+		local changed = value ~= self._value
+		self._value = value
+		if not self._ready then
+			self._ready = true
+			resolveOnReadyPromise(value)
+		end
+		if changed then
+			self.Changed:Fire(value)
+		end
+	end)
+
+	return self
+end
+
+--[=[
+	Gets the value of the property object.
+
+	:::caution
+	This value might not be ready right away. Use `OnReady()` or `IsReady()`
+	before calling `Get()`. If not ready, this value will return `nil`.
+	:::
+]=]
+function ClientRemoteProperty:Get(): any
+	return self._value
+end
+
+--[=[
+	@return Promise<any>
+	Returns a Promise which resolves once the property object is
+	ready to be used. The resolved promise will also contain the
+	value of the property.
+
+	```lua
+	-- Use andThen clause:
+	clientRemoteProperty:OnReady():andThen(function(initialValue)
+		print(initialValue)
+	end)
+
+	-- Use await:
+	local success, initialValue = clientRemoteProperty:OnReady():await()
+	if success then
+		print(initialValue)
+	end
+	```
+]=]
+function ClientRemoteProperty:OnReady()
+	return self._readyPromise
+end
+
+--[=[
+	Returns `true` if the property object is ready to be
+	used. In other words, it has successfully gained
+	connection to the server-side version and has synced
+	in the initial value.
+
+	```lua
+	if clientRemoteProperty:IsReady() then
+		local value = clientRemoteProperty:Get()
+	end
+	```
+]=]
+function ClientRemoteProperty:IsReady(): boolean
+	return self._ready
+end
+
+--[=[
+	@param observer (any) -> nil
+	@return Connection
+	Observes the value of the property. The observer will
+	be called right when the value is first ready, and
+	every time the value changes. This is safe to call
+	immediately (i.e. no need to use `IsReady` or `OnReady`
+	before using this method).
+
+	Observing is essentially listening to `Changed`, but
+	also sends the initial value right away (or at least
+	once `OnReady` is completed).
+
+	```lua
+	local function ObserveValue(value)
+		print(value)
+	end
+
+	clientRemoteProperty:Observe(ObserveValue)
+	```
+]=]
+function ClientRemoteProperty:Observe(observer: (any) -> ())
+	if self._ready then
+		task.defer(observer, self._value)
+	end
+	return self.Changed:Connect(observer)
+end
+
+--[=[
+	Destroys the ClientRemoteProperty object.
+]=]
+function ClientRemoteProperty:Destroy()
+	self._rs:Destroy()
+	if self._readyPromise then
+		self._readyPromise:cancel()
+	end
+	if self._changed then
+		self._changed:Disconnect()
+	end
+	self.Changed:Destroy()
+end
+
+return ClientRemoteProperty

package/vendor/rbxutil/comm/Client/ClientRemoteSignal.luau

@@ -0,0 +1,109 @@
+-- ClientRemoteSignal
+-- Stephen Leitnick
+-- December 20, 2021
+
+local Signal = require(script.Parent.Parent.Parent.Signal)
+local Types = require(script.Parent.Parent.Types)
+
+--[=[
+	@class ClientRemoteSignal
+	@client
+	Created via `ClientComm:GetSignal()`.
+]=]
+local ClientRemoteSignal = {}
+ClientRemoteSignal.__index = ClientRemoteSignal
+
+--[=[
+	@within ClientRemoteSignal
+	@interface Connection
+	.Disconnect () -> ()
+
+	Represents a connection.
+]=]
+
+function ClientRemoteSignal.new(
+	re: RemoteEvent | UnreliableRemoteEvent,
+	inboundMiddleware: Types.ClientMiddleware?,
+	outboudMiddleware: Types.ClientMiddleware?
+)
+	local self = setmetatable({}, ClientRemoteSignal)
+	self._re = re
+	if outboudMiddleware and #outboudMiddleware > 0 then
+		self._hasOutbound = true
+		self._outbound = outboudMiddleware
+	else
+		self._hasOutbound = false
+	end
+	if inboundMiddleware and #inboundMiddleware > 0 then
+		self._directConnect = false
+		self._signal = Signal.new()
+		self._reConn = self._re.OnClientEvent:Connect(function(...)
+			local args = table.pack(...)
+			for _, middlewareFunc in inboundMiddleware do
+				local middlewareResult = table.pack(middlewareFunc(args))
+				if not middlewareResult[1] then
+					return
+				end
+				args.n = #args
+			end
+			self._signal:Fire(table.unpack(args, 1, args.n))
+		end)
+	else
+		self._directConnect = true
+	end
+	return self
+end
+
+function ClientRemoteSignal:_processOutboundMiddleware(...: any)
+	local args = table.pack(...)
+	for _, middlewareFunc in self._outbound do
+		local middlewareResult = table.pack(middlewareFunc(args))
+		if not middlewareResult[1] then
+			return table.unpack(middlewareResult, 2, middlewareResult.n)
+		end
+		args.n = #args
+	end
+	return table.unpack(args, 1, args.n)
+end
+
+--[=[
+	@param fn (...: any) -> ()
+	@return Connection
+	Connects a function to the remote signal. The function will be
+	called anytime the equivalent server-side RemoteSignal is
+	fired at this specific client that created this client signal.
+]=]
+function ClientRemoteSignal:Connect(fn: (...any) -> ())
+	if self._directConnect then
+		return self._re.OnClientEvent:Connect(fn)
+	else
+		return self._signal:Connect(fn)
+	end
+end
+
+--[=[
+	Fires the equivalent server-side signal with the given arguments.
+
+	:::note Outbound Middleware
+	All arguments pass through any outbound middleware before being
+	sent to the server.
+	:::
+]=]
+function ClientRemoteSignal:Fire(...: any)
+	if self._hasOutbound then
+		self._re:FireServer(self:_processOutboundMiddleware(...))
+	else
+		self._re:FireServer(...)
+	end
+end
+
+--[=[
+	Destroys the ClientRemoteSignal object.
+]=]
+function ClientRemoteSignal:Destroy()
+	if self._signal then
+		self._signal:Destroy()
+	end
+end
+
+return ClientRemoteSignal

package/vendor/rbxutil/comm/Client/init.luau

@@ -0,0 +1,135 @@
+local Util = require(script.Parent.Util)
+local Types = require(script.Parent.Types)
+local Promise = require(script.Parent.Parent.Promise)
+local ClientRemoteSignal = require(script.ClientRemoteSignal)
+local ClientRemoteProperty = require(script.ClientRemoteProperty)
+
+local Client = {}
+
+function Client.GetFunction(
+	parent: Instance,
+	name: string,
+	usePromise: boolean,
+	inboundMiddleware: Types.ClientMiddleware?,
+	outboundMiddleware: Types.ClientMiddleware?
+)
+	assert(not Util.IsServer, "GetFunction must be called from the client")
+	local folder = Util.GetCommSubFolder(parent, "RF"):Expect("Failed to get Comm RF folder")
+	local rf = folder:WaitForChild(name, Util.WaitForChildTimeout)
+	assert(rf ~= nil, "Failed to find RemoteFunction: " .. name)
+	local hasInbound = type(inboundMiddleware) == "table" and #inboundMiddleware > 0
+	local hasOutbound = type(outboundMiddleware) == "table" and #outboundMiddleware > 0
+	local function ProcessOutbound(args)
+		for _, middlewareFunc in ipairs(outboundMiddleware) do
+			local middlewareResult = table.pack(middlewareFunc(args))
+			if not middlewareResult[1] then
+				return table.unpack(middlewareResult, 2, middlewareResult.n)
+			end
+			args.n = #args
+		end
+		return table.unpack(args, 1, args.n)
+	end
+	if hasInbound then
+		if usePromise then
+			return function(...)
+				local args = table.pack(...)
+				return Promise.new(function(resolve, reject)
+					local success, res = pcall(function()
+						if hasOutbound then
+							return table.pack(rf:InvokeServer(ProcessOutbound(args)))
+						else
+							return table.pack(rf:InvokeServer(table.unpack(args, 1, args.n)))
+						end
+					end)
+					if success then
+						for _, middlewareFunc in ipairs(inboundMiddleware) do
+							local middlewareResult = table.pack(middlewareFunc(res))
+							if not middlewareResult[1] then
+								return table.unpack(middlewareResult, 2, middlewareResult.n)
+							end
+							res.n = #res
+						end
+						resolve(table.unpack(res, 1, res.n))
+					else
+						reject(res)
+					end
+				end)
+			end
+		else
+			return function(...)
+				local res
+				if hasOutbound then
+					res = table.pack(rf:InvokeServer(ProcessOutbound(table.pack(...))))
+				else
+					res = table.pack(rf:InvokeServer(...))
+				end
+				for _, middlewareFunc in ipairs(inboundMiddleware) do
+					local middlewareResult = table.pack(middlewareFunc(res))
+					if not middlewareResult[1] then
+						return table.unpack(middlewareResult, 2, middlewareResult.n)
+					end
+					res.n = #res
+				end
+				return table.unpack(res, 1, res.n)
+			end
+		end
+	else
+		if usePromise then
+			return function(...)
+				local args = table.pack(...)
+				return Promise.new(function(resolve, reject)
+					local success, res = pcall(function()
+						if hasOutbound then
+							return table.pack(rf:InvokeServer(ProcessOutbound(args)))
+						else
+							return table.pack(rf:InvokeServer(table.unpack(args, 1, args.n)))
+						end
+					end)
+					if success then
+						resolve(table.unpack(res, 1, res.n))
+					else
+						reject(res)
+					end
+				end)
+			end
+		else
+			if hasOutbound then
+				return function(...)
+					return rf:InvokeServer(ProcessOutbound(table.pack(...)))
+				end
+			else
+				return function(...)
+					return rf:InvokeServer(...)
+				end
+			end
+		end
+	end
+end
+
+function Client.GetSignal(
+	parent: Instance,
+	name: string,
+	inboundMiddleware: Types.ClientMiddleware?,
+	outboundMiddleware: Types.ClientMiddleware?
+)
+	assert(not Util.IsServer, "GetSignal must be called from the client")
+	local folder = Util.GetCommSubFolder(parent, "RE"):Expect("Failed to get Comm RE folder")
+	local re = folder:WaitForChild(name, Util.WaitForChildTimeout)
+	assert(re ~= nil, "Failed to find RemoteEvent: " .. name)
+	return ClientRemoteSignal.new(re, inboundMiddleware, outboundMiddleware)
+end
+
+function Client.GetProperty(
+	parent: Instance,
+	name: string,
+	inboundMiddleware: Types.ClientMiddleware?,
+	outboundMiddleware: Types.ClientMiddleware?
+)
+	assert(not Util.IsServer, "GetProperty must be called from the client")
+	local folder = Util.GetCommSubFolder(parent, "RP"):Expect("Failed to get Comm RP folder")
+	local re = folder:WaitForChild(name, Util.WaitForChildTimeout)
+	assert(re ~= nil, "Failed to find RemoteEvent for RemoteProperty: " .. name)
+	return ClientRemoteProperty.new(re, inboundMiddleware, outboundMiddleware)
+end
+
+return Client