cluaupp 1.0.0 → 1.4.0

package/runtime/Iris/_impl/widgets/Table.lua

@@ -1,635 +0,0 @@
-local Types = require(script.Parent.Parent.Types)
-
--- Tables need an overhaul.
-
---[[
-	Iris.Table(
-		{
-			NumColumns,
-			Header,
-			RowBackground,
-			OuterBorders,
-			InnerBorders
-		}
-	)
-
-	Config = {
-		CellPadding: Vector2,
-		CellSize: UDim2,
-	}
-
-	Iris.NextColumn()
-	Iris.NextRow()
-	Iris.SetColumnIndex(index: number)
-	Iris.SetRowIndex(index: number)
-
-	Iris.NextHeaderColumn()
-	Iris.SetHeaderColumnIndex(index: number)
-
-	Iris.SetColumnWidth(index: number, width: number | UDim)
-]]
-
-return function(Iris: Types.Internal, widgets: Types.WidgetUtility)
-    local Tables: { [Types.ID]: Types.Table } = {}
-    local TableMinWidths: { [Types.Table]: { boolean } } = {}
-    local AnyActiveTable = false
-    local ActiveTable: Types.Table? = nil
-    local ActiveColumn = 0
-    local ActiveLeftWidth = -1
-    local ActiveRightWidth = -1
-    local MousePositionX = 0
-
-    local function CalculateMinColumnWidth(thisWidget: Types.Table, index: number)
-        local width = 0
-        for _, row in thisWidget._cellInstances do
-            local cell = row[index]
-            for _, child in cell:GetChildren() do
-                if child:IsA("GuiObject") then
-                    width = math.max(width, child.AbsoluteSize.X)
-                end
-            end
-        end
-
-        thisWidget._minWidths[index] = width + 2 * Iris._config.CellPadding.X
-    end
-
-    table.insert(Iris._postCycleCallbacks, function()
-        for _, thisWidget in Tables do
-            for rowIndex, cycleTick in thisWidget._rowCycles do
-                if cycleTick < Iris._cycleTick - 1 then
-                    local Row = thisWidget._rowInstances[rowIndex]
-                    local RowBorder = thisWidget._rowBorders[rowIndex - 1]
-                    if Row ~= nil then
-                        Row:Destroy()
-                    end
-                    if RowBorder ~= nil then
-                        RowBorder:Destroy()
-                    end
-                    thisWidget._rowInstances[rowIndex] = nil
-                    thisWidget._rowBorders[rowIndex - 1] = nil
-                    thisWidget._cellInstances[rowIndex] = nil
-                    thisWidget._rowCycles[rowIndex] = nil
-                end
-            end
-
-            thisWidget._rowIndex = 1
-            thisWidget._columnIndex = 1
-
-            -- update the border container size to be the same, albeit *every* frame!
-            local Table = thisWidget.Instance :: Frame
-            if Table.Parent == nil then
-                continue
-            end
-            local BorderContainer: Frame = Table.BorderContainer
-            BorderContainer.Size = UDim2.new(1, 0, 0, thisWidget._rowContainer.AbsoluteSize.Y)
-            thisWidget._columnBorders[0].Size = UDim2.fromOffset(5, thisWidget._rowContainer.AbsoluteSize.Y)
-        end
-
-        for thisWidget, columns in TableMinWidths do
-            local refresh = false
-            for column, _ in columns do
-                CalculateMinColumnWidth(thisWidget, column)
-                refresh = true
-            end
-            if refresh then
-                table.clear(columns)
-                Iris._widgets["Table"].UpdateState(thisWidget)
-            end
-        end
-    end)
-
-    local function UpdateActiveColumn()
-        if AnyActiveTable == false or ActiveTable == nil then
-            return
-        end
-
-        local widths = ActiveTable.state.widths
-        local NumColumns = ActiveTable.arguments.NumColumns
-        local Table = ActiveTable.Instance :: Frame
-        local BorderContainer = Table.BorderContainer :: Frame
-        local Fixed = ActiveTable.arguments.FixedWidth
-        local Padding = 2 * Iris._config.CellPadding.X
-
-        if ActiveLeftWidth == -1 then
-            ActiveLeftWidth = widths.value[ActiveColumn]
-            if ActiveLeftWidth == 0 then
-                ActiveLeftWidth = Padding / Table.AbsoluteSize.X
-            end
-            ActiveRightWidth = widths.value[ActiveColumn + 1] or -1
-            if ActiveRightWidth == 0 then
-                ActiveRightWidth = Padding / Table.AbsoluteSize.X
-            end
-        end
-
-        local BorderX = Table.AbsolutePosition.X
-        local LeftX: number -- the start of the current column
-        -- local CurrentX: number = BorderContainer:FindFirstChild(`Border_{ActiveColumn}`).AbsolutePosition.X + 3 - BorderX -- the current column position
-        local RightX: number -- the end of the next column
-        if ActiveColumn == 1 then
-            LeftX = 0
-        else
-            LeftX = math.floor(BorderContainer:FindFirstChild(`Border_{ActiveColumn - 1}`).AbsolutePosition.X + 3 - BorderX)
-        end
-        if ActiveColumn >= NumColumns - 1 then
-            RightX = Table.AbsoluteSize.X
-        else
-            RightX = math.floor(BorderContainer:FindFirstChild(`Border_{ActiveColumn + 1}`).AbsolutePosition.X + 3 - BorderX)
-        end
-
-        local TableX: number = BorderX - widgets.GuiOffset.X
-        local DeltaX: number = math.clamp(widgets.getMouseLocation().X, LeftX + TableX + Padding, RightX + TableX - Padding) - MousePositionX
-        local LeftOffset = (MousePositionX - TableX) - LeftX
-        local LeftRatio = ActiveLeftWidth / LeftOffset
-
-        if Fixed then
-            widths.value[ActiveColumn] = math.clamp(math.round(ActiveLeftWidth + DeltaX), Padding, Table.AbsoluteSize.X - LeftX)
-        else
-            local Change = LeftRatio * DeltaX
-            widths.value[ActiveColumn] = math.clamp(ActiveLeftWidth + Change, 0, (RightX - LeftX - Padding) / Table.AbsoluteSize.X)
-            if ActiveColumn < NumColumns then
-                widths.value[ActiveColumn + 1] = math.clamp(ActiveRightWidth - Change, 0, 1)
-            end
-        end
-
-        widths:set(widths.value, true)
-    end
-
-    local function ColumnMouseDown(thisWidget: Types.Table, index: number)
-        AnyActiveTable = true
-        ActiveTable = thisWidget
-        ActiveColumn = index
-        ActiveLeftWidth = -1
-        ActiveRightWidth = -1
-        MousePositionX = widgets.getMouseLocation().X
-    end
-
-    widgets.registerEvent("InputChanged", function()
-        if not Iris._started then
-            return
-        end
-        UpdateActiveColumn()
-    end)
-
-    widgets.registerEvent("InputEnded", function(inputObject: InputObject)
-        if not Iris._started then
-            return
-        end
-        if inputObject.UserInputType == Enum.UserInputType.MouseButton1 and AnyActiveTable then
-            AnyActiveTable = false
-            ActiveTable = nil
-            ActiveColumn = 0
-            ActiveLeftWidth = -1
-            ActiveRightWidth = -1
-            MousePositionX = 0
-        end
-    end)
-
-    local function GenerateCell(_thisWidget: Types.Table, index: number, width: UDim, header: boolean)
-        local Cell: TextButton
-        if header then
-            Cell = Instance.new("TextButton")
-            Cell.Text = ""
-            Cell.AutoButtonColor = false
-        else
-            Cell = (Instance.new("Frame") :: GuiObject) :: TextButton
-        end
-        Cell.Name = `Cell_{index}`
-        Cell.AutomaticSize = Enum.AutomaticSize.Y
-        Cell.Size = UDim2.new(width, UDim.new())
-        Cell.BackgroundTransparency = 1
-        Cell.ZIndex = index
-        Cell.LayoutOrder = index
-        Cell.ClipsDescendants = true
-
-        if header then
-            widgets.applyInteractionHighlights("Background", Cell, Cell, {
-                Color = Iris._config.HeaderColor,
-                Transparency = 1,
-                HoveredColor = Iris._config.HeaderHoveredColor,
-                HoveredTransparency = Iris._config.HeaderHoveredTransparency,
-                ActiveColor = Iris._config.HeaderActiveColor,
-                ActiveTransparency = Iris._config.HeaderActiveTransparency,
-            })
-        end
-
-        widgets.UIPadding(Cell, Iris._config.CellPadding)
-        widgets.UIListLayout(Cell, Enum.FillDirection.Vertical, UDim.new())
-        widgets.UISizeConstraint(Cell, Vector2.new(2 * Iris._config.CellPadding.X, 0))
-
-        return Cell
-    end
-
-    local function GenerateColumnBorder(thisWidget: Types.Table, index: number, style: "Light" | "Strong")
-        local Border = Instance.new("ImageButton")
-        Border.Name = `Border_{index}`
-        Border.Size = UDim2.new(0, 5, 1, 0)
-        Border.BackgroundTransparency = 1
-        Border.Image = ""
-        Border.ImageTransparency = 1
-        Border.AutoButtonColor = false
-        Border.ZIndex = index
-        Border.LayoutOrder = 2 * index
-
-        local offset = if index == thisWidget.arguments.NumColumns then 3 else 2
-
-        local Line = Instance.new("Frame")
-        Line.Name = "Line"
-        Line.Size = UDim2.new(0, 1, 1, 0)
-        Line.Position = UDim2.fromOffset(offset, 0)
-        Line.BackgroundColor3 = Iris._config[`TableBorder{style}Color`]
-        Line.BackgroundTransparency = Iris._config[`TableBorder{style}Transparency`]
-        Line.BorderSizePixel = 0
-
-        Line.Parent = Border
-
-        local Hover = Instance.new("Frame")
-        Hover.Name = "Hover"
-        Hover.Position = UDim2.fromOffset(offset, 0)
-        Hover.Size = UDim2.new(0, 1, 1, 0)
-        Hover.BackgroundColor3 = Iris._config[`TableBorder{style}Color`]
-        Hover.BackgroundTransparency = Iris._config[`TableBorder{style}Transparency`]
-        Hover.BorderSizePixel = 0
-
-        Hover.Visible = thisWidget.arguments.Resizable
-
-        Hover.Parent = Border
-
-        widgets.applyInteractionHighlights("Background", Border, Hover, {
-            Color = Iris._config.ResizeGripColor,
-            Transparency = 1,
-            HoveredColor = Iris._config.ResizeGripHoveredColor,
-            HoveredTransparency = Iris._config.ResizeGripHoveredTransparency,
-            ActiveColor = Iris._config.ResizeGripActiveColor,
-            ActiveTransparency = Iris._config.ResizeGripActiveTransparency,
-        })
-
-        widgets.applyButtonDown(Border, function()
-            if thisWidget.arguments.Resizable then
-                ColumnMouseDown(thisWidget, index)
-            end
-        end)
-
-        return Border
-    end
-
-    -- creates a new row and all columns, and adds all to the table's row and cell instance tables, but does not parent
-    local function GenerateRow(thisWidget: Types.Table, index: number)
-        local Row: Frame = Instance.new("Frame")
-        Row.Name = `Row_{index}`
-        Row.AutomaticSize = Enum.AutomaticSize.Y
-        Row.Size = UDim2.fromScale(1, 0)
-        if index == 0 then
-            Row.BackgroundColor3 = Iris._config.TableHeaderColor
-            Row.BackgroundTransparency = Iris._config.TableHeaderTransparency
-        elseif thisWidget.arguments.RowBackground == true then
-            if (index % 2) == 0 then
-                Row.BackgroundColor3 = Iris._config.TableRowBgAltColor
-                Row.BackgroundTransparency = Iris._config.TableRowBgAltTransparency
-            else
-                Row.BackgroundColor3 = Iris._config.TableRowBgColor
-                Row.BackgroundTransparency = Iris._config.TableRowBgTransparency
-            end
-        else
-            Row.BackgroundTransparency = 1
-        end
-        Row.BorderSizePixel = 0
-        Row.ZIndex = 2 * index - 1
-        Row.LayoutOrder = 2 * index - 1
-        Row.ClipsDescendants = true
-
-        widgets.UIListLayout(Row, Enum.FillDirection.Horizontal, UDim.new())
-
-        thisWidget._cellInstances[index] = table.create(thisWidget.arguments.NumColumns)
-        for columnIndex = 1, thisWidget.arguments.NumColumns do
-            local Cell = GenerateCell(thisWidget, columnIndex, thisWidget._widths[columnIndex], index == 0)
-            Cell.Parent = Row
-            thisWidget._cellInstances[index][columnIndex] = Cell
-        end
-
-        thisWidget._rowInstances[index] = Row
-
-        return Row
-    end
-
-    local function GenerateRowBorder(_thisWidget: Types.Table, index: number, style: "Light" | "Strong")
-        local Border = Instance.new("Frame")
-        Border.Name = `Border_{index}`
-        Border.Size = UDim2.fromScale(1, 0)
-        Border.BackgroundTransparency = 1
-        Border.ZIndex = 2 * index
-        Border.LayoutOrder = 2 * index
-
-        local Line = Instance.new("Frame")
-        Line.Name = "Line"
-        Line.AnchorPoint = Vector2.new(0, 0.5)
-        Line.Size = UDim2.new(1, 0, 0, 1)
-        Line.BackgroundColor3 = Iris._config[`TableBorder{style}Color`]
-        Line.BackgroundTransparency = Iris._config[`TableBorder{style}Transparency`]
-        Line.BorderSizePixel = 0
-
-        Line.Parent = Border
-
-        return Border
-    end
-
-    --stylua: ignore
-    Iris.WidgetConstructor("Table", {
-        hasState = true,
-        hasChildren = true,
-        Args = {
-            NumColumns = 1,
-            Header = 2,
-            RowBackground = 3,
-            OuterBorders = 4,
-            InnerBorders = 5,
-            Resizable = 6,
-            FixedWidth = 7,
-            ProportionalWidth = 8,
-            LimitTableWidth = 9,
-        },
-        Events = {},
-        Generate = function(thisWidget: Types.Table)
-            Tables[thisWidget.ID] = thisWidget
-            TableMinWidths[thisWidget] = {}
-
-            local Table = Instance.new("Frame")
-            Table.Name = "Iris_Table"
-            Table.AutomaticSize = Enum.AutomaticSize.Y
-            Table.Size = UDim2.fromScale(1, 0)
-            Table.BackgroundTransparency = 1
-
-            local RowContainer = Instance.new("Frame")
-            RowContainer.Name = "RowContainer"
-            RowContainer.AutomaticSize = Enum.AutomaticSize.Y
-            RowContainer.Size = UDim2.fromScale(1, 0)
-            RowContainer.BackgroundTransparency = 1
-            RowContainer.ZIndex = 1
-
-            widgets.UISizeConstraint(RowContainer)
-            widgets.UIListLayout(RowContainer, Enum.FillDirection.Vertical, UDim.new())
-
-            RowContainer.Parent = Table
-			thisWidget._rowContainer = RowContainer
-
-            local BorderContainer = Instance.new("Frame")
-            BorderContainer.Name = "BorderContainer"
-            BorderContainer.Size = UDim2.fromScale(1, 1)
-            BorderContainer.BackgroundTransparency = 1
-            BorderContainer.ZIndex = 2
-            BorderContainer.ClipsDescendants = true
-
-            widgets.UISizeConstraint(BorderContainer)            
-            widgets.UIListLayout(BorderContainer, Enum.FillDirection.Horizontal, UDim.new())
-            widgets.UIStroke(BorderContainer, 1, Iris._config.TableBorderStrongColor, Iris._config.TableBorderStrongTransparency)
-
-            BorderContainer.Parent = Table
-
-            thisWidget._columnIndex = 1
-            thisWidget._rowIndex = 1
-            thisWidget._rowInstances = {}
-            thisWidget._cellInstances = {}
-            thisWidget._rowBorders = {}
-            thisWidget._columnBorders = {}
-            thisWidget._rowCycles = {}
-
-            local callbackIndex = #Iris._postCycleCallbacks + 1
-            local desiredCycleTick = Iris._cycleTick + 1
-            Iris._postCycleCallbacks[callbackIndex] = function()
-                if Iris._cycleTick >= desiredCycleTick then
-                    if thisWidget.lastCycleTick ~= -1 then
-                        thisWidget.state.widths.lastChangeTick = Iris._cycleTick
-                        Iris._widgets["Table"].UpdateState(thisWidget)
-                    end
-                    Iris._postCycleCallbacks[callbackIndex] = nil
-                end
-            end
-
-            return Table
-        end,
-        GenerateState = function(thisWidget: Types.Table)
-            local NumColumns = thisWidget.arguments.NumColumns
-            if thisWidget.state.widths == nil then
-                local Widths: { number } = table.create(NumColumns, 1 / NumColumns)
-                thisWidget.state.widths = Iris._widgetState(thisWidget, "widths", Widths)
-            end
-            thisWidget._widths = table.create(NumColumns, UDim.new())
-            thisWidget._minWidths = table.create(NumColumns, 0)
-
-            local Table = thisWidget.Instance :: Frame
-            local BorderContainer: Frame = Table.BorderContainer
-
-            thisWidget._cellInstances[-1] = table.create(NumColumns)
-            for index = 1, NumColumns do
-                local Border = GenerateColumnBorder(thisWidget, index, "Light")
-                Border.Visible = thisWidget.arguments.InnerBorders
-                thisWidget._columnBorders[index] = Border
-                Border.Parent = BorderContainer
-
-                local Cell = GenerateCell(thisWidget, index, thisWidget._widths[index], false)
-                local UISizeConstraint = Cell:FindFirstChild("UISizeConstraint") :: UISizeConstraint
-                UISizeConstraint.MinSize = Vector2.new(
-                    2 * Iris._config.CellPadding.X + (if index > 1 then -2 else 0) + (if index < NumColumns then -3 else 0),
-                    0
-                )
-                Cell.LayoutOrder = 2 * index - 1
-                thisWidget._cellInstances[-1][index] = Cell
-                Cell.Parent = BorderContainer
-            end
-
-            local TableColumnBorder = GenerateColumnBorder(thisWidget, NumColumns, "Strong")
-            thisWidget._columnBorders[0] = TableColumnBorder
-            TableColumnBorder.Parent = Table
-        end,
-        Update = function(thisWidget: Types.Table)
-            local NumColumns = thisWidget.arguments.NumColumns
-            assert(NumColumns >= 1, "Iris.Table must have at least one column.")
-
-            if thisWidget._widths ~= nil and #thisWidget._widths ~= NumColumns then
-                -- disallow changing the number of columns. It's too much effort
-                thisWidget.arguments.NumColumns = #thisWidget._widths
-                warn("NumColumns cannot change once set. See documentation.")
-            end
-
-            for rowIndex, row in thisWidget._rowInstances do
-                if rowIndex == 0 then
-                    row.BackgroundColor3 = Iris._config.TableHeaderColor
-                    row.BackgroundTransparency = Iris._config.TableHeaderTransparency
-                elseif thisWidget.arguments.RowBackground == true then
-                    if (rowIndex % 2) == 0 then
-                        row.BackgroundColor3 = Iris._config.TableRowBgAltColor
-                        row.BackgroundTransparency = Iris._config.TableRowBgAltTransparency
-                    else
-                        row.BackgroundColor3 = Iris._config.TableRowBgColor
-                        row.BackgroundTransparency = Iris._config.TableRowBgTransparency
-                    end
-                else
-                    row.BackgroundTransparency = 1
-                end
-            end
-            
-            for _, Border: Frame in thisWidget._rowBorders do
-                Border.Visible = thisWidget.arguments.InnerBorders
-            end
-
-            for _, Border: GuiButton in thisWidget._columnBorders do
-                Border.Visible = thisWidget.arguments.InnerBorders or thisWidget.arguments.Resizable
-            end
-
-            for _, border in thisWidget._columnBorders do
-                local hover = border:FindFirstChild("Hover") :: Frame?
-                if hover then
-                    hover.Visible = thisWidget.arguments.Resizable
-                end
-            end
-
-            if thisWidget._columnBorders[NumColumns] ~= nil then
-                thisWidget._columnBorders[NumColumns].Visible =
-                    not thisWidget.arguments.LimitTableWidth and (thisWidget.arguments.Resizable or thisWidget.arguments.InnerBorders)
-                thisWidget._columnBorders[0].Visible =
-                    thisWidget.arguments.LimitTableWidth and (thisWidget.arguments.Resizable or thisWidget.arguments.OuterBorders)
-            end
-            
-            -- the header border visibility must be updated after settings all borders
-            -- visiblity or not
-            local HeaderRow: Frame? = thisWidget._rowInstances[0]
-            local HeaderBorder: Frame? = thisWidget._rowBorders[0]
-            if HeaderRow ~= nil then
-                HeaderRow.Visible = thisWidget.arguments.Header
-            end
-            if HeaderBorder ~= nil then
-                HeaderBorder.Visible = thisWidget.arguments.Header and thisWidget.arguments.InnerBorders
-            end
-
-            local Table = thisWidget.Instance :: Frame
-            local BorderContainer = Table.BorderContainer :: Frame
-            BorderContainer.UIStroke.Enabled = thisWidget.arguments.OuterBorders
-
-            for index = 1, thisWidget.arguments.NumColumns do
-                TableMinWidths[thisWidget][index] = true
-            end
-
-            if thisWidget._widths ~= nil then
-                Iris._widgets["Table"].UpdateState(thisWidget)
-            end
-        end,
-        UpdateState = function(thisWidget: Types.Table)
-            local Table = thisWidget.Instance :: Frame
-            local BorderContainer = Table.BorderContainer :: Frame
-            local RowContainer = Table.RowContainer :: Frame
-            local NumColumns = thisWidget.arguments.NumColumns
-            local ColumnWidths = thisWidget.state.widths.value
-            local MinWidths = thisWidget._minWidths
-            
-            local Fixed = thisWidget.arguments.FixedWidth
-            local Proportional = thisWidget.arguments.ProportionalWidth
-
-            if not thisWidget.arguments.Resizable then
-                if Fixed then
-                    if Proportional then
-                        for index = 1, NumColumns do
-                            ColumnWidths[index] = MinWidths[index]
-                        end
-                    else
-                        local maxWidth = 0
-                        for _, width in MinWidths do
-                            maxWidth = math.max(maxWidth, width)
-                        end
-                        for index = 1, NumColumns do
-                            ColumnWidths[index] = maxWidth
-                        end
-                    end
-                else
-                    if Proportional then
-                        local TotalWidth = 0
-                        for _, width in MinWidths do
-                            TotalWidth += width
-                        end
-                        local Ratio = 1 / TotalWidth
-                        for index = 1, NumColumns do
-                            ColumnWidths[index] = Ratio * MinWidths[index]
-                        end
-                    else
-                        local width = 1 / NumColumns
-                        for index = 1, NumColumns do
-                            ColumnWidths[index] = width
-                        end
-                    end
-                end
-            end
-
-            local Position = UDim.new()
-            for index = 1, NumColumns do
-                local ColumnWidth = ColumnWidths[index]
-
-                local Width = UDim.new(
-                    if Fixed then 0 else math.clamp(ColumnWidth, 0, 1),
-                    if Fixed then math.max(ColumnWidth, 0) else 0
-                )
-                thisWidget._widths[index] = Width
-                Position += Width
-
-                for _, row in thisWidget._cellInstances do
-                    row[index].Size = UDim2.new(Width, UDim.new())
-                end
-
-                thisWidget._cellInstances[-1][index].Size = UDim2.new(Width + UDim.new(0,
-                    (if index > 1 then -2 else 0) - 3
-                ), UDim.new())
-            end
-
-            -- if the table has a fixed width and we want to cap it, we calculate the table width necessary
-            local Width = Position.Offset
-            if not thisWidget.arguments.FixedWidth or not thisWidget.arguments.LimitTableWidth then
-                Width = math.huge
-            end
-
-            BorderContainer.UISizeConstraint.MaxSize = Vector2.new(Width, math.huge)
-            RowContainer.UISizeConstraint.MaxSize = Vector2.new(Width, math.huge)
-            thisWidget._columnBorders[0].Position = UDim2.fromOffset(Width - 3, 0)
-        end,
-        ChildAdded = function(thisWidget: Types.Table, _: Types.Widget)
-            local rowIndex = thisWidget._rowIndex
-            local columnIndex = thisWidget._columnIndex
-            -- determine if the row exists yet
-            local Row = thisWidget._rowInstances[rowIndex]
-            thisWidget._rowCycles[rowIndex] = Iris._cycleTick
-            TableMinWidths[thisWidget][columnIndex] = true
-
-            if Row ~= nil then
-                return thisWidget._cellInstances[rowIndex][columnIndex]
-            end
-
-            Row = GenerateRow(thisWidget, rowIndex)
-            if rowIndex == 0 then
-                Row.Visible = thisWidget.arguments.Header
-            end
-            Row.Parent = thisWidget._rowContainer
-
-            if rowIndex > 0 then
-                local Border = GenerateRowBorder(thisWidget, rowIndex - 1, if rowIndex == 1 then "Strong" else "Light")
-                Border.Visible = thisWidget.arguments.InnerBorders and (if rowIndex == 1 then (thisWidget.arguments.Header and thisWidget.arguments.InnerBorders) and (thisWidget._rowInstances[0] ~= nil) else true)
-                thisWidget._rowBorders[rowIndex - 1] = Border
-                Border.Parent = thisWidget._rowContainer
-            end
-
-            return thisWidget._cellInstances[rowIndex][columnIndex]
-        end,
-        ChildDiscarded = function(thisWidget: Types.Table, thisChild: Types.Widget)
-            local Cell = thisChild.Instance.Parent
-
-            if Cell ~= nil then
-                local columnIndex = tonumber(Cell.Name:sub(6))
-                
-                if columnIndex then
-                    TableMinWidths[thisWidget][columnIndex] = true
-                end
-            end
-        end,
-        Discard = function(thisWidget: Types.Table)
-            Tables[thisWidget.ID] = nil
-            TableMinWidths[thisWidget] = nil
-            thisWidget.Instance:Destroy()
-            widgets.discardState(thisWidget)
-        end
-    } :: Types.WidgetClass)
-end