--!native
-- Compiled with roblox-ts v3.0.0
local TS = _G[script]
local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
local FunctionTools = {}
do
	local _container = FunctionTools
	local function ExecuteIfClient(callback, ...)
		local args = { ... }
		if RunService:IsClient() then
			return callback(unpack(args))
		end
	end
	_container.ExecuteIfClient = ExecuteIfClient
	local function ExecuteIfServer(callback, ...)
		local args = { ... }
		if RunService:IsServer() then
			return callback(unpack(args))
		end
	end
	_container.ExecuteIfServer = ExecuteIfServer
	--*executes client call back for the client and server callback for the server, returns the callback return arguments 
	local function ExecuteOnServerAndClient(server_callback, client_callback, ...)
		local args = { ... }
		if RunService:IsServer() then
			return server_callback(unpack(args))
		end
		return client_callback(unpack(args))
	end
	_container.ExecuteOnServerAndClient = ExecuteOnServerAndClient
	local function Execute(callback, ...)
		local args = { ... }
		return callback(unpack(args))
	end
	_container.Execute = Execute
	local function ExecuteWith(item, callback)
		callback(item)
		return item
	end
	_container.ExecuteWith = ExecuteWith
	--[[
		*
			 * creates the function that accepts optional arguments, but they are getting filled out by default parameters
			 * @param default_parameters
			 * @param callback
			 * @returns
			 
	]]
	local function CreateFunctionWithOptionalArguments(default_parameters, callback)
		return function(data)
			--applies all optional values
			local default_map = default_parameters
			for key, value in default_map do
				if data[key] == nil then
					data[key] = value
				end
			end
			return callback(data)
		end
	end
	_container.CreateFunctionWithOptionalArguments = CreateFunctionWithOptionalArguments
	--[[
		*
			 *
			 * @param value value to switch
			 * @param possible_variants possible variants of value
			 * @param possible_answers possible answers with coresponding indexes to variants
			 * @param default_value if variant wasnt found, will return a default value
			 * @returns if value is a variant, will return the answer with the same index as a variant
			 *
			 * ```ts
			 *
			 * SwitchValueIfEquals(
			 * value,
			 * [1, 2, 3],
			 * [3, 2, 1],
			 * 0)
			 *
			 * //equivalent to
			 * switch(value){
			 * case(1):{
			 * return 3;
			 * }
			 * case(2):{
			 * return 2;
			 * }
			 * case(3):{
			 * return 1}
			 * }
			 * default:{
			 * return: 0}
			 * ```
			 
	]]
	local function SwitchValueIfEquals(value, possible_variants, possible_answers, default_value)
		for i = 0, #possible_answers - 1 do
			local variant = possible_variants[i + 1]
			--if value is a variant, will return the answer with the same index
			if value == variant then
				return possible_answers[i + 1]
			end
		end
		return default_value
	end
	_container.SwitchValueIfEquals = SwitchValueIfEquals
end
return {
	FunctionTools = FunctionTools,
}