@rbxts/replion 1.0.17 → 1.0.19

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/replion",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "",
   "main": "src/init.lua",
   "scripts": {},
@@ -21,4 +21,4 @@
     "roblox-ts": "^3.0.0",
     "typescript": "^5.9.3"
   }
-}
+}

package/src/BaseReplion.lua

@@ -0,0 +1,68 @@
+--!strict
+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;
+
+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:subscribe(path: { string }?, callback: Observer)
+	if not path then
+		local connection = self._allSignal:Connect(callback);
+		return function()
+			connection:Disconnect()
+		end;
+	end;
+
+	local signalKey = Shared.getSignalKey(path);
+	if not self._signals[signalKey] then
+		self._signals[signalKey] = Signal.new();
+	end;
+
+	local connection = self._signals[signalKey]:Connect(callback);
+	
+	return function()
+		connection:Disconnect();
+	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 = {};
+end;
+
+return BaseReplion;

package/src/Client.lua

@@ -1,10 +1,10 @@
 --!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);
 
-type Observer = (newValue: any, oldValue: any) -> ();
 type Deletion = { path: { string }, oldTable: any };
 
 local remote = script.Parent:WaitForChild(Shared.REMOTE_NAME) :: RemoteEvent;
@@ -48,40 +48,26 @@ 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;
-	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);
+function Client:subscribe(path: { string }?, callback: BaseReplion.Observer)
+	return self._base:subscribe(path, callback);
+end;
 
-	task.spawn(callback, initialValue, nil);
-	local connection = self._signals[signalKey]:Connect(callback);
-	return function()
-		connection:Disconnect();
-	end;
+function Client:observe(path: { string }?, callback: BaseReplion.Observer)
+	return self._base:observe(path, callback);
 end;
 
 function Client:_collectDeletions(target: any, updates: any, path: { string }, out: { Deletion })
@@ -101,12 +87,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;
@@ -118,15 +106,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;
 
@@ -136,13 +126,13 @@ function Client:_notifyRecursiveUpdates(currentPath: { string }, updateTree: any
 	end;
 end;
 
-function Client:_applyUpdates(updates: Shared.GenericDataTable)
+function Client:_applyUpdates(updates: BaseReplion.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;
 
@@ -156,31 +146,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,16 +3,15 @@ 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;
 	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
@@ -76,12 +75,10 @@ function Server.new(config: ServerConfig)
 
 	self.player = config.replicateTo;
 	self.channel = config.channel;
-	self.data = Sift.Dictionary.copyDeep(config.data);
+	
+	self._base = BaseReplion.new(Sift.Dictionary.copyDeep(config.data));
 
-	self._signals = {} :: { [string]: any };
-	self._allSignal = Signal.new();
-
-	self._queuedUpdates = {} :: Shared.GenericDataTable;
+	self._queuedUpdates = {} :: BaseReplion.GenericDataTable;
 	self._isQueued = false;
 	self._destroyed = false;
 
@@ -99,27 +96,21 @@ function Server.new(config: ServerConfig)
 	return self;
 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;
+function Server:subscribe(path: { string }?, callback: BaseReplion.Observer)
+	return self._base:subscribe(path, callback);
+end;
 
-	local initialValue = Shared.getNestedValue(self.data, path);
+function Server:observe(path: { string }?, callback: BaseReplion.Observer)
+	return self._base:observe(path, callback);
+end;
 
-	task.spawn(callback, initialValue, nil);
-	local connection = self._signals[signalKey]:Connect(callback);
-	return function()
-		connection:Disconnect();
-	end;
+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);
@@ -128,7 +119,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;
@@ -145,7 +136,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;
@@ -160,25 +151,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;
@@ -188,26 +180,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;
@@ -249,7 +231,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/Shared.lua

@@ -1,6 +1,4 @@
 --!strict
-export type GenericDataTable = { [string]: any };
-
 local Shared = {};
 
 Shared.REMOTE_NAME = 'ReplionNetwork';

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,