@rbxts/centurion-ui 1.0.8 → 2.0.0-rc.1

package/vide/src/defaults.luau

@@ -0,0 +1,113 @@
+local Enum = game and Enum or require "../test/mock".Enum :: never
+local Color3 = game and Color3 or require "../test/mock".Color3 :: never
+
+return {
+    Part = {
+        Material = Enum.Material.SmoothPlastic,
+        Size = vector.create(1, 1, 1),
+        Anchored = true
+    },
+
+    BillboardGui = {
+        ResetOnSpawn = false,
+        ZIndexBehavior = Enum.ZIndexBehavior.Sibling
+    },
+
+    CanvasGroup = nil,
+
+    Frame = {
+        BackgroundColor3 = Color3.new(1, 1, 1),
+        BorderColor3 = Color3.new(0, 0, 0),
+        BorderSizePixel = 0
+    },
+
+    ImageButton = {
+        BackgroundColor3 = Color3.new(1, 1, 1),
+        BorderColor3 = Color3.new(0, 0, 0),
+        BorderSizePixel = 0,
+        AutoButtonColor = false
+    },
+
+    ImageLabel = {
+        BackgroundColor3 = Color3.new(1, 1, 1),
+        BorderColor3 = Color3.new(0, 0, 0),
+        BorderSizePixel = 0,
+    },
+
+    ScreenGui = {
+        ResetOnSpawn = false,
+        ZIndexBehavior = Enum.ZIndexBehavior.Sibling
+    },
+
+    ScrollingFrame = {
+        BackgroundColor3 = Color3.new(1, 1, 1),
+        BorderColor3 = Color3.new(0, 0, 0),
+        BorderSizePixel = 0,
+        ScrollBarImageColor3 = Color3.new(0, 0, 0)
+    },
+    
+    SurfaceGui = {
+        ResetOnSpawn = false,
+        ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
+
+        PixelsPerStud = 50,
+        SizingMode = Enum.SurfaceGuiSizingMode.PixelsPerStud
+    },
+    
+    TextBox = {
+        BackgroundColor3 = Color3.new(1, 1, 1),
+        BorderColor3 = Color3.new(0, 0, 0),
+        BorderSizePixel = 0,
+        ClearTextOnFocus = false,
+        Font = Enum.Font.SourceSans,
+        Text = "",
+        TextColor3 = Color3.new(0, 0, 0)
+    },
+
+    TextButton = {
+        BackgroundColor3 = Color3.new(1, 1, 1),
+        BorderColor3 = Color3.new(0, 0, 0),
+        BorderSizePixel = 0,
+        AutoButtonColor = false,
+        Font = Enum.Font.SourceSans,
+        Text = "",
+        TextColor3 = Color3.new(0, 0, 0)
+    },
+    
+    TextLabel = {
+        BackgroundColor3 = Color3.new(1, 1, 1),
+        BorderColor3 = Color3.new(0, 0, 0),
+        BorderSizePixel = 0,
+        Font = Enum.Font.SourceSans,
+        Text = "",
+        TextColor3 = Color3.new(0, 0, 0)
+    },
+    
+    UIListLayout = {
+        SortOrder = Enum.SortOrder.LayoutOrder
+    },
+   
+    UIGridLayout = {
+        SortOrder = Enum.SortOrder.LayoutOrder
+    },
+
+    UITableLayout = {
+        SortOrder = Enum.SortOrder.LayoutOrder
+    },
+
+    UIPageLayout = {
+        SortOrder = Enum.SortOrder.LayoutOrder
+    },
+    
+    VideoFrame = {
+        BackgroundColor3 = Color3.new(1, 1, 1),
+        BorderColor3 = Color3.new(0, 0, 0),
+        BorderSizePixel = 0
+    },
+    
+    ViewportFrame = {
+        BackgroundColor3 = Color3.new(1, 1, 1),
+        BorderColor3 = Color3.new(0, 0, 0),
+        BorderSizePixel = 0
+    }
+} :: { [string]: { [string]: unknown} }

package/vide/src/derive.luau

@@ -0,0 +1,18 @@
+local graph = require "./graph"
+local create_node = graph.create_node
+local push_scope_as_child_of = graph.push_scope_as_child_of
+local assert_stable_scope = graph.assert_stable_scope
+local evaluate_node = graph.evaluate_node
+
+local function derive<T>(source: () -> T): () -> T
+    local node = create_node(assert_stable_scope(), source, false :: any)
+
+    evaluate_node(node)
+
+    return function()
+        push_scope_as_child_of(node)
+        return node.cache
+    end
+end
+
+return derive

package/vide/src/effect.luau

@@ -0,0 +1,12 @@
+local graph = require "./graph"
+local create_node = graph.create_node
+local assert_stable_scope = graph.assert_stable_scope
+local evaluate_node = graph.evaluate_node
+
+local function effect<T>(callback: (T) -> T, initial_value: T)
+    local node = create_node(assert_stable_scope(), callback, initial_value)
+
+    evaluate_node(node)
+end
+
+return effect :: (<T>(callback: (T) -> T, initial_value: T) -> ()) & ((callback: () -> ()) -> ())

package/vide/src/flags.luau

@@ -0,0 +1,12 @@
+local function inline_test(): string
+    return debug.info(1, "n")
+end
+
+local is_O2 = inline_test() ~= "inline_test"
+
+return {
+    strict = not is_O2,
+    defaults = true,
+    defer_nested_properties = true,
+    batch = false,
+}

package/vide/src/graph.luau

@@ -0,0 +1,321 @@
+local flags = require "./flags"
+
+export type SourceNode<T> = {
+    cache: T,
+    [number]: Node<T>
+}
+
+export type Node<T> =  {
+    cache: T,
+    effect:  ((T) -> T) | false,
+    cleanups: { () -> () } | false,
+
+    context: { [number]: unknown } | false,
+
+    owned: { Node<T> } | false,
+    owner: Node<T> | false,
+
+    parents: { SourceNode<T> },
+    [number]: Node<T> -- children
+}
+
+local scopes = { n = 0 } :: { [number]: Node<any>, n: number } -- scopes stack
+
+local function efn(err: string)
+    local trace = debug.traceback(err, 2)
+
+    if string.find(err, "^effect error stacktrace") then -- if effect error is nested
+        trace = string.gsub("    " .. trace, "\n", function() -- indent entire error
+            return "\n    "
+        end)
+    end
+
+    trace ..= "\nsource update stacktrace:"
+return trace
+end
+
+local function ycall<T, U>(fn: (T) -> U, arg: T): (boolean, string|U)
+
+    local thread = coroutine.create(xpcall)
+    --local function efn(err: string) return debug.traceback(err, 3) end
+    local resume_ok, run_ok, result = coroutine.resume(thread, fn, efn, arg)
+
+    assert(resume_ok)
+        
+    if coroutine.status(thread) ~= "dead" then
+        return false, debug.traceback(thread, "attempt to yield in reactive scope")
+    end
+
+    return run_ok, result
+end
+
+local function get_scope(): Node<unknown>?
+    return scopes[scopes.n]
+end
+
+local function assert_stable_scope(): Node<unknown>
+    local scope = get_scope()
+
+    if not scope then
+        local caller_name = debug.info(2, "n")
+        return error(`cannot use {caller_name}() outside a stable or reactive scope`, 0)
+    elseif scope.effect then
+        error("cannot create a new reactive scope inside another reactive scope", 0)
+    end
+
+    return scope
+end
+
+local function push_child<T>(parent: SourceNode<any>, child: Node<any>)
+    table.insert(parent, child)
+    table.insert(child.parents, parent)
+end
+
+local function push_scope<T>(node: Node<T>)
+    local n = scopes.n + 1
+    scopes.n = n
+    scopes[n] = node
+end
+
+local function pop_scope()
+    local n = scopes.n
+    scopes.n = n - 1
+    scopes[n] = nil
+end
+
+local function push_cleanup<T>(node: Node<T>, cleanup: () -> ())
+    if node.cleanups then
+        table.insert(node.cleanups, cleanup)
+    else
+        node.cleanups = { cleanup }
+    end
+end
+
+local function flush_cleanups<T>(node: Node<T>)
+    if node.cleanups then
+        for _, fn in node.cleanups do
+            local ok, err: string? = xpcall(fn, debug.traceback)
+            if not ok then error(`cleanup error: {err}`, 0) end
+        end
+
+        table.clear(node.cleanups)
+    end
+end
+
+local function find_and_swap_pop<T>(t: { T }, v: T)
+    local i = table.find(t, v) :: number
+    local n = #t
+    t[i] = t[n]
+    t[n] = nil
+end
+
+local function unparent<T>(node: Node<T>)
+    local parents = node.parents
+
+    for i, parent in parents do
+        find_and_swap_pop(parent, node)
+        parents[i] = nil
+    end
+end
+
+local function destroy<T>(node: Node<T>)
+    if flags.strict and table.find(scopes, node) then
+        error("attempt to destroy an active scope", 0)
+    end
+
+    flush_cleanups(node)
+    unparent(node)
+    
+    if node.owner then
+        find_and_swap_pop(node.owner.owned :: { Node<T> }, node)
+        node.owner = false
+    end
+
+    if node.owned then
+        local owned = node.owned
+        while owned[1] do destroy(owned[1]) end
+    end
+end
+
+local function destroy_owned<T>(node: Node<T>)
+    if node.owned then
+        local owned = node.owned
+        while owned[1] do destroy(owned[1]) end
+    end
+end
+
+local update_queue = { n = 0 } :: { n: number, [number]: Node<any> }
+
+local function evaluate_node<T>(node: Node<T>)
+    if flags.strict then
+        if table.find(scopes, node) then
+            error("a scope, that should rerun due to the update of a source, is already active", 0)
+        end
+
+        local initial_value = node.cache
+
+        for i = 1, 2 do
+            local cur_value = node.cache
+
+            flush_cleanups(node)
+            destroy_owned(node)
+    
+            push_scope(node)
+            local ok, new_value = ycall(node.effect :: (T) -> T, cur_value)
+            pop_scope()
+            
+            if not ok then
+                table.clear(update_queue)
+                update_queue.n = 0
+                error(`effect error stacktrace\n{new_value :: string}`, 0)
+            end
+
+            node.cache = new_value :: T
+        end
+
+        return initial_value ~= node.cache
+    else
+        local cur_value = node.cache
+
+        flush_cleanups(node)
+        destroy_owned(node)
+
+        push_scope(node)
+        local ok, new_value = pcall(node.effect :: (T) -> T, node.cache)
+        pop_scope()
+
+        if not ok then
+            table.clear(update_queue)
+            update_queue.n = 0
+            error(`effect error:\n{new_value}\n`, 0)
+        end
+    
+        node.cache = new_value
+        return cur_value ~= new_value
+    end
+end
+
+local function queue_children_for_update<T>(node: SourceNode<T>)
+    local i = update_queue.n
+    while node[1] do
+        i += 1
+        update_queue[i] = node[1]
+        unparent(node[1])
+    end
+    update_queue.n = i
+end
+
+local function get_update_queue_length()
+    return update_queue.n
+end
+
+local function flush_update_queue(from: number)
+    local i = from + 1
+    while i <= update_queue.n do
+        local node = update_queue[i]
+        --assert(node.effect)
+
+        if node.owner and evaluate_node(node) then
+            queue_children_for_update(node)
+        end
+
+        update_queue[i] = false :: any
+        i += 1
+    end
+    
+    update_queue.n = from
+end
+
+local function update_descendants<T>(root: SourceNode<T>)
+    local n0 = update_queue.n
+    queue_children_for_update(root)
+
+    if flags.batch then return end
+
+    local i = n0 + 1
+    while i <= update_queue.n do
+        local node = update_queue[i]
+        --assert(node.effect)
+
+        -- check if node is still owned in case destroyed after queued
+        if node.owner and evaluate_node(node) then
+            queue_children_for_update(node)
+        end
+
+        update_queue[i] = false :: any -- false instead of nil to avoid sparse
+        i += 1
+    end
+
+    update_queue.n = n0
+end
+
+local function push_scope_as_child_of<T>(node: SourceNode<T>)
+    local scope = get_scope()
+    if scope and scope.effect then -- do not track nodes with no effect
+        push_child(node, scope)
+    end
+end
+
+local function create_node<T>(owner: false | Node<any>, effect: false | (T) -> T, value: T): Node<T>
+    local node: Node<T> = {
+        cache = value,
+        effect = effect,
+        cleanups = false,
+
+        context = false,
+
+        owner = owner,
+        owned = false,
+
+        parents = {},
+    }
+
+    if owner then
+        if owner.owned then
+            table.insert(owner.owned, node)
+        else
+            owner.owned = { node }
+        end
+    end
+
+    return node
+end
+
+local function create_source_node<T>(value: T): SourceNode<T>
+    return { cache = value }
+end
+
+local function get_children<T>(node: Node<T>): { Node<unknown> }
+    return { unpack(node) } :: { Node<any> }
+end
+
+local function set_context<T>(node: Node<T>, key: number, value: unknown)
+    if node.context then
+        node.context[key] = value
+    else
+        node.context = { [key] = value }
+    end
+end
+
+return table.freeze {
+    push_scope = push_scope,
+    pop_scope = pop_scope,
+    evaluate_node = evaluate_node,
+    get_scope = get_scope,
+    assert_stable_scope = assert_stable_scope,
+    push_cleanup = push_cleanup,
+    destroy = destroy,
+    flush_cleanups = flush_cleanups,
+    push_scope_as_child_of = push_scope_as_child_of,
+    update_descendants = update_descendants,
+    push_child = push_child,
+    create_node = create_node,
+    create_source_node = create_source_node,
+    get_children = get_children,
+    flush_update_queue = flush_update_queue,
+    get_update_queue_length = get_update_queue_length,
+    set_context = set_context,
+    scopes = scopes,
+
+    q = update_queue
+}

package/vide/src/implicit_effect.luau

@@ -0,0 +1,125 @@
+local graph = require "./graph"
+type Node<T> = graph.Node<T>
+local create_node = graph.create_node
+local assert_stable_scope = graph.assert_stable_scope
+local get_scope = graph.get_scope
+local evaluate_node = graph.evaluate_node
+local push_cleanup = graph.push_cleanup
+
+local function update_property_effect(p: {
+    instance: Instance,
+    property: string,
+    source: () -> unknown  
+})
+    (p.instance :: any)[p.property] = p.source()
+    return p
+end
+
+local function update_parent_effect(p: {
+    instance: Instance,
+    source: () -> Instance
+})
+    p.instance.Parent = p.source()
+    return p
+end
+
+-- todo: investigate if "count" method used in indexes() and values() can improve performance here
+local function update_children_effect(p: {
+    instance: Instance,
+    cur_children_set: { [Instance]: true },
+    new_children_set: { [Instance]: true },
+    source: () -> Instance | { Instance }
+})
+    local cur_children_set: { [Instance]: true } = p.cur_children_set -- cache of all children parented before update
+    local new_children_set: { [Instance]: true } = p.new_children_set -- cache of all children parented after update
+
+    local new_children = p.source() -- all (and only) children that should be parented after this update
+    
+    local function process_child(child: Instance | { Instance })
+        if type(child) == "userdata" then
+            if new_children_set[child] then return end -- stops redundant reparenting
+
+            new_children_set[child] = true -- record child set from this update
+            
+            if not cur_children_set[child] then
+                child.Parent = p.instance -- if child wasn't already parented then parent it
+            else 
+                cur_children_set[child] = nil -- remove child from cache if it was already in cache
+            end  
+        elseif type(child) == "table" then
+            for _, child in child do
+                process_child(child)
+            end
+        elseif type(child) == "function" then
+            local node = create_node(assert(get_scope()), update_children_effect, {
+                instance = p.instance,
+                cur_children_set = {},
+                new_children_set = {},
+                source = child   
+            })
+    
+            evaluate_node(node)
+
+            push_cleanup(assert(get_scope()), function()
+                for child in node.cache.cur_children_set do
+                    child.Parent = nil
+                end
+            end)
+        end
+    end
+
+    process_child(new_children)
+
+    for child in cur_children_set do
+        child.Parent = nil -- unparent all children that weren't in the new children set
+    end
+
+    table.clear(cur_children_set) -- clear cache, preserve capacity
+    p.cur_children_set, p.new_children_set = new_children_set, cur_children_set
+
+    return p
+end
+
+return {
+    property = function(instance, property, source)
+        local node = create_node(assert_stable_scope(), update_property_effect, {
+            instance = instance,
+            property = property,
+            source = source
+        })
+
+        evaluate_node(node)
+
+        return node
+    end,
+
+    parent = function(instance, parent)
+        local node = create_node(assert_stable_scope(), update_parent_effect, {
+            instance = instance,
+            source = parent
+        })
+
+        evaluate_node(node)
+        
+        return node
+    end,
+
+    children = function(instance, children)
+        local node = create_node(assert_stable_scope(), update_children_effect, {
+            instance = instance,
+            cur_children_set = {},
+            new_children_set = {},
+            source = children
+        })
+
+        evaluate_node(node)
+
+        push_cleanup(assert_stable_scope(), function()
+            for child in node.cache.cur_children_set do
+                child.Parent = nil
+            end
+        end)
+
+        return node
+    end
+}