roblox-opencode 1.0.0

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

@@ -0,0 +1,140 @@
+local RemoteProperty = require(script.RemoteProperty)
+local RemoteSignal = require(script.RemoteSignal)
+local Types = require(script.Parent.Types)
+local Util = require(script.Parent.Util)
+
+local Server = {}
+
+--[=[
+	@within Comm
+	@prop ServerComm ServerComm
+]=]
+--[=[
+	@within Comm
+	@prop ClientComm ClientComm
+]=]
+
+--[=[
+	@within Comm
+	@private
+	@interface Server
+	.BindFunction (parent: Instance, name: string, fn: FnBind, inboundMiddleware: ServerMiddleware?, outboundMiddleware: ServerMiddleware?): RemoteFunction
+	.WrapMethod (parent: Instance, tbl: table, name: string, inboundMiddleware: ServerMiddleware?, outboundMiddleware: ServerMiddleware?): RemoteFunction
+	.CreateSignal (parent: Instance, name: string, inboundMiddleware: ServerMiddleware?, outboundMiddleware: ServerMiddleware?): RemoteSignal
+	.CreateProperty (parent: Instance, name: string, value: any, inboundMiddleware: ServerMiddleware?, outboundMiddleware: ServerMiddleware?): RemoteProperty
+	Server Comm
+]=]
+--[=[
+	@within Comm
+	@private
+	@interface Client
+	.GetFunction (parent: Instance, name: string, usePromise: boolean, inboundMiddleware: ClientMiddleware?, outboundMiddleware: ClientMiddleware?): (...: any) -> any
+	.GetSignal (parent: Instance, name: string, inboundMiddleware: ClientMiddleware?, outboundMiddleware: ClientMiddleware?): ClientRemoteSignal
+	.GetProperty (parent: Instance, name: string, inboundMiddleware: ClientMiddleware?, outboundMiddleware: ClientMiddleware?): ClientRemoteProperty
+	Client Comm
+]=]
+
+function Server.BindFunction(
+	parent: Instance,
+	name: string,
+	func: Types.FnBind,
+	inboundMiddleware: Types.ServerMiddleware?,
+	outboundMiddleware: Types.ServerMiddleware?
+): RemoteFunction
+	assert(Util.IsServer, "BindFunction must be called from the server")
+	local folder = Util.GetCommSubFolder(parent, "RF"):Expect("Failed to get Comm RF folder")
+	local rf = Instance.new("RemoteFunction")
+	rf.Name = name
+	local hasInbound = type(inboundMiddleware) == "table" and #inboundMiddleware > 0
+	local hasOutbound = type(outboundMiddleware) == "table" and #outboundMiddleware > 0
+	local function ProcessOutbound(player, ...)
+		local args = table.pack(...)
+		for _, middlewareFunc in ipairs(outboundMiddleware) do
+			local middlewareResult = table.pack(middlewareFunc(player, 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 and hasOutbound then
+		local function OnServerInvoke(player, ...)
+			local args = table.pack(...)
+			for _, middlewareFunc in ipairs(inboundMiddleware) do
+				local middlewareResult = table.pack(middlewareFunc(player, args))
+				if not middlewareResult[1] then
+					return table.unpack(middlewareResult, 2, middlewareResult.n)
+				end
+				args.n = #args
+			end
+			return ProcessOutbound(player, func(player, table.unpack(args, 1, args.n)))
+		end
+		rf.OnServerInvoke = OnServerInvoke
+	elseif hasInbound then
+		local function OnServerInvoke(player, ...)
+			local args = table.pack(...)
+			for _, middlewareFunc in ipairs(inboundMiddleware) do
+				local middlewareResult = table.pack(middlewareFunc(player, args))
+				if not middlewareResult[1] then
+					return table.unpack(middlewareResult, 2, middlewareResult.n)
+				end
+				args.n = #args
+			end
+			return func(player, table.unpack(args, 1, args.n))
+		end
+		rf.OnServerInvoke = OnServerInvoke
+	elseif hasOutbound then
+		local function OnServerInvoke(player, ...)
+			return ProcessOutbound(player, func(player, ...))
+		end
+		rf.OnServerInvoke = OnServerInvoke
+	else
+		rf.OnServerInvoke = func
+	end
+	rf.Parent = folder
+	return rf
+end
+
+function Server.WrapMethod(
+	parent: Instance,
+	tbl: {},
+	name: string,
+	inboundMiddleware: Types.ServerMiddleware?,
+	outboundMiddleware: Types.ServerMiddleware?
+): RemoteFunction
+	assert(Util.IsServer, "WrapMethod must be called from the server")
+	local fn = tbl[name]
+	assert(type(fn) == "function", "Value at index " .. name .. " must be a function; got " .. type(fn))
+	return Server.BindFunction(parent, name, function(...)
+		return fn(tbl, ...)
+	end, inboundMiddleware, outboundMiddleware)
+end
+
+function Server.CreateSignal(
+	parent: Instance,
+	name: string,
+	reliable: boolean?,
+	inboundMiddleware: Types.ServerMiddleware?,
+	outboundMiddleware: Types.ServerMiddleware?
+)
+	assert(Util.IsServer, "CreateSignal must be called from the server")
+	local folder = Util.GetCommSubFolder(parent, "RE"):Expect("Failed to get Comm RE folder")
+	local rs = RemoteSignal.new(folder, name, reliable, inboundMiddleware, outboundMiddleware)
+	return rs
+end
+
+function Server.CreateProperty(
+	parent: Instance,
+	name: string,
+	initialValue: any,
+	inboundMiddleware: Types.ServerMiddleware?,
+	outboundMiddleware: Types.ServerMiddleware?
+)
+	assert(Util.IsServer, "CreateProperty must be called from the server")
+	local folder = Util.GetCommSubFolder(parent, "RP"):Expect("Failed to get Comm RP folder")
+	local rp = RemoteProperty.new(folder, name, initialValue, inboundMiddleware, outboundMiddleware)
+	return rp
+end
+
+return Server

package/vendor/rbxutil/comm/Types.luau

@@ -0,0 +1,18 @@
+-- Types
+-- Stephen Leitnick
+-- December 20, 2021
+
+export type Args = {
+	n: number,
+	[any]: any,
+}
+
+export type FnBind = (Instance, ...any) -> ...any
+
+export type ServerMiddlewareFn = (Instance, Args) -> (boolean, ...any)
+export type ServerMiddleware = { ServerMiddlewareFn }
+
+export type ClientMiddlewareFn = (Args) -> (boolean, ...any)
+export type ClientMiddleware = { ClientMiddlewareFn }
+
+return nil

package/vendor/rbxutil/comm/Util.luau

@@ -0,0 +1,27 @@
+local RunService = game:GetService("RunService")
+
+local Option = require(script.Parent.Parent.Option)
+
+local Util = {}
+
+Util.IsServer = RunService:IsServer()
+Util.WaitForChildTimeout = 60
+Util.DefaultCommFolderName = "__comm__"
+Util.None = newproxy()
+
+function Util.GetCommSubFolder(parent: Instance, subFolderName: string): Option.Option
+	local subFolder: Instance = nil
+	if Util.IsServer then
+		subFolder = parent:FindFirstChild(subFolderName)
+		if not subFolder then
+			subFolder = Instance.new("Folder")
+			subFolder.Name = subFolderName
+			subFolder.Parent = parent
+		end
+	else
+		subFolder = parent:WaitForChild(subFolderName, Util.WaitForChildTimeout)
+	end
+	return Option.Wrap(subFolder)
+end
+
+return Util

package/vendor/rbxutil/comm/init.luau

@@ -0,0 +1,35 @@
+-- Comm
+-- Stephen Leitnick
+-- August 05, 2021
+
+--[=[
+	@class Comm
+	Remote communication library.
+
+	This exposes the raw functions that are used by the `ServerComm` and `ClientComm` classes.
+	Those two classes should be preferred over accessing the functions directly through this
+	Comm library.
+
+	```lua
+	-- Server
+	local ServerComm = require(ReplicatedStorage.Packages.Comm).ServerComm
+	local serverComm = ServerComm.new(somewhere, "MyComm")
+	serverComm:BindFunction("Hello", function(player: Player)
+		return "Hi"
+	end)
+	
+	-- Client
+	local ClientComm = require(ReplicatedStorage.Packages.Comm).ClientComm
+	local clientComm = ClientComm.new(somewhere, false, "MyComm")
+	local comm = clientComm:BuildObject()
+	print(comm:Hello()) --> Hi
+	```
+]=]
+local Comm = {
+	Server = require(script.Server),
+	Client = require(script.Client),
+	ServerComm = require(script.Server.ServerComm),
+	ClientComm = require(script.Client.ClientComm),
+}
+
+return Comm

package/vendor/rbxutil/comm/wally.toml

@@ -0,0 +1,13 @@
+[package]
+name = "sleitnick/comm"
+description = "Comm library for remote communication"
+version = "1.0.1"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"
+
+[dependencies]
+Signal = "sleitnick/signal@2"
+Option = "sleitnick/option@1"
+Promise = "evaera/promise@4"