@rbxts/covenant 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rbxts/covenant",
-    "version": "1.0.8",
+    "version": "1.0.10",
     "main": "src/init.luau",
     "scripts": {
         "build": "rbxtsc",

package/src/covenant.luau

@@ -14,6 +14,7 @@ local Delete = _stringEnums.Delete
 local _helpers = TS.import(script, script.Parent, "helpers")
 local compareMaps = _helpers.compareMaps
 local turnArrayWithIdentifierToMap = _helpers.turnArrayWithIdentifierToMap
+local EventMap = TS.import(script, script.Parent, "dataStructureWithEvents").EventMap
 -- Map<Entity, Delete | Map<Component, state | Remove>>
 -- Map<Component, Map<Entity, state | Remove>>
 local function createWorldWithRange(minClientEntity, maxClientEntity)
@@ -45,7 +46,7 @@ do
 		local predictionSend = _param.predictionSend
 		local predictionConnect = _param.predictionConnect
 		self._world = createWorldWithRange(1000, 20000)
-		self.systems = {}
+		self.systems = EventMap.new()
 		self.worldChangesForReplication = {}
 		self.worldChangesForPrediction = {}
 		self.undefinedStringifiedComponents = {}
@@ -245,41 +246,27 @@ do
 		local _arg1 = `There are {_size} components that are not defined`
 		assert(_exp, _arg1)
 		self.started = true
-		local _exp_1 = self.systems
-		-- ▼ ReadonlyMap.forEach ▼
-		local _callback = function(systemsOfEvent, event)
+		self.systems:forEach(function(systemsOfEvent, event)
 			local _systems = self.systems
-			local _exp_2 = event
+			local _exp_1 = event
 			table.sort(systemsOfEvent, function(a, b)
 				return a.priority < b.priority
 			end)
-			local _systemsOfEvent = systemsOfEvent
-			_systems[_exp_2] = _systemsOfEvent
-			return _systems
-		end
-		for _k, _v in _exp_1 do
-			_callback(_v, _k, _exp_1)
-		end
-		-- ▲ ReadonlyMap.forEach ▲
-		local _exp_2 = self.systems
-		-- ▼ ReadonlyMap.forEach ▼
-		local _callback_1 = function(systemsOfEvent, event)
+			return _systems:set(_exp_1, systemsOfEvent)
+		end)
+		self.systems:forEach(function(systemsOfEvent, event)
 			event:Connect(function()
 				-- ▼ ReadonlyArray.forEach ▼
-				local _callback_2 = function(_param)
+				local _callback = function(_param)
 					local system = _param.system
 					system()
 				end
 				for _k, _v in systemsOfEvent do
-					_callback_2(_v, _k - 1, systemsOfEvent)
+					_callback(_v, _k - 1, systemsOfEvent)
 				end
 				-- ▲ ReadonlyArray.forEach ▲
 			end)
-		end
-		for _k, _v in _exp_2 do
-			_callback_1(_v, _k, _exp_2)
-		end
-		-- ▲ ReadonlyMap.forEach ▲
+		end)
 	end
 	function Covenant:schedule(event, system, priority)
 		if priority == nil then
@@ -287,15 +274,10 @@ do
 		end
 		local _arg0 = not self.started
 		assert(_arg0, "Attempted to schedule system after starting")
-		local _systems = self.systems
-		local _event = event
-		local systemsOfEvent = _systems[_event]
+		local systemsOfEvent = self.systems:get(event)
 		if systemsOfEvent == nil then
 			systemsOfEvent = {}
-			local _systems_1 = self.systems
-			local _event_1 = event
-			local _systemsOfEvent = systemsOfEvent
-			_systems_1[_event_1] = _systemsOfEvent
+			self.systems:set(event, systemsOfEvent)
 		end
 		local _systemsOfEvent = systemsOfEvent
 		local _arg0_1 = {
@@ -442,7 +424,7 @@ do
 	function Covenant:checkComponentDefined(component)
 		local _undefinedStringifiedComponents = self.undefinedStringifiedComponents
 		local _arg0 = tostring(component)
-		local _arg0_1 = _undefinedStringifiedComponents[_arg0] ~= nil
+		local _arg0_1 = not (_undefinedStringifiedComponents[_arg0] ~= nil)
 		local _arg1 = `Component {component} is already defined`
 		assert(_arg0_1, _arg1)
 		local _undefinedStringifiedComponents_1 = self.undefinedStringifiedComponents

package/src/dataStructureWithEvents.d.ts

@@ -0,0 +1,24 @@
+export declare class EventMap<T extends defined> {
+    private stringifiedEventToValue;
+    private stringifiedEventToEvent;
+    constructor();
+    set(key: RBXScriptSignal, value: T): this;
+    delete(key: RBXScriptSignal): boolean;
+    clear(): void;
+    isEmpty(): boolean;
+    forEach(callbackfn: (value: T, key: RBXScriptSignal) => void): void;
+    size(): number;
+    has(key: RBXScriptSignal): boolean;
+    get(key: RBXScriptSignal): T | undefined;
+}
+export declare class EventSet {
+    private stringifiedEventToEvent;
+    constructor();
+    add(value: RBXScriptSignal<Callback>): this;
+    delete(value: RBXScriptSignal<Callback>): boolean;
+    clear(): void;
+    isEmpty(): boolean;
+    forEach(callbackfn: (value: RBXScriptSignal) => void): void;
+    size(): number;
+    has(value: RBXScriptSignal<Callback>): boolean;
+}

package/src/dataStructureWithEvents.luau

@@ -0,0 +1,159 @@
+-- Compiled with roblox-ts v3.0.0
+local EventMap
+do
+	EventMap = setmetatable({}, {
+		__tostring = function()
+			return "EventMap"
+		end,
+	})
+	EventMap.__index = EventMap
+	function EventMap.new(...)
+		local self = setmetatable({}, EventMap)
+		return self:constructor(...) or self
+	end
+	function EventMap:constructor()
+		self.stringifiedEventToValue = {}
+		self.stringifiedEventToEvent = {}
+	end
+	function EventMap:set(key, value)
+		local stringifiedEvent = tostring(key)
+		local _stringifiedEventToValue = self.stringifiedEventToValue
+		local _value = value
+		_stringifiedEventToValue[stringifiedEvent] = _value
+		local _stringifiedEventToEvent = self.stringifiedEventToEvent
+		local _key = key
+		_stringifiedEventToEvent[stringifiedEvent] = _key
+		return self
+	end
+	function EventMap:delete(key)
+		local stringifiedEvent = tostring(key)
+		local _exp = self.stringifiedEventToEvent
+		-- ▼ Map.delete ▼
+		local _valueExisted = _exp[stringifiedEvent] ~= nil
+		_exp[stringifiedEvent] = nil
+		-- ▲ Map.delete ▲
+		local _condition = _valueExisted
+		if _condition then
+			local _exp_1 = self.stringifiedEventToValue
+			-- ▼ Map.delete ▼
+			local _valueExisted_1 = _exp_1[stringifiedEvent] ~= nil
+			_exp_1[stringifiedEvent] = nil
+			-- ▲ Map.delete ▲
+			_condition = _valueExisted_1
+		end
+		return _condition
+	end
+	function EventMap:clear()
+		table.clear(self.stringifiedEventToEvent)
+		table.clear(self.stringifiedEventToValue)
+	end
+	function EventMap:isEmpty()
+		return next(self.stringifiedEventToEvent) == nil and next(self.stringifiedEventToValue) == nil
+	end
+	function EventMap:forEach(callbackfn)
+		local _exp = self.stringifiedEventToValue
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(value, stringifiedEvent)
+			local _fn = callbackfn
+			local _exp_1 = value
+			local _stringifiedEventToEvent = self.stringifiedEventToEvent
+			local _stringifiedEvent = stringifiedEvent
+			_fn(_exp_1, _stringifiedEventToEvent[_stringifiedEvent])
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k, _exp)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+	end
+	function EventMap:size()
+		-- ▼ ReadonlyMap.size ▼
+		local _size = 0
+		for _ in self.stringifiedEventToValue do
+			_size += 1
+		end
+		-- ▲ ReadonlyMap.size ▲
+		-- ▼ ReadonlyMap.size ▼
+		local _size_1 = 0
+		for _ in self.stringifiedEventToValue do
+			_size_1 += 1
+		end
+		-- ▲ ReadonlyMap.size ▲
+		return (_size + _size_1) / 2
+	end
+	function EventMap:has(key)
+		local stringifiedEvent = tostring(key)
+		return self.stringifiedEventToEvent[stringifiedEvent] ~= nil and self.stringifiedEventToValue[stringifiedEvent] ~= nil
+	end
+	function EventMap:get(key)
+		local stringifiedEvent = tostring(key)
+		return self.stringifiedEventToValue[stringifiedEvent]
+	end
+end
+local EventSet
+do
+	EventSet = setmetatable({}, {
+		__tostring = function()
+			return "EventSet"
+		end,
+	})
+	EventSet.__index = EventSet
+	function EventSet.new(...)
+		local self = setmetatable({}, EventSet)
+		return self:constructor(...) or self
+	end
+	function EventSet:constructor()
+		self.stringifiedEventToEvent = {}
+	end
+	function EventSet:add(value)
+		local stringifiedEvent = tostring(value)
+		if not (self.stringifiedEventToEvent[stringifiedEvent] ~= nil) then
+			local _stringifiedEventToEvent = self.stringifiedEventToEvent
+			local _value = value
+			_stringifiedEventToEvent[stringifiedEvent] = _value
+		end
+		return self
+	end
+	function EventSet:delete(value)
+		local stringifiedEvent = tostring(value)
+		local _exp = self.stringifiedEventToEvent
+		-- ▼ Map.delete ▼
+		local _valueExisted = _exp[stringifiedEvent] ~= nil
+		_exp[stringifiedEvent] = nil
+		-- ▲ Map.delete ▲
+		return _valueExisted
+	end
+	function EventSet:clear()
+		table.clear(self.stringifiedEventToEvent)
+	end
+	function EventSet:isEmpty()
+		return next(self.stringifiedEventToEvent) == nil
+	end
+	function EventSet:forEach(callbackfn)
+		local _exp = self.stringifiedEventToEvent
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(event)
+			callbackfn(event)
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k, _exp)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+	end
+	function EventSet:size()
+		-- ▼ ReadonlyMap.size ▼
+		local _size = 0
+		for _ in self.stringifiedEventToEvent do
+			_size += 1
+		end
+		-- ▲ ReadonlyMap.size ▲
+		return _size
+	end
+	function EventSet:has(value)
+		local stringifiedEvent = tostring(value)
+		return self.stringifiedEventToEvent[stringifiedEvent] ~= nil
+	end
+end
+return {
+	EventMap = EventMap,
+	EventSet = EventSet,
+}

package/src/hooks.luau

@@ -1,91 +1,77 @@
 -- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _dataStructureWithEvents = TS.import(script, script.Parent, "dataStructureWithEvents")
+local EventMap = _dataStructureWithEvents.EventMap
+local EventSet = _dataStructureWithEvents.EventSet
 local function createUseEvent(_param)
 	local indicateUpdate = _param.indicateUpdate
-	local queues = {}
-	local watchedEvents = {}
-	local caches = {}
+	local queues = EventMap.new()
+	local watchedEvents = EventSet.new()
+	local caches = EventMap.new()
 	local lastUpdateId = -1
 	return function(updateId, event)
 		if lastUpdateId ~= updateId then
-			table.clear(caches)
+			caches:clear()
 			lastUpdateId = updateId
 		end
-		local _event = event
-		local cache = caches[_event]
+		local cache = caches:get(event)
 		if cache ~= nil then
 			return cache
 		end
-		local _event_1 = event
-		if not (watchedEvents[_event_1] ~= nil) then
-			local _event_2 = event
-			watchedEvents[_event_2] = true
-			local _event_3 = event
-			queues[_event_3] = {}
+		if not watchedEvents:has(event) then
+			watchedEvents:add(event)
+			queues:set(event, {})
 			event:Connect(function(...)
 				local args = { ... }
-				local _event_4 = event
-				local _exp = queues[_event_4]
+				local _exp = queues:get(event)
 				local _args = args
 				table.insert(_exp, _args)
 				indicateUpdate()
 			end)
-			local _event_4 = event
-			caches[_event_4] = {}
+			caches:set(event, {})
 			return {}
 		end
-		local _event_2 = event
-		local queue = queues[_event_2]
+		local queue = queues:get(event)
 		if not (#queue == 0) then
-			local _event_3 = event
-			queues[_event_3] = {}
+			queues:set(event, {})
 		end
-		local _event_3 = event
-		caches[_event_3] = queue
+		caches:set(event, queue)
 		return queue
 	end
 end
 local function createUseEventImmediately(_param)
 	local indicateUpdate = _param.indicateUpdate
-	local queues = {}
-	local watchedEvents = {}
-	local caches = {}
+	local queues = EventMap.new()
+	local watchedEvents = EventSet.new()
+	local caches = EventMap.new()
 	local lastUpdateId = -1
 	return function(updateId, event, callback)
 		if lastUpdateId ~= updateId then
-			table.clear(caches)
+			caches:clear()
 			lastUpdateId = updateId
 		end
-		local _event = event
-		local cache = caches[_event]
+		local cache = caches:get(event)
 		if cache ~= nil then
 			return cache
 		end
-		local _event_1 = event
-		if not (watchedEvents[_event_1] ~= nil) then
-			local _event_2 = event
-			watchedEvents[_event_2] = true
-			local _event_3 = event
-			queues[_event_3] = {}
+		if not watchedEvents:has(event) then
+			watchedEvents:add(event)
+			queues:set(event, {})
 			event:Connect(function(...)
 				local args = { ... }
-				local _event_4 = event
-				local _exp = queues[_event_4]
+				local _exp = queues:get(event)
 				local _arg0 = callback(unpack(args))
 				table.insert(_exp, _arg0)
 				indicateUpdate()
 			end)
-			local _event_4 = event
-			caches[_event_4] = {}
+			caches:set(event, {})
 			return {}
 		end
-		local _event_2 = event
-		local queue = queues[_event_2]
+		local queue = queues:get(event)
 		if not (#queue == 0) then
-			local _event_3 = event
-			queues[_event_3] = {}
+			queues:set(event, {})
 		end
-		local _event_3 = event
-		caches[_event_3] = queue
+		caches:set(event, queue)
 		return queue
 	end
 end
@@ -197,7 +183,6 @@ local function createUseAsync(_param)
 			caches[_discriminator_3] = _result
 			return state.result
 		else
-			coroutine.yield(state.thread)
 			coroutine.close(state.thread)
 			local newResult = {
 				completed = false,
@@ -346,7 +331,7 @@ local function createUseInterval(_param)
 		if nextClock < os.clock() then
 			local _discriminator_3 = discriminator
 			caches[_discriminator_3] = false
-			return false
+			return true
 		else
 			local _discriminator_3 = discriminator
 			local _arg1 = os.clock() + seconds
@@ -354,7 +339,7 @@ local function createUseInterval(_param)
 			task.delay(seconds, indicateUpdate)
 			local _discriminator_4 = discriminator
 			caches[_discriminator_4] = true
-			return true
+			return false
 		end
 	end
 end