@quenty/tie 2.1.0 → 2.2.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.2.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/tie@2.1.0...@quenty/tie@2.2.0) (2022-07-31)
+
+
+### Features
+
+* Add Tie bindings in the opposite direction allowing out-of-oop systems to bind to tie ([6da4426](https://github.com/Quenty/NevermoreEngine/commit/6da4426bb47c9b88e099c461258163f8b26ee4b3))
+
+
+
+
+
 # [2.1.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/tie@2.0.0...@quenty/tie@2.1.0) (2022-06-21)
 
 **Note:** Version bump only for package @quenty/tie

package/README.md

@@ -21,4 +21,14 @@ npm install @quenty/tie --save
 ```
 
 ## Design philosophy
-This package does two things. First of all, it basically automates the creation of interfaced definitions, that is, tying a Lua object to BindableEvent/BindableFunction definitions. Second of all, it lets objects be centralized as an interface definition.
+This package does two things. First of all, it basically automates the creation of interfaced definitions, that is, tying a Lua object to BindableEvent/BindableFunction definitions. Second of all, it lets objects be centralized as an interface definition.
+
+## Changes to make
+
+1. Ensure tie properties can be attributes
+1. Allow tie functions instead of methods
+1. Add tie library as a primary interface (less OOP)
+1. Ensure you can ad-hoc create a tie (low-level scripting)
+1. Support tagged ties with
+1. Ensure ties can be queried via CollectionService
+1. Allow client implementation of server-based ties

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/tie",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Tie allows interfaces to be defined between Lua OOP and Roblox objects.",
   "keywords": [
     "Roblox",
@@ -28,23 +28,25 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/baseobject": "^5.0.0",
-    "@quenty/brio": "^6.1.0",
-    "@quenty/instanceutils": "^5.1.0",
+    "@quenty/attributeutils": "^6.2.0",
+    "@quenty/baseobject": "^5.1.0",
+    "@quenty/brio": "^6.2.0",
+    "@quenty/instanceutils": "^5.2.0",
     "@quenty/loader": "^5.0.0",
-    "@quenty/maid": "^2.3.0",
-    "@quenty/rx": "^5.1.0",
+    "@quenty/maid": "^2.4.0",
+    "@quenty/rx": "^5.2.0",
     "@quenty/string": "^2.3.0",
     "@quenty/symbol": "^2.1.0",
     "@quenty/table": "^3.1.0",
-    "@quenty/valueobject": "^5.1.0"
+    "@quenty/valuebaseutils": "^5.2.0",
+    "@quenty/valueobject": "^5.2.0"
   },
   "devDependencies": {
-    "@quenty/promise": "^5.0.0",
+    "@quenty/promise": "^5.1.0",
     "@quenty/signal": "^2.2.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c8732cc5dea767b3ff362db43137e2a16da7bc0d"
+  "gitHead": "e31b3a35aa475bb5699a24898a8639e107165b36"
 }

package/src/Shared/Definition/TieDefinition.lua

@@ -29,35 +29,57 @@ TieDefinition.ClassName = "TieDefinition"
 TieDefinition.__index = TieDefinition
 
 TieDefinition.Types = Table.readonly({
-	METHOD = "method";
-	SIGNAL = "signal";
-	PROPERTY = "valueobject";
+	METHOD = Symbol.named("method");
+	SIGNAL = Symbol.named("signal");
+	PROPERTY = Symbol.named("property"); -- will default to nil
 })
 
-function TieDefinition.new(definitionName, methods)
+function TieDefinition.new(definitionName, members, isSharedDefinition)
 	local self = setmetatable({}, TieDefinition)
 
 	self._definitionName = assert(definitionName, "No definitionName")
 	self._memberMap = {}
 
-	for memberName, memberType in pairs(methods) do
+	self._isSharedDefinition = isSharedDefinition
+
+	for memberName, memberTypeOrDefaultValue in pairs(members) do
 		assert(type(memberName) == "string", "Bad memberName")
 
-		if memberType == TieDefinition.Types.METHOD then
+		if memberTypeOrDefaultValue == TieDefinition.Types.METHOD then
 			self._memberMap[memberName] = TieMethodDefinition.new(self, memberName)
-		elseif memberType == TieDefinition.Types.SIGNAL then
+		elseif memberTypeOrDefaultValue == TieDefinition.Types.SIGNAL then
 			self._memberMap[memberName] = TieSignalDefinition.new(self, memberName)
-		elseif memberType == TieDefinition.Types.PROPERTY then
-			self._memberMap[memberName] = TiePropertyDefinition.new(self, memberName)
+		elseif memberTypeOrDefaultValue == TieDefinition.Types.PROPERTY then
+			self._memberMap[memberName] = TiePropertyDefinition.new(self, memberName, nil)
 		else
-			error(("Bad memberType %q for member %q for %q"):format(
-				tostring(memberType), tostring(memberName), self._definitionName))
+			self._memberMap[memberName] = TiePropertyDefinition.new(self, memberName, memberTypeOrDefaultValue)
 		end
 	end
 
 	return self
 end
 
+--[=[
+	Gets all valid interfaces for this adornee
+	@param adornee Instance
+	@return { TieInterface }
+]=]
+function TieDefinition:GetImplementations(adornee: Instance)
+	assert(typeof(adornee) == "Instance", "Bad adornee")
+
+	local implementations = {}
+
+	for _, item in pairs(adornee:GetChildren()) do
+		if item.Name == self:GetContainerName() then
+			if self:IsImplementation(item) then
+				table.insert(implementations, TieInterface.new(self, item, nil))
+			end
+		end
+	end
+
+	return implementations
+end
+
 --[=[
 	Returns true if the adornee implements the interface, and false otherwise.
 	@param adornee Instance
@@ -71,7 +93,7 @@ function TieDefinition:HasImplementation(adornee: Instance)
 		return false
 	end
 
-	return self:_checkImplementation(folder)
+	return self:IsImplementation(folder)
 end
 
 --[=[
@@ -82,7 +104,24 @@ end
 function TieDefinition:ObserveIsImplemented(adornee: Instance): boolean
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 
-	return self:ObserveImplementationBrio(adornee)
+	return self:ObserveLastImplementationBrio(adornee)
+		:Pipe({
+			RxBrioUtils.map(function(result)
+				return result and true or false
+			end);
+			RxBrioUtils.emitOnDeath(false);
+			Rx.defaultsTo(false);
+			Rx.distinct();
+		})
+end
+
+--[=[
+	Observes whether the folder is a valid implementation
+	@param folder Instance
+	@return Observable<boolean>>
+]=]
+function TieDefinition:ObserveIsImplementation(folder: Folder)
+	return self:_observeImplementation(folder)
 		:Pipe({
 			RxBrioUtils.map(function(result)
 				return result and true or false
@@ -93,78 +132,133 @@ function TieDefinition:ObserveIsImplemented(adornee: Instance): boolean
 		})
 end
 
+--[=[
+	Observes whether the folder is a valid implementation on the given adornee
+	@param folder Instance
+	@param adornee Instance
+	@return Observable<boolean>>
+]=]
+function TieDefinition:ObserveIsImplementedOn(folder: Folder, adornee: Instance)
+	assert(typeof(folder) == "Instance", "Bad folder")
+	assert(typeof(adornee) == "Instance", "Bad adornee")
+
+	return RxInstanceUtils.observePropertyBrio(folder, "Parent", function(parent)
+		return parent == adornee
+	end):Pipe({
+		RxBrioUtils.switchMapBrio(function()
+			return self:_observeImplementation(folder)
+		end);
+		RxBrioUtils.map(function(result)
+			return result and true or false
+		end);
+		RxBrioUtils.emitOnDeath(false);
+		Rx.defaultsTo(false);
+		Rx.distinct();
+	})
+end
+
 --[=[
 	Observes a valid implementation wrapped in a brio if it exists.
 	@param adornee Instance
 	@return Observable<Brio<TieImplementation<T>>>
 ]=]
-function TieDefinition:ObserveImplementationBrio(adornee: Instance)
+function TieDefinition:ObserveLastImplementationBrio(adornee: Instance)
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 
 	return RxInstanceUtils.observeLastNamedChildBrio(adornee, "Folder", self:GetContainerName())
 		:Pipe({
 			RxBrioUtils.switchMapBrio(function(folder)
-				return Observable.new(function(sub)
-					-- Bind to all children, instead of individually. This is a
-					-- performance gain.
-
-					local maid = Maid.new()
-
-					local update
-					do
-						local isImplemented = ValueObject.new(UNSET_VALUE)
-						maid:GiveTask(isImplemented)
-
-						maid:GiveTask(isImplemented.Changed:Connect(function()
-							maid._brio = nil
-
-							if isImplemented.Value then
-								local brio = Brio.new(self:Get(adornee))
-								sub:Fire(brio)
-								maid._brio = brio
-							else
-								maid._brio = nil
-							end
-						end))
-
-						function update()
-							isImplemented.Value = self:_checkImplementation(folder)
-						end
-					end
-
-					maid:GiveTask(folder.ChildAdded:Connect(function(child)
-						maid[child] = child:GetPropertyChangedSignal("Name"):Connect(update)
-						update()
-					end))
-
-					maid:GiveTask(folder.ChildRemoved:Connect(function(child)
-						maid[child] = nil
-						update()
-					end))
-
-					for _, child in pairs(folder:GetChildren()) do
-						maid[child] = child:GetPropertyChangedSignal("Name"):Connect(update)
-					end
-
-					update()
-
-					return maid
-				end)
+				return self:_observeImplementation(folder)
 			end)
 		})
 end
 
+--[=[
+	Observes valid implementations wrapped in a brio if it exists.
+	@param adornee Instance
+	@return Observable<Brio<TieImplementation<T>>>
+]=]
+function TieDefinition:ObserveImplementationsBrio(adornee: Instance)
+	assert(typeof(adornee) == "Instance", "Bad adornee")
+
+	return RxInstanceUtils.observeChildrenOfNameBrio(adornee, "Folder", self:GetContainerName())
+		:Pipe({
+			RxBrioUtils.flatMapBrio(function(folder)
+				return self:_observeImplementation(folder)
+			end)
+		})
+end
+
+function TieDefinition:_observeImplementation(folder)
+	return Observable.new(function(sub)
+		-- Bind to all children, instead of individually. This is a
+		-- performance gain.
+
+		local maid = Maid.new()
+
+		local update
+		do
+			local isImplemented = ValueObject.new(UNSET_VALUE)
+			maid:GiveTask(isImplemented)
+
+			maid:GiveTask(isImplemented.Changed:Connect(function()
+				maid._brio = nil
+
+				if isImplemented.Value then
+					local brio = Brio.new(TieInterface.new(self, folder, nil))
+					sub:Fire(brio)
+					maid._brio = brio
+				else
+					maid._brio = nil
+				end
+			end))
+
+			function update()
+				isImplemented.Value = self:IsImplementation(folder)
+			end
+		end
+
+		maid:GiveTask(folder.ChildAdded:Connect(function(child)
+			maid[child] = child:GetPropertyChangedSignal("Name"):Connect(update)
+			update()
+		end))
+
+		for memberName, member in pairs(self._memberMap) do
+			if member.ClassName == "TiePropertyDefinition" then
+				maid:GiveTask(folder:GetAttributeChangedSignal(memberName):Connect(update))
+			end
+		end
+
+		maid:GiveTask(folder.ChildRemoved:Connect(function(child)
+			maid[child] = nil
+			update()
+		end))
+
+		for _, child in pairs(folder:GetChildren()) do
+			maid[child] = child:GetPropertyChangedSignal("Name"):Connect(update)
+		end
+
+		update()
+
+		return maid
+	end)
+end
+
 --[=[
 	Ensures implementation of the object, binding table values and Lua OOP objects
 	to Roblox objects that can be invoked generally.
 
+	```lua
+
+	```
+
 	@param adornee Instance -- Adornee to implement interface on
-	@param implementer table -- Table with all interface values
+	@param implementer table? -- Table with all interface values or nil
 	@return TieImplementation<T>
 ]=]
 function TieDefinition:Implement(adornee: Instance, implementer)
 	assert(typeof(adornee) == "Instance", "Bad adornee")
-	assert(type(implementer) == "table", "Bad implementer")
+	assert(type(implementer) == "table" or implementer == nil, "Bad implementer")
 
 	return TieImplementation.new(self, adornee, implementer)
 end
@@ -181,7 +275,7 @@ end
 function TieDefinition:Get(adornee: Instance)
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 
-	return TieInterface.new(self, adornee)
+	return TieInterface.new(self, nil, adornee)
 end
 
 --[=[
@@ -193,7 +287,7 @@ function TieDefinition:GetName(): string
 end
 
 function TieDefinition:GetContainerName(): string
-	if RunService:IsClient() then
+	if RunService:IsClient() and not self._isSharedDefinition then
 		return self._definitionName .. "Client"
 	else
 		return self._definitionName
@@ -204,7 +298,8 @@ function TieDefinition:GetMemberMap()
 	return self._memberMap
 end
 
-function TieDefinition:_checkImplementation(folder)
+function TieDefinition:IsImplementation(folder)
+	local attributes = folder:GetAttributes()
 	local children = {}
 	for _, item in pairs(folder:GetChildren()) do
 		children[item.Name] = item
@@ -213,6 +308,14 @@ function TieDefinition:_checkImplementation(folder)
 	for memberName, member in pairs(self._memberMap) do
 		local found = children[memberName]
 		if not found then
+			if member.ClassName == "TiePropertyDefinition" then
+				if attributes[memberName] == nil then
+					return false
+				else
+					continue
+				end
+			end
+
 			return false
 		end
 

package/src/Shared/Definition/TieMethodDefinition.lua

@@ -4,6 +4,9 @@
 
 local require = require(script.Parent.loader).load(script)
 
+local TieMethodImplementation = require("TieMethodImplementation")
+local TieMethodInterfaceUtils = require("TieMethodInterfaceUtils")
+
 local TieMethodDefinition = {}
 TieMethodDefinition.ClassName = "TieMethodDefinition"
 TieMethodDefinition.__index = TieMethodDefinition
@@ -17,6 +20,21 @@ function TieMethodDefinition.new(tieDefinition, methodName)
 	return self
 end
 
+function TieMethodDefinition:Implement(folder, initialValue, actualSelf)
+	assert(typeof(folder) == "Instance", "Bad folder")
+	assert(actualSelf, "No actualSelf")
+
+	return TieMethodImplementation.new(self, folder, initialValue, actualSelf)
+end
+
+function TieMethodDefinition:GetInterface(folder: Folder, aliasSelf)
+	assert(typeof(folder) == "Instance", "Bad folder")
+	assert(aliasSelf, "No aliasSelf")
+
+	return TieMethodInterfaceUtils.get(aliasSelf, self._tieDefinition, self, folder, nil)
+end
+
+
 function TieMethodDefinition:GetTieDefinition()
 	return self._tieDefinition
 end

package/src/Shared/Definition/TiePropertyDefinition.lua

@@ -5,16 +5,19 @@
 local require = require(script.Parent.loader).load(script)
 
 local BaseObject = require("BaseObject")
+local TiePropertyImplementation = require("TiePropertyImplementation")
+local TiePropertyInterface = require("TiePropertyInterface")
 
 local TiePropertyDefinition = setmetatable({}, BaseObject)
 TiePropertyDefinition.ClassName = "TiePropertyDefinition"
 TiePropertyDefinition.__index = TiePropertyDefinition
 
-function TiePropertyDefinition.new(tieDefinition, propertyName: string)
+function TiePropertyDefinition.new(tieDefinition, propertyName: string, defaultValue: any)
 	local self = setmetatable(BaseObject.new(), TiePropertyDefinition)
 
 	self._tieDefinition = assert(tieDefinition, "No tieDefinition")
 	self._propertyName = assert(propertyName, "No propertyName")
+	self._defaultValue = defaultValue
 
 	return self
 end
@@ -23,6 +26,26 @@ function TiePropertyDefinition:GetTieDefinition()
 	return self._tieDefinition
 end
 
+function TiePropertyDefinition:IsAttribute()
+	return self._isAttribute
+end
+
+function TiePropertyDefinition:GetDefaultValue()
+	return self._defaultValue
+end
+
+function TiePropertyDefinition:Implement(folder: Folder, initialValue)
+	assert(typeof(folder) == "Instance", "Bad folder")
+
+	return TiePropertyImplementation.new(self, folder, initialValue)
+end
+
+function TiePropertyDefinition:GetInterface(folder: Folder)
+	assert(typeof(folder) == "Instance", "Bad folder")
+
+	return TiePropertyInterface.new(folder, nil, self)
+end
+
 function TiePropertyDefinition:GetMemberName(): string
 	return self._propertyName
 end

package/src/Shared/Definition/TieSignalDefinition.lua

@@ -4,6 +4,9 @@
 
 local require = require(script.Parent.loader).load(script)
 
+local TieSignalImplementation = require("TieSignalImplementation")
+local TieSignalInterface = require("TieSignalInterface")
+
 local TieSignalDefinition = {}
 TieSignalDefinition.ClassName = "TieSignalDefinition"
 TieSignalDefinition.__index = TieSignalDefinition
@@ -21,6 +24,18 @@ function TieSignalDefinition:GetTieDefinition()
 	return self._tieDefinition
 end
 
+function TieSignalDefinition:Implement(folder, initialValue)
+	assert(typeof(folder) == "Instance", "Bad folder")
+
+	return TieSignalImplementation.new(self, folder, initialValue)
+end
+
+function TieSignalDefinition:GetInterface(folder: Folder)
+	assert(typeof(folder) == "Instance", "Bad folder")
+
+	return TieSignalInterface.new(folder, nil, self)
+end
+
 function TieSignalDefinition:GetMemberName()
 	return self._signalName
 end

package/src/Shared/Encoding/TieUtils.lua

@@ -2,8 +2,6 @@
 	@class TieUtils
 ]=]
 
-local require = require(script.Parent.loader).load(script)
-
 local TieUtils = {}
 
 --[=[