@rbxts/replion 1.0.15 → 1.0.17

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.17"`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/replion",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "",
   "main": "src/init.lua",
   "scripts": {},
@@ -20,9 +20,5 @@
     "@rbxts/types": "^1.0.896",
     "roblox-ts": "^3.0.0",
     "typescript": "^5.9.3"
-  },
-  "dependencies": {
-    "@rbxts/sift": "^0.0.11",
-    "@rbxts/sleitnick-signal": "^1.0.8"
   }
-}
+}

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;
 
@@ -77,10 +78,46 @@ function Client:observe(path: { string }?, callback: Observer)
 	local initialValue = Shared.getNestedValue(self.data, path);
 
 	task.spawn(callback, initialValue, nil);
-	return self._signals[signalKey]:Connect(callback);
+	local connection = self._signals[signalKey]:Connect(callback);
+	return function()
+		connection:Disconnect();
+	end;
+end;
+
+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:_recursiveSignalCheck(currentPath: { string }, updateTree: any)
+function Client:_notifyRecursiveUpdates(currentPath: { string }, updateTree: any)
 	for k, v in updateTree do
 		local nextPath = table.clone(currentPath);
 		table.insert(nextPath, k);
@@ -94,30 +131,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

@@ -113,24 +113,44 @@ function Server:observe(path: { string }?, callback: Observer)
 	local initialValue = Shared.getNestedValue(self.data, path);
 
 	task.spawn(callback, initialValue, nil);
-	return self._signals[signalKey]:Connect(callback);
+	local connection = self._signals[signalKey]:Connect(callback);
+	return function()
+		connection:Disconnect();
+	end;
 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;
 
-		if typeof(v) == 'table' then
-			self:_recursiveSignalCheck(nextPath, v);
+			local nextPath = table.clone(currentPath);
+			table.insert(nextPath, k);
+
+			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 +183,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);

package/src/index.d.ts

@@ -1,5 +1,3 @@
-import { Connection } from '@rbxts/sleitnick-signal';
-
 declare namespace Replion {
 	/**
 	 * Recursively builds a union of all valid path tuples for object T.
@@ -20,6 +18,8 @@ declare namespace Replion {
 			: never
 		: never;
 
+	type Cleanup = () => void;
+
 	interface ServerConfig<T extends object> {
 		channel: string;
 		replicateTo?: Player;
@@ -30,11 +30,11 @@ declare namespace Replion {
 		get(): T;
 		get<P extends Path<T>>(path: P): PathValue<T, P>;
 
-		observe(key: undefined, callback: (newValue: T, oldValue: Partial<T>) => void): Connection;
+		observe(key: undefined, callback: (newValue: T, oldValue: Partial<T>) => void): Cleanup;
 		observe<P extends Path<T>>(
 			path: P,
 			callback: (newValue: PathValue<T, P>, oldValue: PathValue<T, P> | undefined) => void,
-		): Connection;
+		): Cleanup;
 
 		destroy(): void;
 	}