@quenty/tie 10.6.0 → 10.7.0

package/src/Shared/{Implementation → Members/Signals}/TieSignalImplementation.lua

@@ -7,28 +7,22 @@ local require = require(script.Parent.loader).load(script)
 local BaseObject = require("BaseObject")
 local TieUtils = require("TieUtils")
 local Maid = require("Maid")
+local Tuple = require("Tuple")
 
 local TieSignalImplementation = setmetatable({}, BaseObject)
 TieSignalImplementation.ClassName = "TieSignalImplementation"
 TieSignalImplementation.__index = TieSignalImplementation
 
-function TieSignalImplementation.new(memberDefinition, folder, initialValue)
+function TieSignalImplementation.new(memberDefinition, implParent, initialValue)
 	local self = setmetatable(BaseObject.new(), TieSignalImplementation)
 
 	self._memberDefinition = assert(memberDefinition, "No memberDefinition")
-	self._folder = assert(folder, "No folder")
+	self._implParent = assert(implParent, "No implParent")
 
-	self._bindableEvent = Instance.new("BindableEvent")
+	self._bindableEvent = self._maid:Add(Instance.new("BindableEvent"))
 	self._bindableEvent.Archivable = false
 	self._bindableEvent.Name = memberDefinition:GetMemberName()
-	self._bindableEvent.Parent = self._folder
-	self._maid:GiveTask(self._bindableEvent)
-
-	-- Abuse the fact that the first signal connected is the first
-	-- signal to fire!
-	self._maid:GiveTask(self._bindableEvent.Event:Connect(function()
-		self._thisIsUsFiring = false
-	end))
+	self._bindableEvent.Parent = self._implParent
 
 	self:SetImplementation(initialValue)
 
@@ -39,16 +33,36 @@ function TieSignalImplementation:SetImplementation(signal)
 	local maid = Maid.new()
 
 	if type(signal) == "table" then
+		-- Prevent re-entrance from stuff fired from ourselves when forwarding events in either direction
+		local signalFiredArgs = {}
+		local bindableEventFiredArgs = {}
+
 		maid:GiveTask(signal:Connect(function(...)
-			self._thisIsUsFiring = true
+			local args = Tuple.new(...)
+			for pendingArgs, _ in pairs(signalFiredArgs) do
+				if pendingArgs == args then
+					-- Remove from queue
+					signalFiredArgs[pendingArgs] = nil
+					return
+				end
+			end
+
+			bindableEventFiredArgs[args] = true
 			self._bindableEvent:Fire(TieUtils.encode(...))
 		end))
 
-		-- TODO: Listen to the event and fire off our own event (if we aren't the source).
 		maid:GiveTask(self._bindableEvent.Event:Connect(function(...)
-			if not self._thisIsUsFiring then
-				signal:Fire(TieUtils.decode(...))
+			local args = Tuple.new(TieUtils.decode(...))
+			for pendingArgs, _ in pairs(bindableEventFiredArgs) do
+				if pendingArgs == args then
+					-- Remove from queue
+					bindableEventFiredArgs[pendingArgs] = nil
+					return
+				end
 			end
+
+			signalFiredArgs[args] = true
+			signal:Fire(args:Unpack())
 		end))
 	end
 

package/src/Shared/Members/Signals/TieSignalInterface.lua

@@ -0,0 +1,90 @@
+--[=[
+	Interface that mirrors [Signal] API
+
+	@class TieSignalInterface
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local TieMemberInterface = require("TieMemberInterface")
+local TieSignalConnection = require("TieSignalConnection")
+local TieUtils = require("TieUtils")
+local RxBrioUtils = require("RxBrioUtils")
+local RxInstanceUtils = require("RxInstanceUtils")
+local TieRealmUtils = require("TieRealmUtils")
+
+local TieSignalInterface = setmetatable({}, TieMemberInterface)
+TieSignalInterface.ClassName = "TieSignalInterface"
+TieSignalInterface.__index = TieSignalInterface
+
+function TieSignalInterface.new(implParent, adornee, memberDefinition, interfaceTieRealm)
+	assert(TieRealmUtils.isTieRealm(interfaceTieRealm), "Bad interfaceTieRealm")
+
+	local self = setmetatable(TieMemberInterface.new(implParent, adornee, memberDefinition, interfaceTieRealm), TieSignalInterface)
+
+	return self
+end
+
+--[=[
+	Fires the signal
+
+	@param ... T
+]=]
+function TieSignalInterface:Fire(...)
+	local bindableEvent = self:_getBindableEvent()
+	if not bindableEvent then
+		warn(string.format("[TieSignalInterface] - No bindableEvent for %q", self._memberDefinition:GetMemberName()))
+	end
+
+	bindableEvent:Fire(TieUtils.encode(...))
+end
+
+--[=[
+	Connects like an RBXSignalConnection
+
+	@param callback (T...) -> ()
+	@return TieSignalConnection
+]=]
+function TieSignalInterface:Connect(callback)
+	assert(type(callback) == "function", "Bad callback")
+
+	return TieSignalConnection.new(self, callback)
+end
+
+function TieSignalInterface:Wait()
+	-- TODO: Implement
+	error("Not implemented")
+end
+
+function TieSignalInterface:Once(_callback)
+	-- TODO: Implement
+	error("Not implemented")
+end
+
+function TieSignalInterface:ObserveBindableEventBrio()
+	local name = self._memberDefinition:GetMemberName()
+
+	return self:ObserveImplParentBrio():Pipe({
+		RxBrioUtils.switchMapBrio(function(implParent)
+			return RxInstanceUtils.observeLastNamedChildBrio(implParent, "BindableEvent", name)
+		end);
+		RxBrioUtils.onlyLastBrioSurvives();
+	})
+
+end
+
+function TieSignalInterface:_getBindableEvent()
+	local implParent = self:GetImplParent()
+	if not implParent then
+		return nil
+	end
+
+	local implementation = implParent:FindFirstChild(self._memberDefinition:GetMemberName())
+	if implementation and implementation:IsA("BindableEvent") then
+		return implementation
+	else
+		return nil
+	end
+end
+
+return TieSignalInterface

package/src/Shared/Members/TieMemberDefinition.lua

@@ -0,0 +1,104 @@
+--[=[
+	Base class for a member definition/declaration.
+
+	@class TieMemberDefinition
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local TieRealmUtils = require("TieRealmUtils")
+local TieRealms = require("TieRealms")
+
+local TieMemberDefinition = {}
+TieMemberDefinition.ClassName = "TieMemberDefinition"
+TieMemberDefinition.__index = TieMemberDefinition
+
+function TieMemberDefinition.new(tieDefinition, memberName, memberTieRealm)
+	assert(TieRealmUtils.isTieRealm(memberTieRealm), "Bad memberTieRealm")
+
+	local self = setmetatable({}, TieMemberDefinition)
+
+	self._tieDefinition = assert(tieDefinition, "No tieDefinition")
+	self._memberName = assert(memberName, "Bad memberName")
+	self._memberTieRealm = assert(memberTieRealm, "No memberTieRealm")
+
+	return self
+end
+
+function TieMemberDefinition:Implement()
+	error("Not implemented")
+end
+
+function TieMemberDefinition:GetInterface()
+	error("Not implemented")
+end
+
+function TieMemberDefinition:GetFriendlyName()
+	return string.format("%s.%s", self._tieDefinition:GetName(), self._memberName)
+end
+
+function TieMemberDefinition:IsRequiredForInterface(currentRealm)
+	assert(TieRealmUtils.isTieRealm(currentRealm), "Bad currentRealm")
+
+	if self._memberTieRealm == TieRealms.SHARED then
+		return true
+	elseif currentRealm == TieRealms.SHARED then
+		-- Interface can retrieve just the smallest subset... can allow cross sharing unfortunately....
+		return false
+	else
+		return self._memberTieRealm == currentRealm
+	end
+end
+
+function TieMemberDefinition:IsAllowedOnInterface(currentRealm)
+	assert(TieRealmUtils.isTieRealm(currentRealm), "Bad currentRealm")
+
+	if self._memberTieRealm == TieRealms.SHARED then
+		return true
+	elseif currentRealm == TieRealms.SHARED then
+		-- Allow these to be used on interface if they exist...
+		return true
+	else
+		return self._memberTieRealm == currentRealm
+	end
+end
+
+function TieMemberDefinition:IsRequiredForImplementation(currentRealm)
+	assert(TieRealmUtils.isTieRealm(currentRealm), "Bad currentRealm")
+
+	if currentRealm == TieRealms.SHARED then
+		-- Require both client and server if we're shared to be implemented
+		return true
+	elseif self._memberTieRealm == TieRealms.SHARED then
+		return true
+	else
+		return self._memberTieRealm == currentRealm
+	end
+end
+
+function TieMemberDefinition:IsAllowedForImplementation(currentRealm)
+	assert(TieRealmUtils.isTieRealm(currentRealm), "Bad currentRealm")
+
+	if self._memberTieRealm == TieRealms.SHARED then
+		return true
+	elseif currentRealm == TieRealms.SHARED then
+		-- Allowed
+		return true
+	else
+		return self._memberTieRealm == currentRealm
+	end
+end
+
+function TieMemberDefinition:GetMemberTieRealm()
+	return self._memberTieRealm
+end
+
+function TieMemberDefinition:GetTieDefinition()
+	return self._tieDefinition
+end
+
+function TieMemberDefinition:GetMemberName()
+	return self._memberName
+end
+
+return TieMemberDefinition

package/src/Shared/Members/TieMemberInterface.lua

@@ -0,0 +1,94 @@
+--[=[
+	@class TieMemberInterface
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Rx = require("Rx")
+local RxBrioUtils = require("RxBrioUtils")
+local RxInstanceUtils = require("RxInstanceUtils")
+local TieRealmUtils = require("TieRealmUtils")
+
+local TieMemberInterface = {}
+TieMemberInterface.ClassName = "TieMemberInterface"
+TieMemberInterface.__index = TieMemberInterface
+
+function TieMemberInterface.new(implParent, adornee, memberDefinition, interfaceTieRealm)
+	assert(TieRealmUtils.isTieRealm(interfaceTieRealm), "Bad interfaceTieRealm")
+
+	local self = setmetatable({}, TieMemberInterface)
+
+	assert(implParent or adornee, "Parent or adornee required")
+
+	self._implParent = implParent
+	self._adornee = adornee
+	self._memberDefinition = assert(memberDefinition, "No memberDefinition")
+	self._interfaceTieRealm = assert(interfaceTieRealm, "No interfaceTieRealm")
+
+	self._tieDefinition = self._memberDefinition:GetTieDefinition()
+
+	return self
+end
+
+function TieMemberInterface:GetInterfaceTieRealm()
+	return self._interfaceTieRealm
+end
+
+function TieMemberInterface:GetImplParent()
+	local validContainerNameSet = self._tieDefinition:GetValidContainerNameSet(self._interfaceTieRealm)
+
+	if self._implParent and self._adornee then
+		if self._implParent.Parent == self._adornee and validContainerNameSet[self._implParent.Name] then
+			return self._implParent
+		else
+			return nil
+		end
+	elseif self._implParent then
+		if validContainerNameSet[self._implParent.Name] then
+			return self._implParent
+		else
+			return nil
+		end
+	elseif self._adornee then
+		return self._tieDefinition:GetImplementationParents(self._adornee, self._interfaceTieRealm)
+	else
+		error("Must have self._implParent or self._adornee")
+	end
+end
+
+function TieMemberInterface:ObserveImplParentBrio()
+	local validContainerNameSet = self._tieDefinition:GetValidContainerNameSet(self._interfaceTieRealm)
+
+	if self._implParent and self._adornee then
+		return Rx.combineLatest({
+			Parent = RxInstanceUtils.observeProperty(self._implParent, "Parent");
+			Name = RxInstanceUtils.observeProperty(self._implParent, "Name");
+		})
+		:Pipe({
+			Rx.map(function(state)
+				if validContainerNameSet[state.Name] and state.Parent == self._adornee then
+					return self._implParent
+				else
+					return nil
+				end
+			end);
+			Rx.distinct();
+			RxBrioUtils.toBrio();
+			RxBrioUtils.onlyLastBrioSurvives();
+		})
+	elseif self._implParent then
+		return RxInstanceUtils.observePropertyBrio(self._implParent, "Name", function(name)
+			return validContainerNameSet[name]
+		end):Pipe({
+			RxBrioUtils.map(function()
+				return self._implParent
+			end);
+		})
+	elseif self._adornee then
+		return self._tieDefinition:ObserveValidContainerChildrenBrio(self._adornee, self._interfaceTieRealm)
+	else
+		error("No self._implParent or adornee")
+	end
+end
+
+return TieMemberInterface

package/src/Shared/Realms/TieRealmUtils.lua

@@ -0,0 +1,41 @@
+--[=[
+	Utility methods to oeprate around [TieRealms]
+
+	@class TieRealmUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local RunService = game:GetService("RunService")
+local TieRealms = require("TieRealms")
+
+local TieRealmUtils = {}
+
+--[=[
+	Returns true if the value is a tie realm
+
+	@param tieRealm any
+	@return boolean
+]=]
+function TieRealmUtils.isTieRealm(tieRealm)
+	return tieRealm == TieRealms.CLIENT
+		or tieRealm == TieRealms.SERVER
+		or tieRealm == TieRealms.SHARED
+end
+
+--[=[
+	Infers the tie realm from the current RunService state
+
+	@return TieRealm
+]=]
+function TieRealmUtils.inferTieRealm()
+	if RunService:IsServer() then
+		return TieRealms.SERVER
+	elseif RunService:IsClient() then
+		return TieRealms.CLIENT
+	else
+		error("[TieRealmUtils.inferTieRealm] - Unknown RunService state")
+	end
+end
+
+return TieRealmUtils

package/src/Shared/{Definition/Types → Realms}/TieRealms.lua

@@ -7,10 +7,9 @@
 local require = require(script.Parent.loader).load(script)
 
 local Table = require("Table")
-local Symbol = require("Symbol")
 
 return Table.readonly({
-	SHARED = Symbol.named("shared");
-	CLIENT = Symbol.named("client");
-	SERVER = Symbol.named("server");
+	SHARED = "shared";
+	CLIENT = "client";
+	SERVER = "server";
 })

package/src/Shared/Services/TieRealmService.lua

@@ -0,0 +1,31 @@
+--[=[
+	@class TieRealmService
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local TieRealmUtils = require("TieRealmUtils")
+
+local TieRealmService = {}
+TieRealmService.ServiceName = "TieRealmService"
+
+function TieRealmService:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+	if not self._tieRealm then
+		self._tieRealm = TieRealmUtils.inferTieRealm()
+	end
+end
+
+function TieRealmService:SetTieRealm(tieRealm)
+	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
+
+	self._tieRealm = tieRealm
+end
+
+function TieRealmService:GetTieRealm()
+	return self._tieRealm
+end
+
+return TieRealmService