@rbxts/covenant 1.1.0 → 1.3.0

package/package.json

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

package/src/covenant.d.ts

@@ -42,6 +42,7 @@ export declare class Covenant {
     subscribeComponent<T>(component: Entity<T>, subscriber: (entity: Entity, state: T | undefined, previousState: T | undefined) => void): () => void;
     private worldDelete;
     worldComponent<T extends defined>(): Entity<T>;
+    worldTag(): Entity<undefined>;
     private worldInternalComponent;
     private checkComponentDefined;
     private defineComponentNetworkBehavior;
@@ -60,13 +61,10 @@ export declare class Covenant {
         queriedComponents: Entity[][];
         recipe: (entity: Entity, lastChildrenStates: ReadonlyArray<T>, updateId: number, hooks: CovenantHooks) => ReadonlyArray<T>;
     }): void;
-    defineEntitySource<T extends defined>({ identityComponent, recipe, replicated, }: {
+    defineStaticEntity<T extends defined>({ identityComponent, recipe, replicated, }: {
         replicated: boolean;
         identityComponent: Entity<T>;
-        recipe: (updateId: number, hooks: CovenantHooks) => {
-            statesToCreate?: ReadonlyArray<T>;
-            entitiesToDelete?: ReadonlyArray<Entity>;
-        };
+        recipe: (updateId: number, hooks: CovenantHooks) => T[];
     }): void;
     private worldEntity;
     worldQuery<T extends Id[]>(...components: T): import("@rbxts/jecs").Query<import("@rbxts/jecs").InferComponents<T>>;

package/src/covenant.luau

@@ -428,6 +428,14 @@ do
 		_undefinedStringifiedComponents[_arg0] = true
 		return c
 	end
+	function Covenant:worldTag()
+		self:preventPostStartCall()
+		local c = self._world:component()
+		local _undefinedStringifiedComponents = self.undefinedStringifiedComponents
+		local _arg0 = tostring(c)
+		_undefinedStringifiedComponents[_arg0] = true
+		return c
+	end
 	function Covenant:worldInternalComponent()
 		self:preventPostStartCall()
 		return self._world:component()
@@ -762,7 +770,7 @@ do
 			updater()
 		end)
 	end
-	function Covenant:defineEntitySource(_param)
+	function Covenant:defineStaticEntity(_param)
 		local identityComponent = _param.identityComponent
 		local recipe = _param.recipe
 		local replicated = _param.replicated
@@ -781,35 +789,16 @@ do
 		local lastUpdateId = 0
 		local updater = function()
 			lastUpdateId += 1
-			local _binding = recipe(lastUpdateId, hooks)
-			local statesToCreate = _binding.statesToCreate
-			local entitiesToDelete = _binding.entitiesToDelete
-			local _result = statesToCreate
-			if _result ~= nil then
-				-- ▼ ReadonlyArray.forEach ▼
-				local _callback = function(state)
-					local entity = self:worldEntity()
-					self:worldSet(entity, identityComponent, state)
-				end
-				for _k, _v in _result do
-					_callback(_v, _k - 1, _result)
-				end
-				-- ▲ ReadonlyArray.forEach ▲
+			local states = recipe(lastUpdateId, hooks)
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback = function(state)
+				local entity = self:worldEntity()
+				self:worldSet(entity, identityComponent, state)
 			end
-			local _result_1 = entitiesToDelete
-			if _result_1 ~= nil then
-				-- ▼ ReadonlyArray.forEach ▼
-				local _callback = function(entity)
-					if not self:worldHas(entity, identityComponent) then
-						return nil
-					end
-					self:worldDelete(entity)
-				end
-				for _k, _v in _result_1 do
-					_callback(_v, _k - 1, _result_1)
-				end
-				-- ▲ ReadonlyArray.forEach ▲
+			for _k, _v in states do
+				_callback(_v, _k - 1, states)
 			end
+			-- ▲ ReadonlyArray.forEach ▲
 		end
 		self:schedule(RunService.Heartbeat, function()
 			if not willUpdate then

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