@quenty/tie 10.6.0 → 10.7.0

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [10.7.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/tie@10.6.0...@quenty/tie@10.7.0) (2024-09-12)
+
+
+### Bug Fixes
+
+* Tie signal implementation fix ([8dc23bb](https://github.com/Quenty/NevermoreEngine/commit/8dc23bb8300598431a58b273ee2382ee90e76243))
+* TODO FIX THIS ([3731acd](https://github.com/Quenty/NevermoreEngine/commit/3731acdf4cf888bdac55157670fc61d6a6ba7c3d))
+
+
+### Features
+
+* Add tuple package and fix tie signal ([134f90c](https://github.com/Quenty/NevermoreEngine/commit/134f90c03b265b9d2232198475ca27f4d5e87071))
+* Allow default values to be defined for TiePropertyDefinition ([89112f1](https://github.com/Quenty/NevermoreEngine/commit/89112f15ffdc8c637681ba9f4e7aa1c60e2c7e23))
+* Unedited all changes ([60e64e3](https://github.com/Quenty/NevermoreEngine/commit/60e64e3efce17c10c4b8965871187d231b338dd4))
+
+
+
+
+
 # [10.6.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/tie@10.5.0...@quenty/tie@10.6.0) (2024-08-09)
 
 **Note:** Version bump only for package @quenty/tie

package/README.md

@@ -32,3 +32,7 @@ This package does two things. First of all, it basically automates the creation
 1. Support tagged ties with
 1. Ensure ties can be queried via CollectionService
 1. Allow client implementation of server-based ties
+
+## Realms
+
+1. By default everything is a "shared" realm

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/tie",
-  "version": "10.6.0",
+  "version": "10.7.0",
   "description": "Tie allows interfaces to be defined between Lua OOP and Roblox objects.",
   "keywords": [
     "Roblox",
@@ -28,27 +28,28 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/attributeutils": "^14.4.0",
-    "@quenty/baseobject": "^10.3.0",
-    "@quenty/brio": "^14.4.0",
-    "@quenty/collectionserviceutils": "^8.4.0",
-    "@quenty/instanceutils": "^13.4.0",
-    "@quenty/loader": "^10.3.0",
-    "@quenty/maid": "^3.2.0",
-    "@quenty/rx": "^13.4.0",
-    "@quenty/statestack": "^14.5.0",
+    "@quenty/attributeutils": "^14.5.0",
+    "@quenty/baseobject": "^10.4.0",
+    "@quenty/brio": "^14.5.0",
+    "@quenty/collectionserviceutils": "^8.5.0",
+    "@quenty/instanceutils": "^13.5.0",
+    "@quenty/loader": "^10.4.0",
+    "@quenty/maid": "^3.3.0",
+    "@quenty/rx": "^13.5.0",
+    "@quenty/statestack": "^14.6.0",
     "@quenty/string": "^3.2.0",
     "@quenty/symbol": "^3.1.0",
     "@quenty/table": "^3.5.0",
-    "@quenty/valuebaseutils": "^13.4.0",
-    "@quenty/valueobject": "^13.4.0"
+    "@quenty/tuple": "^1.1.0",
+    "@quenty/valuebaseutils": "^13.5.0",
+    "@quenty/valueobject": "^13.5.0"
   },
   "devDependencies": {
-    "@quenty/promise": "^10.3.0",
-    "@quenty/signal": "^7.3.0"
+    "@quenty/promise": "^10.4.0",
+    "@quenty/signal": "^7.4.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ba466bdbc05c42fb607cf5e228c16339201d21d7"
+  "gitHead": "fb172906f3ee725269ec1e5f4daf9dca227e729d"
 }

package/src/Shared/Members/Methods/TieMethodDefinition.lua

@@ -0,0 +1,44 @@
+--[=[
+	@class TieMethodDefinition
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local TieMethodImplementation = require("TieMethodImplementation")
+local TieMethodInterfaceUtils = require("TieMethodInterfaceUtils")
+local TieMemberDefinition = require("TieMemberDefinition")
+local TieRealmUtils = require("TieRealmUtils")
+
+local TieMethodDefinition = setmetatable({}, TieMemberDefinition)
+TieMethodDefinition.ClassName = "TieMethodDefinition"
+TieMethodDefinition.__index = TieMethodDefinition
+
+function TieMethodDefinition.new(tieDefinition, methodName, memberTieRealm)
+	assert(TieRealmUtils.isTieRealm(memberTieRealm), "Bad memberTieRealm")
+
+	local self = setmetatable(TieMemberDefinition.new(tieDefinition, methodName, memberTieRealm), TieMethodDefinition)
+
+	return self
+end
+
+function TieMethodDefinition:GetFriendlyName()
+	return string.format("%s:%s()", self._tieDefinition:GetName(), self._memberName)
+end
+
+function TieMethodDefinition:Implement(implParent: Instance, initialValue, actualSelf, tieRealm)
+	assert(typeof(implParent) == "Instance", "Bad implParent")
+	assert(actualSelf, "No actualSelf")
+	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
+
+	return TieMethodImplementation.new(self, implParent, initialValue, actualSelf)
+end
+
+function TieMethodDefinition:GetInterface(implParent: Instance, aliasSelf, tieRealm)
+	assert(typeof(implParent) == "Instance", "Bad implParent")
+	assert(aliasSelf, "No aliasSelf")
+	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
+
+	return TieMethodInterfaceUtils.get(aliasSelf, self, implParent, nil, tieRealm)
+end
+
+return TieMethodDefinition

package/src/Shared/{Implementation → Members/Methods}/TieMethodImplementation.lua

@@ -11,18 +11,17 @@ local TieMethodImplementation = setmetatable({}, BaseObject)
 TieMethodImplementation.ClassName = "TieMethodImplementation"
 TieMethodImplementation.__index = TieMethodImplementation
 
-function TieMethodImplementation.new(memberDefinition, folder, initialValue, actualSelf)
+function TieMethodImplementation.new(memberDefinition, parent, initialValue, actualSelf)
 	local self = setmetatable(BaseObject.new(), TieMethodImplementation)
 
 	self._memberDefinition = assert(memberDefinition, "No memberDefinition")
-	self._folder = assert(folder, "No folder")
+	self._parent = assert(parent, "No parent")
 	self._actualSelf = assert(actualSelf, "No actualSelf")
 
-	self._bindableFunction = Instance.new("BindableFunction")
+	self._bindableFunction = self._maid:Add(Instance.new("BindableFunction"))
 	self._bindableFunction.Name = memberDefinition:GetMemberName()
 	self._bindableFunction.Archivable = false
-	self._bindableFunction.Parent = self._folder
-	self._maid:GiveTask(self._bindableFunction)
+	self._bindableFunction.Parent = self._parent
 
 	self:SetImplementation(initialValue)
 

package/src/Shared/Members/Methods/TieMethodInterfaceUtils.lua

@@ -0,0 +1,58 @@
+--[=[
+	@class TieMethodInterfaceUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local TieUtils = require("TieUtils")
+local TieRealmUtils = require("TieRealmUtils")
+
+local TieMethodInterfaceUtils = {}
+
+function TieMethodInterfaceUtils.get(aliasSelf, tieMethodDefinition, implParent, adornee, interfaceTieRealm)
+	assert(TieRealmUtils.isTieRealm(interfaceTieRealm), "Bad interfaceTieRealm")
+
+	local tieDefinition = tieMethodDefinition:GetTieDefinition()
+
+	return function(firstArg, ...)
+		if firstArg ~= aliasSelf then
+			error(string.format("Must call methods with self as first parameter (Hint use `%s:%s()` instead of `%s.%s()`)",
+				tieDefinition:GetName(),
+				tieMethodDefinition:GetMemberName(),
+				tieDefinition:GetName(),
+				tieMethodDefinition:GetMemberName()))
+		end
+
+		if implParent and adornee then
+			if implParent.Parent ~= adornee then
+				error("implParent is not a parent of the adornee")
+			end
+		elseif implParent then
+			implParent = implParent
+		elseif adornee then
+			-- Search the adornee (rip this is SO slow)
+
+			local validContainerNameSet = tieDefinition:GetValidContainerNameSet(interfaceTieRealm)
+			for containerName, _ in pairs(validContainerNameSet) do
+				local found = adornee:FindFirstChild(containerName)
+				if found then
+					local bindableFunction = found:FindFirstChild(tieMethodDefinition:GetMemberName())
+					if bindableFunction then
+						return TieUtils.decode(bindableFunction:Invoke(TieUtils.encode(...)))
+					end
+				end
+			end
+
+			error(string.format("No implemented for %s on %q", tieMethodDefinition:GetFriendlyName(), implParent:GetFullName()))
+		end
+
+		local bindableFunction = implParent:FindFirstChild(tieMethodDefinition:GetMemberName())
+		if not bindableFunction then
+			error(string.format("No implemented for %s on %q", tieMethodDefinition:GetFriendlyName(), implParent:GetFullName()))
+		end
+
+		return TieUtils.decode(bindableFunction:Invoke(TieUtils.encode(...)))
+	end;
+end
+
+return TieMethodInterfaceUtils

package/src/Shared/{Interface → Members/Properties}/TiePropertyChangedSignalConnection.lua

@@ -31,7 +31,7 @@ function TiePropertyChangedSignalConnection:__index(index)
 	elseif TiePropertyChangedSignalConnection[index] then
 		return TiePropertyChangedSignalConnection[index]
 	else
-		error(("Bad index %q for TiePropertyChangedSignalConnection"):format(tostring(index)))
+		error(string.format("Bad index %q for TiePropertyChangedSignalConnection", tostring(index)))
 	end
 end
 

package/src/Shared/Members/Properties/TiePropertyDefinition.lua

@@ -0,0 +1,58 @@
+--[=[
+	@class TiePropertyDefinition
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local TiePropertyImplementation = require("TiePropertyImplementation")
+local TiePropertyInterface = require("TiePropertyInterface")
+local TieMemberDefinition = require("TieMemberDefinition")
+local TieRealmUtils = require("TieRealmUtils")
+
+local TiePropertyDefinition = setmetatable({}, TieMemberDefinition)
+TiePropertyDefinition.ClassName = "TiePropertyDefinition"
+TiePropertyDefinition.__index = TiePropertyDefinition
+
+function TiePropertyDefinition.new(tieDefinition, propertyName: string, defaultValue: any, memberTieRealm)
+	assert(TieRealmUtils.isTieRealm(memberTieRealm), "Bad memberTieRealm")
+
+	local self = setmetatable(TieMemberDefinition.new(tieDefinition, propertyName, memberTieRealm), TiePropertyDefinition)
+
+	self._defaultValue = defaultValue
+
+	return self
+end
+
+function TiePropertyDefinition:GetDefaultValue()
+	return self._defaultValue
+end
+
+function TiePropertyDefinition:IsRequiredForImplementation(currentRealm)
+	-- Override
+	if getmetatable(TiePropertyDefinition).IsRequiredForImplementation(self, currentRealm) then
+		if self:GetDefaultValue() ~= nil then
+			return false
+		end
+
+		return true
+	end
+
+	return false
+end
+
+function TiePropertyDefinition:Implement(implParent: Instance, initialValue, _actualSelf, tieRealm)
+	assert(typeof(implParent) == "Instance", "Bad implParent")
+	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
+
+	return TiePropertyImplementation.new(self, implParent, initialValue, tieRealm)
+end
+
+function TiePropertyDefinition:GetInterface(implParent: Instance, _actualSelf, tieRealm)
+	assert(typeof(implParent) == "Instance", "Bad implParent")
+	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
+
+	return TiePropertyInterface.new(implParent, nil, self, tieRealm)
+end
+
+
+return TiePropertyDefinition

package/src/Shared/{Interface → Members/Properties}/TiePropertyInterface.lua

@@ -4,37 +4,30 @@
 
 local require = require(script.Parent.loader).load(script)
 
+local AttributeUtils = require("AttributeUtils")
+local AttributeValue = require("AttributeValue")
 local Maid = require("Maid")
 local Observable = require("Observable")
 local Rx = require("Rx")
 local RxBrioUtils = require("RxBrioUtils")
 local RxInstanceUtils = require("RxInstanceUtils")
 local String = require("String")
-local TieInterfaceUtils = require("TieInterfaceUtils")
+local Symbol = require("Symbol")
 local TiePropertyChangedSignalConnection = require("TiePropertyChangedSignalConnection")
 local TiePropertyImplementationUtils = require("TiePropertyImplementationUtils")
 local TieUtils = require("TieUtils")
 local ValueBaseUtils = require("ValueBaseUtils")
 local ValueObject = require("ValueObject")
-local AttributeUtils = require("AttributeUtils")
-local AttributeValue = require("AttributeValue")
-local Symbol = require("Symbol")
+local TieMemberInterface = require("TieMemberInterface")
 
 local UNSET_VALUE = Symbol.named("unsetValue")
 
-local TiePropertyInterface = {}
+local TiePropertyInterface = setmetatable({}, TieMemberInterface)
 TiePropertyInterface.ClassName = "TiePropertyInterface"
 TiePropertyInterface.__index = TiePropertyInterface
 
-function TiePropertyInterface.new(folder, adornee, memberDefinition)
-	local self = setmetatable({}, TiePropertyInterface)
-
-	assert(folder or adornee, "Folder or adornee required")
-
-	self._folder = folder
-	self._adornee = adornee
-	self._memberDefinition = assert(memberDefinition, "No memberDefinition")
-	self._tieDefinition = self._memberDefinition:GetTieDefinition()
+function TiePropertyInterface.new(implParent, adornee, memberDefinition, interfaceTieRealm)
+	local self = setmetatable(TieMemberInterface.new(implParent, adornee, memberDefinition, interfaceTieRealm), TiePropertyInterface)
 
 	return self
 end
@@ -84,17 +77,13 @@ function TiePropertyInterface:Observe()
 	})
 end
 
-function TiePropertyInterface:_getFolder()
-	return TieInterfaceUtils.getFolder(self._tieDefinition, self._folder, self._adornee)
-end
-
 function TiePropertyInterface:_findValueBase()
-	local folder = self:_getFolder()
-	if not folder then
+	local implParent = self:GetImplParent()
+	if not implParent then
 		return nil
 	end
 
-	local implementation = folder:FindFirstChild(self._memberDefinition:GetMemberName())
+	local implementation = implParent:FindFirstChild(self._memberDefinition:GetMemberName())
 	if not implementation then
 		return nil
 	end
@@ -112,21 +101,20 @@ end
 function TiePropertyInterface:_getValueBaseOrError()
 	local valueBase = self:_findValueBase()
 	if not valueBase then
-		error(("%s.%s is not implemented for %s"):format(
-			self._tieDefinition:GetContainerName(),
-			self._memberDefinition:GetMemberName(),
+		error(string.format("%s.%s is not implemented for %s",
+			self._memberDefinition:GetFriendlyName(),
 			self:_getFullName()))
 	end
 	return valueBase
 end
 
 function TiePropertyInterface:_getFullName()
-	if self._folder then
-		return self._folder:GetFullName()
+	if self._implParent then
+		return self._implParent:GetFullName()
 	elseif self._adornee then
 		return self._adornee:GetFullName()
 	else
-		error("[TiePropertyInterface] - Either folder or adornee should be defined")
+		error("[TiePropertyInterface] - Either implParent or adornee should be defined")
 	end
 end
 
@@ -135,8 +123,7 @@ function TiePropertyInterface:_getChangedEvent()
 		Connect = function(_, callback)
 			assert(type(callback) == "function", "Bad callback")
 			return TiePropertyChangedSignalConnection.new(function(connMaid)
-				local valueObject = ValueObject.new(nil)
-				connMaid:GiveTask(valueObject)
+				local valueObject = connMaid:Add(ValueObject.new(nil)		)
 
 				connMaid:GiveTask(self:Observe():Subscribe(function(value)
 					valueObject.Value = value
@@ -154,7 +141,7 @@ local IMPLEMENTATION_TYPES = {
 	none = "none";
 }
 
-function TiePropertyInterface:_observeFromFolder(folder)
+function TiePropertyInterface:_observeFromImplParent(implParent)
 	return Observable.new(function(sub)
 		local memberName = self._memberDefinition:GetMemberName()
 		local topMaid = Maid.new()
@@ -169,11 +156,11 @@ function TiePropertyInterface:_observeFromFolder(folder)
 			end
 
 			-- Prioritize attributes first
-			local currentAttribute = folder:GetAttribute(memberName)
+			local currentAttribute = implParent:GetAttribute(memberName)
 			if currentAttribute ~= nil then
 				if lastImplementationType ~= IMPLEMENTATION_TYPES.attribute then
 					lastImplementationType = IMPLEMENTATION_TYPES.attribute
-					sub:Fire(AttributeValue.new(folder, memberName))
+					sub:Fire(AttributeValue.new(implParent, memberName))
 				end
 
 				return
@@ -210,7 +197,7 @@ function TiePropertyInterface:_observeFromFolder(folder)
 		end
 
 		-- Subscribe to named children
-		topMaid:GiveTask(RxInstanceUtils.observeChildrenOfNameBrio(folder, "Instance", self._memberDefinition:GetMemberName())
+		topMaid:GiveTask(RxInstanceUtils.observeChildrenOfNameBrio(implParent, "Instance", self._memberDefinition:GetMemberName())
 			:Subscribe(function(brio)
 				if brio:IsDead() then
 					return
@@ -233,7 +220,7 @@ function TiePropertyInterface:_observeFromFolder(folder)
 				update()
 			end))
 
-		topMaid:GiveTask(folder:GetAttributeChangedSignal(memberName):Connect(update))
+		topMaid:GiveTask(implParent:GetAttributeChangedSignal(memberName):Connect(update))
 		update()
 
 		return topMaid
@@ -241,25 +228,21 @@ function TiePropertyInterface:_observeFromFolder(folder)
 end
 
 function TiePropertyInterface:_observeValueBaseBrio()
-	return self:_observeFolderBrio():Pipe({
-		RxBrioUtils.switchMapBrio(function(folder)
-			return self:_observeFromFolder(folder)
+	return self:ObserveImplParentBrio():Pipe({
+		RxBrioUtils.switchMapBrio(function(implParent)
+			return self:_observeFromImplParent(implParent)
 		end);
 		RxBrioUtils.onlyLastBrioSurvives();
 	})
 end
 
-function TiePropertyInterface:_observeFolderBrio()
-	return TieInterfaceUtils.observeFolderBrio(self._tieDefinition, self._folder, self._adornee)
-end
-
 function TiePropertyInterface:__index(index)
 	if TiePropertyInterface[index] then
 		return TiePropertyInterface[index]
 	elseif index == "Value" then
-		local folder = self:_getFolder()
-		if folder then
-			local currentAttributeValue = folder:GetAttribute(self._memberDefinition:GetMemberName())
+		local implParent = self:GetImplParent()
+		if implParent then
+			local currentAttributeValue = implParent:GetAttribute(self._memberDefinition:GetMemberName())
 			if currentAttributeValue ~= nil then
 				return currentAttributeValue
 			end
@@ -269,51 +252,51 @@ function TiePropertyInterface:__index(index)
 		return valueBase.Value
 	elseif index == "Changed" then
 		return self:_getChangedEvent()
-	elseif index == "_adornee" or index == "_folder" or index == "_memberDefinition" or index == "_tieDefinition" then
+	elseif index == "_adornee" or index == "_implParent" or index == "_memberDefinition" or index == "_tieDefinition" then
 		return rawget(self, index)
 	else
-		error(("Bad index %q for TiePropertyInterface"):format(tostring(index)))
+		error(string.format("Bad index %q for TiePropertyInterface", tostring(index)))
 	end
 end
 
 function TiePropertyInterface:__newindex(index, value)
-	if index == "_adornee" or index == "_folder" or index == "_memberDefinition" or index == "_tieDefinition" then
+	if index == "_adornee" or index == "_implParent" or index == "_memberDefinition" or index == "_tieDefinition" then
 		rawset(self, index, value)
 	elseif index == "Value" then
 		local className = ValueBaseUtils.getClassNameFromType(typeof(value))
 		if not className then
-			error(("[TiePropertyImplementation] - Bad implementation value type %q, cannot set"):format(typeof(value)))
+			error(string.format("[TiePropertyImplementation] - Bad implementation value type %q, cannot set", typeof(value)))
 		end
 
 		local valueBase = self:_findValueBase()
 		if type(valueBase) == "table" or (typeof(valueBase) == "Instance" and valueBase.ClassName == className) then
 			valueBase.Value = value
 		elseif AttributeUtils.isValidAttributeType(typeof(value)) and value ~= nil then
-			local folder = self:_getFolder()
-			if folder then
-				folder:SetAttribute(self._memberDefinition:GetMemberName(), value)
+			local implParent = self:GetImplParent()
+			if implParent then
+				implParent:SetAttribute(self._memberDefinition:GetMemberName(), value)
 
 				-- Remove existing as needed
-				local current = folder:FindFirstChild(self._memberDefinition:GetMemberName())
+				local current = implParent:FindFirstChild(self._memberDefinition:GetMemberName())
 				if current then
 					current:Destroy()
 				end
 				return
 			end
 		else
-			local folder = self:_getFolder()
-			if folder then
-				local copy = TiePropertyImplementationUtils.changeToClassIfNeeded(self._memberDefinition, folder, className)
+			local implParent = self:GetImplParent()
+			if implParent then
+				local copy = TiePropertyImplementationUtils.changeToClassIfNeeded(self._memberDefinition, implParent, className)
 				copy.Value = value
-				copy.Parent = folder
+				copy.Parent = implParent
 			else
-				error(("[TiePropertyImplementation] - No folder for %q"):format(self._memberDefinition:GetMemberName()))
+				error(string.format("[TiePropertyImplementation] - No implParent for %q", self._memberDefinition:GetMemberName()))
 			end
 		end
 	elseif index == "Changed" then
-		error(("Cannot assign %q for TiePropertyInterface"):format(tostring(index)))
+		error(string.format("Cannot assign %q for TiePropertyInterface", tostring(index)))
 	else
-		error(("Bad index %q for TiePropertyInterface"):format(tostring(index)))
+		error(string.format("Bad index %q for TiePropertyInterface", tostring(index)))
 	end
 end
 

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

@@ -0,0 +1,63 @@
+--[=[
+	@class TieSignalConnection
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Maid = require("Maid")
+local TieUtils = require("TieUtils")
+
+local TieSignalConnection = {}
+TieSignalConnection.ClassName = "TieSignalConnection"
+TieSignalConnection.__index = TieSignalConnection
+
+function TieSignalConnection.new(tieSignalInterface, callback)
+	local self = setmetatable({}, TieSignalConnection)
+
+	self._maid = Maid.new()
+	self._connected = true
+
+	self._tieSignalInterface = assert(tieSignalInterface, "No tieSignalInterface")
+	self._callback = assert(callback, "No callback")
+
+	self:_connect()
+
+	return self
+end
+
+function TieSignalConnection:Disconnect()
+	self:Destroy()
+end
+
+function TieSignalConnection:_connect()
+	self._maid:GiveTask(self._tieSignalInterface:ObserveBindableEventBrio():Subscribe(function(brio)
+		if brio:IsDead() then
+			return
+		end
+
+		local maid, bindableEvent = brio:ToMaidAndValue()
+		maid:GiveTask(bindableEvent.Event:Connect(function(...)
+			task.spawn(self._callback, TieUtils.decode(...))
+		end))
+	end))
+end
+
+function TieSignalConnection:__index(index)
+	if index == "_tieSignalInterface" then
+		return rawget(self, index)
+	elseif index == "IsConnected" then
+		return self._connected
+	elseif TieSignalConnection[index] then
+		return TieSignalConnection[index]
+	else
+		error(string.format("Bad index %q for TieSignalConnection", tostring(index)))
+	end
+end
+
+function TieSignalConnection:Destroy()
+	self._connected = false
+	self._maid:DoCleaning()
+	-- Avoid setting the metatable so calling methods is always valid
+end
+
+return TieSignalConnection

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

@@ -0,0 +1,38 @@
+--[=[
+	@class TieSignalDefinition
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local TieMemberDefinition = require("TieMemberDefinition")
+local TieSignalImplementation = require("TieSignalImplementation")
+local TieSignalInterface = require("TieSignalInterface")
+local TieRealmUtils = require("TieRealmUtils")
+
+local TieSignalDefinition = setmetatable({}, TieMemberDefinition)
+TieSignalDefinition.ClassName = "TieSignalDefinition"
+TieSignalDefinition.__index = TieSignalDefinition
+
+function TieSignalDefinition.new(tieDefinition, signalName, memberTieRealm)
+	assert(TieRealmUtils.isTieRealm(memberTieRealm), "Bad memberTieRealm")
+
+	local self = setmetatable(TieMemberDefinition.new(tieDefinition, signalName, memberTieRealm), TieSignalDefinition)
+
+	return self
+end
+
+function TieSignalDefinition:Implement(implParent: Instance, initialValue, _actualSelf, tieRealm)
+	assert(typeof(implParent) == "Instance", "Bad implParent")
+	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
+
+	return TieSignalImplementation.new(self, implParent, initialValue, tieRealm)
+end
+
+function TieSignalDefinition:GetInterface(implParent: Instance, _actualSelf, tieRealm)
+	assert(typeof(implParent) == "Instance", "Bad implParent")
+	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
+
+	return TieSignalInterface.new(implParent, nil, self, tieRealm)
+end
+
+return TieSignalDefinition