@skating/swiftpacket 0.1.4

package/src/cursor.luau

@@ -0,0 +1,18 @@
+--!strict
+--!optimize 2
+
+--[[
+	Author: @skaterstudios
+	Website: skaterstudios.com
+	GitHub: github.com/skatingii/SwiftPacket
+	Discord Server: discord.gg/skaterstudios
+
+	Licensed under the MIT License. You may use, modify, redistribute and sell
+	this system freely, as long as this notice and the LICENSE file stay with it.
+]]
+
+const Schema = require("./schema")
+
+export type Cursor = Schema.Cursor
+
+return Schema.Cursor

package/src/index.d.ts

@@ -0,0 +1,122 @@
+declare namespace SwiftPacket {
+	type Results<R extends unknown[]> = R extends [] ? void : R extends [infer T] ? T : LuaTuple<R>;
+
+	type OptionalKeys<T> = { [K in keyof T]-?: undefined extends T[K] ? K : never }[keyof T];
+
+	type Shape<T> = { [K in Exclude<keyof T, OptionalKeys<T>>]: T[K] } & { [K in OptionalKeys<T>]?: T[K] };
+
+	type Flatten<T> = { [K in keyof T]: T[K] };
+
+	interface Options {
+		Logging?: boolean;
+		IncomingBytesPerSecond?: number;
+		UnreliableByteLimit?: number;
+	}
+
+	interface Connection {
+		readonly Connected: boolean;
+		Disconnect(): void;
+	}
+
+	interface Signal<A extends unknown[]> {
+		Connect(callback: (...args: A) => void): Connection;
+		Once(callback: (...args: A) => void): Connection;
+		Wait(): LuaTuple<A>;
+		DisconnectAll(): void;
+	}
+
+	interface Event<A extends unknown[]> {
+		readonly Name: string;
+		readonly OnServerEvent: Signal<[player: Player, ...args: A]>;
+		readonly OnClientEvent: Signal<A>;
+		Fire(...args: A): void;
+		FireClient(player: Player, ...args: A): void;
+		FireClients(players: ReadonlyArray<Player>, ...args: A): void;
+		FireExcept(player: Player, ...args: A): void;
+		Response<R extends unknown[]>(...types: R): Request<A, R>;
+		Unreliable(): Event<A>;
+		RateLimit(count: number, interval: number): Event<A>;
+		Validate(validator: (player: Player, ...args: A) => boolean): Event<A>;
+		Serialize(...args: A): LuaTuple<[buffer, Array<Instance> | undefined]>;
+		Deserialize(data: buffer, instances?: ReadonlyArray<Instance>): Results<A>;
+	}
+
+	interface Request<A extends unknown[], R extends unknown[]> {
+		readonly Name: string;
+		OnServerInvoke?: (player: Player, ...args: A) => Results<R>;
+		OnClientInvoke?: (...args: A) => Results<R>;
+		Fire(...args: A): Results<R>;
+		FireClient(player: Player, ...args: A): Results<R>;
+		SetServerInvoke(handler: (player: Player, ...args: A) => Results<R>): Request<A, R>;
+		SetClientInvoke(handler: (...args: A) => Results<R>): Request<A, R>;
+		Timeout(seconds: number, ...fallback: R): Request<A, R>;
+		RateLimit(count: number, interval: number): Request<A, R>;
+		Validate(validator: (player: Player, ...args: A) => boolean): Request<A, R>;
+		Serialize(...args: A): LuaTuple<[buffer, Array<Instance> | undefined]>;
+		Deserialize(data: buffer, instances?: ReadonlyArray<Instance>): Results<A>;
+	}
+
+	interface Library {
+		<A extends unknown[]>(name: string, ...types: A): Event<A>;
+
+		readonly Version: string;
+		readonly Configure: (options: Options) => void;
+
+		readonly Any: unknown;
+		readonly Nil: undefined;
+		readonly Boolean: boolean;
+
+		readonly U8: number;
+		readonly U16: number;
+		readonly U24: number;
+		readonly U32: number;
+		readonly I8: number;
+		readonly I16: number;
+		readonly I24: number;
+		readonly I32: number;
+		readonly F16: number;
+		readonly F24: number;
+		readonly F32: number;
+		readonly F64: number;
+
+		readonly String: string;
+		readonly Characters: string;
+		readonly Buffer: buffer;
+		readonly Instance: Instance | undefined;
+
+		readonly Vector2: Vector2;
+		readonly Vector2F16: Vector2;
+		readonly Vector2I16: Vector2;
+		readonly Vector3: Vector3;
+		readonly Vector3F24: Vector3;
+		readonly Vector3F16: Vector3;
+		readonly Vector3I16: Vector3;
+		readonly CFrame: CFrame;
+		readonly CFrameF24: CFrame;
+
+		readonly Color3: Color3;
+		readonly BrickColor: BrickColor;
+		readonly UDim: UDim;
+		readonly UDim2: UDim2;
+		readonly Rect: Rect;
+		readonly NumberRange: NumberRange;
+		readonly NumberSequence: NumberSequence;
+		readonly ColorSequence: ColorSequence;
+		readonly DateTime: DateTime;
+
+		readonly Array: <T>(element: T, maximumLength?: number) => Array<T>;
+		readonly Map: <K, V>(key: K, value: V, maximumCount?: number) => Map<K, V>;
+		readonly Struct: <T extends object>(shape: T) => Flatten<Shape<T>>;
+		readonly Optional: <T>(inner: T) => T | undefined;
+		readonly Static: <const T>(values: ReadonlyArray<T>) => T;
+		readonly Range: (inner: number, minimum: number, maximum: number) => number;
+		readonly Flags: <const N extends string>(names: ReadonlyArray<N>) => Record<N, boolean>;
+		readonly Charset: (characters: string) => string;
+		readonly InstanceOf: <T extends keyof Instances>(className: T) => Instances[T] | undefined;
+		readonly EnumItem: <T extends EnumItem>(enumType: { GetEnumItems(): Array<T> }) => T;
+	}
+}
+
+declare const SwiftPacket: SwiftPacket.Library;
+
+export = SwiftPacket;

package/src/init.luau

@@ -0,0 +1,199 @@
+--!nonstrict
+--!optimize 2
+
+--[[
+	Author: @skaterstudios
+	Website: skaterstudios.com
+	GitHub: github.com/skatingii/SwiftPacket
+	Discord Server: discord.gg/skaterstudios
+
+	Licensed under the MIT License. You may use, modify, redistribute and sell
+	this system freely, as long as this notice and the LICENSE file stay with it.
+]]
+
+const RunService = game:GetService("RunService")
+
+const Client = require("@self/client")
+const Configuration = require("@self/configuration")
+const Packet = require("@self/packet")
+const Schema = require("@self/schema")
+const Server = require("@self/server")
+
+export type Options = Configuration.Options
+
+export type Connection = {
+	Connected: boolean,
+	Disconnect: (self: Connection) -> (),
+}
+
+export type Signal<A...> = {
+	Connect: (self: Signal<A...>, Callback: (A...) -> ()) -> Connection,
+	Once: (self: Signal<A...>, Callback: (A...) -> ()) -> Connection,
+	Wait: (self: Signal<A...>) -> A...,
+	DisconnectAll: (self: Signal<A...>) -> (),
+}
+
+export type Request<A..., B...> = {
+	Name: string,
+	OnServerInvoke: ((Player: Player, A...) -> B...)?,
+	OnClientInvoke: ((A...) -> B...)?,
+	Fire: (self: Request<A..., B...>, A...) -> B...,
+	FireClient: (self: Request<A..., B...>, Player: Player, A...) -> B...,
+	SetServerInvoke: (self: Request<A..., B...>, Handler: (Player: Player, A...) -> B...) -> Request<A..., B...>,
+	SetClientInvoke: (self: Request<A..., B...>, Handler: (A...) -> B...) -> Request<A..., B...>,
+	Timeout: (self: Request<A..., B...>, Seconds: number, B...) -> Request<A..., B...>,
+	RateLimit: (self: Request<A..., B...>, Count: number, Interval: number) -> Request<A..., B...>,
+	Validate: (self: Request<A..., B...>, Validator: (Player: Player, A...) -> boolean) -> Request<A..., B...>,
+	Serialize: (self: Request<A..., B...>, A...) -> (buffer, { Instance }?),
+	Deserialize: (self: Request<A..., B...>, Data: buffer, Instances: { Instance }?) -> A...,
+}
+
+export type Event<A...> = {
+	Name: string,
+	OnServerEvent: Signal<(Player, A...)>,
+	OnClientEvent: Signal<A...>,
+	Fire: (self: Event<A...>, A...) -> (),
+	FireClient: (self: Event<A...>, Player: Player, A...) -> (),
+	FireClients: (self: Event<A...>, Players: { Player }, A...) -> (),
+	FireExcept: (self: Event<A...>, Player: Player, A...) -> (),
+	Response: <B...>(self: Event<A...>, B...) -> Request<A..., B...>,
+	Unreliable: (self: Event<A...>) -> Event<A...>,
+	RateLimit: (self: Event<A...>, Count: number, Interval: number) -> Event<A...>,
+	Validate: (self: Event<A...>, Validator: (Player: Player, A...) -> boolean) -> Event<A...>,
+	Serialize: (self: Event<A...>, A...) -> (buffer, { Instance }?),
+	Deserialize: (self: Event<A...>, Data: buffer, Instances: { Instance }?) -> A...,
+}
+
+export type Fields = {
+	Version: string,
+	Configure: (Options: Options) -> (),
+
+	Any: any,
+	Nil: nil,
+	Boolean: boolean,
+
+	U8: number,
+	U16: number,
+	U24: number,
+	U32: number,
+	I8: number,
+	I16: number,
+	I24: number,
+	I32: number,
+	F16: number,
+	F24: number,
+	F32: number,
+	F64: number,
+
+	String: string,
+	Characters: string,
+	Buffer: buffer,
+	Instance: Instance?,
+
+	Vector2: Vector2,
+	Vector2F16: Vector2,
+	Vector2I16: Vector2,
+	Vector3: Vector3,
+	Vector3F24: Vector3,
+	Vector3F16: Vector3,
+	Vector3I16: Vector3,
+	CFrame: CFrame,
+	CFrameF24: CFrame,
+
+	Color3: Color3,
+	BrickColor: BrickColor,
+	UDim: UDim,
+	UDim2: UDim2,
+	Rect: Rect,
+	NumberRange: NumberRange,
+	NumberSequence: NumberSequence,
+	ColorSequence: ColorSequence,
+	DateTime: DateTime,
+
+	Array: <T>(Element: T, MaximumLength: number?) -> { T },
+	Map: <K, V>(Key: K, Value: V, MaximumCount: number?) -> { [K]: V },
+	Struct: <T>(Shape: T) -> T,
+	Optional: <T>(Inner: T) -> T?,
+	Static: <T>(Values: { T }) -> T,
+	Range: (Inner: number, Minimum: number, Maximum: number) -> number,
+	Flags: (Names: { string }) -> { [string]: boolean },
+	Charset: (Characters: string) -> string,
+	InstanceOf: (ClassName: string) -> Instance?,
+	EnumItem: (EnumType: Enum) -> EnumItem,
+}
+
+export type SwiftPacket = setmetatable<Fields, {
+	__call: <A...>(self: Fields, Name: string, A...) -> Event<A...>,
+}>
+
+if RunService:IsServer() then
+	Server.Start(script)
+else
+	Client.Start(script)
+end
+
+const Library = {
+	Version = "0.1.4",
+	Configure = Configuration.Configure,
+
+	Any = Schema.Any,
+	Nil = Schema.Nil,
+	Boolean = Schema.Boolean,
+
+	U8 = Schema.U8,
+	U16 = Schema.U16,
+	U24 = Schema.U24,
+	U32 = Schema.U32,
+	I8 = Schema.I8,
+	I16 = Schema.I16,
+	I24 = Schema.I24,
+	I32 = Schema.I32,
+	F16 = Schema.F16,
+	F24 = Schema.F24,
+	F32 = Schema.F32,
+	F64 = Schema.F64,
+
+	String = Schema.String,
+	Characters = Schema.Characters,
+	Buffer = Schema.Buffer,
+	Instance = Schema.Instance,
+
+	Vector2 = Schema.Vector2,
+	Vector2F16 = Schema.Vector2F16,
+	Vector2I16 = Schema.Vector2I16,
+	Vector3 = Schema.Vector3,
+	Vector3F24 = Schema.Vector3F24,
+	Vector3F16 = Schema.Vector3F16,
+	Vector3I16 = Schema.Vector3I16,
+	CFrame = Schema.CFrame,
+	CFrameF24 = Schema.CFrameF24,
+
+	Color3 = Schema.Color3,
+	BrickColor = Schema.BrickColor,
+	UDim = Schema.UDim,
+	UDim2 = Schema.UDim2,
+	Rect = Schema.Rect,
+	NumberRange = Schema.NumberRange,
+	NumberSequence = Schema.NumberSequence,
+	ColorSequence = Schema.ColorSequence,
+	DateTime = Schema.DateTime,
+
+	Array = Schema.Array,
+	Map = Schema.Map,
+	Struct = Schema.Struct,
+	Optional = Schema.Optional,
+	Static = Schema.Static,
+	Range = Schema.Range,
+	Flags = Schema.Flags,
+	Charset = Schema.Charset,
+	InstanceOf = Schema.InstanceOf,
+	EnumItem = Schema.EnumItem,
+}
+
+const SwiftPacket: SwiftPacket = setmetatable(Library, {
+	__call = function(Target, Name: string, ...)
+		return Packet.New(Name, table.pack(...))
+	end,
+})
+
+return SwiftPacket

package/src/packet.luau

@@ -0,0 +1,186 @@
+--!strict
+--!optimize 2
+
+--[[
+	Author: @skaterstudios
+	Website: skaterstudios.com
+	GitHub: github.com/skatingii/SwiftPacket
+	Discord Server: discord.gg/skaterstudios
+
+	Licensed under the MIT License. You may use, modify, redistribute and sell
+	this system freely, as long as this notice and the LICENSE file stay with it.
+]]
+
+const RunService = game:GetService("RunService")
+
+const Client = require("./client")
+const Registry = require("./registry")
+const Schema = require("./schema")
+const Server = require("./server")
+const Signal = require("./signal")
+
+const IsServer = RunService:IsServer()
+
+const Packet = {}
+Packet.__index = Packet
+
+export type Packet = setmetatable<Registry.Definition, typeof(Packet)>
+
+const Packets: { [string]: Packet } = {}
+const NoInstances: { any } = {}
+
+const function RequireServer(self: Packet, Method: string)
+	if not IsServer then
+		error(`[swiftpacket] {Method} on {self.Name} can only be called on the server`, 3)
+	end
+end
+
+const function RequireEvent(self: Packet, Method: string)
+	if self.Responses then
+		error(`[swiftpacket] {self.Name} expects a response, so {Method} cannot be used with it`, 3)
+	end
+end
+
+function Packet.New(Name: string, Parameters: Schema.Arguments): Packet
+	if #Name > 100 or string.match(Name, "^[%a_][%w_]*$") == nil or string.sub(Name, 1, 3) == "RBX" then
+		error(`[swiftpacket] "{Name}" is not a valid packet name, use letters, digits and underscores`, 3)
+	end
+
+	const Existing = Packets[Name]
+
+	if Existing then
+		return Existing
+	end
+
+	const State: Registry.Definition = {
+		Name = Name,
+		Arguments = Schema.CompileList(Parameters),
+		TimeoutSeconds = 10,
+		TimeoutValues = { n = 0 },
+		Reliable = true,
+		OnServerEvent = Signal.New(),
+		OnClientEvent = Signal.New(),
+	}
+
+	const self: Packet = setmetatable(State, Packet)
+	Packets[Name] = self
+
+	if IsServer then
+		Server.Register(self)
+	else
+		Client.Register(self)
+	end
+
+	return self
+end
+
+function Packet.Fire(self: Packet, ...: any): ...any
+	if IsServer then
+		RequireEvent(self, "Fire")
+		Server.Broadcast(self, nil, ...)
+
+		return
+	end
+
+	if self.Responses then
+		return Client.Invoke(self, ...)
+	end
+
+	Client.Send(self, ...)
+
+	return
+end
+
+function Packet.FireClient(self: Packet, Player: Player, ...: any): ...any
+	RequireServer(self, "FireClient")
+
+	if self.Responses then
+		return Server.Invoke(Player, self, ...)
+	end
+
+	Server.SendTo(Player, self, ...)
+
+	return
+end
+
+function Packet.FireClients(self: Packet, Recipients: { Player }, ...: any)
+	RequireServer(self, "FireClients")
+	RequireEvent(self, "FireClients")
+	Server.SendMany(Recipients, nil, self, ...)
+end
+
+function Packet.FireExcept(self: Packet, Excluded: Player, ...: any)
+	RequireServer(self, "FireExcept")
+	RequireEvent(self, "FireExcept")
+	Server.Broadcast(self, Excluded, ...)
+end
+
+function Packet.Response(self: Packet, ...: any): Packet
+	if not self.Reliable then
+		error(`[swiftpacket] {self.Name} is unreliable and cannot expect a response`, 2)
+	end
+
+	self.Responses = Schema.CompileList(table.pack(...))
+
+	return self
+end
+
+function Packet.Timeout(self: Packet, Seconds: number, ...: any): Packet
+	if Seconds <= 0 then
+		error(`[swiftpacket] timeout for {self.Name} must be above zero`, 2)
+	end
+
+	self.TimeoutSeconds = Seconds
+	self.TimeoutValues = table.pack(...)
+
+	return self
+end
+
+function Packet.Unreliable(self: Packet): Packet
+	if self.Responses then
+		error(`[swiftpacket] {self.Name} expects a response and cannot be unreliable`, 2)
+	end
+
+	self.Reliable = false
+
+	return self
+end
+
+function Packet.RateLimit(self: Packet, Count: number, Interval: number): Packet
+	if Count < 1 or Interval <= 0 then
+		error(`[swiftpacket] rate limit for {self.Name} needs a count of at least 1 and an interval above zero`, 2)
+	end
+
+	self.RateLimitCount = Count
+	self.RateLimitInterval = Interval
+
+	return self
+end
+
+function Packet.Validate(self: Packet, Validator: (Player, ...any) -> boolean): Packet
+	self.Validator = Validator
+
+	return self
+end
+
+function Packet.SetServerInvoke(self: Packet, Handler: (Player, ...any) -> ...any): Packet
+	self.OnServerInvoke = Handler
+
+	return self
+end
+
+function Packet.SetClientInvoke(self: Packet, Handler: (...any) -> ...any): Packet
+	self.OnClientInvoke = Handler
+
+	return self
+end
+
+function Packet.Serialize(self: Packet, ...: any): (buffer, { any }?)
+	return Schema.Serialize(self.Name, self.Arguments, ...)
+end
+
+function Packet.Deserialize(self: Packet, Source: buffer, Instances: { any }?): ...any
+	return Schema.Deserialize(self.Arguments, Source, Instances or NoInstances)
+end
+
+return Packet

package/src/rate_limit.luau

@@ -0,0 +1,38 @@
+--!strict
+--!optimize 2
+
+--[[
+	Author: @skaterstudios
+	Website: skaterstudios.com
+	GitHub: github.com/skatingii/SwiftPacket
+	Discord Server: discord.gg/skaterstudios
+
+	Licensed under the MIT License. You may use, modify, redistribute and sell
+	this system freely, as long as this notice and the LICENSE file stay with it.
+]]
+
+const RateLimit = {}
+
+function RateLimit.Refill(Tokens: number, Elapsed: number, Rate: number, Capacity: number): number
+	return math.min(Capacity, Tokens + math.max(Elapsed, 0) * Rate)
+end
+
+function RateLimit.Window(
+	Count: number,
+	EndsAt: number,
+	Now: number,
+	Limit: number,
+	Interval: number
+): (boolean, number, number)
+	if Now >= EndsAt then
+		return true, 1, Now + Interval
+	end
+
+	if Count >= Limit then
+		return false, Count, EndsAt
+	end
+
+	return true, Count + 1, EndsAt
+end
+
+return RateLimit

package/src/registry.luau

@@ -0,0 +1,40 @@
+--!strict
+--!optimize 2
+
+--[[
+	Author: @skaterstudios
+	Website: skaterstudios.com
+	GitHub: github.com/skatingii/SwiftPacket
+	Discord Server: discord.gg/skaterstudios
+
+	Licensed under the MIT License. You may use, modify, redistribute and sell
+	this system freely, as long as this notice and the LICENSE file stay with it.
+]]
+
+const Schema = require("./schema")
+const Signal = require("./signal")
+
+export type Definition = {
+	Name: string,
+	Id: number?,
+	Arguments: { Schema.Schema },
+	Responses: { Schema.Schema }?,
+	TimeoutSeconds: number,
+	TimeoutValues: Schema.Arguments,
+	Reliable: boolean,
+	RateLimitCount: number?,
+	RateLimitInterval: number?,
+	Validator: ((Player, ...any) -> boolean)?,
+	OnServerEvent: Signal.Signal,
+	OnClientEvent: Signal.Signal,
+	OnServerInvoke: ((Player, ...any) -> ...any)?,
+	OnClientInvoke: ((...any) -> ...any)?,
+}
+
+const ById: { [number]: Definition } = {}
+
+const Registry = {
+	ById = ById,
+}
+
+return Registry