@rbxts/replion 1.0.18 → 1.0.20

package/README.md

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

package/package.json

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

package/src/BaseReplion.lua

@@ -1,11 +1,12 @@
 --!strict
-export type GenericDataTable = { [string]: any };
-
 local isTypeScriptEnv = script.Parent.Name == 'src';
 local dependencies = if isTypeScriptEnv then script.Parent.Parent.Parent else script.Parent.Parent;
 local Shared = require(script.Parent.Shared);
 local Signal = require(isTypeScriptEnv and dependencies['sleitnick-signal'] or dependencies.Signal);
 
+export type GenericDataTable = { [string]: any };
+export type Observer = (newValue: any, oldValue: any) -> ();
+
 local BaseReplion = {};
 BaseReplion.__index = BaseReplion;
 
@@ -14,7 +15,7 @@ function BaseReplion.new(data: GenericDataTable)
 
 	self.data = data;
 
-	self._signals = {} :: { [string]: any };
+	self._signalRoot = {}; 
 	self._allSignal = Signal.new();
 
 	return self;
@@ -25,32 +26,108 @@ function BaseReplion:get(path: { string }?)
 	return Shared.getNestedValue(self.data, path);
 end;
 
-function BaseReplion:observe(path: { string }?, callback: (any, any) -> ())
-	if not path then
-		task.spawn(callback, self.data, nil);
-		return self._allSignal:Connect(callback);
+function BaseReplion:_pruneSignalTree(path: {string})
+	local stack = {self._signalRoot};
+	local current = self._signalRoot;
+	
+	for _, key in path do
+		current = current[key];
+		if not current then return; end;
+		table.insert(stack, current);
+	end
+
+	for i = #path, 1, -1 do
+		local key = path[i];
+		local node = stack[i + 1];
+		local parent = stack[i];
+
+		local hasListeners = (node._refCount or 0) > 0;
+		local hasChildren = false;
+		
+		if not hasListeners then
+			for k in node do
+				if k == '_signal' then continue; end;
+				if k == '_refCount' then continue; end;
+				hasChildren = true;
+				break;
+			end;
+		end;
+
+		if not hasListeners and not hasChildren then
+			parent[key] = nil;
+		else
+			break;
+		end;
 	end;
+end;
 
-	local signalKey = Shared.getSignalKey(path);
-	if not self._signals[signalKey] then
-		self._signals[signalKey] = Signal.new();
+function BaseReplion:subscribe(path: { string }?, callback: Observer)
+	if (not path) or (#path == 0) then
+		local connection = self._allSignal:Connect(callback);
+		return function()
+			connection:Disconnect()
+		end;
 	end;
 
-	local initialValue = Shared.getNestedValue(self.data, path);
+	local current = self._signalRoot;
+	for _, key in path do
+		if not current[key] then current[key] = {}; end;
+		current = current[key];
+	end;
+
+	if not current._signal then
+		current._signal = Signal.new();
+        current._refCount = 0;
+	end;
+
+    local connection = current._signal:Connect(callback);
+    current._refCount = (current._refCount or 0) + 1;
 
-	task.spawn(callback, initialValue, nil);
-	local connection = self._signals[signalKey]:Connect(callback);
 	return function()
 		connection:Disconnect();
+
+        if current._refCount then
+            current._refCount -= 1;
+        end;
+
+        if current._refCount <= 0 then
+            if current._signal then
+                current._signal:Destroy();
+                current._signal = nil;
+            end;
+            current._refCount = nil;
+            self:_pruneSignalTree(path);
+        end
+	end;
+end;
+
+function BaseReplion:observe(path: { string }?, callback: Observer)
+	if path then
+		local initialValue = Shared.getNestedValue(self.data, path);
+		task.spawn(callback, initialValue, nil);
+	else
+		task.spawn(callback, self.data, nil);
 	end;
+
+	return self:subscribe(path, callback);
 end;
 
 function BaseReplion:destroy()
 	self._allSignal:Destroy();
-	for _, signal in self._signals do
-		signal:Destroy();
-	end;
-	self._signals = {};
+    
+    local function destroyTree(node)
+        if node._signal then 
+            node._signal:Destroy();
+        end;
+        for k, v in node do
+			if k == '_signal' then continue; end;
+			if k == '_refCount' then continue; end;
+			if typeof(v) ~= 'table' then continue; end;
+			destroyTree(v);
+        end;
+    end;
+    destroyTree(self._signalRoot)
+	table.clear(self._signalRoot);
 end;
 
 return BaseReplion;

package/src/Client.lua

@@ -5,23 +5,8 @@ local BaseReplion = require(script.Parent.BaseReplion)
 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;
 
-local function deepMergeAndApply(target: any, updates: any)
-	for key, value in updates do
-		if value == Shared.NIL_SENTINEL then
-			target[key] = nil;
-		elseif typeof(value) == 'table' and typeof(target[key]) == 'table' then
-			deepMergeAndApply(target[key], value);
-		else
-			target[key] = value;
-		end;
-	end;
-end;
-
 local Client = {};
 Client.__index = Client;
 
@@ -49,7 +34,7 @@ function Client.waitForReplion(channel: string)
 	return replion;
 end;
 
-function Client.new(channel: string, data: Shared.GenericDataTable)
+function Client.new(channel: string, data: BaseReplion.GenericDataTable)
 	local self = setmetatable({}, Client);
 
 	self.channel = channel;
@@ -63,103 +48,71 @@ function Client:get(path: { string }?)
 	return self._base:get(path);
 end;
 
-function Client:observe(path: { string }?, callback: Observer)
-	return self._base:observe(path, callback);
+function Client:subscribe(path: { string }?, callback: BaseReplion.Observer)
+	return self._base:subscribe(path, callback);
 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;
+function Client:observe(path: { string }?, callback: BaseReplion.Observer)
+	return self._base:observe(path, callback);
 end;
 
-function Client:_notifyDeepDeletion(path: { string }, oldTable: any)
-	local signals = self._base._signals;
-
-	for k, v in oldTable do
-		local nextPath = table.clone(path);
-		table.insert(nextPath, k);
-
-		local signalKey = Shared.getSignalKey(nextPath);
-		local signal = signals[signalKey];
-		if signal then
-			signal:Fire(nil, v);
-		end;
-
-		if typeof(v) == 'table' then
-			self:_notifyDeepDeletion(nextPath, v);
-		end;
-	end;
+function Client:_fireRecursive(signalNode: any, newValue: any, oldValue: any)
+    if not signalNode then return; end;
+
+    if signalNode._signal then
+        signalNode._signal:Fire(newValue, oldValue);
+    end;
+
+    for key, childNode in signalNode do
+		if key == '_signal' then continue; end;
+		if key == '_refCount' then continue; end;
+        
+        local newChild = if typeof(newValue) == 'table' then newValue[key] else nil;
+        local oldChild = if typeof(oldValue) == 'table' then oldValue[key] else nil;
+        
+        if newChild ~= nil or oldChild ~= nil then
+			self:_fireRecursive(childNode, newChild, oldChild);
+        end;
+    end;
 end;
 
-function Client:_notifyRecursiveUpdates(currentPath: { string }, updateTree: any)
-	local signals = self._base._signals;
-
-	for k, v in updateTree do
-		local nextPath = table.clone(currentPath);
-		table.insert(nextPath, k);
-
-		local signalKey = Shared.getSignalKey(nextPath);
-		local signal = signals[signalKey];
-
-		if signal then
-			local newValue = Shared.getNestedValue(self._base.data, nextPath);
-			signal:Fire(newValue, newValue); -- Warning: Sends improper 'old' argument due to shallow copy optimization.
-		end;
-
-		if typeof(v) == 'table' then
-			self:_notifyRecursiveUpdates(nextPath, v);
-		end;
-	end;
+function Client:_applyUpdatesRecursive(target: any, updates: any, signalNode: any)
+    local anyChanged = false;
+
+    for key, updateVal in updates do
+        local currentVal = target[key];
+        local nextSignalNode = if signalNode then signalNode[key] else nil;
+
+        local finalVal = updateVal;
+        if finalVal == Shared.NIL_SENTINEL then finalVal = nil; end;
+
+        if typeof(finalVal) == 'table' and typeof(currentVal) == 'table' then
+            if self:_applyUpdatesRecursive(currentVal, finalVal, nextSignalNode) then
+                anyChanged = true;
+                
+                if nextSignalNode and nextSignalNode._signal then
+					nextSignalNode._signal:Fire(currentVal, currentVal);
+                end;
+            end;
+        else
+            if currentVal ~= finalVal then
+                target[key] = finalVal;
+                anyChanged = true;
+                
+                if nextSignalNode then
+                    self:_fireRecursive(nextSignalNode, finalVal, currentVal);
+                end;
+            end;
+        end;
+    end;
+
+    return anyChanged;
 end;
 
-function Client:_applyUpdates(updates: Shared.GenericDataTable)
-	local deletions: { Deletion } = {};
-	self:_collectDeletions(self._base.data, updates, {}, deletions);
-
-	local oldData = table.clone(self._base.data); -- Note: Shallow copy instead of deep copy.
-
-	deepMergeAndApply(self._base.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;
-			local signal = self._base._signals[key];
-			if signal then
-				signal:Fire(self._base.data[key], self._base.data[key]); -- Warning: Sends improper 'old' argument due to shallow copy optimization.
-			end;
-			self:_notifyRecursiveUpdates({key}, newValue);
-		elseif self._base.data[key] ~= oldValue then
-			anyChanged = true;
-			local signal = self._base._signals[key];
-			if signal then
-				signal:Fire(self._base.data[key], oldValue);
-			end;
-		end;
-	end;
-
-	if anyChanged then
-		self._base._allSignal:Fire(self._base.data, updates);
-	end;
+function Client:_applyUpdates(updates: BaseReplion.GenericDataTable)
+    local changed = self:_applyUpdatesRecursive(self._base.data, updates, self._base._signalRoot);
+	if not changed then return; end;
+	self._base._allSignal:Fire(self._base.data, updates);
 end;
 
 function Client:destroy()

package/src/Server.lua

@@ -10,9 +10,8 @@ local Sift = require(isTypeScriptEnv and dependencies.sift.out or dependencies.S
 type ServerConfig = {
 	channel: string;
 	replicateTo: Player?;
-	data: Shared.GenericDataTable;
+	data: BaseReplion.GenericDataTable;
 };
-type Observer = (newValue: any, oldValue: any) -> ();
 
 local remote = script.Parent:FindFirstChild(Shared.REMOTE_NAME) :: RemoteEvent;
 if not remote then
@@ -62,7 +61,6 @@ Server._globalReplions = {} :: { [string]: Replion };
 function Server._getPlayerReplion(player: Player, channel: string)
 	local playerReplions = Server._activeReplions[player];
 	if not playerReplions then return nil; end;
-
 	return playerReplions[channel];
 end;
 
@@ -79,7 +77,7 @@ function Server.new(config: ServerConfig)
 	
 	self._base = BaseReplion.new(Sift.Dictionary.copyDeep(config.data));
 
-	self._queuedUpdates = {} :: Shared.GenericDataTable;
+	self._queuedUpdates = {} :: BaseReplion.GenericDataTable;
 	self._isQueued = false;
 	self._destroyed = false;
 
@@ -97,7 +95,11 @@ function Server.new(config: ServerConfig)
 	return self;
 end;
 
-function Server:observe(path: { string }?, callback: Observer)
+function Server:subscribe(path: { string }?, callback: BaseReplion.Observer)
+	return self._base:subscribe(path, callback);
+end;
+
+function Server:observe(path: { string }?, callback: BaseReplion.Observer)
 	return self._base:observe(path, callback);
 end;
 
@@ -105,75 +107,56 @@ function Server:get(path: { string }?)
 	return self._base:get(path);
 end;
 
-function Server:_notifyDeep(currentPath: { string }, newValue: any, oldValue: any)
-	local signals = self._base._signals;
-
-	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 = signals[signalKey];
-			if signal then
-				signal:Fire(v, nextOld);
-			end;
-
-			self:_notifyDeep(nextPath, v, nextOld);
-		end;
-	end;
+function Server:_notifyDeep(signalNode: any, newValue: any, oldValue: any)
+	if not signalNode then return; end;
 
-	if typeof(oldValue) == 'table' then
-		for k, v in oldValue do
-			if typeof(newValue) == 'table' and newValue[k] ~= nil then continue; end;
+    if signalNode._signal then
+        signalNode._signal:Fire(newValue, oldValue);
+    end;
 
-			local nextPath = table.clone(currentPath);
-			table.insert(nextPath, k);
+    for key, childNode in signalNode do
+		if key == '_signal' then continue; end;
+		if key == '_refCount' then continue; end;
 
-			local signalKey = Shared.getSignalKey(nextPath);
-			local signal = signals[signalKey];
-			if signal then
-				signal:Fire(nil, v);
-			end;
+        local nextNew = if typeof(newValue) == 'table' then newValue[key] else nil;
+        local nextOld = if typeof(oldValue) == 'table' then oldValue[key] else nil;
 
-			self:_notifyDeep(nextPath, nil, v);
-		end;
-	end;
+        if nextNew ~= nil or nextOld ~= nil then
+            self:_notifyDeep(childNode, nextNew, nextOld);
+        end;
+    end;
 end;
 
 function Server:set(path: { string }, value: any)
 	if self._destroyed then return; end;
 
-	local topKey = path[1];
-
 	local oldValue = Shared.getNestedValue(self._base.data, path);
 	local newValue = if typeof(value) == 'function' then value(oldValue) else value;
 	if oldValue == newValue then return; end;
 
-	local oldTop = self._base.data[topKey]; 
-
 	setNestedValue(self._base.data, path, newValue);
 	queueNestedUpdate(self._queuedUpdates, path, newValue);
 	self:_scheduleUpdatesFlush();
 
 	do
-		local signals = self._base._signals;
-		local topSignal = signals[topKey];
-		if topSignal then
-			topSignal:Fire(self._base.data[topKey], oldTop);
-		end;
+        local rootKey = path[1];
+        local currentSignalNode = self._base._signalRoot;
 
-		local signalKey = Shared.getSignalKey(path);
-		if signalKey ~= topKey then
-			local pathSignal = signals[signalKey];
-			if pathSignal then
-				pathSignal:Fire(newValue, oldValue)
-			end;
-		end;
+        local rootSignalNode = if currentSignalNode then currentSignalNode[rootKey] else nil;
+
+        for _, key in path do
+            if not currentSignalNode then break; end;
+			currentSignalNode = currentSignalNode[key];
+        end;
+
+        if rootSignalNode and rootSignalNode ~= currentSignalNode and rootSignalNode._signal then
+			local rootValue = self._base.data[rootKey];
+			rootSignalNode._signal:Fire(rootValue, rootValue); 
+        end;
 
-		self:_notifyDeep(path, newValue, oldValue);
+        if currentSignalNode then
+            self:_notifyDeep(currentSignalNode, newValue, oldValue);
+        end;
 
 		local thisUpdate = {};
 		setNestedValue(thisUpdate, path, newValue);

package/src/Shared.lua

@@ -1,6 +1,4 @@
 --!strict
-export type GenericDataTable = { [string]: any };
-
 local Shared = {};
 
 Shared.REMOTE_NAME = 'ReplionNetwork';
@@ -15,9 +13,4 @@ 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

@@ -6,7 +6,6 @@ declare namespace Replion {
 	type Path<T> = T extends object
 		? { [K in keyof T & string]: [K] | [K, ...Path<T[K]>] }[keyof T & string]
 		: never;
-
 	/**
 	 * Resolves the type of the value at a specific path P within object T.
 	 */
@@ -30,6 +29,12 @@ declare namespace Replion {
 		get(): T;
 		get<P extends Path<T>>(path: P): PathValue<T, P>;
 
+		subscribe(key: undefined, callback: (newValue: T, oldValue: Partial<T>) => void): Cleanup;
+		subscribe<P extends Path<T>>(
+			path: P,
+			callback: (newValue: PathValue<T, P>, oldValue: PathValue<T, P> | undefined) => void,
+		): Cleanup;
+
 		observe(key: undefined, callback: (newValue: T, oldValue: Partial<T>) => void): Cleanup;
 		observe<P extends Path<T>>(
 			path: P,