@rbxts/planck 0.2.5 → 0.3.0-alpha.2

package/{out → src}/hooks.luau

@@ -1,145 +1,163 @@
--- Super-duper experimental Plugin Hooks API
-
-local function systemAdd(scheduler, systemInfo)
-	local hooks = scheduler._hooks[scheduler.Hooks.SystemAdd]
-	local info = {
-		scheduler = scheduler,
-		system = systemInfo,
-	}
-
-	for _, hook in hooks do
-		local success, err = pcall(hook, info)
-		if not success then
-			warn("Unexpected error in hook:", err)
-		end
-	end
-end
-
-local function systemRemove(scheduler, systemInfo)
-	local hooks = scheduler._hooks[scheduler.Hooks.SystemRemove]
-	local info = {
-		scheduler = scheduler,
-		system = systemInfo,
-	}
-
-	for _, hook in hooks do
-		local success, err = pcall(hook, info)
-		if not success then
-			warn("Unexpected error in hook:", err)
-		end
-	end
-end
-
-local function systemReplace(scheduler, oldSystemInfo, newSystemInfo)
-	local hooks = scheduler._hooks[scheduler.Hooks.SystemReplace]
-	local info = {
-		scheduler = scheduler,
-		new = newSystemInfo,
-		old = oldSystemInfo,
-	}
-
-	for _, hook in hooks do
-		local success, err = pcall(hook, info)
-		if not success then
-			warn("Unexpected error in hook:", err)
-		end
-	end
-end
-
-local function systemCall(scheduler, hookName, systemInfo, nextFn)
-	local hooks = scheduler._hooks[scheduler.Hooks[hookName] ]
-
-	if hooks then
-		for _, hook in hooks do
-			nextFn = hook({
-				scheduler = nil,
-				system = systemInfo,
-				nextFn = nextFn,
-			})
-
-			if not nextFn then
-				local source, line = debug.info(hook, "sl")
-				warn(
-					`{source}:{line}: Expected 'SystemCall' hook to return a function`
-				)
-			end
-		end
-	end
-
-	nextFn()
-end
-
-local function systemError(scheduler, systemInfo, err)
-	local hooks = scheduler._hooks[scheduler.Hooks["SystemError"] ]
-
-	if hooks then
-		for _, hook in hooks do
-			hook({
-				scheduler = scheduler,
-				system = systemInfo,
-				error = err,
-			})
-		end
-	end
-end
-
-type PhaseAdd = {
-	scheduler: any,
-	phase: any
-}
-
-local function phaseAdd(scheduler, phase)
-	local hooks = scheduler._hooks[scheduler.Hooks.PhaseAdd]
-	local info = {
-		scheduler = scheduler,
-		phase = phase,
-	}
-
-	for _, hook in hooks do
-		local success, err = pcall(hook, info)
-		if not success then
-			warn("Unexpected error in hook:", err)
-		end
-	end
-end
-
-local function phaseBegan(scheduler, phase)
-	local hooks = scheduler._hooks[scheduler.Hooks.PhaseBegan]
-	local info = {
-		scheduler = scheduler,
-		phase = phase,
-	}
-
-	for _, hook in hooks do
-		local success, err = pcall(hook, info)
-		if not success then
-			warn("Unexpected error in hook:", err)
-		end
-	end
-end
-
-local Hooks = {
-	SystemAdd = "SystemAdd",
-	SystemRemove = "SystemRemove",
-	SystemReplace = "SystemReplace",
-	SystemError = "SystemError",
-
-	OuterSystemCall = "OuterSystemCall",
-	InnerSystemCall = "InnerSystemCall",
-	SystemCall = "SystemCall",
-
-	PhaseAdd = "PhaseAdd",
-	PhaseBegan = "PhaseBegan",
-}
-
-return {
-	Hooks = Hooks,
-
-	systemAdd = systemAdd,
-	systemRemove = systemRemove,
-	systemReplace = systemReplace,
-	systemCall = systemCall,
-	systemError = systemError,
-	phaseAdd = phaseAdd,
-	phaseBegan = phaseBegan,
-}
+-- Super-duper experimental Plugin Hooks API
+
+local function systemAdd(scheduler, systemInfo)
+	local hooks = scheduler._hooks[scheduler.Hooks.SystemAdd]
+	local info = {
+		scheduler = scheduler,
+		system = systemInfo,
+	}
+
+	for _, hook in hooks do
+		local success, err = pcall(hook, info)
+		if not success then
+			warn("Unexpected error in hook:", err)
+		end
+	end
+end
+
+local function systemRemove(scheduler, systemInfo)
+	local hooks = scheduler._hooks[scheduler.Hooks.SystemRemove]
+	local info = {
+		scheduler = scheduler,
+		system = systemInfo,
+	}
+
+	for _, hook in hooks do
+		local success, err = pcall(hook, info)
+		if not success then
+			warn("Unexpected error in hook:", err)
+		end
+	end
+end
+
+local function systemCleanup(scheduler, systemInfo, cleanupError)
+	local hooks = scheduler._hooks[scheduler.Hooks.SystemCleanup]
+	local info = {
+		scheduler = scheduler,
+		system = systemInfo,
+		error = cleanupError,
+	}
+
+	for _, hook in hooks do
+		local success, err = pcall(hook, info)
+		if not success then
+			warn("Unexpected error in hook:", err)
+		end
+	end
+end
+
+local function systemReplace(scheduler, oldSystemInfo, newSystemInfo)
+	local hooks = scheduler._hooks[scheduler.Hooks.SystemReplace]
+	local info = {
+		scheduler = scheduler,
+		new = newSystemInfo,
+		old = oldSystemInfo,
+	}
+
+	for _, hook in hooks do
+		local success, err = pcall(hook, info)
+		if not success then
+			warn("Unexpected error in hook:", err)
+		end
+	end
+end
+
+local function systemCall(scheduler, hookName, systemInfo, nextFn)
+	local hooks = scheduler._hooks[scheduler.Hooks[hookName]]
+
+	if hooks then
+		for _, hook in hooks do
+			nextFn = hook({
+				scheduler = nil,
+				system = systemInfo,
+				nextFn = nextFn,
+			})
+
+			if not nextFn then
+				local source, line = debug.info(hook, "sl")
+				warn(
+					`{source}:{line}: Expected 'SystemCall' hook to return a function`
+				)
+			end
+		end
+	end
+
+	nextFn()
+end
+
+local function systemError(scheduler, systemInfo, err)
+	local hooks = scheduler._hooks[scheduler.Hooks["SystemError"]]
+
+	if hooks then
+		for _, hook in hooks do
+			hook({
+				scheduler = scheduler,
+				system = systemInfo,
+				error = err,
+			})
+		end
+	end
+end
+
+type PhaseAdd = {
+	scheduler: any,
+	phase: any,
+}
+
+local function phaseAdd(scheduler, phase)
+	local hooks = scheduler._hooks[scheduler.Hooks.PhaseAdd]
+	local info = {
+		scheduler = scheduler,
+		phase = phase,
+	}
+
+	for _, hook in hooks do
+		local success, err = pcall(hook, info)
+		if not success then
+			warn("Unexpected error in hook:", err)
+		end
+	end
+end
+
+local function phaseBegan(scheduler, phase)
+	local hooks = scheduler._hooks[scheduler.Hooks.PhaseBegan]
+	local info = {
+		scheduler = scheduler,
+		phase = phase,
+	}
+
+	for _, hook in hooks do
+		local success, err = pcall(hook, info)
+		if not success then
+			warn("Unexpected error in hook:", err)
+		end
+	end
+end
+
+local Hooks = {
+	SystemAdd = "SystemAdd",
+	SystemRemove = "SystemRemove",
+	SystemReplace = "SystemReplace",
+	SystemCleanup = "SystemCleanup",
+	SystemError = "SystemError",
+
+	OuterSystemCall = "OuterSystemCall",
+	InnerSystemCall = "InnerSystemCall",
+	SystemCall = "SystemCall",
+
+	PhaseAdd = "PhaseAdd",
+	PhaseBegan = "PhaseBegan",
+}
+
+return {
+	Hooks = Hooks,
+
+	systemAdd = systemAdd,
+	systemRemove = systemRemove,
+	systemReplace = systemReplace,
+	systemCleanup = systemCleanup,
+	systemCall = systemCall,
+	systemError = systemError,
+	phaseAdd = phaseAdd,
+	phaseBegan = phaseBegan,
+}

package/src/index.d.ts

@@ -0,0 +1,12 @@
+import { Scheduler } from "./Scheduler";
+
+export * from "./conditions";
+export * from "./Phase";
+export * from "./Pipeline";
+export * from "./Scheduler";
+
+export interface Plugin<T extends unknown[]> {
+  build(scheduler: Scheduler<T>): void;
+  cleanup?(): void;
+  [key: string | number | symbol]: any;
+}

package/src/init.luau

@@ -0,0 +1,207 @@
+local Phase = require(script.Phase) :: any
+local Pipeline = require(script.Pipeline) :: any
+local Scheduler = require(script.Scheduler) :: any
+
+local conditions = require(script.conditions)
+local utils = require(script.utils)
+
+type GenericTable = utils.GenericTable
+type SignalLike<U...> = utils.SignalLike<U...>
+type ConnectionLike = utils.ConnectionLike
+type ConnectFn<T, U...> = utils.ConnectFn<T, U...>
+type Callback<U...> = utils.Callback<U...>
+
+export type CleanupFn<U...> = (U...) -> ()
+
+export type SystemFn<U...> = (U...) -> ()
+
+export type InitializerResult<U...> = {
+	system: SystemFn<U...>?,
+	cleanup: CleanupFn<U...>?,
+}
+
+export type InitializerSystemFn<U...> =
+	| ((U...) -> SystemFn<U...>)
+	| ((U...) -> (SystemFn<U...>, CleanupFn<U...>))
+	| ((U...) -> InitializerResult<U...>)
+
+export type SystemTable<U...> = {
+	system: SystemFn<U...> | InitializerSystemFn<U...>,
+	phase: Phase?,
+	name: string?,
+	runConditions: { (U...) -> boolean }?,
+	[any]: any,
+}
+
+export type System<U...> =
+	SystemFn<U...>
+	| InitializerSystemFn<U...>
+	| SystemTable<U...>
+
+export type Phase = {
+	PreStartup: Phase,
+	Startup: Phase,
+	PostStartup: Phase,
+
+	new: (debugName: string?) -> Phase,
+}
+
+export type Pipeline = {
+	Startup: Pipeline,
+
+	insert: (self: Pipeline, phase: Phase) -> Pipeline,
+	insertAfter: (self: Pipeline, phase: Phase, after: Phase) -> Pipeline,
+	insertBefore: (self: Pipeline, phase: Phase, before: Phase) -> Pipeline,
+	new: (debugName: string?) -> Pipeline,
+}
+
+type Plugin<U...> =
+	{
+		build: (self: Plugin<U...>, scheduler: Scheduler<U...>) -> (),
+		[any]: any,
+	}
+	| {
+		build: (self: Plugin<U...>, scheduler: Scheduler<U...>) -> (),
+		cleanup: (self: Plugin<U...>) -> (),
+		[any]: any,
+	}
+
+export type Scheduler<U...> = {
+	addPlugin: (self: Scheduler<U...>, plugin: Plugin<U...>) -> Scheduler<U...>,
+
+	addSystem: (
+		self: Scheduler<U...>,
+		system: System<U...>,
+		phase: Phase?
+	) -> Scheduler<U...>,
+
+	addSystems: (
+		self: Scheduler<U...>,
+		systems: { System<U...> },
+		phase: Phase?
+	) -> Scheduler<U...>,
+
+	editSystem: (
+		self: Scheduler<U...>,
+		system: System<U...>,
+		new: Phase
+	) -> Scheduler<U...>,
+
+	replaceSystem: (
+		self: Scheduler<U...>,
+		system: System<U...>,
+		new: System<U...>
+	) -> Scheduler<U...>,
+
+	removeSystem: (
+		self: Scheduler<U...>,
+		system: System<U...>
+	) -> Scheduler<U...>,
+
+	addRunCondition: ((
+		self: Scheduler<U...>,
+		system: System<U...>,
+		fn: (U...) -> boolean,
+		...any
+	) -> Scheduler<U...>) & ((
+		self: Scheduler<U...>,
+		phase: Phase,
+		fn: (U...) -> boolean,
+		...any
+	) -> Scheduler<U...>) & ((
+		self: Scheduler<U...>,
+		pipeline: Pipeline,
+		fn: (U...) -> boolean,
+		...any
+	) -> Scheduler<U...>),
+
+	run: ((self: Scheduler<U...>, system: System<U...>) -> Scheduler<U...>)
+		& ((self: Scheduler<U...>, phase: Phase) -> Scheduler<U...>)
+		& ((self: Scheduler<U...>, pipeline: Pipeline) -> Scheduler<U...>),
+
+	runAll: (self: Scheduler<U...>) -> Scheduler<U...>,
+
+	getDeltaTime: (self: Scheduler<U...>) -> number,
+
+	insert: ((
+		self: Scheduler<U...>,
+		dependency: Phase | Pipeline
+	) -> Scheduler<U...>)
+		-- RBXScriptSignal & nil
+		& ((
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			signal: RBXScriptSignal<U...>
+		) -> Scheduler<U...>)
+		-- Instance & RBXScriptSignal
+		-- Instance & string
+		& ((
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			instance: Instance,
+			event: RBXScriptSignal<U...> | string
+		) -> Scheduler<U...>)
+		-- SignalLike & nil
+		& ((
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			signal: SignalLike<U...>
+		) -> Scheduler<U...>)
+		-- table & string
+		& ((
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			table: GenericTable,
+			event: string
+		) -> Scheduler<U...>)
+		-- table & connectable method
+		& (<T>(
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			instance: GenericTable,
+			connectMethod: (GenericTable, Callback<U...>, ...any) -> T
+		) -> Scheduler<U...>)
+		-- connectable function
+		& (<T>(
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			connectFn: (Callback<U...>, ...any) -> T
+		) -> Scheduler<U...>),
+
+	insertAfter: ((
+		self: Scheduler<U...>,
+		phase: Phase,
+		after: Phase | Pipeline
+	) -> Scheduler<U...>) & ((
+		self: Scheduler<U...>,
+		pipeline: Pipeline,
+		after: Phase | Pipeline
+	) -> Scheduler<U...>),
+
+	insertBefore: ((
+		self: Scheduler<U...>,
+		phase: Phase,
+		before: Phase | Pipeline
+	) -> Scheduler<U...>) & ((
+		self: Scheduler<U...>,
+		pipeline: Pipeline,
+		before: Phase | Pipeline
+	) -> Scheduler<U...>),
+
+	cleanup: (self: Scheduler<U...>) -> (),
+
+	new: (U...) -> Scheduler<U...>,
+}
+
+return {
+	Phase = Phase :: Phase,
+	Pipeline = Pipeline :: Pipeline,
+	Scheduler = Scheduler :: {
+		new: <U...>(U...) -> Scheduler<U...>,
+	},
+
+	isNot = conditions.isNot,
+	runOnce = conditions.runOnce,
+	timePassed = conditions.timePassed,
+	onEvent = conditions.onEvent,
+}

package/src/utils.d.ts

@@ -0,0 +1,10 @@
+export type EventLike<T extends unknown[] = unknown[]> =
+  | RBXScriptSignal<(...args: T) => void>
+  | { connect(listener: (...args: T) => void): unknown }
+  | { Connect(listener: (...args: T) => void): unknown }
+  | { on(listener: (...args: T) => void): unknown };
+export type EventInstance = Instance | { [k: string]: EventLike };
+
+export type ExtractEvents<T extends EventInstance> = {
+  [K in keyof T]: T[K] extends EventLike ? K : never;
+}[keyof T];