@flamework-experimental/networking 2.0.0-alpha.1 → 2.0.0-alpha.3

package/out/util/signal.luau

@@ -0,0 +1,135 @@
+--[[
+	A signal of networking's own, and the recycled threads it and the receive pipeline run on.
+
+	Plain Luau rather than TypeScript: roblox-ts turns every `...args` into a table and spreads it with
+	`unpack`, which stops at the first nil it happens to land on. Here a vararg list keeps its count
+	from the remote to the handler, and nothing is allocated on the way.
+
+	Arguments are handed over by reference. A BindableEvent would copy them, turning a decoded
+	`Map<Instance, ...>` into one keyed by strings and raising on a `Set<boolean>`.
+
+	Like an engine signal, each handler runs on a thread of its own: one that yields does not hold up
+	the others, and one that raises has its error printed while the others still run. The newest
+	connection runs first, which is the order the engine runs a BindableEvent's handlers in; one made
+	during a fire does not receive it, and one disconnected before its turn is skipped.
+]]
+
+--- Threads that finished their last job, waiting in `coroutine.yield()` for the next.
+local idle: { thread } = {}
+
+--- How many finished threads are kept. More than a few are only ever needed while handlers yield;
+--- past this, a thread that finishes simply ends.
+local MAX_IDLE = 16
+
+local function call(callback: (...any) -> ...any, ...: any)
+	callback(...)
+end
+
+--[[
+	The body of a recycled thread: waits for a job, runs it, parks itself, and runs whatever it is
+	resumed with next. A job that raises ends the thread, and the error is printed by the scheduler
+	that resumed it; a job that yields keeps the thread until it returns, so it is only ever parked
+	when idle.
+
+	It takes no arguments, and every job arrives through `coroutine.yield()`: a job passed as the
+	thread's own arguments would stay in this frame's varargs for as long as the thread lives,
+	keeping its handler, sender and arguments reachable long after it returned.
+]]
+local function runner()
+	local thread = coroutine.running()
+
+	while true do
+		call(coroutine.yield())
+
+		if #idle >= MAX_IDLE then
+			return
+		end
+		table.insert(idle, thread)
+	end
+end
+
+--[[
+	Runs `callback(...)` at once on a thread of its own, recycling one that finished its last job. An
+	idle thread that was killed meanwhile (`task.cancel`) is dropped rather than resumed.
+]]
+local function spawn(callback: (...any) -> ...any, ...: any)
+	local count = #idle
+	while count > 0 do
+		local thread = idle[count]
+		idle[count] = nil
+		count -= 1
+
+		if coroutine.status(thread) == "suspended" then
+			task.spawn(thread, callback, ...)
+			return
+		end
+	end
+
+	-- A new thread, started up to its first `coroutine.yield()`, gets its first job the same way.
+	local thread = coroutine.create(runner)
+	coroutine.resume(thread)
+	task.spawn(thread, callback, ...)
+end
+
+local Connection = {}
+Connection.__index = Connection
+
+--- Disconnects the handler. Takes effect at once, even for a fire under way.
+function Connection:Disconnect()
+	if not self.Connected then
+		return
+	end
+
+	self.Connected = false
+	self._callback = nil
+
+	-- Copied rather than edited in place: a fire under way keeps walking the list it started with.
+	local signal = self._signal
+	local connections = signal._connections
+	local index = table.find(connections, self)
+	if index ~= nil then
+		local remaining = table.clone(connections)
+		table.remove(remaining, index)
+		signal._connections = remaining
+	end
+end
+
+--- The name maids and janitors call.
+Connection.Destroy = Connection.Disconnect
+
+local Signal = {}
+Signal.__index = Signal
+
+function Signal:Connect(callback: (...any) -> ...any)
+	local connection = setmetatable({
+		Connected = true,
+		_callback = callback,
+		_signal = self,
+	}, Connection)
+
+	-- Newest first, copied so that a fire under way does not reach it.
+	local connections = self._connections
+	local updated = table.create(#connections + 1)
+	updated[1] = connection
+	table.move(connections, 1, #connections, 2, updated)
+	self._connections = updated
+
+	return connection
+end
+
+function Signal:Fire(...: any)
+	for _, connection in self._connections do
+		if connection.Connected then
+			spawn(connection._callback, ...)
+		end
+	end
+end
+
+local function createSignal()
+	return setmetatable({ _connections = {} }, Signal)
+end
+
+return {
+	createSignal = createSignal,
+	spawn = spawn,
+}

package/out/util/trimArguments.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `args` cut after its last value, so that spreading it passes every argument.
+ *
+ * roblox-ts spreads a list as `unpack(list)`, which stops at `#list`. When the last slot is nil, `#`
+ * may stop at any earlier gap: `#{1, nil, nil, 4, nil}` can be 1, which drops the 4. A list that ends
+ * in a value always spreads whole. The `{ ... }` that roblox-ts rebuilds from that spread at the next
+ * hop also ends in a value, and so does every hop after it that passes the list on. So a list is
+ * trimmed where it enters, and again wherever code may build its own: a middleware that names its
+ * parameters passes on a list that can end in nil. Nothing is lost by trimming: an argument that was
+ * not passed reads as nil too.
+ */
+export declare function trimArguments<T extends unknown[]>(args: T): T;

package/out/util/trimArguments.luau

@@ -0,0 +1,48 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * `args` cut after its last value, so that spreading it passes every argument.
+	 *
+	 * roblox-ts spreads a list as `unpack(list)`, which stops at `#list`. When the last slot is nil, `#`
+	 * may stop at any earlier gap: `#{1, nil, nil, 4, nil}` can be 1, which drops the 4. A list that ends
+	 * in a value always spreads whole. The `{ ... }` that roblox-ts rebuilds from that spread at the next
+	 * hop also ends in a value, and so does every hop after it that passes the list on. So a list is
+	 * trimmed where it enters, and again wherever code may build its own: a middleware that names its
+	 * parameters passes on a list that can end in nil. Nothing is lost by trimming: an argument that was
+	 * not passed reads as nil too.
+	 
+]]
+local function trimArguments(args)
+	-- `pairs` visits every value, holes or not. Read as a map, the list gives the raw Luau (1-based)
+	-- index, which is the length up to that value.
+	local length = 0
+	for index in pairs(args) do
+		if index > length then
+			length = index
+		end
+	end
+	if #args == length then
+		return args
+	end
+	-- Sized up front, so that the last slot is the last value and `#` is exact.
+	local trimmed = table.create(length)
+	do
+		local i = 0
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				i += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (i < length) then
+				break
+			end
+			trimmed[i + 1] = args[i + 1]
+		end
+	end
+	return trimmed
+end
+return {
+	trimArguments = trimArguments,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flamework-experimental/networking",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.3",
   "main": "out/init.luau",
   "types": "out/index.d.ts",
   "scripts": {
@@ -15,10 +15,10 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@flamework-experimental/core": "*"
+    "@flamework-experimental/core": "^2.0.0-alpha.0"
   },
   "devDependencies": {
-    "@flamework-experimental/core": "2.0.0-alpha.0",
+    "@flamework-experimental/core": "2.0.0-alpha.2",
     "@rbxts/compiler-types": "^3.0.0-types.0",
     "@rbxts/types": "^1.0.948",
     "roblox-ts": "^3.0.0"
@@ -26,7 +26,6 @@
   "dependencies": {
     "@rbxts/object-utils": "^1.0.4",
     "@rbxts/services": "^1.1.5",
-    "@rbxts/signal": "^1.0.3",
     "@rbxts/t": "^3.1.0"
   }
 }

package/out/middleware/createGuardMiddleware.d.ts

@@ -1,6 +0,0 @@
-import { t } from "@rbxts/t";
-import { MiddlewareFactory } from "./types";
-import { SignalContainer } from "../util/createSignalContainer";
-import { EventNetworkingEvents } from "../handlers";
-import { NetworkInfo } from "../types";
-export declare function createGuardMiddleware<I extends unknown[], O>(name: string, fixedParameters: t.check<unknown>[], restParameter: t.check<unknown> | undefined, networkInfo: NetworkInfo, warnOnInvalid: boolean, signals: SignalContainer<EventNetworkingEvents>, failureValue?: O): MiddlewareFactory<I, O>;

package/out/middleware/createGuardMiddleware.luau

@@ -1,44 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
-local Players = TS.import(script, TS.getModule(script, "@rbxts", "services")).Players
-local function createGuardMiddleware(name, fixedParameters, restParameter, networkInfo, warnOnInvalid, signals, failureValue)
-	return function(processNext)
-		return function(player, ...)
-			local args = { ... }
-			do
-				local i = 0
-				local _shouldIncrement = false
-				while true do
-					if _shouldIncrement then
-						i += 1
-					else
-						_shouldIncrement = true
-					end
-					if not (i < math.max(#fixedParameters, #args)) then
-						break
-					end
-					local guard = fixedParameters[i + 1] or restParameter
-					if guard and not guard(args[i + 1]) then
-						if warnOnInvalid then
-							if player then
-								warn(`'{player}' sent invalid arguments for event '{name}' (arg #{i}):`, args[i + 1])
-							else
-								warn(`Server sent invalid arguments for event '{name}' (arg #{i}):`, args[i + 1])
-							end
-						end
-						signals:fire("onBadRequest", player or Players.LocalPlayer, {
-							networkInfo = networkInfo,
-							argIndex = i,
-							argValue = args[i + 1],
-						})
-						return failureValue
-					end
-				end
-			end
-			return processNext(player, unpack(args))
-		end
-	end
-end
-return {
-	createGuardMiddleware = createGuardMiddleware,
-}

package/out/middleware/createMiddlewareProcessor.d.ts

@@ -1,3 +0,0 @@
-import { NetworkInfo } from "../types";
-import { Middleware, MiddlewareFactory, MiddlewareProcessor } from "./types";
-export declare function createMiddlewareProcessor<I extends readonly unknown[], O>(middlewareFactories: MiddlewareFactory<I, O>[] | undefined, networkInfo: NetworkInfo, finalize: Middleware<I, O>): MiddlewareProcessor<I, O>;

package/out/middleware/createMiddlewareProcessor.luau

@@ -1,24 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
-local function createMiddlewareProcessor(middlewareFactories, networkInfo, finalize)
-	local middleware = {}
-	if not middlewareFactories or #middlewareFactories == 0 then
-		middleware[1] = finalize
-	else
-		for i = #middlewareFactories - 1, 0, -1 do
-			local factory = middlewareFactories[i + 1]
-			local processNext = middleware[i + 2] or finalize
-			middleware[i + 1] = factory(TS.async(function(player, ...)
-				local args = { ... }
-				return processNext(player, unpack(args))
-			end), networkInfo)
-		end
-	end
-	return TS.async(function(player, ...)
-		local args = { ... }
-		return middleware[1](player, unpack(args))
-	end)
-end
-return {
-	createMiddlewareProcessor = createMiddlewareProcessor,
-}

package/out/util/timeoutPromise.d.ts

@@ -1 +0,0 @@
-export declare function timeoutPromise(timeout: number, rejectValue: unknown): Promise<unknown>;

package/out/util/timeoutPromise.luau

@@ -1,10 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
-local function timeoutPromise(timeout, rejectValue)
-	return TS.Promise.delay(timeout):andThen(function()
-		return TS.Promise.reject(rejectValue)
-	end)
-end
-return {
-	timeoutPromise = timeoutPromise,
-}