@snailycfx/nexus 1.0.1

package/out/events/core/EventClass.d.ts

@@ -0,0 +1 @@
+export type EventClass = new (...args: unknown[]) => object;

package/out/events/core/EventClass.luau

@@ -0,0 +1,2 @@
+-- Compiled with roblox-ts v3.0.0
+return nil

package/out/events/core/EventHandlerMeta.d.ts

@@ -0,0 +1,8 @@
+import { EventPriority } from "./EventPriority";
+import { EventClass } from "./EventClass";
+export interface EventHandlerMeta {
+    readonly methodName: string;
+    readonly eventClass: EventClass;
+    readonly async: boolean;
+    readonly priority: EventPriority;
+}

package/out/events/core/EventHandlerMeta.luau

@@ -0,0 +1,2 @@
+-- Compiled with roblox-ts v3.0.0
+return nil

package/out/events/core/EventHandlerOptions.d.ts

@@ -0,0 +1,5 @@
+import { EventPriority } from "./EventPriority";
+export interface EventHandlerOptions {
+    readonly async?: boolean;
+    readonly priority?: EventPriority;
+}

package/out/events/core/EventHandlerOptions.luau

@@ -0,0 +1,2 @@
+-- Compiled with roblox-ts v3.0.0
+return nil

package/out/events/core/EventPriority.d.ts

@@ -0,0 +1,8 @@
+export declare const enum EventPriority {
+    Lowest = 0,
+    Low = 1,
+    Normal = 2,
+    High = 3,
+    Highest = 4,
+    Monitor = 5
+}

package/out/events/core/EventPriority.luau

@@ -0,0 +1,2 @@
+-- Compiled with roblox-ts v3.0.0
+return nil

package/out/events/core/NexusEvent.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class NexusEvent {
+    private cancelled;
+    setCancelled(cancelled: boolean): void;
+    isCancelled(): boolean;
+}

package/out/events/core/NexusEvent.luau

@@ -0,0 +1,17 @@
+-- Compiled with roblox-ts v3.0.0
+local NexusEvent
+do
+	NexusEvent = {}
+	function NexusEvent:constructor()
+		self.cancelled = false
+	end
+	function NexusEvent:setCancelled(cancelled)
+		self.cancelled = cancelled
+	end
+	function NexusEvent:isCancelled()
+		return self.cancelled
+	end
+end
+return {
+	NexusEvent = NexusEvent,
+}

package/out/events/core/metadata/NexusMetadata.d.ts

@@ -0,0 +1,6 @@
+import { EventClass } from "../EventClass";
+export declare class NexusMetadata {
+    private static readonly store;
+    static define(key: string, paramTypes: EventClass[], _target: object, methodName: string): void;
+    static getEventClass(methodName: string): EventClass | undefined;
+}

package/out/events/core/metadata/NexusMetadata.luau

@@ -0,0 +1,37 @@
+-- Compiled with roblox-ts v3.0.0
+local NexusMetadata
+do
+	NexusMetadata = setmetatable({}, {
+		__tostring = function()
+			return "NexusMetadata"
+		end,
+	})
+	NexusMetadata.__index = NexusMetadata
+	function NexusMetadata.new(...)
+		local self = setmetatable({}, NexusMetadata)
+		return self:constructor(...) or self
+	end
+	function NexusMetadata:constructor()
+	end
+	function NexusMetadata:define(key, paramTypes, _target, methodName)
+		if key ~= "paramtypes" then
+			return nil
+		end
+		if #paramTypes == 0 then
+			return nil
+		end
+		local _store = NexusMetadata.store
+		local _methodName = methodName
+		local _arg1 = paramTypes[1]
+		_store[_methodName] = _arg1
+	end
+	function NexusMetadata:getEventClass(methodName)
+		local _store = NexusMetadata.store
+		local _methodName = methodName
+		return _store[_methodName]
+	end
+	NexusMetadata.store = {}
+end
+return {
+	NexusMetadata = NexusMetadata,
+}

package/out/events/decorators/EventHandler.d.ts

@@ -0,0 +1,4 @@
+import { EventHandlerOptions } from "../../events/core/EventHandlerOptions";
+import { EventHandlerMeta } from "../../events/core/EventHandlerMeta";
+export declare function EventHandler(options?: EventHandlerOptions): (target: object, methodName: string) => void;
+export declare function getEventHandlerMetas(target: object): EventHandlerMeta[];

package/out/events/decorators/EventHandler.luau

@@ -0,0 +1,47 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local NexusMetadata = TS.import(script, script.Parent.Parent, "core", "metadata", "NexusMetadata").NexusMetadata
+local EVENT_HANDLER_KEY = "__nexus_event_handlers__"
+local function EventHandler(options)
+	return function(target, methodName)
+		local eventClass = NexusMetadata:getEventClass(methodName)
+		if eventClass == nil then
+			return nil
+		end
+		local _object = {
+			methodName = methodName,
+			eventClass = eventClass,
+		}
+		local _left = "async"
+		local _result = options
+		if _result ~= nil then
+			_result = _result.async
+		end
+		local _condition = _result
+		if _condition == nil then
+			_condition = false
+		end
+		_object[_left] = _condition
+		local _left_1 = "priority"
+		local _result_1 = options
+		if _result_1 ~= nil then
+			_result_1 = _result_1.priority
+		end
+		local _condition_1 = _result_1
+		if _condition_1 == nil then
+			_condition_1 = 2
+		end
+		_object[_left_1] = _condition_1
+		local meta = _object
+		local existing = target[EVENT_HANDLER_KEY] or {}
+		table.insert(existing, meta)
+		target[EVENT_HANDLER_KEY] = existing
+	end
+end
+local function getEventHandlerMetas(target)
+	return target[EVENT_HANDLER_KEY] or {}
+end
+return {
+	EventHandler = EventHandler,
+	getEventHandlerMetas = getEventHandlerMetas,
+}

package/out/events/handlers/player/PlayerJoinEvent.d.ts

@@ -0,0 +1,6 @@
+import { NexusEvent } from "../../core/NexusEvent";
+export declare class PlayerJoinEvent extends NexusEvent {
+    private readonly player;
+    constructor(player: Player);
+    getPlayer(): Player;
+}

package/out/events/handlers/player/PlayerJoinEvent.luau

@@ -0,0 +1,28 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local NexusEvent = TS.import(script, script.Parent.Parent.Parent, "core", "NexusEvent").NexusEvent
+local PlayerJoinEvent
+do
+	local super = NexusEvent
+	PlayerJoinEvent = setmetatable({}, {
+		__tostring = function()
+			return "PlayerJoinEvent"
+		end,
+		__index = super,
+	})
+	PlayerJoinEvent.__index = PlayerJoinEvent
+	function PlayerJoinEvent.new(...)
+		local self = setmetatable({}, PlayerJoinEvent)
+		return self:constructor(...) or self
+	end
+	function PlayerJoinEvent:constructor(player)
+		super.constructor(self)
+		self.player = player
+	end
+	function PlayerJoinEvent:getPlayer()
+		return self.player
+	end
+end
+return {
+	PlayerJoinEvent = PlayerJoinEvent,
+}

package/out/events/handlers/player/PlayerLeaveEvent.d.ts

@@ -0,0 +1,6 @@
+import { NexusEvent } from "../../core/NexusEvent";
+export declare class PlayerLeaveEvent extends NexusEvent {
+    private readonly player;
+    constructor(player: Player);
+    getPlayer(): Player;
+}

package/out/events/handlers/player/PlayerLeaveEvent.luau

@@ -0,0 +1,28 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local NexusEvent = TS.import(script, script.Parent.Parent.Parent, "core", "NexusEvent").NexusEvent
+local PlayerLeaveEvent
+do
+	local super = NexusEvent
+	PlayerLeaveEvent = setmetatable({}, {
+		__tostring = function()
+			return "PlayerLeaveEvent"
+		end,
+		__index = super,
+	})
+	PlayerLeaveEvent.__index = PlayerLeaveEvent
+	function PlayerLeaveEvent.new(...)
+		local self = setmetatable({}, PlayerLeaveEvent)
+		return self:constructor(...) or self
+	end
+	function PlayerLeaveEvent:constructor(player)
+		super.constructor(self)
+		self.player = player
+	end
+	function PlayerLeaveEvent:getPlayer()
+		return self.player
+	end
+end
+return {
+	PlayerLeaveEvent = PlayerLeaveEvent,
+}

package/out/index.server.d.ts

@@ -0,0 +1,9 @@
+export { Nexus } from './server/Nexus';
+export { NexusEvent } from './events/core/NexusEvent';
+export { NexusMetadata } from './events/core/metadata/NexusMetadata';
+export { EventPriority } from './events/core/EventPriority';
+export { EventHandler } from './events/decorators/EventHandler';
+export { EventHandlerMeta } from './events/core/EventHandlerMeta';
+export { EventHandlerOptions } from './events/core/EventHandlerOptions';
+export { PlayerJoinEvent } from './events/handlers/player/PlayerJoinEvent';
+export { PlayerLeaveEvent } from './events/handlers/player/PlayerLeaveEvent';

package/out/init.server.luau

@@ -0,0 +1,10 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+exports.Nexus = TS.import(script, script, "server", "Nexus").Nexus
+exports.NexusEvent = TS.import(script, script, "events", "core", "NexusEvent").NexusEvent
+exports.NexusMetadata = TS.import(script, script, "events", "core", "metadata", "NexusMetadata").NexusMetadata
+exports.EventHandler = TS.import(script, script, "events", "decorators", "EventHandler").EventHandler
+exports.PlayerJoinEvent = TS.import(script, script, "events", "handlers", "player", "PlayerJoinEvent").PlayerJoinEvent
+exports.PlayerLeaveEvent = TS.import(script, script, "events", "handlers", "player", "PlayerLeaveEvent").PlayerLeaveEvent
+return exports

package/out/interfaces/IListener.d.ts

@@ -0,0 +1,2 @@
+export default interface IListener {
+}

package/out/interfaces/IListener.luau

@@ -0,0 +1,2 @@
+-- Compiled with roblox-ts v3.0.0
+return nil

package/out/server/Nexus.d.ts

@@ -0,0 +1,10 @@
+import { EventManager } from "./managers/EventManager";
+export declare abstract class Nexus {
+    private readonly eventManager;
+    private static instance;
+    constructor();
+    static getInstance<T extends Nexus>(): T;
+    getEventManager(): EventManager;
+    onEnable(): void;
+    onDisable(): void;
+}

package/out/server/Nexus.luau

@@ -0,0 +1,34 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local EventManager = TS.import(script, script.Parent, "managers", "EventManager").EventManager
+local Nexus
+do
+	Nexus = {}
+	function Nexus:constructor()
+		self.eventManager = EventManager.new()
+		if not RunService:IsServer() then
+			error("Nexus can only be instantiated in server!")
+		end
+		if Nexus.instance ~= nil then
+			error("Nexus can only be instantiated once!")
+		end
+		Nexus.instance = self
+		game:BindToClose(function()
+			return self:onDisable()
+		end)
+	end
+	function Nexus:getInstance()
+		return Nexus.instance
+	end
+	function Nexus:getEventManager()
+		return self.eventManager
+	end
+	function Nexus:onEnable()
+	end
+	function Nexus:onDisable()
+	end
+end
+return {
+	Nexus = Nexus,
+}

package/out/server/managers/EventManager.d.ts

@@ -0,0 +1,8 @@
+import { NexusEvent } from "../../index.server";
+import IListener from "../../interfaces/IListener";
+export declare class EventManager {
+    private readonly handlers;
+    register(listener: IListener): void;
+    dispatch<T extends NexusEvent>(event: T): void;
+    private addHandler;
+}

package/out/server/managers/EventManager.luau

@@ -0,0 +1,84 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local getEventHandlerMetas = TS.import(script, script.Parent.Parent.Parent, "events", "decorators", "EventHandler").getEventHandlerMetas
+local EventManager
+do
+	EventManager = setmetatable({}, {
+		__tostring = function()
+			return "EventManager"
+		end,
+	})
+	EventManager.__index = EventManager
+	function EventManager.new(...)
+		local self = setmetatable({}, EventManager)
+		return self:constructor(...) or self
+	end
+	function EventManager:constructor()
+		self.handlers = {}
+	end
+	function EventManager:register(listener)
+		local metas = getEventHandlerMetas(listener)
+		if #metas == 0 then
+			return nil
+		end
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback = function(meta)
+			return self:addHandler(meta.eventClass, {
+				listener = listener,
+				meta = meta,
+			})
+		end
+		for _k, _v in metas do
+			_callback(_v, _k - 1, metas)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+		return nil
+	end
+	function EventManager:dispatch(event)
+		local eventClass = getmetatable(event)
+		local registered = self.handlers[eventClass]
+		if registered == nil then
+			return nil
+		end
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback = function(_param)
+			local listener = _param.listener
+			local meta = _param.meta
+			if meta.priority == 5 and event:isCancelled() then
+				return nil
+			end
+			local method = listener[meta.methodName]
+			if meta.async then
+				task.defer(function()
+					return method(event)
+				end)
+			else
+				method(event)
+			end
+		end
+		for _k, _v in registered do
+			_callback(_v, _k - 1, registered)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+	end
+	function EventManager:addHandler(eventClass, handler)
+		local _handlers = self.handlers
+		local _eventClass = eventClass
+		local _condition = _handlers[_eventClass]
+		if _condition == nil then
+			_condition = {}
+		end
+		local existing = _condition
+		local _handler = handler
+		table.insert(existing, _handler)
+		table.sort(existing, function(a, b)
+			return a.meta.priority < b.meta.priority
+		end)
+		local _handlers_1 = self.handlers
+		local _eventClass_1 = eventClass
+		_handlers_1[_eventClass_1] = existing
+	end
+end
+return {
+	EventManager = EventManager,
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "@snailycfx/nexus",
+    "version": "1.0.1",
+    "description": "",
+    "main": "out/init.lua",
+    "types": "out/index.d.ts",
+    "scripts": {
+        "build": "rbxtsc",
+        "watch": "rbxtsc -w",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "packageManager": "pnpm@10.11.0",
+    "devDependencies": {
+        "@rbxts/compiler-types": "3.0.0-types.0",
+        "@rbxts/types": "^1.0.911",
+        "roblox-ts": "^3.0.0",
+        "typescript": "^5.9.3"
+    },
+    "dependencies": {
+        "@rbxts/services": "^1.6.0",
+        "@snailycfx/nexus-transformer": "^1.0.1",
+        "ts-patch": "^3.3.0"
+    }
+}

package/src/events/core/EventClass.ts

@@ -0,0 +1 @@
+export type EventClass = new (...args: unknown[]) => object;

package/src/events/core/EventHandlerMeta.ts

@@ -0,0 +1,9 @@
+import { EventPriority } from "./EventPriority"
+import { EventClass } from "./EventClass";
+
+export interface EventHandlerMeta {
+    readonly methodName: string;
+    readonly eventClass: EventClass;
+    readonly async: boolean;
+    readonly priority: EventPriority;
+}

package/src/events/core/EventHandlerOptions.ts

@@ -0,0 +1,6 @@
+import { EventPriority } from "./EventPriority"
+
+export interface EventHandlerOptions {
+    readonly async?: boolean;
+    readonly priority?: EventPriority;
+}

package/src/events/core/EventPriority.ts

@@ -0,0 +1,8 @@
+export const enum EventPriority {
+    Lowest  = 0,
+    Low     = 1,
+    Normal  = 2,
+    High    = 3,
+    Highest = 4,
+    Monitor = 5,
+}

package/src/events/core/NexusEvent.ts

@@ -0,0 +1,11 @@
+export abstract class NexusEvent {
+    private cancelled: boolean = false;
+
+    public setCancelled(cancelled: boolean): void {
+        this.cancelled = cancelled;
+    }
+
+    public isCancelled(): boolean {
+        return this.cancelled;
+    }
+}

package/src/events/core/metadata/NexusMetadata.ts

@@ -0,0 +1,16 @@
+import { EventClass } from "../EventClass";
+
+export class NexusMetadata {
+    private static readonly store = new Map<string, EventClass>();
+
+    public static define(key: string, paramTypes: EventClass[], _target: object, methodName: string): void {
+        if (key !== 'paramtypes') return;
+        if (paramTypes.size() === 0) return;
+
+        NexusMetadata.store.set(methodName, paramTypes[0]);
+    }
+
+    public static getEventClass(methodName: string): EventClass | undefined {
+        return NexusMetadata.store.get(methodName);
+    }
+}

package/src/events/decorators/EventHandler.ts

@@ -0,0 +1,30 @@
+import { EventHandlerOptions } from "../../events/core/EventHandlerOptions";
+import { EventHandlerMeta } from "../../events/core/EventHandlerMeta";
+import { EventPriority } from "../../events/core/EventPriority";
+
+import { NexusMetadata } from "../../events/core/metadata/NexusMetadata";
+
+const EVENT_HANDLER_KEY = '__nexus_event_handlers__';
+
+export function EventHandler(options?: EventHandlerOptions) {
+    return (target: object, methodName: string) => {
+        const eventClass = NexusMetadata.getEventClass(methodName);
+        if (eventClass === undefined) return;
+
+        const meta: EventHandlerMeta = {
+            methodName,
+            eventClass,
+            async: options?.async ?? false,
+            priority: options?.priority ?? EventPriority.Normal
+        }
+
+        const existing: EventHandlerMeta[] = (target as Record<string, unknown>)[EVENT_HANDLER_KEY] as EventHandlerMeta[] ?? [];
+        existing.push(meta);
+    
+        (target as Record<string, unknown>)[EVENT_HANDLER_KEY] = existing;
+    }
+}
+
+export function getEventHandlerMetas(target: object): EventHandlerMeta[] {
+    return (target as Record<string, unknown>)[EVENT_HANDLER_KEY] as EventHandlerMeta[] ?? [];
+}

package/src/events/handlers/player/PlayerJoinEvent.ts

@@ -0,0 +1,12 @@
+import { NexusEvent } from "../../core/NexusEvent";
+
+export class PlayerJoinEvent extends NexusEvent {
+    private readonly player: Player;
+
+    public constructor(player: Player) {
+        super();
+        this.player = player;
+    }
+
+    public getPlayer(): Player { return this.player; }
+}

package/src/events/handlers/player/PlayerLeaveEvent.ts

@@ -0,0 +1,12 @@
+import { NexusEvent } from "../../core/NexusEvent";
+
+export class PlayerLeaveEvent extends NexusEvent {
+    private readonly player: Player;
+
+    public constructor(player: Player) {
+        super();
+        this.player = player;
+    }
+
+    public getPlayer(): Player { return this.player; }
+}

package/src/index.server.ts

@@ -0,0 +1,11 @@
+export { Nexus } from './server/Nexus';
+export { NexusEvent } from './events/core/NexusEvent';
+export { NexusMetadata } from './events/core/metadata/NexusMetadata';
+
+export { EventPriority } from './events/core/EventPriority';
+export { EventHandler } from './events/decorators/EventHandler';
+export { EventHandlerMeta } from './events/core/EventHandlerMeta';
+export { EventHandlerOptions } from './events/core/EventHandlerOptions';
+
+export { PlayerJoinEvent } from './events/handlers/player/PlayerJoinEvent';
+export { PlayerLeaveEvent } from './events/handlers/player/PlayerLeaveEvent';

package/src/interfaces/IListener.ts

@@ -0,0 +1 @@
+export default interface IListener {}

package/src/server/Nexus.ts

@@ -0,0 +1,29 @@
+import { RunService } from "@rbxts/services";
+import { EventManager } from "./managers/EventManager";
+
+export abstract class Nexus {
+    private readonly eventManager: EventManager = new EventManager();
+    private static instance: Nexus;
+
+    public constructor() {
+        if (!RunService.IsServer()) {
+            error('Nexus can only be instantiated in server!');
+        }
+
+        if (Nexus.instance !== undefined) {
+            error('Nexus can only be instantiated once!');
+        }
+
+        Nexus.instance = this;
+        game.BindToClose(() => this.onDisable());
+    }
+
+    public static getInstance<T extends Nexus>(): T {
+        return Nexus.instance as T;
+    }
+
+    public getEventManager(): EventManager { return this.eventManager; }
+
+    public onEnable(): void {};
+    public onDisable(): void {};
+}

package/src/server/managers/EventManager.ts

@@ -0,0 +1,48 @@
+import { getEventHandlerMetas } from "../../events/decorators/EventHandler";
+import { EventHandlerMeta, NexusEvent, EventPriority } from "../../index.server";
+
+import { EventClass } from "../../events/core/EventClass";
+import IListener from "../../interfaces/IListener";
+
+interface RegisteredHandler {
+    readonly listener: IListener; // TODO: IListener
+    readonly meta: EventHandlerMeta;
+}
+
+export class EventManager {
+    private readonly handlers = new Map<EventClass, RegisteredHandler[]>();
+
+    public register(listener: IListener): void {
+        const metas = getEventHandlerMetas(listener);
+        if (metas.size() === 0) return;
+
+        return metas.forEach((meta) => this.addHandler(meta.eventClass as EventClass, { listener, meta }));
+    }
+
+    public dispatch<T extends NexusEvent>(event: T): void {
+        const eventClass = getmetatable(event) as unknown as EventClass
+        const registered = this.handlers.get(eventClass)
+        if (registered === undefined) return
+
+        registered.forEach(({ listener, meta }) => {
+            if (meta.priority === EventPriority.Monitor && event.isCancelled()) return
+
+            const method = (listener as Record<string, unknown>)[meta.methodName] as (event: NexusEvent) => void
+
+            if (meta.async) {
+                task.defer(() => method(event))
+            } else {
+                method(event)
+            }
+        })
+    }
+
+    private addHandler(eventClass: EventClass, handler: RegisteredHandler): void {
+        const existing = this.handlers.get(eventClass) ?? [];
+
+        existing.push(handler);
+        existing.sort((a, b) => a.meta.priority < b.meta.priority);
+
+        this.handlers.set(eventClass, existing);
+    }
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+    "compilerOptions": {
+        "allowSyntheticDefaultImports": true,
+        "downlevelIteration": true,
+        "jsx": "react",
+        "jsxFactory": "React.createElement",
+        "jsxFragmentFactory": "React.Fragment",
+        "experimentalDecorators": true,
+        "module": "commonjs",
+        "moduleResolution": "Node",
+        "noLib": true,
+        "resolveJsonModule": true,
+        "strict": true,
+        "target": "ESNext",
+        "stripInternal": true,
+        "typeRoots": ["node_modules/@rbxts"],
+        "moduleDetection": "force",
+        "declaration": true,
+        "rootDir": "src",
+        "outDir": "out",
+        "plugins": [
+            { "transform": "@snailycfx/nexus-transformer" }
+        ]
+    },
+    "include": ["src"]
+}