roblox-opencode 1.0.0 → 1.0.2

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

@@ -1,140 +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
+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

@@ -1,18 +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
+-- 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

@@ -1,27 +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
+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

@@ -1,35 +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
+-- 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

@@ -1,13 +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"
+[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"