Initial commit

src/apply.luau

@@ -0,0 +1,83 @@
+if not game then
+    script = (require :: any) "test/wrap-require"
+    typeof = require "test/mock".typeof
+end
+
+local graph = require(script.Parent.graph)
+type Node<T> = graph.Node<T>
+
+local throw = require(script.Parent.throw)
+local bind = require(script.Parent.bind)
+local _, is_action = require(script.Parent.action)()
+
+local event_buffer: { [string]: () -> () } = {}
+local action_buffers = {} :: { { () -> () } }
+
+setmetatable(action_buffers :: any, {
+    __index = function(_, i: number)
+        action_buffers[i] = {}
+        return action_buffers[i]
+    end
+})
+
+local function recurse(instance: Instance, properties: { [unknown]: unknown })
+    for property, value in properties do
+        if type(value) == "table" then
+            if is_action(value) then
+                table.insert(action_buffers[(value :: any).priority], (value :: any).callback :: () -> ())
+            else
+                recurse(instance, value :: {})
+            end
+        elseif type(property) == "string" then
+            if type(value) == "function" then
+                if typeof((instance :: any)[property]) == "RBXScriptSignal" then
+                    event_buffer[property] = value  :: () -> ()
+                else
+                    bind.property(instance, property, value :: () -> ())
+                end
+            else
+                (instance :: any)[property] = value
+            end    
+        elseif type(property) == "number" then
+            if type(value) == "function" then
+                bind.children(instance, value :: () -> { Instance })
+            else
+                (value :: Instance).Parent = instance
+            end
+        end
+    end
+end
+
+local function apply<T>(instance: T & Instance, properties: { [unknown]: unknown }): T
+    local parent: unknown = properties.Parent 
+    if parent then properties.Parent = nil end
+
+    table.clear(event_buffer)
+    for _, buffer in next, action_buffers do
+        table.clear(buffer)
+    end
+
+    recurse(instance, properties)
+
+    for event, fn in next, event_buffer do
+        (instance :: any)[event]:Connect(fn)   
+    end
+
+    for _, buffer in next, action_buffers do
+        for _, callback in next, buffer do
+            callback()
+        end
+    end
+
+    if parent then
+        if type(parent) == "function" then
+            error("cannot set parent to state")
+        else
+            instance.Parent = parent :: Instance
+        end
+    end
+
+    return instance
+end
+
+return apply