@rbxts/covenant 1.1.0 → 1.2.0

package/package.json

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

package/src/dataStructureWithEvents.d.ts

@@ -11,6 +11,20 @@ export declare class EventMap<T extends defined> {
     has(key: RBXScriptSignal): boolean;
     get(key: RBXScriptSignal): T | undefined;
 }
+export declare class EventMapWithInstance<T extends defined> {
+    private instanceEventMaps;
+    constructor();
+    set(instance: Instance, key: RBXScriptSignal, value: T): this;
+    delete(instance: Instance, key: RBXScriptSignal): boolean;
+    clear(): void;
+    deletedInstance(instance: Instance): boolean;
+    isEmpty(): boolean;
+    isInstanceEmpty(instance: Instance): boolean;
+    forEach(callbackfn: (value: T, key: RBXScriptSignal) => void): void;
+    size(): number;
+    has(instance: Instance, key: RBXScriptSignal): boolean;
+    get(instance: Instance, key: RBXScriptSignal): T | undefined;
+}
 export declare class EventSet {
     private stringifiedEventToEvent;
     constructor();
@@ -22,3 +36,16 @@ export declare class EventSet {
     size(): number;
     has(value: RBXScriptSignal<Callback>): boolean;
 }
+export declare class EventSetWithInstance {
+    private instanceEventSets;
+    constructor();
+    add(instance: Instance, value: RBXScriptSignal<Callback>): this;
+    delete(instance: Instance, value: RBXScriptSignal<Callback>): boolean;
+    deleteInstance(instance: Instance): boolean;
+    clear(): void;
+    isEmpty(): boolean;
+    isInstanceEmpty(instance: Instance): boolean;
+    forEach(callbackfn: (value: RBXScriptSignal) => void): void;
+    size(): number;
+    has(instance: Instance, value: RBXScriptSignal<Callback>): boolean;
+}

package/src/dataStructureWithEvents.luau

@@ -89,6 +89,113 @@ do
 		return self.stringifiedEventToValue[stringifiedEvent]
 	end
 end
+local EventMapWithInstance
+do
+	EventMapWithInstance = setmetatable({}, {
+		__tostring = function()
+			return "EventMapWithInstance"
+		end,
+	})
+	EventMapWithInstance.__index = EventMapWithInstance
+	function EventMapWithInstance.new(...)
+		local self = setmetatable({}, EventMapWithInstance)
+		return self:constructor(...) or self
+	end
+	function EventMapWithInstance:constructor()
+		self.instanceEventMaps = {}
+	end
+	function EventMapWithInstance:set(instance, key, value)
+		local _instanceEventMaps = self.instanceEventMaps
+		local _instance = instance
+		local eventMap = _instanceEventMaps[_instance]
+		if eventMap == nil then
+			eventMap = EventMap.new()
+			local _instanceEventMaps_1 = self.instanceEventMaps
+			local _instance_1 = instance
+			local _eventMap = eventMap
+			_instanceEventMaps_1[_instance_1] = _eventMap
+		end
+		eventMap:set(key, value)
+		return self
+	end
+	function EventMapWithInstance:delete(instance, key)
+		local _instanceEventMaps = self.instanceEventMaps
+		local _instance = instance
+		local eventMap = _instanceEventMaps[_instance]
+		if eventMap == nil then
+			return false
+		end
+		return eventMap:delete(key)
+	end
+	function EventMapWithInstance:clear()
+		table.clear(self.instanceEventMaps)
+	end
+	function EventMapWithInstance:deletedInstance(instance)
+		local _instanceEventMaps = self.instanceEventMaps
+		local _instance = instance
+		-- ▼ Map.delete ▼
+		local _valueExisted = _instanceEventMaps[_instance] ~= nil
+		_instanceEventMaps[_instance] = nil
+		-- ▲ Map.delete ▲
+		return _valueExisted
+	end
+	function EventMapWithInstance:isEmpty()
+		return next(self.instanceEventMaps) == nil
+	end
+	function EventMapWithInstance:isInstanceEmpty(instance)
+		local _instanceEventMaps = self.instanceEventMaps
+		local _instance = instance
+		local eventMap = _instanceEventMaps[_instance]
+		if eventMap == nil then
+			return true
+		end
+		return eventMap:isEmpty()
+	end
+	function EventMapWithInstance:forEach(callbackfn)
+		local _exp = self.instanceEventMaps
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(eventMap)
+			eventMap:forEach(function(value, event)
+				callbackfn(value, event)
+			end)
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k, _exp)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+	end
+	function EventMapWithInstance:size()
+		local size = 0
+		local _exp = self.instanceEventMaps
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(eventMap)
+			size += eventMap:size()
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k, _exp)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		return size
+	end
+	function EventMapWithInstance:has(instance, key)
+		local _instanceEventMaps = self.instanceEventMaps
+		local _instance = instance
+		local eventMap = _instanceEventMaps[_instance]
+		if eventMap == nil then
+			return false
+		end
+		return eventMap:has(key)
+	end
+	function EventMapWithInstance:get(instance, key)
+		local _instanceEventMaps = self.instanceEventMaps
+		local _instance = instance
+		local eventMap = _instanceEventMaps[_instance]
+		if eventMap == nil then
+			return nil
+		end
+		return eventMap:get(key)
+	end
+end
 local EventSet
 do
 	EventSet = setmetatable({}, {
@@ -153,7 +260,107 @@ do
 		return self.stringifiedEventToEvent[stringifiedEvent] ~= nil
 	end
 end
+local EventSetWithInstance
+do
+	EventSetWithInstance = setmetatable({}, {
+		__tostring = function()
+			return "EventSetWithInstance"
+		end,
+	})
+	EventSetWithInstance.__index = EventSetWithInstance
+	function EventSetWithInstance.new(...)
+		local self = setmetatable({}, EventSetWithInstance)
+		return self:constructor(...) or self
+	end
+	function EventSetWithInstance:constructor()
+		self.instanceEventSets = {}
+	end
+	function EventSetWithInstance:add(instance, value)
+		local _instanceEventSets = self.instanceEventSets
+		local _instance = instance
+		local eventSet = _instanceEventSets[_instance]
+		if eventSet == nil then
+			eventSet = EventSet.new()
+			local _instanceEventSets_1 = self.instanceEventSets
+			local _instance_1 = instance
+			local _eventSet = eventSet
+			_instanceEventSets_1[_instance_1] = _eventSet
+		end
+		eventSet:add(value)
+		return self
+	end
+	function EventSetWithInstance:delete(instance, value)
+		local _instanceEventSets = self.instanceEventSets
+		local _instance = instance
+		local eventSet = _instanceEventSets[_instance]
+		if eventSet == nil then
+			return false
+		end
+		return eventSet:delete(value)
+	end
+	function EventSetWithInstance:deleteInstance(instance)
+		local _instanceEventSets = self.instanceEventSets
+		local _instance = instance
+		-- ▼ Map.delete ▼
+		local _valueExisted = _instanceEventSets[_instance] ~= nil
+		_instanceEventSets[_instance] = nil
+		-- ▲ Map.delete ▲
+		return _valueExisted
+	end
+	function EventSetWithInstance:clear()
+		table.clear(self.instanceEventSets)
+	end
+	function EventSetWithInstance:isEmpty()
+		return next(self.instanceEventSets) == nil
+	end
+	function EventSetWithInstance:isInstanceEmpty(instance)
+		local _instanceEventSets = self.instanceEventSets
+		local _instance = instance
+		local eventSet = _instanceEventSets[_instance]
+		if eventSet == nil then
+			return true
+		end
+		return eventSet:isEmpty()
+	end
+	function EventSetWithInstance:forEach(callbackfn)
+		local _exp = self.instanceEventSets
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(eventSet)
+			eventSet:forEach(function(event)
+				callbackfn(event)
+			end)
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k, _exp)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+	end
+	function EventSetWithInstance:size()
+		local size = 0
+		local _exp = self.instanceEventSets
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(eventSet)
+			size += eventSet:size()
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k, _exp)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		return size
+	end
+	function EventSetWithInstance:has(instance, value)
+		local _instanceEventSets = self.instanceEventSets
+		local _instance = instance
+		local eventSet = _instanceEventSets[_instance]
+		if eventSet == nil then
+			return false
+		end
+		return eventSet:has(value)
+	end
+end
 return {
 	EventMap = EventMap,
+	EventMapWithInstance = EventMapWithInstance,
 	EventSet = EventSet,
+	EventSetWithInstance = EventSetWithInstance,
 }

package/src/hooks.d.ts

@@ -6,8 +6,8 @@ type AsyncResult<T = unknown> = {
 };
 export type Discriminator = Exclude<defined, number>;
 export interface CovenantHooks {
-    useEvent: <T extends Array<unknown>>(updateId: number, event: RBXScriptSignal<(...args: T) => void>) => T[];
-    useEventImmediately: <T extends Array<unknown>, TReturn extends defined>(updateId: number, event: RBXScriptSignal<(...args: T) => void>, callback: (...args: T) => TReturn) => TReturn[];
+    useEvent: <T extends Array<unknown>>(updateId: number, instance: Instance, event: RBXScriptSignal<(...args: T) => void>) => T[];
+    useEventImmediately: <T extends Array<unknown>, TReturn extends defined>(updateId: number, instance: Instance, event: RBXScriptSignal<(...args: T) => void>, callback: (...args: T) => TReturn) => TReturn[];
     useComponentChange: <T extends defined>(updateId: number, component: Entity<T>) => {
         entity: Entity;
         state: T | undefined;

package/src/hooks.luau

@@ -1,78 +1,78 @@
 -- 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 EventMapWithInstance = _dataStructureWithEvents.EventMapWithInstance
+local EventSetWithInstance = _dataStructureWithEvents.EventSetWithInstance
 -- TODO: make events available for dynamic instances
 local function createUseEvent(_param)
 	local indicateUpdate = _param.indicateUpdate
-	local queues = EventMap.new()
-	local watchedEvents = EventSet.new()
-	local caches = EventMap.new()
+	local queues = EventMapWithInstance.new()
+	local watchedEvents = EventSetWithInstance.new()
+	local caches = EventMapWithInstance.new()
 	local lastUpdateId = -1
-	return function(updateId, event)
+	return function(updateId, instance, event)
 		if lastUpdateId ~= updateId then
 			caches:clear()
 			lastUpdateId = updateId
 		end
-		local cache = caches:get(event)
+		local cache = caches:get(instance, event)
 		if cache ~= nil then
 			return cache
 		end
-		if not watchedEvents:has(event) then
-			watchedEvents:add(event)
-			queues:set(event, {})
+		if not watchedEvents:has(instance, event) then
+			watchedEvents:add(instance, event)
+			queues:set(instance, event, {})
 			event:Connect(function(...)
 				local args = { ... }
-				local _exp = queues:get(event)
+				local _exp = queues:get(instance, event)
 				local _args = args
 				table.insert(_exp, _args)
 				indicateUpdate()
 			end)
-			caches:set(event, {})
+			caches:set(instance, event, {})
 			return {}
 		end
-		local queue = queues:get(event)
+		local queue = queues:get(instance, event)
 		if not (#queue == 0) then
-			queues:set(event, {})
+			queues:set(instance, event, {})
 		end
-		caches:set(event, queue)
+		caches:set(instance, event, queue)
 		return queue
 	end
 end
 local function createUseEventImmediately(_param)
 	local indicateUpdate = _param.indicateUpdate
-	local queues = EventMap.new()
-	local watchedEvents = EventSet.new()
-	local caches = EventMap.new()
+	local queues = EventMapWithInstance.new()
+	local watchedEvents = EventSetWithInstance.new()
+	local caches = EventMapWithInstance.new()
 	local lastUpdateId = -1
-	return function(updateId, event, callback)
+	return function(updateId, instance, event, callback)
 		if lastUpdateId ~= updateId then
 			caches:clear()
 			lastUpdateId = updateId
 		end
-		local cache = caches:get(event)
+		local cache = caches:get(instance, event)
 		if cache ~= nil then
 			return cache
 		end
-		if not watchedEvents:has(event) then
-			watchedEvents:add(event)
-			queues:set(event, {})
+		if not watchedEvents:has(instance, event) then
+			watchedEvents:add(instance, event)
+			queues:set(instance, event, {})
 			event:Connect(function(...)
 				local args = { ... }
-				local _exp = queues:get(event)
+				local _exp = queues:get(instance, event)
 				local _arg0 = callback(unpack(args))
 				table.insert(_exp, _arg0)
 				indicateUpdate()
 			end)
-			caches:set(event, {})
+			caches:set(instance, event, {})
 			return {}
 		end
-		local queue = queues:get(event)
+		local queue = queues:get(instance, event)
 		if not (#queue == 0) then
-			queues:set(event, {})
+			queues:set(instance, event, {})
 		end
-		caches:set(event, queue)
+		caches:set(instance, event, queue)
 		return queue
 	end
 end