Initial commit

src/bind.luau

@@ -0,0 +1,125 @@
+local warn = warn -- todo
+
+if not game then
+    script = (require :: any) "test/wrap-require"
+    warn = print
+end
+
+local graph = require(script.Parent.graph)
+type Node<T> = graph.Node<T>
+local get = graph.get
+local set_effect = graph.set_effect
+local capture = graph.capture
+
+local throw = require(script.Parent.throw)
+local flags = require(script.Parent.flags)
+
+local hold: { Instance? } = {}
+local weak: { Instance? } = setmetatable({}, { __mode = "v" }) :: any 
+local bindcount = 0
+
+local srcs do
+    local src1 = debug.info(1, "s")
+    local srctrunc = string.sub(src1, 1, #src1-4)
+
+    srcs = {
+        src1,
+        srctrunc .. "apply",
+        srctrunc .. "create",
+    }
+end
+
+local function traceback() -- ensures trace begins outside of any vide library file
+    local s = 1
+    repeat
+        s += 1
+        local src = debug.info(s, "s")
+    until not table.find(srcs, src)
+    return debug.traceback("", s)
+end
+
+function setup(instance: Instance, setter: (Instance) -> ())
+    if flags.strict then
+        local fn = setter
+        local trace = traceback()
+        setter = function(instance)
+            local ok, err: string? = pcall(fn, instance)
+            if not ok then warn(`error occured updating state binding:\n{err}\nset from:{trace}`) end
+        end
+    end
+
+    local nodes = (capture(setter :: () -> unknown, instance))
+
+    for _, node in next, nodes do
+        set_effect(node, setter, instance)
+    end
+
+    bindcount += 1
+    local key = bindcount
+    
+    weak[key] = instance
+
+    local function ref()
+        local _ = setter
+        local instance = weak[key] :: Instance
+        hold[key] = instance.Parent and instance or nil -- prevent gc of instance while parented
+    end
+
+    ref()
+    instance:GetPropertyChangedSignal("Parent"):Connect(ref)
+end
+
+-- todo: move `fn` as arg?
+
+local function bind_property(instance: Instance, property: string, fn: () -> unknown)
+    setup(instance, function(instance_weak: any)
+        instance_weak[property] = fn()
+    end)
+end
+
+local function bind_parent(instance: Instance, fn: () -> Instance?)
+    instance.Destroying:Connect(function()
+        instance= nil :: any -- allow gc when destroyed
+    end)
+    setup(instance, function(instance)
+        local _ = instance -- state will strongly reference instance when parent is bound
+        instance.Parent = fn()    
+    end)
+end
+
+-- todo: could optimize, see: maps.luau values()
+local function bind_children(parent: Instance, fn: () -> { Instance })
+    local current_child_set: { [Instance]: true } = {} -- cache of all children parented before update
+    local new_child_set: { [Instance]: true } = {} -- cache of all children parented after update
+
+    setup(parent, function(parent_weak)
+        local new_childs = fn() -- all (and only) children that should be parented after this update
+        if new_childs and type(new_childs) ~= "table" then
+            throw(`Cannot parent instance of type { type(new_childs) } `)
+        end
+
+        if new_childs then
+            for _, child in next, new_childs do
+                new_child_set[child] = true -- record child set from this update
+                if not current_child_set[child] then
+                    child.Parent = parent_weak -- if child wasn't already parented then parent it
+                else 
+                    current_child_set[child] = nil -- remove child from cache if it was already in cache
+                end
+            end
+        end
+
+        for child in next, current_child_set do
+            child.Parent = nil -- unparent all children that weren't in the new children set
+        end
+
+        table.clear(current_child_set) -- clear cache, preserve capacity
+        current_child_set, new_child_set = new_child_set, current_child_set
+    end)
+end
+
+return {
+    property = bind_property,
+    parent = bind_parent,
+    children = bind_children,
+}