cluaupp 0.2.3 → 1.3.0

package/templates/game/libs/Iris/_impl/widgets/RadioButton.lua

@@ -0,0 +1,126 @@
+local Types = require(script.Parent.Parent.Types)
+
+return function(Iris: Types.Internal, widgets: Types.WidgetUtility)
+    --stylua: ignore
+    Iris.WidgetConstructor("RadioButton", {
+        hasState = true,
+        hasChildren = false,
+        Args = {
+            ["Text"] = 1,
+            ["Index"] = 2,
+        },
+        Events = {
+            ["selected"] = {
+                ["Init"] = function(_thisWidget: Types.RadioButton) end,
+                ["Get"] = function(thisWidget: Types.RadioButton)
+                    return thisWidget.lastSelectedTick == Iris._cycleTick
+                end,
+            },
+            ["unselected"] = {
+                ["Init"] = function(_thisWidget: Types.RadioButton) end,
+                ["Get"] = function(thisWidget: Types.RadioButton)
+                    return thisWidget.lastUnselectedTick == Iris._cycleTick
+                end,
+            },
+            ["active"] = {
+                ["Init"] = function(_thisWidget: Types.RadioButton) end,
+                ["Get"] = function(thisWidget: Types.RadioButton)
+                    return thisWidget.state.index.value == thisWidget.arguments.Index
+                end,
+            },
+            ["hovered"] = widgets.EVENTS.hover(function(thisWidget: Types.Widget)
+                return thisWidget.Instance
+            end),
+        },
+        Generate = function(thisWidget: Types.RadioButton)
+            local RadioButton = Instance.new("TextButton")
+            RadioButton.Name = "Iris_RadioButton"
+            RadioButton.AutomaticSize = Enum.AutomaticSize.XY
+            RadioButton.Size = UDim2.fromOffset(0, 0)
+            RadioButton.BackgroundTransparency = 1
+            RadioButton.BorderSizePixel = 0
+            RadioButton.Text = ""
+            RadioButton.AutoButtonColor = false
+
+            widgets.UIListLayout(RadioButton, Enum.FillDirection.Horizontal, UDim.new(0, Iris._config.ItemInnerSpacing.X)).VerticalAlignment = Enum.VerticalAlignment.Center
+
+            local buttonSize = Iris._config.TextSize + 2 * (Iris._config.FramePadding.Y - 1)
+            local Button = Instance.new("Frame")
+            Button.Name = "Button"
+            Button.Size = UDim2.fromOffset(buttonSize, buttonSize)
+            Button.BackgroundColor3 = Iris._config.FrameBgColor
+            Button.BackgroundTransparency = Iris._config.FrameBgTransparency
+            Button.Parent = RadioButton
+
+            widgets.UICorner(Button)
+            widgets.UIPadding(Button, Vector2.new(math.max(1, math.floor(buttonSize / 5)), math.max(1, math.floor(buttonSize / 5))))
+
+            local Circle = Instance.new("Frame")
+            Circle.Name = "Circle"
+            Circle.Size = UDim2.fromScale(1, 1)
+            Circle.BackgroundColor3 = Iris._config.CheckMarkColor
+            Circle.BackgroundTransparency = Iris._config.CheckMarkTransparency
+            widgets.UICorner(Circle)
+            
+            Circle.Parent = Button
+
+            widgets.applyInteractionHighlights("Background", RadioButton, Button, {
+                Color = Iris._config.FrameBgColor,
+                Transparency = Iris._config.FrameBgTransparency,
+                HoveredColor = Iris._config.FrameBgHoveredColor,
+                HoveredTransparency = Iris._config.FrameBgHoveredTransparency,
+                ActiveColor = Iris._config.FrameBgActiveColor,
+                ActiveTransparency = Iris._config.FrameBgActiveTransparency,
+            })
+
+            widgets.applyButtonClick(RadioButton, function()
+                thisWidget.state.index:set(thisWidget.arguments.Index)
+            end)
+
+            local TextLabel = Instance.new("TextLabel")
+            TextLabel.Name = "TextLabel"
+            TextLabel.AutomaticSize = Enum.AutomaticSize.XY
+            TextLabel.BackgroundTransparency = 1
+            TextLabel.BorderSizePixel = 0
+            TextLabel.LayoutOrder = 1
+            
+            widgets.applyTextStyle(TextLabel)
+            TextLabel.Parent = RadioButton
+
+            return RadioButton
+        end,
+        Update = function(thisWidget: Types.RadioButton)
+            local RadioButton = thisWidget.Instance :: TextButton
+            local TextLabel: TextLabel = RadioButton.TextLabel
+
+            TextLabel.Text = thisWidget.arguments.Text or "Radio Button"
+            if thisWidget.state then
+                thisWidget.state.index.lastChangeTick = Iris._cycleTick
+                Iris._widgets[thisWidget.type].UpdateState(thisWidget)
+            end
+        end,
+        Discard = function(thisWidget: Types.RadioButton)
+            thisWidget.Instance:Destroy()
+            widgets.discardState(thisWidget)
+        end,
+        GenerateState = function(thisWidget: Types.RadioButton)
+            if thisWidget.state.index == nil then
+                thisWidget.state.index = Iris._widgetState(thisWidget, "index", thisWidget.arguments.Index)
+            end
+        end,
+        UpdateState = function(thisWidget: Types.RadioButton)
+            local RadioButton = thisWidget.Instance :: TextButton
+            local Button = RadioButton.Button :: Frame
+            local Circle: Frame = Button.Circle
+
+            if thisWidget.state.index.value == thisWidget.arguments.Index then
+                -- only need to hide the circle
+                Circle.BackgroundTransparency = Iris._config.CheckMarkTransparency
+                thisWidget.lastSelectedTick = Iris._cycleTick + 1
+            else
+                Circle.BackgroundTransparency = 1
+                thisWidget.lastUnselectedTick = Iris._cycleTick + 1
+            end
+        end,
+    } :: Types.WidgetClass)
+end

package/templates/game/libs/Iris/_impl/widgets/Root.lua

@@ -0,0 +1,143 @@
+local Types = require(script.Parent.Parent.Types)
+
+return function(Iris: Types.Internal, widgets: Types.WidgetUtility)
+    local NumNonWindowChildren: number = 0
+
+    --stylua: ignore
+    Iris.WidgetConstructor("Root", {
+        hasState = false,
+        hasChildren = true,
+        Args = {},
+        Events = {},
+        Generate = function(_thisWidget: Types.Root)
+            local Root = Instance.new("Folder")
+            Root.Name = "Iris_Root"
+
+            local PseudoWindowScreenGui
+            if Iris._config.UseScreenGUIs then
+                PseudoWindowScreenGui = Instance.new("ScreenGui")
+                PseudoWindowScreenGui.ResetOnSpawn = false
+                PseudoWindowScreenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
+                PseudoWindowScreenGui.ScreenInsets = Iris._config.ScreenInsets
+                PseudoWindowScreenGui.IgnoreGuiInset = Iris._config.IgnoreGuiInset
+                PseudoWindowScreenGui.DisplayOrder = Iris._config.DisplayOrderOffset
+            else
+                PseudoWindowScreenGui = Instance.new("Frame")
+                PseudoWindowScreenGui.AnchorPoint = Vector2.new(0.5, 0.5)
+                PseudoWindowScreenGui.Position = UDim2.fromScale(0.5, 0.5)
+                PseudoWindowScreenGui.Size = UDim2.fromScale(1, 1)
+                PseudoWindowScreenGui.BackgroundTransparency = 1
+                PseudoWindowScreenGui.ZIndex = Iris._config.DisplayOrderOffset
+            end
+            PseudoWindowScreenGui.Name = "PseudoWindowScreenGui"
+            PseudoWindowScreenGui.Parent = Root
+
+            local PopupScreenGui
+            if Iris._config.UseScreenGUIs then
+                PopupScreenGui = Instance.new("ScreenGui")
+                PopupScreenGui.ResetOnSpawn = false
+                PopupScreenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
+                PopupScreenGui.DisplayOrder = Iris._config.DisplayOrderOffset + 1024 -- room for 1024 regular windows before overlap
+                PopupScreenGui.ScreenInsets = Iris._config.ScreenInsets
+                PopupScreenGui.IgnoreGuiInset = Iris._config.IgnoreGuiInset
+            else
+                PopupScreenGui = Instance.new("Frame")
+                PopupScreenGui.AnchorPoint = Vector2.new(0.5, 0.5)
+                PopupScreenGui.Position = UDim2.fromScale(0.5, 0.5)
+                PopupScreenGui.Size = UDim2.fromScale(1, 1)
+                PopupScreenGui.BackgroundTransparency = 1
+                PopupScreenGui.ZIndex = Iris._config.DisplayOrderOffset + 1024
+            end
+            PopupScreenGui.Name = "PopupScreenGui"
+            PopupScreenGui.Parent = Root
+
+            local TooltipContainer = Instance.new("Frame")
+            TooltipContainer.Name = "TooltipContainer"
+            TooltipContainer.AutomaticSize = Enum.AutomaticSize.XY
+            TooltipContainer.Size = UDim2.fromOffset(0, 0)
+            TooltipContainer.BackgroundTransparency = 1
+            TooltipContainer.BorderSizePixel = 0
+
+            widgets.UIListLayout(TooltipContainer, Enum.FillDirection.Vertical, UDim.new(0, Iris._config.PopupBorderSize))
+
+            TooltipContainer.Parent = PopupScreenGui
+
+            local MenuBarContainer = Instance.new("Frame")
+            MenuBarContainer.Name = "MenuBarContainer"
+            MenuBarContainer.AutomaticSize = Enum.AutomaticSize.Y
+            MenuBarContainer.Size = UDim2.fromScale(1, 0)
+            MenuBarContainer.BackgroundTransparency = 1
+            MenuBarContainer.BorderSizePixel = 0
+
+            MenuBarContainer.Parent = PopupScreenGui
+
+            local PseudoWindow = Instance.new("Frame")
+            PseudoWindow.Name = "PseudoWindow"
+            PseudoWindow.AutomaticSize = Enum.AutomaticSize.XY
+            PseudoWindow.Size = UDim2.new(0, 0, 0, 0)
+            PseudoWindow.Position = UDim2.fromOffset(0, 22)
+            PseudoWindow.BackgroundTransparency = Iris._config.WindowBgTransparency
+            PseudoWindow.BackgroundColor3 = Iris._config.WindowBgColor
+            PseudoWindow.BorderSizePixel = Iris._config.WindowBorderSize
+            PseudoWindow.BorderColor3 = Iris._config.BorderColor
+
+            PseudoWindow.Selectable = false
+            PseudoWindow.SelectionGroup = true
+            PseudoWindow.SelectionBehaviorUp = Enum.SelectionBehavior.Stop
+            PseudoWindow.SelectionBehaviorDown = Enum.SelectionBehavior.Stop
+            PseudoWindow.SelectionBehaviorLeft = Enum.SelectionBehavior.Stop
+            PseudoWindow.SelectionBehaviorRight = Enum.SelectionBehavior.Stop
+
+            PseudoWindow.Visible = false
+
+            widgets.UIPadding(PseudoWindow, Iris._config.WindowPadding)
+            widgets.UIListLayout(PseudoWindow, Enum.FillDirection.Vertical, UDim.new(0, Iris._config.ItemSpacing.Y))
+
+            PseudoWindow.Parent = PseudoWindowScreenGui
+
+            return Root
+        end,
+        Update = function(thisWidget: Types.Root)
+            if NumNonWindowChildren > 0 then
+                local Root = thisWidget.Instance :: any
+                local PseudoWindowScreenGui = Root.PseudoWindowScreenGui :: any
+                local PseudoWindow: Frame = PseudoWindowScreenGui.PseudoWindow
+                PseudoWindow.Visible = true
+            end
+        end,
+        Discard = function(thisWidget: Types.Root)
+            NumNonWindowChildren = 0
+            thisWidget.Instance:Destroy()
+        end,
+        ChildAdded = function(thisWidget: Types.Root, thisChild: Types.Widget)
+            local Root = thisWidget.Instance :: any
+
+            if thisChild.type == "Window" then
+                return thisWidget.Instance
+            elseif thisChild.type == "Tooltip" then
+                return Root.PopupScreenGui.TooltipContainer
+            elseif thisChild.type == "MenuBar" then
+                return Root.PopupScreenGui.MenuBarContainer
+            else
+                local PseudoWindowScreenGui = Root.PseudoWindowScreenGui :: any
+                local PseudoWindow: Frame = PseudoWindowScreenGui.PseudoWindow
+
+                NumNonWindowChildren += 1
+                PseudoWindow.Visible = true
+
+                return PseudoWindow
+            end
+        end,
+        ChildDiscarded = function(thisWidget: Types.Root, thisChild: Types.Widget)
+            if thisChild.type ~= "Window" and thisChild.type ~= "Tooltip" and thisChild.type ~= "MenuBar" then
+                NumNonWindowChildren -= 1
+                if NumNonWindowChildren == 0 then
+                    local Root = thisWidget.Instance :: any
+                    local PseudoWindowScreenGui = Root.PseudoWindowScreenGui :: any
+                    local PseudoWindow: Frame = PseudoWindowScreenGui.PseudoWindow
+                    PseudoWindow.Visible = false
+                end
+            end
+        end,
+    } :: Types.WidgetClass)
+end

package/templates/game/libs/Iris/_impl/widgets/Tab.lua

@@ -0,0 +1,333 @@
+local Types = require(script.Parent.Parent.Types)
+
+return function(Iris: Types.Internal, widgets: Types.WidgetUtility)
+    local function openTab(TabBar: Types.TabBar, Index: number)
+        if TabBar.state.index.value > 0 then
+            return
+        end
+
+        TabBar.state.index:set(Index)
+    end
+
+    local function closeTab(TabBar: Types.TabBar, Index: number)
+        if TabBar.state.index.value ~= Index then
+            return
+        end
+
+        -- search left for open tabs
+        for i = Index - 1, 1, -1 do
+            if TabBar.Tabs[i].state.isOpened.value == true then
+                TabBar.state.index:set(i)
+                return
+            end
+        end
+
+        -- search right for open tabs
+        for i = Index, #TabBar.Tabs do
+            if TabBar.Tabs[i].state.isOpened.value == true then
+                TabBar.state.index:set(i)
+                return
+            end
+        end
+
+        -- no open tabs, so wait for one
+        TabBar.state.index:set(0)
+    end
+
+    --stylua: ignore
+    Iris.WidgetConstructor("TabBar", {
+        hasState = true,
+        hasChildren = true,
+        Args = {},
+        Events = {},
+        Generate = function(thisWidget: Types.TabBar)
+            local TabBar = Instance.new("Frame")
+            TabBar.Name = "Iris_TabBar"
+            TabBar.AutomaticSize = Enum.AutomaticSize.Y
+            TabBar.Size = UDim2.fromScale(1, 0)
+            TabBar.BackgroundTransparency = 1
+            TabBar.BorderSizePixel = 0
+
+            widgets.UIListLayout(TabBar, Enum.FillDirection.Vertical, UDim.new()).VerticalAlignment = Enum.VerticalAlignment.Bottom
+            
+            local Bar = Instance.new("Frame")
+            Bar.Name = "Bar"
+            Bar.AutomaticSize = Enum.AutomaticSize.Y
+            Bar.Size = UDim2.fromScale(1, 0)
+            Bar.BackgroundTransparency = 1
+            Bar.BorderSizePixel = 0
+            
+            widgets.UIListLayout(Bar, Enum.FillDirection.Horizontal, UDim.new(0, Iris._config.ItemInnerSpacing.X))
+
+            Bar.Parent = TabBar
+
+            local Underline = Instance.new("Frame")
+            Underline.Name = "Underline"
+            Underline.Size = UDim2.new(1, 0, 0, 1)
+            Underline.BackgroundColor3 = Iris._config.TabActiveColor
+            Underline.BackgroundTransparency = Iris._config.TabActiveTransparency
+            Underline.BorderSizePixel = 0
+            Underline.LayoutOrder = 1
+
+            Underline.Parent = TabBar
+
+            local ChildContainer = Instance.new("Frame")
+            ChildContainer.Name = "TabContainer"
+            ChildContainer.AutomaticSize = Enum.AutomaticSize.Y
+            ChildContainer.Size = UDim2.fromScale(1, 0)
+            ChildContainer.BackgroundTransparency = 1
+            ChildContainer.BorderSizePixel = 0
+            ChildContainer.LayoutOrder = 2
+            ChildContainer.ClipsDescendants = true
+
+            ChildContainer.Parent = TabBar
+
+            thisWidget.ChildContainer = ChildContainer
+            thisWidget.Tabs = {}
+
+            return TabBar
+        end,
+        Update = function(_thisWidget: Types.TabBar) end,
+        ChildAdded = function(thisWidget: Types.TabBar, thisChild: Types.Tab)
+            assert(thisChild.type == "Tab", "Only Iris.Tab can be parented to Iris.TabBar.")
+            local TabBar = thisWidget.Instance :: Frame
+            thisChild.ChildContainer.Parent = thisWidget.ChildContainer
+            thisChild.Index = #thisWidget.Tabs + 1
+            thisWidget.state.index.ConnectedWidgets[thisChild.ID] = thisChild
+            table.insert(thisWidget.Tabs, thisChild)
+
+            return TabBar.Bar
+        end,
+        ChildDiscarded = function(thisWidget: Types.TabBar, thisChild: Types.Tab)
+            local Index = thisChild.Index
+            table.remove(thisWidget.Tabs, Index)
+
+            for i = Index, #thisWidget.Tabs do
+                thisWidget.Tabs[i].Index = i
+            end
+
+            closeTab(thisWidget, Index)
+        end,
+        GenerateState = function(thisWidget: Types.Tab)
+            if thisWidget.state.index == nil then
+                thisWidget.state.index = Iris._widgetState(thisWidget, "index", 1)
+            end
+        end,
+        UpdateState = function(_thisWidget: Types.Tab)
+        end,
+        Discard = function(thisWidget: Types.TabBar)
+            thisWidget.Instance:Destroy()
+        end,
+    } :: Types.WidgetClass)
+
+    --stylua: ignore
+    Iris.WidgetConstructor("Tab", {
+        hasState = true,
+        hasChildren = true,
+        Args = {
+            ["Text"] = 1,
+            ["Hideable"] = 2,
+        },
+        Events = {
+            ["clicked"] = widgets.EVENTS.click(function(thisWidget: Types.Widget)
+                return thisWidget.Instance
+            end),
+            ["hovered"] = widgets.EVENTS.hover(function(thisWidget: Types.Widget)
+                return thisWidget.Instance
+            end),
+            ["selected"] = {
+                ["Init"] = function(_thisWidget: Types.Tab) end,
+                ["Get"] = function(thisWidget: Types.Tab)
+                    return thisWidget.lastSelectedTick == Iris._cycleTick
+                end,
+            },
+            ["unselected"] = {
+                ["Init"] = function(_thisWidget: Types.Tab) end,
+                ["Get"] = function(thisWidget: Types.Tab)
+                    return thisWidget.lastUnselectedTick == Iris._cycleTick
+                end,
+            },
+            ["active"] = {
+                ["Init"] = function(_thisWidget: Types.Tab) end,
+                ["Get"] = function(thisWidget: Types.Tab)
+                    return thisWidget.state.index.value == thisWidget.Index
+                end,
+            },
+            ["opened"] = {
+                ["Init"] = function(_thisWidget: Types.Tab) end,
+                ["Get"] = function(thisWidget: Types.Tab)
+                    return thisWidget.lastOpenedTick == Iris._cycleTick
+                end,
+            },
+            ["closed"] = {
+                ["Init"] = function(_thisWidget: Types.Tab) end,
+                ["Get"] = function(thisWidget: Types.Tab)
+                    return thisWidget.lastClosedTick == Iris._cycleTick
+                end,
+            },
+        },
+        Generate = function(thisWidget: Types.Tab)
+            local Tab = Instance.new("TextButton")
+            Tab.Name = "Iris_Tab"
+            Tab.AutomaticSize = Enum.AutomaticSize.XY
+            Tab.BackgroundColor3 = Iris._config.TabColor
+            Tab.BackgroundTransparency = Iris._config.TabTransparency
+            Tab.BorderSizePixel = 0
+            Tab.Text = ""
+            Tab.AutoButtonColor = false
+
+            thisWidget.ButtonColors = {
+                Color = Iris._config.TabColor,
+                Transparency = Iris._config.TabTransparency,
+                HoveredColor = Iris._config.TabHoveredColor,
+                HoveredTransparency = Iris._config.TabHoveredTransparency,
+                ActiveColor = Iris._config.TabActiveColor,
+                ActiveTransparency = Iris._config.TabActiveTransparency,
+            }
+
+            widgets.UIPadding(Tab, Vector2.new(Iris._config.FramePadding.X, 0))
+            widgets.applyFrameStyle(Tab, true, true)
+            widgets.UIListLayout(Tab, Enum.FillDirection.Horizontal, UDim.new(0, Iris._config.ItemInnerSpacing.X)).VerticalAlignment = Enum.VerticalAlignment.Center
+            widgets.applyInteractionHighlights("Background", Tab, Tab, thisWidget.ButtonColors)
+            widgets.applyButtonClick(Tab, function()
+                thisWidget.state.index:set(thisWidget.Index)
+            end)
+
+            local TextLabel = Instance.new("TextLabel")
+            TextLabel.Name = "TextLabel"
+            TextLabel.AutomaticSize = Enum.AutomaticSize.XY
+            TextLabel.BackgroundTransparency = 1
+            TextLabel.BorderSizePixel = 0
+
+            widgets.applyTextStyle(TextLabel)
+            widgets.UIPadding(TextLabel, Vector2.new(0, Iris._config.FramePadding.Y))
+
+            TextLabel.Parent = Tab
+
+            local ButtonSize = Iris._config.TextSize + ((Iris._config.FramePadding.Y - 1) * 2)
+
+            local CloseButton = Instance.new("TextButton")
+            CloseButton.Name = "CloseButton"
+            CloseButton.Size = UDim2.fromOffset(ButtonSize, ButtonSize)
+            CloseButton.BackgroundTransparency = 1
+            CloseButton.BorderSizePixel = 0
+            CloseButton.Text = ""
+            CloseButton.AutoButtonColor = false
+            CloseButton.LayoutOrder = 1
+
+            widgets.UICorner(CloseButton)
+            widgets.applyButtonClick(CloseButton, function()
+                thisWidget.state.isOpened:set(false)
+                closeTab(thisWidget.parentWidget, thisWidget.Index)
+            end)
+
+            widgets.applyInteractionHighlights("Background", CloseButton, CloseButton, {
+                Color = Iris._config.TabColor,
+                Transparency = 1,
+                HoveredColor = Iris._config.ButtonHoveredColor,
+                HoveredTransparency = Iris._config.ButtonHoveredTransparency,
+                ActiveColor = Iris._config.ButtonActiveColor,
+                ActiveTransparency = Iris._config.ButtonActiveTransparency,
+            })
+
+            CloseButton.Parent = Tab
+
+            local Icon = Instance.new("ImageLabel")
+            Icon.Name = "Icon"
+            Icon.AnchorPoint = Vector2.new(0.5, 0.5)
+            Icon.Position = UDim2.fromScale(0.5, 0.5)
+            Icon.Size = UDim2.fromOffset(math.floor(0.7 * ButtonSize), math.floor(0.7 * ButtonSize))
+            Icon.BackgroundTransparency = 1
+            Icon.BorderSizePixel = 0
+            Icon.Image = widgets.ICONS.MULTIPLICATION_SIGN
+            Icon.ImageTransparency = 1
+
+            widgets.applyInteractionHighlights("Image", Tab, Icon, {
+                Color = Iris._config.TextColor,
+                Transparency = 1,
+                HoveredColor = Iris._config.TextColor,
+                HoveredTransparency = Iris._config.TextTransparency,
+                ActiveColor = Iris._config.TextColor,
+                ActiveTransparency = Iris._config.TextTransparency,
+            })
+            Icon.Parent = CloseButton
+
+            local ChildContainer = Instance.new("Frame")
+            ChildContainer.Name = "TabContainer"
+            ChildContainer.AutomaticSize = Enum.AutomaticSize.Y
+            ChildContainer.Size = UDim2.fromScale(1, 0)
+            ChildContainer.BackgroundTransparency = 1
+            ChildContainer.BorderSizePixel = 0
+            
+            ChildContainer.ClipsDescendants = true
+            widgets.UIListLayout(ChildContainer, Enum.FillDirection.Vertical, UDim.new(0, Iris._config.ItemSpacing.Y))
+            widgets.UIPadding(ChildContainer, Vector2.new(0, Iris._config.ItemSpacing.Y)).PaddingBottom = UDim.new()
+
+            thisWidget.ChildContainer = ChildContainer
+
+            return Tab
+        end,
+        Update = function(thisWidget: Types.Tab)
+            local Tab = thisWidget.Instance :: TextButton
+            local TextLabel: TextLabel = Tab.TextLabel
+            local CloseButton: TextButton = Tab.CloseButton
+
+            TextLabel.Text = thisWidget.arguments.Text
+            CloseButton.Visible = if thisWidget.arguments.Hideable == true then true else false
+        end,
+        ChildAdded = function(thisWidget: Types.Tab, _thisChild: Types.Widget)
+            return thisWidget.ChildContainer
+        end,
+        GenerateState = function(thisWidget: Types.Tab)
+            thisWidget.state.index = thisWidget.parentWidget.state.index
+            thisWidget.state.index.ConnectedWidgets[thisWidget.ID] = thisWidget
+
+            if thisWidget.state.isOpened == nil then
+                thisWidget.state.isOpened = Iris._widgetState(thisWidget, "isOpened", true)
+            end
+        end,
+        UpdateState = function(thisWidget: Types.Tab)
+            local Tab = thisWidget.Instance :: TextButton
+            local Container = thisWidget.ChildContainer :: Frame
+
+            if thisWidget.state.isOpened.lastChangeTick == Iris._cycleTick then
+                if thisWidget.state.isOpened.value == true then
+                    thisWidget.lastOpenedTick = Iris._cycleTick + 1
+                    openTab(thisWidget.parentWidget, thisWidget.Index)
+                    Tab.Visible = true
+                else
+                    thisWidget.lastClosedTick = Iris._cycleTick + 1
+                    closeTab(thisWidget.parentWidget, thisWidget.Index)
+                    Tab.Visible = false
+                end
+            end
+
+            if thisWidget.state.index.lastChangeTick == Iris._cycleTick then
+                if thisWidget.state.index.value == thisWidget.Index then
+                    thisWidget.ButtonColors.Color = Iris._config.TabActiveColor
+                    thisWidget.ButtonColors.Transparency = Iris._config.TabActiveTransparency
+            Tab.BackgroundColor3 = Iris._config.TabActiveColor
+                    Tab.BackgroundTransparency = Iris._config.TabActiveTransparency
+                    Container.Visible = true
+                    thisWidget.lastSelectedTick = Iris._cycleTick + 1
+                else
+                    thisWidget.ButtonColors.Color = Iris._config.TabColor
+                    thisWidget.ButtonColors.Transparency = Iris._config.TabTransparency
+                    Tab.BackgroundColor3 = Iris._config.TabColor
+                    Tab.BackgroundTransparency = Iris._config.TabTransparency
+                    Container.Visible = false
+                    thisWidget.lastUnselectedTick = Iris._cycleTick + 1
+                end
+            end
+        end,
+        Discard = function(thisWidget: Types.Tab)
+            if thisWidget.state.isOpened.value == true then
+                closeTab(thisWidget.parentWidget, thisWidget.Index)
+            end
+            
+            thisWidget.Instance:Destroy()
+            thisWidget.ChildContainer:Destroy()
+            widgets.discardState(thisWidget)
+        end
+    } :: Types.WidgetClass)
+end