@rbxts/replion 1.0.11 → 1.0.13

package/README.md

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

package/package.json

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

package/src/Client.lua

@@ -58,82 +58,78 @@ function Client.new(channel: string, data: Shared.GenericDataTable)
 	return self;
 end;
 
-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);
-	end;
-
-	return self.data[key];
+function Client:get(path: { string }?)
+	if not path then return self.data; end;
+	return Shared.getNestedValue(self.data, path);
 end;
 
-function Client:observe(key: (string | { string })?, callback: Observer)
-    if not key then
-        task.spawn(callback, self.data, nil);
-        return self._allSignal:Connect(callback);
-    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(key);
-    if not self._signals[signalKey] then
-        self._signals[signalKey] = Signal.new();
-    end;
+	local signalKey = Shared.getSignalKey(path);
+	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];
+	local initialValue = Shared.getNestedValue(self.data, path);
 
-    task.spawn(callback, initialValue, nil);
-    return self._signals[signalKey]:Connect(callback);
+	task.spawn(callback, initialValue, nil);
+	return self._signals[signalKey]:Connect(callback);
 end;
 
 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;
+	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.
+	local oldData = table.clone(self.data); -- Note: Shallow copy instead of deep copy.
 
-    deepMergeAndApply(self.data, updates);
+	deepMergeAndApply(self.data, updates);
 
-    local anyChanged = false;
+	local anyChanged = false;
+
+	for key, newValue in updates do
+		local oldValue = oldData[key];
 
-    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;
+		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()
@@ -148,7 +144,7 @@ remote.OnClientEvent:Connect(function(type, channel, payload)
 	if type == 'I' then
 		local newReplion = Client.new(channel, payload);
 		Client._activeReplions[channel] = newReplion;
-		
+
 		local initializedSignal = Client._replionInitializedSignals[channel];
 		if not initializedSignal then return; end;
 

package/src/Server.lua

@@ -99,66 +99,61 @@ function Server.new(config: ServerConfig)
 	return self;
 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
+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(key);
-    if not self._signals[signalKey] then
-        self._signals[signalKey] = Signal.new();
-    end;
+	local signalKey = Shared.getSignalKey(path);
+	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];
+	local initialValue = Shared.getNestedValue(self.data, path);
 
-    task.spawn(callback, initialValue, nil);
-    return self._signals[signalKey]: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;
+function Server:set(path: { string }, value: any)
+	if self._destroyed then return; end;
 
-    local path = if typeof(key) == 'table' then key else {key};
-    local topKey = path[1];
+	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 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]; 
+	local oldTop = self.data[topKey]; 
 
-    setNestedValue(self.data, path, newValue);
-    queueNestedUpdate(self._queuedUpdates, path, newValue);
-    self:_scheduleUpdatesFlush();
+	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;
+	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 signalKey = Shared.getSignalKey(path);
+		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;
+		end;
 
-function Server:get(key: (string | {string})?)
-	if not key then return self.data; end;
-	if typeof(key) == 'table' then
-		return Shared.getNestedValue(self.data, key);
+		local thisUpdate = {};
+		setNestedValue(thisUpdate, path, newValue);
+		self._allSignal:Fire(self.data, thisUpdate);
 	end;
+end;
 
-	return self.data[key];
+function Server:get(path: { string }?)
+	if not path then return self.data; end;
+	return Shared.getNestedValue(self.data, path);
 end;
 
 function Server:destroy()

package/src/Shared.lua

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

package/src/index.d.ts

@@ -1,53 +1,59 @@
 import { Connection } from '@rbxts/sleitnick-signal';
 
 declare namespace Replion {
+	/**
+	 * Recursively builds a union of all valid path tuples for object T.
+	 * E.g., { a: { b: 1 } } -> ['a'] | ['a', 'b']
+	 */
+	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.
+	 */
+	type PathValue<T, P extends any[]> = P extends [infer K, ...infer R]
+		? K extends keyof T
+			? R extends []
+				? T[K]
+				: PathValue<T[K], R>
+			: never
+		: never;
+
 	interface ServerConfig<T extends object> {
 		channel: string;
 		replicateTo?: Player;
 		data: T;
 	}
 
-	class Server<T extends object> {
-		constructor(config: ServerConfig<T>);
-
-		set<K extends keyof T>(key: K, value: T[K] | ((oldValue: T[K]) => T[K])): void;
-		set(path: string[], value: any | ((oldValue: any) => any)): void;
-
+	interface ReplionBase<T extends object> {
 		get(): T;
-		get<K extends keyof T>(key: K): T[K];
-		get(path: string[]): any;
+		get<P extends Path<T>>(path: P): PathValue<T, P>;
 
 		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,
+		observe<P extends Path<T>>(
+			path: P,
+			callback: (newValue: PathValue<T, P>, oldValue: PathValue<T, P> | undefined) => void,
 		): Connection;
 
 		destroy(): void;
 	}
 
-	class Client<T extends object> {
-		static waitForReplion: <T extends object>(channel: string) => Client<T>;
+	interface Server<T extends object> extends ReplionBase<T> { }
+	class Server<T extends object> {
+		constructor(config: ServerConfig<T>);
 
-		get(): T;
-		get<K extends keyof T>(key: K): T[K];
-		get(path: string[]): any;
+		set<P extends Path<T>>(
+			path: P,
+			value: PathValue<T, P> | ((oldValue: PathValue<T, P>) => PathValue<T, P>),
+		): void;
+	}
 
-		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;
+	interface Client<T extends object> extends ReplionBase<T> { }
+	class Client<T extends object> {
+		static waitForReplion: <T extends object>(channel: string) => Client<T>;
 
-		destroy(): void;
+		private constructor();
 	}
 }