@rbxts/replion 1.0.15 → 1.0.16

package/README.md

@@ -2,4 +2,4 @@
 
 ## Install
 Install with [wally](https://wally.run/):\
-`Replion = "shouxtech/replion@1.0.15"`
+`Replion = "shouxtech/replion@1.0.16"`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/replion",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "",
   "main": "src/init.lua",
   "scripts": {},

package/src/Client.lua

@@ -5,6 +5,7 @@ local Shared = require(script.Parent.Shared);
 local Signal = require(isTypeScriptEnv and dependencies['sleitnick-signal'] or dependencies.Signal);
 
 type Observer = (newValue: any, oldValue: any) -> ();
+type Deletion = { path: { string }, oldTable: any };
 
 local remote = script.Parent:WaitForChild(Shared.REMOTE_NAME) :: RemoteEvent;
 
@@ -80,7 +81,40 @@ function Client:observe(path: { string }?, callback: Observer)
 	return self._signals[signalKey]:Connect(callback);
 end;
 
-function Client:_recursiveSignalCheck(currentPath: { string }, updateTree: any)
+function Client:_collectDeletions(target: any, updates: any, path: { string }, out: { Deletion })
+	for k, v in updates do
+		local currentVal = target[k];
+		local newPath = table.clone(path);
+		table.insert(newPath, k);
+
+		if v == Shared.NIL_SENTINEL or (typeof(currentVal) == 'table' and typeof(v) ~= 'table') then
+			if typeof(currentVal) == 'table' then
+				table.insert(out, { path = newPath, oldTable = currentVal });
+			end;
+		elseif typeof(v) == 'table' and typeof(currentVal) == 'table' then
+			self:_collectDeletions(currentVal, v, newPath, out);
+		end;
+	end;
+end;
+
+function Client:_notifyDeepDeletion(path: { string }, oldTable: any)
+	for k, v in oldTable do
+		local nextPath = table.clone(path);
+		table.insert(nextPath, k);
+
+		local signalKey = Shared.getSignalKey(nextPath);
+		local signal = self._signals[signalKey];
+		if signal then
+			signal:Fire(nil, v);
+		end;
+
+		if typeof(v) == 'table' then
+			self:_notifyDeepDeletion(nextPath, v);
+		end;
+	end;
+end;
+
+function Client:_notifyRecursiveUpdates(currentPath: { string }, updateTree: any)
 	for k, v in updateTree do
 		local nextPath = table.clone(currentPath);
 		table.insert(nextPath, k);
@@ -94,30 +128,36 @@ function Client:_recursiveSignalCheck(currentPath: { string }, updateTree: any)
 		end;
 
 		if typeof(v) == 'table' then
-			self:_recursiveSignalCheck(nextPath, v);
+			self:_notifyRecursiveUpdates(nextPath, v);
 		end;
 	end;
 end;
 
 function Client:_applyUpdates(updates: Shared.GenericDataTable)
+	local deletions: { Deletion } = {};
+	self:_collectDeletions(self.data, updates, {}, deletions);
+
 	local oldData = table.clone(self.data); -- Note: Shallow copy instead of deep copy.
 
 	deepMergeAndApply(self.data, updates);
 
 	local anyChanged = false;
 
+	for _, item in deletions do
+		self:_notifyDeepDeletion(item.path, item.oldTable);
+	end;
+
 	for key, newValue in updates do
 		local oldValue = oldData[key];
 
 		-- If it's a table, we assume it changed if it's in the updates list.
 		if typeof(newValue) == 'table' then
-			anyChanged = true
+			anyChanged = true;
 			local signal = self._signals[key];
 			if signal then
 				signal:Fire(self.data[key], self.data[key]); -- Warning: Sends improper 'old' argument due to shallow copy optimization.
 			end;
-
-			self:_recursiveSignalCheck({key}, newValue);
+			self:_notifyRecursiveUpdates({key}, newValue);
 		elseif self.data[key] ~= oldValue then
 			anyChanged = true;
 			local signal = self._signals[key];

package/src/Server.lua

@@ -116,21 +116,38 @@ function Server:observe(path: { string }?, callback: Observer)
 	return self._signals[signalKey]:Connect(callback);
 end;
 
-function Server:_recursiveSignalCheck(currentPath: { string }, updateTree: any)
-	for k, v in updateTree do
-		local nextPath = table.clone(currentPath);
-		table.insert(nextPath, k);
-
-		local signalKey = Shared.getSignalKey(nextPath);
-		local signal = self._signals[signalKey];
+function Server:_notifyDeep(currentPath: { string }, newValue: any, oldValue: any)
+	if typeof(newValue) == 'table' then
+		for k, v in newValue do
+			local nextPath = table.clone(currentPath);
+			table.insert(nextPath, k);
+
+			local nextOld = if typeof(oldValue) == 'table' then oldValue[k] else nil;
+            
+			local signalKey = Shared.getSignalKey(nextPath);
+			local signal = self._signals[signalKey];
+			if signal then
+				signal:Fire(v, nextOld);
+			end;
 
-		if signal then
-			local newValue = Shared.getNestedValue(self.data, nextPath);
-			signal:Fire(newValue, newValue); -- Warning: Sends improper 'old' argument due to shallow copy optimization.
+			self:_notifyDeep(nextPath, v, nextOld);
 		end;
+	end;
+
+	if typeof(oldValue) == 'table' then
+		for k, v in oldValue do
+			if typeof(newValue) == 'table' and newValue[k] ~= nil then continue; end;
+
+			local nextPath = table.clone(currentPath);
+			table.insert(nextPath, k);
 
-		if typeof(v) == 'table' then
-			self:_recursiveSignalCheck(nextPath, v);
+			local signalKey = Shared.getSignalKey(nextPath);
+			local signal = self._signals[signalKey];
+			if signal then
+				signal:Fire(nil, v);
+			end;
+
+			self:_notifyDeep(nextPath, nil, v);
 		end;
 	end;
 end;
@@ -163,10 +180,8 @@ function Server:set(path: { string }, value: any)
 				pathSignal:Fire(newValue, oldValue)
 			end;
 		end;
-		
-		if typeof(newValue) == 'table' then
-			self:_recursiveSignalCheck(path, newValue);
-		end;
+
+		self:_notifyDeep(path, newValue, oldValue);
 
 		local thisUpdate = {};
 		setNestedValue(thisUpdate, path, newValue);