@rbxts/replion 1.0.16 → 1.0.18

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/replion",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "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/BaseReplion.lua

@@ -0,0 +1,56 @@
+--!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);
+
+local BaseReplion = {};
+BaseReplion.__index = BaseReplion;
+
+function BaseReplion.new(data: GenericDataTable)
+	local self = setmetatable({}, BaseReplion);
+
+	self.data = data;
+
+	self._signals = {} :: { [string]: any };
+	self._allSignal = Signal.new();
+
+	return self;
+end;
+
+function BaseReplion:get(path: { string }?)
+	if not path then return self.data; end;
+	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);
+	end;
+
+	local signalKey = Shared.getSignalKey(path);
+	if not self._signals[signalKey] then
+		self._signals[signalKey] = Signal.new();
+	end;
+
+	local initialValue = Shared.getNestedValue(self.data, path);
+
+	task.spawn(callback, initialValue, nil);
+	local connection = self._signals[signalKey]:Connect(callback);
+	return function()
+		connection:Disconnect();
+	end;
+end;
+
+function BaseReplion:destroy()
+	self._allSignal:Destroy();
+	for _, signal in self._signals do
+		signal:Destroy();
+	end;
+	self._signals = {};
+end;
+
+return BaseReplion;

package/src/Client.lua

@@ -1,6 +1,7 @@
 --!strict
 local isTypeScriptEnv = script.Parent.Name == 'src';
 local dependencies = if isTypeScriptEnv then script.Parent.Parent.Parent else script.Parent.Parent;
+local BaseReplion = require(script.Parent.BaseReplion)
 local Shared = require(script.Parent.Shared);
 local Signal = require(isTypeScriptEnv and dependencies['sleitnick-signal'] or dependencies.Signal);
 
@@ -52,33 +53,18 @@ function Client.new(channel: string, data: Shared.GenericDataTable)
 	local self = setmetatable({}, Client);
 
 	self.channel = channel;
-	self.data = data;
-	self._signals = {} :: { [string]: any };
-	self._allSignal = Signal.new();
+
+	self._base = BaseReplion.new(data);
 
 	return self;
 end;
 
 function Client:get(path: { string }?)
-	if not path then return self.data; end;
-	return Shared.getNestedValue(self.data, path);
+	return self._base:get(path);
 end;
 
 function Client:observe(path: { string }?, callback: Observer)
-	if not path then
-		task.spawn(callback, self.data, nil);
-		return self._allSignal:Connect(callback);
-	end;
-
-	local signalKey = Shared.getSignalKey(path);
-	if not self._signals[signalKey] then
-		self._signals[signalKey] = Signal.new();
-	end;
-
-	local initialValue = Shared.getNestedValue(self.data, path);
-
-	task.spawn(callback, initialValue, nil);
-	return self._signals[signalKey]:Connect(callback);
+	return self._base:observe(path, callback);
 end;
 
 function Client:_collectDeletions(target: any, updates: any, path: { string }, out: { Deletion })
@@ -98,12 +84,14 @@ function Client:_collectDeletions(target: any, updates: any, path: { string }, o
 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 = self._signals[signalKey];
+		local signal = signals[signalKey];
 		if signal then
 			signal:Fire(nil, v);
 		end;
@@ -115,15 +103,17 @@ function Client:_notifyDeepDeletion(path: { string }, oldTable: any)
 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 = self._signals[signalKey];
+		local signal = signals[signalKey];
 
 		if signal then
-			local newValue = Shared.getNestedValue(self.data, nextPath);
+			local newValue = Shared.getNestedValue(self._base.data, nextPath);
 			signal:Fire(newValue, newValue); -- Warning: Sends improper 'old' argument due to shallow copy optimization.
 		end;
 
@@ -135,11 +125,11 @@ end;
 
 function Client:_applyUpdates(updates: Shared.GenericDataTable)
 	local deletions: { Deletion } = {};
-	self:_collectDeletions(self.data, updates, {}, deletions);
+	self:_collectDeletions(self._base.data, updates, {}, deletions);
 
-	local oldData = table.clone(self.data); -- Note: Shallow copy instead of deep copy.
+	local oldData = table.clone(self._base.data); -- Note: Shallow copy instead of deep copy.
 
-	deepMergeAndApply(self.data, updates);
+	deepMergeAndApply(self._base.data, updates);
 
 	local anyChanged = false;
 
@@ -153,31 +143,27 @@ function Client:_applyUpdates(updates: Shared.GenericDataTable)
 		-- 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];
+			local signal = self._base._signals[key];
 			if signal then
-				signal:Fire(self.data[key], self.data[key]); -- Warning: Sends improper 'old' argument due to shallow copy optimization.
+				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.data[key] ~= oldValue then
+		elseif self._base.data[key] ~= oldValue then
 			anyChanged = true;
-			local signal = self._signals[key];
+			local signal = self._base._signals[key];
 			if signal then
-				signal:Fire(self.data[key], oldValue);
+				signal:Fire(self._base.data[key], oldValue);
 			end;
 		end;
 	end;
 
 	if anyChanged then
-		self._allSignal:Fire(self.data, updates);
+		self._base._allSignal:Fire(self._base.data, updates);
 	end;
 end;
 
 function Client:destroy()
-	self._allSignal:Destroy();
-	for _, signal in self._signals do
-		signal:Destroy();
-	end;
-	self._signals = {};
+	self._base:destroy();
 end;
 
 remote.OnClientEvent:Connect(function(type, channel, payload)

package/src/Server.lua

@@ -3,9 +3,9 @@ local Players = game:GetService('Players');
 
 local isTypeScriptEnv = script.Parent.Name == 'src';
 local dependencies = if isTypeScriptEnv then script.Parent.Parent.Parent else script.Parent.Parent;
+local BaseReplion = require(script.Parent.BaseReplion)
 local Shared = require(script.Parent.Shared);
 local Sift = require(isTypeScriptEnv and dependencies.sift.out or dependencies.Sift);
-local Signal = require(isTypeScriptEnv and dependencies['sleitnick-signal'] or dependencies.Signal);
 
 type ServerConfig = {
 	channel: string;
@@ -76,10 +76,8 @@ function Server.new(config: ServerConfig)
 
 	self.player = config.replicateTo;
 	self.channel = config.channel;
-	self.data = Sift.Dictionary.copyDeep(config.data);
-
-	self._signals = {} :: { [string]: any };
-	self._allSignal = Signal.new();
+	
+	self._base = BaseReplion.new(Sift.Dictionary.copyDeep(config.data));
 
 	self._queuedUpdates = {} :: Shared.GenericDataTable;
 	self._isQueued = false;
@@ -100,23 +98,16 @@ function Server.new(config: ServerConfig)
 end;
 
 function Server:observe(path: { string }?, callback: Observer)
-	if not path then
-		task.spawn(callback, self.data, nil);
-		return self._allSignal:Connect(callback);
-	end;
-
-	local signalKey = Shared.getSignalKey(path);
-	if not self._signals[signalKey] then
-		self._signals[signalKey] = Signal.new();
-	end;
-
-	local initialValue = Shared.getNestedValue(self.data, path);
+	return self._base:observe(path, callback);
+end;
 
-	task.spawn(callback, initialValue, nil);
-	return self._signals[signalKey]:Connect(callback);
+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);
@@ -125,7 +116,7 @@ function Server:_notifyDeep(currentPath: { string }, newValue: any, oldValue: an
 			local nextOld = if typeof(oldValue) == 'table' then oldValue[k] else nil;
             
 			local signalKey = Shared.getSignalKey(nextPath);
-			local signal = self._signals[signalKey];
+			local signal = signals[signalKey];
 			if signal then
 				signal:Fire(v, nextOld);
 			end;
@@ -142,7 +133,7 @@ function Server:_notifyDeep(currentPath: { string }, newValue: any, oldValue: an
 			table.insert(nextPath, k);
 
 			local signalKey = Shared.getSignalKey(nextPath);
-			local signal = self._signals[signalKey];
+			local signal = signals[signalKey];
 			if signal then
 				signal:Fire(nil, v);
 			end;
@@ -157,25 +148,26 @@ function Server:set(path: { string }, value: any)
 
 	local topKey = path[1];
 
-	local oldValue = Shared.getNestedValue(self.data, path);
+	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.data[topKey]; 
+	local oldTop = self._base.data[topKey]; 
 
-	setNestedValue(self.data, path, newValue);
+	setNestedValue(self._base.data, path, newValue);
 	queueNestedUpdate(self._queuedUpdates, path, newValue);
 	self:_scheduleUpdatesFlush();
 
 	do
-		local topSignal = self._signals[topKey];
+		local signals = self._base._signals;
+		local topSignal = signals[topKey];
 		if topSignal then
-			topSignal:Fire(self.data[topKey], oldTop);
+			topSignal:Fire(self._base.data[topKey], oldTop);
 		end;
 
 		local signalKey = Shared.getSignalKey(path);
 		if signalKey ~= topKey then
-			local pathSignal = self._signals[signalKey];
+			local pathSignal = signals[signalKey];
 			if pathSignal then
 				pathSignal:Fire(newValue, oldValue)
 			end;
@@ -185,26 +177,16 @@ function Server:set(path: { string }, value: any)
 
 		local thisUpdate = {};
 		setNestedValue(thisUpdate, path, newValue);
-		self._allSignal:Fire(self.data, thisUpdate);
+		self._base._allSignal:Fire(self._base.data, thisUpdate);
 	end;
 end;
 
-function Server:get(path: { string }?)
-	if not path then return self.data; end;
-	return Shared.getNestedValue(self.data, path);
-end;
-
 function Server:destroy()
 	self._destroyed = true;
-	self.data = {};
 	self._queuedUpdates = {};
-
-	self._allSignal:Destroy();
-	for _, signal in self._signals do
-		signal:Destroy();
-	end;
-	self._signals = {};
-
+	
+	self._base:destroy();
+	
 	if self.player then
 		local playerReplions = self._activeReplions[self.player];
 		if not playerReplions then return; end;
@@ -246,7 +228,7 @@ function Server:_sendInitial(player: Player?)
 	local receiver = player or self.player;
 	if not receiver then return; end;
 
-	remote:FireClient(receiver, 'I', self.channel, self.data);
+	remote:FireClient(receiver, 'I', self.channel, self._base.data);
 end;
 
 remote.OnServerEvent:Connect(function(player, action, ...)

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;
 	}