@rbxts/replion 1.0.9 → 1.0.11

package/README.md

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

package/package.json

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

package/src/Client.lua

@@ -58,7 +58,7 @@ function Client.new(channel: string, data: Shared.GenericDataTable)
 	return self;
 end;
 
-function Client:get(key: (string | {string})?)
+function Client:get(key: (string | { string })?)
 	if not key then return self.data; end;
 	if typeof(key) == 'table' then
 		return Shared.getNestedValue(self.data, key);
@@ -67,51 +67,73 @@ function Client:get(key: (string | {string})?)
 	return self.data[key];
 end;
 
-function Client:observe(key: string?, callback: Observer)
-	if not key then
-		task.spawn(callback, self.data, nil);
+function Client:observe(key: (string | { string })?, callback: Observer)
+    if not key then
+        task.spawn(callback, self.data, nil);
+        return self._allSignal:Connect(callback);
+    end;
 
-		return self._allSignal:Connect(callback);
-	end;
+    local signalKey = Shared.getSignalKey(key);
+    if not self._signals[signalKey] then
+        self._signals[signalKey] = Signal.new();
+    end;
 
-	if not self._signals[key] then
-		self._signals[key] = Signal.new();
-	end;
+    local initialValue = if typeof(key) == 'table' then Shared.getNestedValue(self.data, key) else self.data[key];
 
-	task.spawn(callback, self.data[key], nil);
+    task.spawn(callback, initialValue, nil);
+    return self._signals[signalKey]:Connect(callback);
+end;
 
-	return self._signals[key]:Connect(callback);
+function Client:_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];
+
+        if signal then
+            local newValue = Shared.getNestedValue(self.data, nextPath);
+            signal:Fire(newValue, newValue); -- Warning: Sends improper 'old' argument due to shallow copy optimization.
+        end;
+
+        if typeof(v) == 'table' then
+            self:_recursiveSignalCheck(nextPath, v)
+        end;
+    end;
 end;
 
 function Client:_applyUpdates(updates: Shared.GenericDataTable)
-	local oldData = table.clone(self.data); -- Note: Shallow copy instead of deep copy.
-
-	deepMergeAndApply(self.data, updates);
-
-	local anyChanged = false;
-
-	for key, newValue in updates do
-		local oldValue = oldData[key];
-
-		-- If it's a table, we assume it changed if it's in the update list.
-		if typeof(newValue) == 'table' then
-			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;
-		elseif self.data[key] ~= oldValue then
-			anyChanged = true;
-			local signal = self._signals[key];
-			if signal then
-				signal:Fire(self.data[key], oldValue);
-			end;
-		end;
-	end;
-
-	if anyChanged then
-		self._allSignal:Fire(self.data, updates);
-	end;
+    local oldData = table.clone(self.data); -- Note: Shallow copy instead of deep copy.
+
+    deepMergeAndApply(self.data, updates);
+
+    local anyChanged = false;
+
+    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
+            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)
+        elseif self.data[key] ~= oldValue then
+            anyChanged = true;
+            local signal = self._signals[key];
+            if signal then
+                signal:Fire(self.data[key], oldValue);
+            end;
+        end;
+    end;
+
+    if anyChanged then
+        self._allSignal:Fire(self.data, updates);
+    end;
 end;
 
 function Client:destroy()

package/src/Server.lua

@@ -99,46 +99,57 @@ function Server.new(config: ServerConfig)
 	return self;
 end;
 
-function Server:observe(key: string?, callback: Observer)
-	if not key then
-		task.spawn(callback, self.data, nil);
-		return self._allSignal:Connect(callback);
-	end;
+function Server:observe(key: (string | {string})?, callback: Observer)
+    if not key then
+        task.spawn(callback, self.data, nil);
+        return self._allSignal:Connect(callback);
+    end
 
-	if not self._signals[key] then
-		self._signals[key] = Signal.new();
-	end;
+    local signalKey = Shared.getSignalKey(key);
+    if not self._signals[signalKey] then
+        self._signals[signalKey] = Signal.new();
+    end;
+
+    local initialValue = if typeof(key) == 'table' then Shared.getNestedValue(self.data, key) else self.data[key];
 
-	task.spawn(callback, self.data[key], nil);
-	return self._signals[key]:Connect(callback);
+    task.spawn(callback, initialValue, nil);
+    return self._signals[signalKey]:Connect(callback);
 end;
 
 function Server:set(key: string | {string}, value: any)
-	if self._destroyed then return; end;
-
-	local path = if typeof(key) == 'table' then key else {key};
-	local topKey = path[1];
-
-	local oldValue = Shared.getNestedValue(self.data, path);
-	local newValue = if typeof(value) == 'function' then value(oldValue) else value;
-	if oldValue == newValue then return; end;
-
-	local oldTop = self.data[topKey]; 
-
-	setNestedValue(self.data, path, newValue);
-	queueNestedUpdate(self._queuedUpdates, path, newValue);
-	self:_scheduleUpdatesFlush();
-
-	do
-		local signal = self._signals[topKey];
-		if signal then
-			signal:Fire(self.data[topKey], oldTop);
-		end;
-
-		local thisUpdate = {};
-		setNestedValue(thisUpdate, path, newValue);
-		self._allSignal:Fire(self.data, thisUpdate);
-	end;
+    if self._destroyed then return; end;
+
+    local path = if typeof(key) == 'table' then key else {key};
+    local topKey = path[1];
+
+    local oldValue = Shared.getNestedValue(self.data, path);
+    local newValue = if typeof(value) == 'function' then value(oldValue) else value;
+    if oldValue == newValue then return; end;
+
+    local oldTop = self.data[topKey]; 
+
+    setNestedValue(self.data, path, newValue);
+    queueNestedUpdate(self._queuedUpdates, path, newValue);
+    self:_scheduleUpdatesFlush();
+
+    do
+        local topSignal = self._signals[topKey];
+        if topSignal then
+            topSignal:Fire(self.data[topKey], oldTop);
+        end;
+
+        local signalKey = Shared.getSignalKey(key);
+        if signalKey ~= topKey then
+			local pathSignal = self._signals[signalKey];
+			if pathSignal then
+				pathSignal:Fire(newValue, oldValue)
+			end;
+        end;
+
+        local thisUpdate = {};
+        setNestedValue(thisUpdate, path, newValue);
+        self._allSignal:Fire(self.data, thisUpdate);
+    end;
 end;
 
 function Server:get(key: (string | {string})?)

package/src/Shared.lua

@@ -15,4 +15,9 @@ function Shared.getNestedValue(root: any, path: { string })
 	return current;
 end;
 
+function Shared.getSignalKey(key: string | {string})
+    if typeof(key) == 'string' then return key; end;
+    return table.concat(key, '\0');
+end;
+
 return Shared;

package/src/index.d.ts

@@ -17,6 +17,16 @@ declare namespace Replion {
 		get<K extends keyof T>(key: K): T[K];
 		get(path: string[]): any;
 
+		observe(key: undefined, callback: (newValue: T, oldValue: Partial<T>) => void): Connection;
+		observe<K extends keyof T>(
+			key: K,
+			callback: (newValue: T[K], oldValue: T[K] | undefined) => void,
+		): Connection;
+		observe(
+			path: string[],
+			callback: (newValue: any, oldValue: any) => void,
+		): Connection;
+
 		destroy(): void;
 	}
 
@@ -27,11 +37,15 @@ declare namespace Replion {
 		get<K extends keyof T>(key: K): T[K];
 		get(path: string[]): any;
 
-		observe(key: undefined, callback: (newValue: T, oldValue: T | undefined) => void): Connection;
+		observe(key: undefined, callback: (newValue: T, oldValue: Partial<T>) => void): Connection;
 		observe<K extends keyof T>(
 			key: K,
 			callback: (newValue: T[K], oldValue: T[K] | undefined) => void,
 		): Connection;
+		observe(
+			path: string[],
+			callback: (newValue: any, oldValue: any) => void,
+		): Connection;
 
 		destroy(): void;
 	}