From 72c04a69973a88b549f677085597da26f5a8fa31 Mon Sep 17 00:00:00 2001
From: Enrico Galassi <enrico.galassi.88@gmail.com>
Date: Mon, 6 Feb 2023 22:34:03 +0100
Subject: [PATCH] Refactor of CEs internal

---
 README.md                                     |   8 +-
 Showcase.fsx                                  |  25 ++--
 .../Prompts/MultiSelectionPromptBuilder.fs    |  85 +++++++++---
 .../Prompts/SelectionPromptBuilder.fs         |  50 +++++--
 src/FsSpectre/Prompts/TextPromptBuilder.fs    |  95 ++++++++++---
 src/FsSpectre/Syle.fs                         |  39 ++++--
 src/FsSpectre/Widgets/BarChartBuilder.fs      |  67 ++++++---
 .../Widgets/BreakdownChartBuilder.fs          |  48 +++++--
 src/FsSpectre/Widgets/CalendarBuilder.fs      |  66 ++++-----
 src/FsSpectre/Widgets/CalendarEventBuilder.fs |  35 ++---
 src/FsSpectre/Widgets/ColumnsBuilder.fs       |  21 ++-
 src/FsSpectre/Widgets/GridBuilder.fs          |  62 +++++++--
 src/FsSpectre/Widgets/GridColumnBuilder.fs    |  61 ++++++---
 src/FsSpectre/Widgets/LayoutBuilder.fs        |  50 ++++---
 src/FsSpectre/Widgets/MarkupBuilder.fs        |  37 ++++-
 src/FsSpectre/Widgets/PanelBuilder.fs         |  64 ++++++---
 src/FsSpectre/Widgets/PanelHeaderBuilder.fs   |  31 ++++-
 src/FsSpectre/Widgets/RowsBuilder.fs          |  24 +++-
 src/FsSpectre/Widgets/RuleBuilder.fs          |  41 ++++--
 src/FsSpectre/Widgets/TableBuilder.fs         | 127 +++++++++++++-----
 src/FsSpectre/Widgets/TableColumnBuilder.fs   | 100 ++++++++++----
 src/FsSpectre/Widgets/TableTitleBuilder.fs    |  19 ++-
 src/FsSpectre/Widgets/TextBuilder.fs          |  36 +++--
 src/FsSpectre/Widgets/TreeBuilder.fs          |  43 +++---
 src/FsSpectre/Widgets/TreeNodeBuilder.fs      |  45 ++++---
 25 files changed, 923 insertions(+), 356 deletions(-)

diff --git a/README.md b/README.md
index cdf3c05..9b92fa1 100644
--- a/README.md
+++ b/README.md
@@ -43,7 +43,7 @@ With F# + FsSpectre:
 ```fsharp
 table {
     column_text ""
-    column (tableColumn { header "Feature"; centerd })
+    column (tableColumn { header_text "Feature"; centerd })
     row_text [| "Baz"; "[green]Qux[/]" |]
     row [| markup { text "[blue]Corgi[/]" }; panel { content "Waldo" } |]
 } |> AnsiConsole.Write
@@ -68,9 +68,9 @@ barChart {
     width 60
     label "[green bold underline]Number of fruits[/]"
     center_label
-    item "Apple" 12 Color.Yellow
-    item "Oranges" 54 Color.Green
-    item "Bananas" 33 Color.Red
+    item ("Apple", 12, Color.Yellow)
+    item ("Oranges", 54, Color.Green)
+    item ("Bananas", 33, Color.Red)
 } |> AnsiConsole.Write
 ```
 
diff --git a/Showcase.fsx b/Showcase.fsx
index ca74271..5e12c4e 100644
--- a/Showcase.fsx
+++ b/Showcase.fsx
@@ -12,7 +12,7 @@ table {
 
     column (
         tableColumn {
-            header "Feature"
+            header_text "Feature"
             no_wrap
             right_aligned
             width 10
@@ -22,7 +22,7 @@ table {
 
     column (
         tableColumn {
-            header "Demonstration"
+            header_text "Demonstration"
             pad_right 0
         }
     )
@@ -35,8 +35,8 @@ table {
             no_headers
             no_border
 
-            column (tableColumn { header "Desc"; pad_right 3 })
-            column (tableColumn { header "Colors"; pad_right 0 })
+            column (tableColumn { header_text "Desc"; pad_right 3 })
+            column (tableColumn { header_text "Colors"; pad_right 0 })
             row [|
                 markup {
                     text ("✓ [bold grey]NO_COLOR support[/]\n"+
@@ -111,8 +111,8 @@ table {
                     simple_border
                     border_color Color.Grey
                     columns [|
-                        tableColumn { header "Overview" }
-                        tableColumn { footer "[grey]3 Files, 225 KiB[/]" }
+                        tableColumn { header_text "Overview" }
+                        tableColumn { footer_text "[grey]3 Files, 225 KiB[/]" }
                     |]
 
                     row [|
@@ -149,7 +149,6 @@ table {
     row [|
         markup { text "[red]Tables and Trees[/]" }
         grid {
-            collapse
             number_of_columns 2
             row [|
                 panel {
@@ -157,17 +156,17 @@ table {
                     content_renderable (breakdownChart {
                         show_percentage
                         full_size
-                        item "F#" 82 Color.Violet
-                        item "PowerShell" 13 Color.Red
-                        item "Bash" 5 Color.Blue
+                        item ("F#", 82, Color.Violet)
+                        item ("PowerShell", 13, Color.Red)
+                        item ("Bash", 5, Color.Blue)
                     })
                 }
                 panel {
                     border_color Color.Grey
                     content_renderable (barChart {
-                        item "Apple" 32 Color.Green
-                        item "Oranges" 13 Color.Orange1
-                        item "Bananas" 22 Color.Yellow
+                        item ("Apple", 32, Color.Green)
+                        item ("Oranges", 13, Color.Orange1)
+                        item ("Bananas", 22, Color.Yellow)
                     })
                 }
             |]
diff --git a/src/FsSpectre/Prompts/MultiSelectionPromptBuilder.fs b/src/FsSpectre/Prompts/MultiSelectionPromptBuilder.fs
index ad45637..1b6fe43 100644
--- a/src/FsSpectre/Prompts/MultiSelectionPromptBuilder.fs
+++ b/src/FsSpectre/Prompts/MultiSelectionPromptBuilder.fs
@@ -1,47 +1,90 @@
 namespace FsSpectre
 
+open System
+open System.Collections.Generic
 open Spectre.Console
 
 [<AutoOpen>]
 module MultiSelectionPromptBuilder =
 
+    type MulitSelectionPromptConfig<'T> =
+        { Title: string
+          Comparer: IEqualityComparer<'T>
+          Choices: ('T option * 'T array) array
+          PageSize: int
+          Required: bool
+          MoreChoicesText: string
+          InstructionsText: string
+          Converter: Option<'T -> string> }
+
+        static member Default =
+            { Title = String.Empty
+              Comparer = EqualityComparer<'T>.Default
+              Choices = Array.empty<('T option * 'T array)>
+              PageSize = 10
+              Required = true
+              MoreChoicesText = "[grey](Move up and down to reveal more choices)[/]"
+              InstructionsText = "[grey](Press <space> to select, <enter> to accept)[/]"
+              Converter = None }
+
+
     type MultiSelectionPromptBuilder<'T>() =
-        member __.Yield _ = MultiSelectionPrompt<'T>()
+        member __.Yield _ = MulitSelectionPromptConfig<'T>.Default
+
+        member __.Run(config: MulitSelectionPromptConfig<'T>) =
+            let result = MultiSelectionPrompt<'T>(config.Comparer)
+            result.Title <- config.Title
+
+            config.Choices
+            |> Array.iter (fun (grpOpt, choices) ->
+                match grpOpt with
+                | Some grp -> result.AddChoiceGroup(grp, choices) |> ignore
+                | None -> result.AddChoices(choices) |> ignore)
+
+            result.PageSize <- config.PageSize
+            result.Required <- config.Required
+            result.MoreChoicesText <- config.MoreChoicesText
+            result.InstructionsText <- config.InstructionsText
+            config.Converter |> Option.iter (fun c -> result.Converter <- c)
+            result
 
         [<CustomOperation "title">]
-        member __.Title(multiSelectionPrompt: MultiSelectionPrompt<'T>, title: string) =
-            multiSelectionPrompt.Title <- title
-            multiSelectionPrompt
+        member __.Title(config: MulitSelectionPromptConfig<'T>, title: string) = { config with Title = title }
+
+        [<CustomOperation "comparer">]
+        member __.Title(config: MulitSelectionPromptConfig<'T>, comparer: IEqualityComparer<'T>) =
+            { config with Comparer = comparer }
 
         [<CustomOperation "choices">]
-        member __.Choices(multiSelectionPrompt: MultiSelectionPrompt<'T>, choices: 'T array) =
-            multiSelectionPrompt.AddChoices(choices)
+        member __.Choices(config: MulitSelectionPromptConfig<'T>, choices: 'T array) =
+            { config with
+                Choices = Array.append config.Choices [| (None, choices) |] }
 
         [<CustomOperation "choice_group">]
-        member __.ChoiceGroup(multiSelectionPrompt: MultiSelectionPrompt<'T>, choiceGroup: 'T, choices: 'T array) =
-            multiSelectionPrompt.AddChoiceGroup(choiceGroup, choices)
+        member __.ChoiceGroup(config: MulitSelectionPromptConfig<'T>, choiceGroup: 'T, choices: 'T array) =
+            { config with
+                Choices = Array.append config.Choices [| (Some choiceGroup, choices) |] }
 
         [<CustomOperation "not_required">]
-        member __.PageSize(multiSelectionPrompt: MultiSelectionPrompt<'T>) = multiSelectionPrompt.NotRequired()
+        member __.PageSize(config: MulitSelectionPromptConfig<'T>) = { config with Required = false }
 
         [<CustomOperation "page_size">]
-        member __.PageSize(multiSelectionPrompt: MultiSelectionPrompt<'T>, pageSize: int) =
-            multiSelectionPrompt.PageSize <- pageSize
-            multiSelectionPrompt
+        member __.PageSize(config: MulitSelectionPromptConfig<'T>, pageSize: int) = { config with PageSize = pageSize }
 
         [<CustomOperation "more_choices_text">]
-        member __.MoreChoicesText(multiSelectionPrompt: MultiSelectionPrompt<'T>, moreChoicesText: string) =
-            multiSelectionPrompt.MoreChoicesText <- moreChoicesText
-            multiSelectionPrompt
+        member __.MoreChoicesText(config: MulitSelectionPromptConfig<'T>, moreChoicesText: string) =
+            { config with
+                MoreChoicesText = moreChoicesText }
 
         [<CustomOperation "instructions_text">]
-        member __.InstructionsText(multiSelectionPrompt: MultiSelectionPrompt<'T>, instructionsText: string) =
-            multiSelectionPrompt.InstructionsText <- instructionsText
-            multiSelectionPrompt
+        member __.InstructionsText(config: MulitSelectionPromptConfig<'T>, instructionsText: string) =
+            { config with
+                InstructionsText = instructionsText }
 
         [<CustomOperation "converter">]
-        member __.Converter(multiSelectionPrompt: MultiSelectionPrompt<'T>, converter: 'T -> string) =
-            multiSelectionPrompt.Converter <- converter
-            multiSelectionPrompt
+        member __.Converter(config: MulitSelectionPromptConfig<'T>, converter: 'T -> string) =
+            { config with
+                Converter = Some converter }
+
 
     let multiSelectionPrompt<'T> = MultiSelectionPromptBuilder<'T>()
diff --git a/src/FsSpectre/Prompts/SelectionPromptBuilder.fs b/src/FsSpectre/Prompts/SelectionPromptBuilder.fs
index 22e8ee8..ec7b537 100644
--- a/src/FsSpectre/Prompts/SelectionPromptBuilder.fs
+++ b/src/FsSpectre/Prompts/SelectionPromptBuilder.fs
@@ -1,34 +1,56 @@
 namespace FsSpectre
 
+open System
 open Spectre.Console
 
 [<AutoOpen>]
 module SelectionPromptBuilder =
 
+    type SelectionPromptConfig<'T> =
+        { Title: string
+          Choices: 'T array
+          PageSize: int
+          MoreChoicesText: string
+          Converter: Option<'T -> string> }
+
+        static member Default =
+            { Title = String.Empty
+              Choices = Array.empty<'T>
+              PageSize = 10
+              MoreChoicesText = "[grey](Move up and down to reveal more choices)[/]"
+              Converter = None }
+
     type SelectionPromptBuilder<'T>() =
-        member __.Yield _ = SelectionPrompt<'T>()
+        member __.Yield _ = SelectionPromptConfig<'T>.Default
+
+        member __.Run(config: SelectionPromptConfig<'T>) =
+            let result = SelectionPrompt<'T>()
+            result.Title <- config.Title
+            result.AddChoices(config.Choices) |> ignore
+            result.PageSize <- config.PageSize
+            result.MoreChoicesText <- config.MoreChoicesText
+            config.Converter |> Option.iter (fun c -> result.Converter <- c)
+            result
 
         [<CustomOperation "title">]
-        member __.Title(selectionPrompt: SelectionPrompt<'T>, title: string) =
-            selectionPrompt.Title <- title
-            selectionPrompt
+        member __.Title(config: SelectionPromptConfig<'T>, title: string) = { config with Title = title }
 
         [<CustomOperation "choices">]
-        member __.Choices(selectionPrompt: SelectionPrompt<'T>, choices: 'T array) = selectionPrompt.AddChoices(choices)
+        member __.Choices(config: SelectionPromptConfig<'T>, choices: 'T array) =
+            { config with
+                Choices = Array.append config.Choices choices }
 
         [<CustomOperation "page_size">]
-        member __.PageSize(selectionPrompt: SelectionPrompt<'T>, pageSize: int) =
-            selectionPrompt.PageSize <- pageSize
-            selectionPrompt
+        member __.PageSize(config: SelectionPromptConfig<'T>, pageSize: int) = { config with PageSize = pageSize }
 
         [<CustomOperation "more_choices_text">]
-        member __.MoreChoicesText(selectionPrompt: SelectionPrompt<'T>, moreChoicesText: string) =
-            selectionPrompt.MoreChoicesText <- moreChoicesText
-            selectionPrompt
+        member __.MoreChoicesText(config: SelectionPromptConfig<'T>, moreChoicesText: string) =
+            { config with
+                MoreChoicesText = moreChoicesText }
 
         [<CustomOperation "converter">]
-        member __.Converter(selectionPrompt: SelectionPrompt<'T>, converter: 'T -> string) =
-            selectionPrompt.Converter <- converter
-            selectionPrompt
+        member __.Converter(config: SelectionPromptConfig<'T>, converter: 'T -> string) =
+            { config with
+                Converter = Some converter }
 
     let selectionPrompt<'T> = SelectionPromptBuilder<'T>()
diff --git a/src/FsSpectre/Prompts/TextPromptBuilder.fs b/src/FsSpectre/Prompts/TextPromptBuilder.fs
index 56859f9..3daa7b1 100644
--- a/src/FsSpectre/Prompts/TextPromptBuilder.fs
+++ b/src/FsSpectre/Prompts/TextPromptBuilder.fs
@@ -6,39 +6,92 @@ open Spectre.Console
 [<AutoOpen>]
 module TextPromptBuilder =
 
+    type TextPromptConfig<'T> =
+        { Text: string
+          Comparer: StringComparer option
+          PromptStyle: Style
+          IsSecret: bool
+          Mask: char option
+          HasHiddenInput: bool
+          AllowEmpty: bool
+          ValidationErrorMessage: string
+          Validator: Option<'T -> ValidationResult>
+          Converter: Option<'T -> string> }
+
+        static member Default =
+            { Text = String.Empty
+              Comparer = None
+              PromptStyle = Style.Plain
+              IsSecret = false
+              Mask = None
+              HasHiddenInput = false
+              AllowEmpty = false
+              ValidationErrorMessage = "[red]Invalid input[/]"
+              Validator = None
+              Converter = None }
+
     type TextPromptBuilder<'T>() =
-        member __.Yield _ = TextPrompt<'T>(String.Empty)
+        member __.Yield _ = TextPromptConfig<'T>.Default
+
+        member __.Run(config: TextPromptConfig<'T>) =
+            let result = TextPrompt<'T>(config.Text, Option.toObj config.Comparer)
+            result.IsSecret <- config.IsSecret
+
+            if config.HasHiddenInput then
+                result.Mask <- Nullable()
+            else
+                config.Mask |> Option.iter (fun m -> result.Mask <- m)
+
+            result.AllowEmpty <- config.AllowEmpty
+            result.ValidationErrorMessage <- config.ValidationErrorMessage
+            config.Validator |> Option.iter (fun v -> result.Validator <- v)
+            config.Converter |> Option.iter (fun c -> result.Converter <- c)
+
+            result
 
         [<CustomOperation "text">]
-        member __.Title(_, text: string) = TextPrompt<'T>(text)
+        member __.Text(config: TextPromptConfig<'T>, text: string) = { config with Text = text }
+
+        [<CustomOperation "comparer">]
+        member __.Comparer(config: TextPromptConfig<'T>, comparer: StringComparer) =
+            { config with Comparer = Some comparer }
 
         [<CustomOperation "prompt_style">]
-        member __.PromptStyle(textPrompt: TextPrompt<'T>, style: Style) =
-            textPrompt.PromptStyle <- style
-            textPrompt
+        member __.PromptStyle(config: TextPromptConfig<'T>, style: Style) = { config with PromptStyle = style }
 
         [<CustomOperation "secret">]
-        member __.Secret(textPrompt: TextPrompt<'T>) = textPrompt.Secret()
+        member __.Secret(config: TextPromptConfig<'T>) = { config with IsSecret = true }
 
-        [<CustomOperation "mask">]
-        member __.Mask(textPrompt: TextPrompt<'T>, mask: char) = textPrompt.Secret(mask)
+        [<CustomOperation "secret_with_mask">]
+        member __.SecretWithMask(config: TextPromptConfig<'T>, mask: char) =
+            { config with
+                IsSecret = true
+                Mask = Some mask
+                HasHiddenInput = false }
 
-        [<CustomOperation "hide_input">]
-        member __.HideInput(textPrompt: TextPrompt<'T>) = textPrompt.Secret(Nullable())
+        [<CustomOperation "secret_with_hidden_input">]
+        member __.SecretWithHiddenInput(config: TextPromptConfig<'T>) =
+            { config with
+                IsSecret = true
+                Mask = None
+                HasHiddenInput = true }
 
         [<CustomOperation "allow_empty">]
-        member __.AllowEmpty(textPrompt: TextPrompt<'T>) =
-            textPrompt.AllowEmpty <- true
-            textPrompt
+        member __.AllowEmpty(config: TextPromptConfig<'T>) = { config with AllowEmpty = true }
 
         [<CustomOperation "validation_error_message">]
-        member __.ValidationErrorMessage(textPrompt: TextPrompt<'T>, validationErrorMessage: string) =
-            textPrompt.ValidationErrorMessage <- validationErrorMessage
-            textPrompt
-
-        [<CustomOperation "validate">]
-        member __.Validate(textPrompt: TextPrompt<'T>, validator: 'T -> ValidationResult) =
-            textPrompt.Validator <- validator
-            textPrompt
+        member __.ValidationErrorMessage(config: TextPromptConfig<'T>, validationErrorMessage: string) =
+            { config with
+                ValidationErrorMessage = validationErrorMessage }
+
+        [<CustomOperation "validator">]
+        member __.Validator(config: TextPromptConfig<'T>, validator: 'T -> ValidationResult) =
+            { config with
+                Validator = Some validator }
+
+        [<CustomOperation "converter">]
+        member __.Converter(config: TextPromptConfig<'T>, converter: 'T -> string) =
+            { config with
+                Converter = Some converter }
 
     let textPrompt<'T> = TextPromptBuilder<'T>()
diff --git a/src/FsSpectre/Syle.fs b/src/FsSpectre/Syle.fs
index c098daf..c6ce702 100644
--- a/src/FsSpectre/Syle.fs
+++ b/src/FsSpectre/Syle.fs
@@ -6,23 +6,44 @@ open Spectre.Console
 [<AutoOpen>]
 module StyleBuilder =
 
+    type StyleConfig =
+        { Foreground: Color
+          Background: Color
+          Decoration: Decoration
+          Link: string option }
+
+        static member Default =
+            { Foreground = Color.Default
+              Background = Color.Default
+              Decoration = Decoration.None
+              Link = None }
+
     type StyleBuilder() =
-        member __.Yield _ = Style()
+        member __.Yield _ = StyleConfig.Default
+
+        member __.Run(config: StyleConfig) =
+            Style(config.Foreground, config.Background, config.Decoration, Option.toObj config.Link)
+
+        [<CustomOperation "plain">]
+        member __.Plain(config: StyleConfig) =
+            let plain = Style.Plain
+
+            { config with
+                Foreground = plain.Foreground
+                Background = plain.Background
+                Decoration = plain.Decoration
+                Link = None }
 
         [<CustomOperation "foreground">]
-        member __.Foreground(style: Style, foreground: Color) =
-            Style(foreground, style.Background, style.Decoration, style.Link)
+        member __.Foreground(config: StyleConfig, foreground: Color) = { config with Foreground = foreground }
 
         [<CustomOperation "background">]
-        member __.Background(style: Style, background: Color) =
-            Style(style.Foreground, background, style.Decoration, style.Link)
+        member __.Background(config: StyleConfig, background: Color) = { config with Background = background }
 
         [<CustomOperation "decoration">]
-        member __.Decoration(style: Style, decoration: Decoration) =
-            Style(style.Foreground, style.Background, decoration, style.Link)
+        member __.Decoration(config: StyleConfig, decoration: Decoration) = { config with Decoration = decoration }
 
         [<CustomOperation "link">]
-        member __.Link(style: Style, link: string) =
-            Style(style.Foreground, style.Background, style.Decoration, link)
+        member __.Link(config: StyleConfig, link: string) = { config with Link = Some link }
 
     let style = StyleBuilder()
diff --git a/src/FsSpectre/Widgets/BarChartBuilder.fs b/src/FsSpectre/Widgets/BarChartBuilder.fs
index 770fb56..6f51900 100644
--- a/src/FsSpectre/Widgets/BarChartBuilder.fs
+++ b/src/FsSpectre/Widgets/BarChartBuilder.fs
@@ -1,41 +1,72 @@
 namespace FsSpectre
 
+open System
 open Spectre.Console
 
 [<AutoOpen>]
 module BarChartBuilder =
 
+    type BarChartConfig =
+        { Label: string
+          LabelAlignment: Justify
+          Width: int option
+          ShowValues: bool
+          Items: (string * float * Color) array }
+
+        static member Default =
+            { Label = String.Empty
+              LabelAlignment = Justify.Center
+              Width = None
+              ShowValues = true
+              Items = Array.empty<(string * float * Color)> }
+
     type BarChartBuilder() =
-        member __.Yield _ = BarChart()
+        member __.Yield _ = BarChartConfig.Default
+
+        member __.Run(config: BarChartConfig) =
+            let result = BarChart()
+            result.Label <- config.Label
+            result.LabelAlignment <- config.LabelAlignment
+            config.Width |> Option.iter (fun w -> result.Width <- w)
+            result.ShowValues <- config.ShowValues
+
+            config.Items
+            |> Array.iter (fun (label, value, color) -> result.AddItem(label, value, color) |> ignore)
+
+            result
 
         [<CustomOperation "label">]
-        member __.FullSize(barChart: BarChart, label: string) =
-            barChart.Label <- label
-            barChart
+        member __.FullSize(config: BarChartConfig, label: string) = { config with Label = label }
 
-        [<CustomOperation "left_align_label">]
-        member __.LeftAlignLabel(barChart: BarChart) = barChart.LeftAlignLabel()
+        [<CustomOperation "left_aligned_label">]
+        member __.LeftAlignedLabel(config: BarChartConfig) =
+            { config with
+                LabelAlignment = Justify.Left }
 
-        [<CustomOperation "center_label">]
-        member __.CenterLabel(barChart: BarChart) = barChart.CenterLabel()
+        [<CustomOperation "centered_label">]
+        member __.CenteredLabel(config: BarChartConfig) =
+            { config with
+                LabelAlignment = Justify.Center }
 
-        [<CustomOperation "right_align_label">]
-        member __.RightAlignLabel(barChart: BarChart) = barChart.RightAlignLabel()
+        [<CustomOperation "right_aligned_label">]
+        member __.RightAlignedLabel(config: BarChartConfig) =
+            { config with
+                LabelAlignment = Justify.Right }
 
         [<CustomOperation "width">]
-        member __.Width(barChart: BarChart, width: int) =
-            barChart.Width <- width
-            barChart
+        member __.Width(config: BarChartConfig, width: int) = { config with Width = Some width }
 
         [<CustomOperation "hide_values">]
-        member __.HideValues(barChart: BarChart) = barChart.HideValues()
+        member __.HideValues(config: BarChartConfig) = { config with ShowValues = false }
 
         [<CustomOperation "item">]
-        member __.Item(barChart: BarChart, label: string, value: float, color: Color) =
-            barChart.AddItem(label, value, color)
+        member __.Item(config: BarChartConfig, item: (string * float * Color)) =
+            { config with
+                Items = Array.append config.Items [| item |] }
 
         [<CustomOperation "items">]
-        member __.Items(barChart: BarChart, elements: 'T array, converter: 'T -> BarChartItem) =
-            barChart.AddItems(elements, converter)
+        member __.Items(config: BarChartConfig, items: 'T array, converter: 'T -> (string * float * Color)) =
+            { config with
+                Items = items |> Array.map converter |> Array.append config.Items }
 
     let barChart = BarChartBuilder()
diff --git a/src/FsSpectre/Widgets/BreakdownChartBuilder.fs b/src/FsSpectre/Widgets/BreakdownChartBuilder.fs
index 946036b..de92309 100644
--- a/src/FsSpectre/Widgets/BreakdownChartBuilder.fs
+++ b/src/FsSpectre/Widgets/BreakdownChartBuilder.fs
@@ -5,27 +5,57 @@ open Spectre.Console
 [<AutoOpen>]
 module BreakdownChartBuilder =
 
+    type BreakdownChartConfig =
+        { Compact: bool
+          ShowPercentage: bool
+          ShowTags: bool
+          ShowTagValues: bool
+          Items: (string * float * Color) array }
+
+        static member Default =
+            { Compact = true
+              ShowPercentage = false
+              ShowTags = true
+              ShowTagValues = true
+              Items = Array.empty<(string * float * Color)> }
+
     type BreakdownChartBuilder() =
-        member __.Yield _ = BreakdownChart()
+        member __.Yield _ = BreakdownChartConfig.Default
+
+        member __.Run(config: BreakdownChartConfig) =
+            let result = BreakdownChart()
+            result.Compact <- config.Compact
+            result.ShowTags <- config.ShowTags
+            result.ShowTagValues <- config.ShowTagValues
+
+            if config.ShowPercentage then
+                result.ShowPercentage() |> ignore
+
+            config.Items
+            |> Array.iter (fun (label, value, color) -> result.AddItem(label, value, color) |> ignore)
+
+            result
 
         [<CustomOperation "full_size">]
-        member __.FullSize(breakdownChart: BreakdownChart) = breakdownChart.FullSize()
+        member __.FullSize(config: BreakdownChartConfig) = { config with Compact = false }
 
         [<CustomOperation "show_percentage">]
-        member __.ShowPercentage(breakdownChart: BreakdownChart) = breakdownChart.ShowPercentage()
+        member __.ShowPercentage(config: BreakdownChartConfig) = { config with ShowPercentage = true }
 
         [<CustomOperation "hide_tags">]
-        member __.HideTags(breakdownChart: BreakdownChart) = breakdownChart.HideTags()
+        member __.HideTags(config: BreakdownChartConfig) = { config with ShowTags = false }
 
         [<CustomOperation "hide_tag_values">]
-        member __.HideTagValues(breakdownChart: BreakdownChart) = breakdownChart.HideTagValues()
+        member __.HideTagValues(config: BreakdownChartConfig) = { config with ShowTagValues = false }
 
         [<CustomOperation "item">]
-        member __.Item(breakdownChart: BreakdownChart, label: string, value: float, color: Color) =
-            breakdownChart.AddItem(label, value, color)
+        member __.Item(config: BreakdownChartConfig, item: (string * float * Color)) =
+            { config with
+                Items = Array.append config.Items [| item |] }
 
         [<CustomOperation "items">]
-        member __.Items(breakdownChart: BreakdownChart, elements: 'T array, converter: 'T -> IBreakdownChartItem) =
-            breakdownChart.AddItems(elements, converter)
+        member __.Items(config: BreakdownChartConfig, items: 'T array, converter: 'T -> (string * float * Color)) =
+            { config with
+                Items = items |> Array.map converter |> Array.append config.Items }
 
     let breakdownChart = BreakdownChartBuilder()
diff --git a/src/FsSpectre/Widgets/CalendarBuilder.fs b/src/FsSpectre/Widgets/CalendarBuilder.fs
index c44db6e..7008dee 100644
--- a/src/FsSpectre/Widgets/CalendarBuilder.fs
+++ b/src/FsSpectre/Widgets/CalendarBuilder.fs
@@ -7,46 +7,52 @@ open Spectre.Console
 [<AutoOpen>]
 module CalendarBuilder =
 
-    type CalendarBuilder() =
-        member __.Yield _ = Calendar(DateTime.Now)
-
-        [<CustomOperation "default">]
-        member __.Default(calendar: Calendar) = calendar
+    type CalendarConfig =
+        { DateTime: DateTime
+          CultureInfo: CultureInfo
+          ShowHeader: bool
+          HeaderStyle: Style
+          HighlightStyle: Style
+          Events: CalendarEvent array }
+
+        static member Default(dateTime: DateTime) =
+            { DateTime = dateTime
+              CultureInfo = CultureInfo.CurrentCulture
+              ShowHeader = true
+              HeaderStyle = Style.Plain
+              HighlightStyle = Style.Plain
+              Events = Array.empty<CalendarEvent> }
 
-        [<CustomOperation "year">]
-        member __.Year(calendar: Calendar, year: int) =
-            calendar.Year <- year
-            calendar
+    type CalendarBuilder() =
+        member __.Yield _ = CalendarConfig.Default(DateTime.Now)
 
-        [<CustomOperation "month">]
-        member __.Month(calendar: Calendar, month: int) =
-            calendar.Month <- month
-            calendar
+        member __.Run(config: CalendarConfig) =
+            let result = Calendar(config.DateTime)
+            result.Culture <- config.CultureInfo
+            result.HeaderStyle <- config.HeaderStyle
+            result.HightlightStyle <- config.HighlightStyle
+            config.Events |> Array.map result.CalendarEvents.Add |> ignore
+            result
 
-        [<CustomOperation "day">]
-        member __.Day(calendar: Calendar, day: int) =
-            calendar.Day <- day
-            calendar
+        [<CustomOperation "default">]
+        member __.Default(config: CalendarConfig) = config
 
         [<CustomOperation "date_time">]
-        member __.DateTime(_, dateTime: DateTime) = Calendar(dateTime)
+        member __.DateTime(config: CalendarConfig, dateTime: DateTime) = { config with DateTime = dateTime }
 
         [<CustomOperation "culture">]
-        member __.Culture(calendar: Calendar, cultureInfo: CultureInfo) =
-            calendar.Culture <- cultureInfo
-            calendar
+        member __.Culture(config: CalendarConfig, cultureInfo: CultureInfo) =
+            { config with
+                CultureInfo = cultureInfo }
 
         [<CustomOperation "hide_header">]
-        member __.HideHeader(calendar: Calendar) = calendar.HideHeader()
-
-        [<CustomOperation "event">]
-        member __.Event(calendar: Calendar, event: CalendarEvent) =
-            calendar.CalendarEvents.Add(event)
-            calendar
+        member __.HideHeader(config: CalendarConfig) =
+            { config with
+                ShowHeader = false }
 
         [<CustomOperation "events">]
-        member __.Events(calendar: Calendar, events: CalendarEvent array) =
-            events |> Array.map calendar.CalendarEvents.Add |> ignore
-            calendar
+        member __.Events(config: CalendarConfig, events: CalendarEvent array) =
+            { config with
+                Events = Array.append config.Events events }
 
     let calendar = CalendarBuilder()
diff --git a/src/FsSpectre/Widgets/CalendarEventBuilder.fs b/src/FsSpectre/Widgets/CalendarEventBuilder.fs
index 77a7ee7..45926de 100644
--- a/src/FsSpectre/Widgets/CalendarEventBuilder.fs
+++ b/src/FsSpectre/Widgets/CalendarEventBuilder.fs
@@ -6,29 +6,30 @@ open Spectre.Console
 [<AutoOpen>]
 module CalendarEventBuilder =
 
+    type CalendarEventConfig =
+        { DateTime: DateTime
+          Description: string }
+
+        static member Default(dateTime: DateTime) =
+            { DateTime = dateTime
+              Description = String.Empty }
+
     type CalendarEventBuilder() =
         member __.Yield _ =
-            let now = DateTime.Now
-            CalendarEvent(now.Year, now.Month, now.Day)
-
-        [<CustomOperation "year">]
-        member __.Year(calendarEvent: CalendarEvent, year: int) =
-            CalendarEvent(calendarEvent.Description, year, calendarEvent.Month, calendarEvent.Day)
+            CalendarEventConfig.Default(DateTime.Now)
 
-        [<CustomOperation "month">]
-        member __.Month(calendarEvent: CalendarEvent, month: int) =
-            CalendarEvent(calendarEvent.Description, calendarEvent.Year, month, calendarEvent.Day)
+        member __.Run(config: CalendarEventConfig) =
+            CalendarEvent(config.Description, config.DateTime.Year, config.DateTime.Month, config.DateTime.Day)
 
-        [<CustomOperation "day">]
-        member __.Day(calendarEvent: CalendarEvent, day: int) =
-            CalendarEvent(calendarEvent.Description, calendarEvent.Year, calendarEvent.Month, day)
+        [<CustomOperation "default">]
+        member __.Default(config: CalendarEventConfig) = config
 
-        [<CustomOperation "year_month_day">]
-        member __.Year(calendarEvent: CalendarEvent, year: int, month: int, day: int) =
-            CalendarEvent(calendarEvent.Description, year, month, day)
+        [<CustomOperation "date_time">]
+        member __.Year(config: CalendarEventConfig, dateTime: DateTime) = { config with DateTime = dateTime }
 
         [<CustomOperation "description">]
-        member __.Description(calendarEvent: CalendarEvent, description: string) =
-            CalendarEvent(description, calendarEvent.Year, calendarEvent.Month, calendarEvent.Day)
+        member __.Description(config: CalendarEventConfig, description: string) =
+            { config with
+                Description = description }
 
     let calendarEvent = CalendarEventBuilder()
diff --git a/src/FsSpectre/Widgets/ColumnsBuilder.fs b/src/FsSpectre/Widgets/ColumnsBuilder.fs
index 7059afd..7b4915d 100644
--- a/src/FsSpectre/Widgets/ColumnsBuilder.fs
+++ b/src/FsSpectre/Widgets/ColumnsBuilder.fs
@@ -6,13 +6,26 @@ open Spectre.Console.Rendering
 [<AutoOpen>]
 module ColumnsBuilder =
 
+    type ColumnsConfig =
+        { Items: IRenderable array }
+
+        static member Default = { Items = Array.empty<IRenderable> }
+
     type ColumnsBuilder() =
-        member __.Yield _ = Columns(Array.empty<IRenderable>)
+        member __.Yield _ = ColumnsConfig.Default
+
+        member __.Run(config: ColumnsConfig) = Columns(config.Items)
+
+        [<CustomOperation "items_text">]
+        member __.ItemsText(config: ColumnsConfig, items: string array) =
+            let markups = items |> Array.map Markup |> Array.map (fun x -> x :> IRenderable)
 
-        [<CustomOperation "items">]
-        member __.Items(_, items: string array) = Columns(items)
+            { config with
+                Items = Array.append config.Items markups }
 
         [<CustomOperation "items_renderable">]
-        member __.ItemsRenderable(_, items: IRenderable array) = Columns(items)
+        member __.ItemsRenderable(config: ColumnsConfig, items: IRenderable array) =
+            { config with
+                Items = Array.append config.Items items }
 
     let columns = ColumnsBuilder()
diff --git a/src/FsSpectre/Widgets/GridBuilder.fs b/src/FsSpectre/Widgets/GridBuilder.fs
index 4913315..bdb309a 100644
--- a/src/FsSpectre/Widgets/GridBuilder.fs
+++ b/src/FsSpectre/Widgets/GridBuilder.fs
@@ -6,27 +6,67 @@ open Spectre.Console.Rendering
 [<AutoOpen>]
 module GridBuilder =
 
+    type GridConfig =
+        { Expand: bool
+          ExplicitNumberOfColumns: int option
+          Columns: GridColumn array
+          Rows: IRenderable array array }
+
+        static member Default =
+            { Expand = false
+              ExplicitNumberOfColumns = None
+              Columns = Array.empty<GridColumn>
+              Rows = Array.empty<IRenderable array> }
+
     type GridBuilder() =
-        member __.Yield _ = Grid()
+        member __.Yield _ = GridConfig.Default
 
-        [<CustomOperation "expand">]
-        member __.Expand(grid: Grid) =
-            grid.Expand <- true
-            grid
+        member __.Run(config: GridConfig) =
+            let result = Grid()
+            result.Expand <- config.Expand
 
-        [<CustomOperation "collapse">]
-        member __.Collapse(grid: Grid) = grid.Collapse()
+            if Option.isSome config.ExplicitNumberOfColumns then
+                config.ExplicitNumberOfColumns
+                |> Option.iter (fun n -> result.AddColumns(n) |> ignore)
+            else
+                result.AddColumns(config.Columns) |> ignore
+
+            config.Rows |> Array.iter (fun row -> result.AddRow(row) |> ignore)
+            result
+
+        [<CustomOperation "expand">]
+        member __.Expand(config: GridConfig) = { config with Expand = true }
 
         [<CustomOperation "number_of_columns">]
-        member __.NodeText(grid: Grid, count: int) = grid.AddColumns(count)
+        member __.NodeText(config: GridConfig, count: int) =
+            { config with
+                ExplicitNumberOfColumns = Some count }
+
+        [<CustomOperation "empty_column">]
+        member __.Column(config: GridConfig) =
+            { config with
+                Columns = Array.append config.Columns [| GridColumn() |] }
 
         [<CustomOperation "column">]
-        member __.Column(grid: Grid, column: GridColumn) = grid.AddColumn(column)
+        member __.Column(config: GridConfig, column: GridColumn) =
+            { config with
+                Columns = Array.append config.Columns [| column |] }
+
+        [<CustomOperation "empty_row">]
+        member __.Row(config: GridConfig) =
+            { config with
+                Rows = Array.append config.Rows [| [||] |] }
 
         [<CustomOperation "row">]
-        member __.Row(grid: Grid, columns: IRenderable array) = grid.AddRow(columns)
+        member __.Row(config: GridConfig, columns: IRenderable array) =
+            { config with
+                Rows = Array.append config.Rows [| columns |] }
 
         [<CustomOperation "row_text">]
-        member __.RowText(grid: Grid, columns: string array) = grid.AddRow(columns)
+        member __.RowText(config: GridConfig, columns: string array) =
+            let markups = columns |> Array.map Markup |> Array.map (fun x -> x :> IRenderable)
+
+            { config with
+                Rows = Array.append config.Rows [| markups |] }
 
     let grid = GridBuilder()
diff --git a/src/FsSpectre/Widgets/GridColumnBuilder.fs b/src/FsSpectre/Widgets/GridColumnBuilder.fs
index 56013cd..bb612ce 100644
--- a/src/FsSpectre/Widgets/GridColumnBuilder.fs
+++ b/src/FsSpectre/Widgets/GridColumnBuilder.fs
@@ -5,38 +5,67 @@ open Spectre.Console
 [<AutoOpen>]
 module GridColumnBuilder =
 
+    type GridColumnConfig =
+        { NoWrap: bool
+          Alignment: Justify
+          Width: int option
+          Padding: Padding }
+
+        static member Default =
+            { NoWrap = false
+              Alignment = Justify.Left
+              Width = None
+              Padding = Padding(0, 0, 0, 0) }
+
     type GridColumnBuilder() =
-        member __.Yield _ = GridColumn()
+        member __.Yield _ = GridColumnConfig.Default
+
+        member __.Run(config: GridColumnConfig) =
+            let result = GridColumn()
+            result.NoWrap <- config.NoWrap
+            result.Alignment <- config.Alignment
+            config.Width |> Option.iter (fun w -> result.Width <- w)
+            result.Padding <- config.Padding
+            result
 
         [<CustomOperation "no_wrap">]
-        member __.NoWrap(gridColumn: GridColumn) =
-            gridColumn.NoWrap <- true
-            gridColumn
+        member __.NoWrap(config: GridColumnConfig) = { config with NoWrap = true }
 
         [<CustomOperation "left_aligned">]
-        member __.LeftAligned(gridColumn: GridColumn) = gridColumn.LeftAligned()
+        member __.LeftAligned(config: GridColumnConfig) =
+            { config with Alignment = Justify.Left }
 
         [<CustomOperation "centerd">]
-        member __.Centered(gridColumn: GridColumn) = gridColumn.Centered()
+        member __.Centered(config: GridColumnConfig) =
+            { config with
+                Alignment = Justify.Center }
 
         [<CustomOperation "right_aligned">]
-        member __.RightAligned(gridColumn: GridColumn) = gridColumn.RightAligned()
+        member __.RightAligned(config: GridColumnConfig) =
+            { config with
+                Alignment = Justify.Right }
 
         [<CustomOperation "width">]
-        member __.Width(gridColumn: GridColumn, width: int) =
-            gridColumn.Width <- width
-            gridColumn
-
-        [<CustomOperation "pad_right">]
-        member __.PadRight(gridColumn: GridColumn, pad: int) = gridColumn.PadRight(pad)
+        member __.Width(config: GridColumnConfig, width: int) = { config with Width = Some width }
 
         [<CustomOperation "pad_left">]
-        member __.PadLeft(gridColumn: GridColumn, pad: int) = gridColumn.PadLeft(pad)
+        member __.PadLeft(config: GridColumnConfig, pad: int) =
+            { config with
+                Padding = Padding(pad, config.Padding.Top, config.Padding.Right, config.Padding.Bottom) }
 
         [<CustomOperation "pad_top">]
-        member __.PadTop(gridColumn: GridColumn, pad: int) = gridColumn.PadTop(pad)
+        member __.PadTop(config: GridColumnConfig, pad: int) =
+            { config with
+                Padding = Padding(config.Padding.Left, pad, config.Padding.Right, config.Padding.Bottom) }
+
+        [<CustomOperation "pad_right">]
+        member __.PadRight(config: GridColumnConfig, pad: int) =
+            { config with
+                Padding = Padding(config.Padding.Left, config.Padding.Top, pad, config.Padding.Bottom) }
 
         [<CustomOperation "pad_bottom">]
-        member __.PadBottom(gridColumn: GridColumn, pad: int) = gridColumn.PadBottom(pad)
+        member __.PadBottom(config: GridColumnConfig, pad: int) =
+            { config with
+                Padding = Padding(config.Padding.Left, config.Padding.Top, config.Padding.Right, pad) }
 
     let gridColumn = GridColumnBuilder()
diff --git a/src/FsSpectre/Widgets/LayoutBuilder.fs b/src/FsSpectre/Widgets/LayoutBuilder.fs
index 0edf6e1..a4fbe50 100644
--- a/src/FsSpectre/Widgets/LayoutBuilder.fs
+++ b/src/FsSpectre/Widgets/LayoutBuilder.fs
@@ -1,39 +1,57 @@
 namespace FsSpectre
 
 open System
-open System.Globalization
 open Spectre.Console
 open Spectre.Console.Rendering
 
 [<AutoOpen>]
 module LayoutBuilder =
 
+    type LayoutConfig =
+        { Name: string
+          SplitColumns: Layout array
+          SplitRows: Layout array
+          Ratio: int
+          Width: int option
+          MinimumWidth: int option
+          Content: IRenderable option }
+
+        static member Default =
+            { Name = String.Empty
+              SplitColumns = Array.empty<Layout>
+              SplitRows = Array.empty<Layout>
+              Ratio = 1
+              Width = None
+              MinimumWidth = None
+              Content = None }
+
     type LayoutBuilder() =
-        member __.Yield _ = Layout(String.Empty)
+        member __.Yield _ = LayoutConfig.Default
+
+        member __.Run(config: LayoutConfig) =
+            let result = Layout(config.Name, Option.toObj config.Content)
+            config.Width |> Option.iter (fun w -> result.Size <- (Nullable w))
+            config.MinimumWidth |> Option.iter (fun w -> result.MinimumSize <- w)
+            result.SplitColumns(config.SplitColumns).SplitRows(config.SplitRows)
 
         [<CustomOperation "split_columns">]
-        member __.SplitColumns(layout: Layout, columns: Layout array) = layout.SplitColumns(columns)
+        member __.SplitColumns(config: LayoutConfig, columns: Layout array) = { config with SplitColumns = columns }
 
         [<CustomOperation "split_rows">]
-        member __.SplitRows(layout: Layout, rows: Layout array) = layout.SplitRows(rows)
+        member __.SplitRows(config: LayoutConfig, rows: Layout array) = { config with SplitRows = rows }
 
         [<CustomOperation "ratio">]
-        member __.Ratio(layout: Layout, ratio: int) = 
-            layout.Ratio <- ratio
-            layout
+        member __.Ratio(config: LayoutConfig, ratio: int) = { config with Ratio = ratio }
 
         [<CustomOperation "width">]
-        member __.Width(layout: Layout, width: int) = 
-            layout.Size <- width
-            layout
+        member __.Width(config: LayoutConfig, width: int) = { config with Width = Some width }
 
         [<CustomOperation "minimum_width">]
-        member __.MinimumWidth(layout: Layout, width: int) = 
-            layout.MinimumSize <- width
-            layout
+        member __.MinimumWidth(config: LayoutConfig, width: int) =
+            { config with
+                MinimumWidth = Some width }
 
         [<CustomOperation "content">]
-        member __.Content(layout: Layout, content: IRenderable) = 
-            layout.Update(content)
-    
+        member __.Content(config: LayoutConfig, content: IRenderable) = { config with Content = Some content }
+
     let layout = LayoutBuilder()
diff --git a/src/FsSpectre/Widgets/MarkupBuilder.fs b/src/FsSpectre/Widgets/MarkupBuilder.fs
index dc5ecf8..917f238 100644
--- a/src/FsSpectre/Widgets/MarkupBuilder.fs
+++ b/src/FsSpectre/Widgets/MarkupBuilder.fs
@@ -6,22 +6,45 @@ open Spectre.Console
 [<AutoOpen>]
 module MarkupBuilder =
 
+    type MarkupConfig =
+        { Text: string
+          Style: Style
+          Justification: Justify }
+
+        static member Default =
+            { Text = String.Empty
+              Style = Style.Plain
+              Justification = Justify.Left }
+
     type MarkupBuilder() =
-        member __.Yield _ = Markup(String.Empty)
+        member __.Yield _ = MarkupConfig.Default
+
+        member __.Run(config: MarkupConfig) =
+            let result = Markup(config.Text, config.Style)
+            result.Justify(config.Justification)
+
+        [<CustomOperation "empty">]
+        member __.Empty(config: MarkupConfig) = { config with Text = String.Empty }
 
         [<CustomOperation "text">]
-        member __.Text(_, text: string) = Markup(text)
+        member __.Text(config: MarkupConfig, text: string) = { config with Text = text }
 
-        [<CustomOperation "text_with_style">]
-        member __.TextWithStyle(_, text: string, style: Style) = Markup(text, style)
+        [<CustomOperation "style">]
+        member __.Style(config: MarkupConfig, style: Style) = { config with Style = style }
 
         [<CustomOperation "left_justified">]
-        member __.LeftJustified(markup: Markup) = markup.LeftJustified()
+        member __.LeftJustified(config: MarkupConfig) =
+            { config with
+                Justification = Justify.Left }
 
         [<CustomOperation "right_justified">]
-        member __.RightJustified(markup: Markup) = markup.RightJustified()
+        member __.RightJustified(config: MarkupConfig) =
+            { config with
+                Justification = Justify.Right }
 
         [<CustomOperation "centered">]
-        member __.Centered(markup: Markup) = markup.Centered()
+        member __.Centered(config: MarkupConfig) =
+            { config with
+                Justification = Justify.Center }
 
     let markup = MarkupBuilder()
diff --git a/src/FsSpectre/Widgets/PanelBuilder.fs b/src/FsSpectre/Widgets/PanelBuilder.fs
index d0c95eb..80c4a1c 100644
--- a/src/FsSpectre/Widgets/PanelBuilder.fs
+++ b/src/FsSpectre/Widgets/PanelBuilder.fs
@@ -7,41 +7,65 @@ open Spectre.Console.Rendering
 [<AutoOpen>]
 module PanelBuilder =
 
+    type PanelConfig =
+        { Content: IRenderable
+          BorderStyle: Style option
+          BorderColor: Color option
+          Header: PanelHeader
+          Expand: bool
+          Width: int option
+          Height: int option }
+
+        static member Default =
+            { Content = Markup(String.Empty)
+              BorderStyle = None
+              BorderColor = None
+              Header = PanelHeader(String.Empty)
+              Expand = false
+              Width = None
+              Height = None }
+
     type PanelBuilder() =
-        member __.Yield _ = Panel(String.Empty)
+        member __.Yield _ = PanelConfig.Default
 
-        [<CustomOperation "content">]
-        member __.Content(_, text: string) = Panel(text)
+        member __.Run(config: PanelConfig) =
+            let result = Panel(config.Content)
+            config.BorderStyle |> Option.iter (fun s -> result.BorderStyle <- s)
+            config.BorderColor |> Option.iter (fun c -> result.BorderColor(c) |> ignore)
+            result.Header <- config.Header
+            config.Width |> Option.iter (fun w -> result.Width <- (Nullable w))
+            config.Height |> Option.iter (fun h -> result.Height <- (Nullable h))
+            result
+
+        [<CustomOperation "content_text">]
+        member __.ContentText(config: PanelConfig, text: string) = { config with Content = Markup(text) }
 
         [<CustomOperation "content_renderable">]
-        member __.ContentRenderable(_, renderable: IRenderable) = Panel(renderable)
+        member __.ContentRenderable(config: PanelConfig, renderable: IRenderable) = { config with Content = renderable }
+
+        [<CustomOperation "border_style">]
+        member __.BorderStyle(config: PanelConfig, style: Style) =
+            { config with BorderStyle = Some style }
 
         [<CustomOperation "border_color">]
-        member __.BorderColor(panel: Panel, color: Color) = panel.BorderColor(color)
+        member __.BorderColor(config: PanelConfig, color: Color) =
+            { config with BorderColor = Some color }
 
         [<CustomOperation "header">]
-        member __.Header(panel: Panel, header: PanelHeader) =
-            panel.Header <- header
-            panel
+        member __.Header(config: PanelConfig, header: PanelHeader) = { config with Header = header }
 
         [<CustomOperation "header_text">]
-        member __.HeaderText(panel: Panel, text: string) =
-            panel.Header <- PanelHeader(text)
-            panel
+        member __.HeaderText(config: PanelConfig, text: string) =
+            { config with
+                Header = PanelHeader(text) }
 
         [<CustomOperation "expand">]
-        member __.Expand(panel: Panel) =
-            panel.Expand <- true
-            panel
+        member __.Expand(config: PanelConfig) = { config with Expand = true }
 
         [<CustomOperation "width">]
-        member __.Width(panel: Panel, width: int) =
-            panel.Width <- width
-            panel
+        member __.Width(config: PanelConfig, width: int) = { config with Width = Some width }
 
         [<CustomOperation "height">]
-        member __.Height(panel: Panel, height: int) =
-            panel.Height <- height
-            panel
+        member __.Height(config: PanelConfig, height: int) = { config with Height = Some height }
 
     let panel = PanelBuilder()
diff --git a/src/FsSpectre/Widgets/PanelHeaderBuilder.fs b/src/FsSpectre/Widgets/PanelHeaderBuilder.fs
index fe130e0..49d754d 100644
--- a/src/FsSpectre/Widgets/PanelHeaderBuilder.fs
+++ b/src/FsSpectre/Widgets/PanelHeaderBuilder.fs
@@ -6,19 +6,40 @@ open Spectre.Console
 [<AutoOpen>]
 module PanelHeaderBuilder =
 
+    type PanelHeaderConfig =
+        { Text: string
+          Justification: Justify }
+
+        static member Default =
+            { Text = String.Empty
+              Justification = Justify.Left }
+
     type PanelHeaderBuilder() =
-        member __.Yield _ = PanelHeader(String.Empty)
+        member __.Yield _ = PanelHeaderConfig.Default
+
+        member __.Run(config: PanelHeaderConfig) =
+            let result = PanelHeader(config.Text)
+            result.Justify(config.Justification)
+
+        [<CustomOperation "empty">]
+        member __.Empty(config: PanelHeaderConfig) = { config with Text = String.Empty }
 
         [<CustomOperation "text">]
-        member __.Text(_, text: string) = PanelHeader(text)
+        member __.Text(config: PanelHeaderConfig, text: string) = { config with Text = text }
 
         [<CustomOperation "left_justified">]
-        member __.LeftJustified(panelHeader: PanelHeader) = panelHeader.LeftJustified()
+        member __.LeftJustified(config: PanelHeaderConfig) =
+            { config with
+                Justification = Justify.Left }
 
         [<CustomOperation "right_justified">]
-        member __.RightJustified(panelHeader: PanelHeader) = panelHeader.RightJustified()
+        member __.RightJustified(config: PanelHeaderConfig) =
+            { config with
+                Justification = Justify.Right }
 
         [<CustomOperation "centered">]
-        member __.Centered(panelHeader: PanelHeader) = panelHeader.Centered()
+        member __.Centered(config: PanelHeaderConfig) =
+            { config with
+                Justification = Justify.Center }
 
     let panelHeader = PanelHeaderBuilder()
diff --git a/src/FsSpectre/Widgets/RowsBuilder.fs b/src/FsSpectre/Widgets/RowsBuilder.fs
index 61957ab..c34cfed 100644
--- a/src/FsSpectre/Widgets/RowsBuilder.fs
+++ b/src/FsSpectre/Widgets/RowsBuilder.fs
@@ -6,17 +6,27 @@ open Spectre.Console.Rendering
 [<AutoOpen>]
 module RowsBuilder =
 
+    type RowsConfig =
+        { Items: IRenderable array }
+
+        static member Default = { Items = Array.empty<IRenderable> }
+
     type RowsBuilder() =
-        member __.Yield _ = Rows(Array.empty<IRenderable>)
+        member __.Yield _ = RowsConfig.Default
 
-        [<CustomOperation "items">]
-        member this.Items(rows: Rows, items: string array) =
-            let renderables =
-                items |> Array.map (Markup) |> Array.map (fun x -> x :> IRenderable)
+        member __.Run(config: RowsConfig) = Rows(config.Items)
 
-            this.ItemsRenderable(rows, renderables)
+        [<CustomOperation "items_text">]
+        member __.ItemsText(config: RowsConfig, items: string array) =
+            let markups = items |> Array.map Markup |> Array.map (fun x -> x :> IRenderable)
+
+            { config with
+                Items = Array.append config.Items markups }
 
         [<CustomOperation "items_renderable">]
-        member __.ItemsRenderable(_, items: IRenderable array) = Rows(items)
+        member __.ItemsRenderable(config: RowsConfig, items: IRenderable array) =
+            { config with
+                Items = Array.append config.Items items }
+
 
     let rows = RowsBuilder()
diff --git a/src/FsSpectre/Widgets/RuleBuilder.fs b/src/FsSpectre/Widgets/RuleBuilder.fs
index 1a8bc0e..2b9f9a2 100644
--- a/src/FsSpectre/Widgets/RuleBuilder.fs
+++ b/src/FsSpectre/Widgets/RuleBuilder.fs
@@ -1,24 +1,45 @@
 namespace FsSpectre
 
+open System
 open Spectre.Console
 
 [<AutoOpen>]
 module RuleBuilder =
 
+    type RuleConfig =
+        { Title: string
+          Justification: Justify }
+
+        static member Default =
+            { Title = String.Empty
+              Justification = Justify.Left }
+
     type RuleBuilder() =
-        member __.Yield _ = Rule()
+        member __.Yield _ = RuleConfig.Default
+
+        member __.Run(config: RuleConfig) =
+            let result = Rule(config.Title)
+            result.Justify(config.Justification)
 
         [<CustomOperation "empty">]
-        member __.Empty(rule: Rule) = rule
+        member __.Empty(config: RuleConfig) = { config with Title = String.Empty }
 
         [<CustomOperation "title">]
-        member __.Title(rule: Rule, title: string) =
-            rule.Title <- title
-            rule
-
-        [<CustomOperation "justification">]
-        member __.Justification(rule: Rule, justify: Justify) =
-            rule.Justification <- justify
-            rule
+        member __.Title(config: RuleConfig, title: string) = { config with Title = title }
+
+        [<CustomOperation "left_justified">]
+        member __.LeftJustified(config: RuleConfig) =
+            { config with
+                Justification = Justify.Left }
+
+        [<CustomOperation "right_justified">]
+        member __.RightJustified(config: RuleConfig) =
+            { config with
+                Justification = Justify.Right }
+
+        [<CustomOperation "centered">]
+        member __.Centered(config: RuleConfig) =
+            { config with
+                Justification = Justify.Center }
 
     let rule = RuleBuilder()
diff --git a/src/FsSpectre/Widgets/TableBuilder.fs b/src/FsSpectre/Widgets/TableBuilder.fs
index 177b69a..23d51cf 100644
--- a/src/FsSpectre/Widgets/TableBuilder.fs
+++ b/src/FsSpectre/Widgets/TableBuilder.fs
@@ -6,71 +6,130 @@ open Spectre.Console.Rendering
 [<AutoOpen>]
 module TableBuilder =
 
-    type TableBuilder() =
+    type TableConfig =
+        { Title: TableTitle option
+          Columns: TableColumn array
+          Rows: IRenderable array array
+          ShowHeaders: bool
+          ShowFooters: bool
+          Width: int option
+          Expand: bool
+          Border: TableBorder
+          BorderColor: Color option }
+
+        static member Default =
+            { Title = None
+              Columns = Array.empty<TableColumn>
+              Rows = Array.empty<IRenderable array>
+              ShowHeaders = true
+              ShowFooters = true
+              Width = None
+              Expand = true
+              Border = TableBorder.Square
+              BorderColor = None }
 
-        member __.Yield _ = Table()
+    type TableBuilder() =
+        member __.Yield _ = TableConfig.Default
+
+        member __.Run(config: TableConfig) =
+            let result = Table()
+            config.Title |> Option.iter (fun t -> result.Title <- t)
+            result.AddColumns(config.Columns) |> ignore
+            config.Rows |> Array.iter (fun row -> result.AddRow(row) |> ignore)
+            result.ShowHeaders <- config.ShowHeaders
+            result.ShowFooters <- config.ShowFooters
+            config.Width |> Option.iter (fun w -> result.Width <- w)
+            result.Border <- config.Border
+            config.BorderColor |> Option.iter (fun c -> result.BorderColor(c) |> ignore)
+            result
 
         [<CustomOperation "title">]
-        member __.Title(table: Table, title: TableTitle) =
-            table.Title <- title
-            table
+        member __.Title(config: TableConfig, title: TableTitle) = { config with Title = Some title }
 
         [<CustomOperation "title_text">]
-        member __.TitleText(table: Table, text: string) =
-            table.Title <- TableTitle(text)
-            table
+        member __.TitleText(config: TableConfig, text: string) =
+            let title = TableTitle(text)
+            { config with Title = Some title }
+
+        [<CustomOperation "no_headers">]
+        member __.NoHeaders(config: TableConfig) = { config with ShowHeaders = false }
+
+        [<CustomOperation "no_footers">]
+        member __.NoFooters(config: TableConfig) = { config with ShowFooters = false }
 
         [<CustomOperation "width">]
-        member __.Width(table: Table, width: int) =
-            table.Width <- width
-            table
+        member __.Width(config: TableConfig, width: int) = { config with Width = Some width }
 
         [<CustomOperation "collapse">]
-        member __.Collapse(table: Table) = table.Collapse()
+        member __.Collapse(config: TableConfig) = { config with Expand = false }
 
         [<CustomOperation "simple_border">]
-        member __.SimpleBorder(table: Table) = table.SimpleBorder()
+        member __.SimpleBorder(config: TableConfig) =
+            { config with
+                Border = TableBorder.Simple }
 
         [<CustomOperation "rounded_border">]
-        member __.RoundedBorder(table: Table) = table.RoundedBorder()
+        member __.RoundedBorder(config: TableConfig) =
+            { config with
+                Border = TableBorder.Rounded }
 
-        [<CustomOperation "border_color">]
-        member __.BorderColor(table: Table, color: Color) = table.BorderColor(color)
+        [<CustomOperation "ascii_border">]
+        member __.AsciiBorder(config: TableConfig) =
+            { config with
+                Border = TableBorder.Ascii }
 
-        [<CustomOperation "no_headers">]
-        member __.NoHeaders(table: Table) = table.HideHeaders()
-
-        [<CustomOperation "no_footers">]
-        member __.NoFooters(table: Table) = table.HideFooters()
-
-        [<CustomOperation "border">]
-        member __.Border(table: Table, tableBorder: TableBorder) =
-            table.Border <- tableBorder
-            table
+        [<CustomOperation "double_edge_border">]
+        member __.DoubleEdgeBorder(config: TableConfig) =
+            { config with
+                Border = TableBorder.DoubleEdge }
 
         [<CustomOperation "no_border">]
-        member __.NoBorder(table: Table) = table.NoBorder()
+        member __.NoBorder(config: TableConfig) =
+            { config with
+                Border = TableBorder.None }
+
+        [<CustomOperation "border_color">]
+        member __.BorderColor(config: TableConfig, color: Color) =
+            { config with BorderColor = Some color }
 
         [<CustomOperation "column">]
-        member __.Column(table: Table, column: TableColumn) = table.AddColumn(column)
+        member __.Column(config: TableConfig, column: TableColumn) =
+            { config with
+                Columns = Array.append config.Columns [| column |] }
 
         [<CustomOperation "columns">]
-        member __.Columns(table: Table, column: TableColumn array) = table.AddColumns(column)
+        member __.Columns(config: TableConfig, columns: TableColumn array) =
+            { config with
+                Columns = Array.append config.Columns columns }
 
         [<CustomOperation "column_text">]
-        member __.ColumnText(table: Table, text: string) = table.AddColumn(text)
+        member __.ColumnText(config: TableConfig, text: string) =
+            { config with
+                Columns = Array.append config.Columns [| TableColumn(text) |] }
 
         [<CustomOperation "columns_text">]
-        member __.ColumnsText(table: Table, texts: string array) = table.AddColumns(texts)
+        member __.ColumnsText(config: TableConfig, texts: string array) =
+            let columns = texts |> Array.map (fun t -> TableColumn(t))
+
+            { config with
+                Columns = Array.append config.Columns columns }
 
         [<CustomOperation "empty_row">]
-        member __.EmptyRow(table: Table) = table.AddEmptyRow()
+        member __.EmptyRow(config: TableConfig) =
+            { config with
+                Rows = Array.append config.Rows [| [||] |] }
 
         [<CustomOperation "row">]
-        member __.Row(table: Table, columns: IRenderable array) = table.AddRow(columns)
+        member __.Row(config: TableConfig, columns: IRenderable array) =
+            { config with
+                Rows = Array.append config.Rows [| columns |] }
 
         [<CustomOperation "row_text">]
-        member __.RowText(table: Table, columns: string array) = table.AddRow(columns)
+        member __.RowText(config: TableConfig, columns: string array) =
+            let markups = columns |> Array.map Markup |> Array.map (fun x -> x :> IRenderable)
+
+            { config with
+                Rows = Array.append config.Rows [| markups |] }
 
 
     let table = TableBuilder()
diff --git a/src/FsSpectre/Widgets/TableColumnBuilder.fs b/src/FsSpectre/Widgets/TableColumnBuilder.fs
index 68fd8db..e7bfcc3 100644
--- a/src/FsSpectre/Widgets/TableColumnBuilder.fs
+++ b/src/FsSpectre/Widgets/TableColumnBuilder.fs
@@ -7,55 +7,99 @@ open Spectre.Console.Rendering
 [<AutoOpen>]
 module TableColumnBuilder =
 
-    type TableColumnBuilder() =
-
-        member __.Yield _ = TableColumn(String.Empty)
+    type TableColumnConfig =
+        { HeaderText: string
+          HeaderRenderable: IRenderable option
+          Footer: IRenderable option
+          NoWrap: bool
+          Width: int option
+          Alignment: Justify option
+          Padding: Padding }
+
+        static member Default =
+            { HeaderText = String.Empty
+              HeaderRenderable = None
+              Footer = None
+              NoWrap = false
+              Width = None
+              Alignment = None
+              Padding = Padding(1, 0, 1, 0) }
 
-        [<CustomOperation "header">]
-        member __.Header(_, header: string) = TableColumn(header)
+    type TableColumnBuilder() =
+        member __.Yield _ = TableColumnConfig.Default
+
+        member __.Run(config: TableColumnConfig) =
+            let result =
+                match config.HeaderRenderable with
+                | Some h -> TableColumn(h)
+                | None -> TableColumn(config.HeaderText)
+
+            config.Footer |> Option.iter (fun f -> result.Footer <- f)
+            result.NoWrap <- config.NoWrap
+            config.Alignment |> Option.iter (fun a -> result.Alignment <- a)
+            result.Padding <- config.Padding
+            result
+
+        [<CustomOperation "header_text">]
+        member __.HeaderText(config: TableColumnConfig, text: string) =
+            { config with
+                HeaderText = text
+                HeaderRenderable = None }
 
         [<CustomOperation "header_renderable">]
-        member __.HeaderRenderable(_, renderable: IRenderable) = TableColumn(renderable)
+        member __.HeaderRenderable(config: TableColumnConfig, renderable: IRenderable) =
+            { config with
+                HeaderText = String.Empty
+                HeaderRenderable = Some renderable }
 
-        [<CustomOperation "footer">]
-        member __.Footer(tableColumn: TableColumn, footer: string) =
-            tableColumn.Footer <- Markup(footer)
-            tableColumn
+        [<CustomOperation "footer_text">]
+        member __.FooterText(config: TableColumnConfig, text: string) =
+            let renderable = Markup(text)
+            { config with Footer = Some renderable }
 
         [<CustomOperation "footer_renderable">]
-        member __.FooterRenderable(tableColumn: TableColumn, renderable: IRenderable) =
-            tableColumn.Footer <- renderable
-            tableColumn
+        member __.FooterRenderable(config: TableColumnConfig, renderable: IRenderable) =
+            { config with Footer = Some renderable }
 
         [<CustomOperation "no_wrap">]
-        member __.NoWrap(tableColumn: TableColumn) =
-            tableColumn.NoWrap <- true
-            tableColumn
+        member __.NoWrap(config: TableColumnConfig) = { config with NoWrap = true }
 
         [<CustomOperation "left_aligned">]
-        member __.LeftAligned(tableColumn: TableColumn) = tableColumn.LeftAligned()
+        member __.LeftAligned(config: TableColumnConfig) =
+            { config with
+                Alignment = Some Justify.Left }
 
         [<CustomOperation "centerd">]
-        member __.Centered(tableColumn: TableColumn) = tableColumn.Centered()
+        member __.Centered(config: TableColumnConfig) =
+            { config with
+                Alignment = Some Justify.Center }
 
         [<CustomOperation "right_aligned">]
-        member __.RightAligned(tableColumn: TableColumn) = tableColumn.RightAligned()
+        member __.RightAligned(config: TableColumnConfig) =
+            { config with
+                Alignment = Some Justify.Right }
 
         [<CustomOperation "width">]
-        member __.Width(tableColumn: TableColumn, width: int) =
-            tableColumn.Width <- width
-            tableColumn
-
-        [<CustomOperation "pad_right">]
-        member __.PadRight(tableColumn: TableColumn, pad: int) = tableColumn.PadRight(pad)
+        member __.Width(config: TableColumnConfig, width: int) = { config with Width = Some width }
 
         [<CustomOperation "pad_left">]
-        member __.PadLeft(tableColumn: TableColumn, pad: int) = tableColumn.PadLeft(pad)
+        member __.PadLeft(config: TableColumnConfig, pad: int) =
+            { config with
+                Padding = Padding(pad, config.Padding.Top, config.Padding.Right, config.Padding.Bottom) }
 
         [<CustomOperation "pad_top">]
-        member __.PadTop(tableColumn: TableColumn, pad: int) = tableColumn.PadTop(pad)
+        member __.PadTop(config: TableColumnConfig, pad: int) =
+            { config with
+                Padding = Padding(config.Padding.Left, pad, config.Padding.Right, config.Padding.Bottom) }
+
+        [<CustomOperation "pad_right">]
+        member __.PadRight(config: TableColumnConfig, pad: int) =
+            { config with
+                Padding = Padding(config.Padding.Left, config.Padding.Top, pad, config.Padding.Bottom) }
 
         [<CustomOperation "pad_bottom">]
-        member __.PadBottom(tableColumn: TableColumn, pad: int) = tableColumn.PadBottom(pad)
+        member __.PadBottom(config: TableColumnConfig, pad: int) =
+            { config with
+                Padding = Padding(config.Padding.Left, config.Padding.Top, config.Padding.Right, pad) }
 
     let tableColumn = TableColumnBuilder()
diff --git a/src/FsSpectre/Widgets/TableTitleBuilder.fs b/src/FsSpectre/Widgets/TableTitleBuilder.fs
index 5a0885c..1606075 100644
--- a/src/FsSpectre/Widgets/TableTitleBuilder.fs
+++ b/src/FsSpectre/Widgets/TableTitleBuilder.fs
@@ -6,14 +6,27 @@ open Spectre.Console
 [<AutoOpen>]
 module TableTitleBuilder =
 
+    type TableTitleConfig =
+        { Text: string
+          Style: Style }
+
+        static member Default =
+            { Text = String.Empty
+              Style = Style.Plain }
+
     type TableTitleBuilder() =
 
-        member __.Yield _ = TableTitle(String.Empty)
+        member __.Yield _ = TableTitleConfig.Default
+
+        member __.Run(config: MarkupConfig) = TableTitle(config.Text, config.Style)
+
+        [<CustomOperation "empty">]
+        member __.Empty(config: TableTitleConfig) = { config with Text = String.Empty }
 
         [<CustomOperation "text">]
-        member __.Text(_, text: string) = TableTitle(text)
+        member __.Text(config: TableTitleConfig, text: string) = { config with Text = text }
 
         [<CustomOperation "style">]
-        member __.Style(tableTitle: TableTitle, style: Style) = tableTitle.SetStyle(style)
+        member __.Style(config: TableTitleConfig, style: Style) = { config with Style = style }
 
     let tableTitle = TableTitleBuilder()
diff --git a/src/FsSpectre/Widgets/TextBuilder.fs b/src/FsSpectre/Widgets/TextBuilder.fs
index 3214644..cf005b8 100644
--- a/src/FsSpectre/Widgets/TextBuilder.fs
+++ b/src/FsSpectre/Widgets/TextBuilder.fs
@@ -6,25 +6,45 @@ open Spectre.Console
 [<AutoOpen>]
 module TextBuilder =
 
+    type TextConfig =
+        { Text: string
+          Style: Style
+          Justification: Justify }
+
+        static member Default =
+            { Text = String.Empty
+              Style = Style.Plain
+              Justification = Justify.Left }
+
     type TextBuilder() =
-        member __.Yield _ = Text(String.Empty)
+        member __.Yield _ = TextConfig.Default
+
+        member __.Run(config: TextConfig) =
+            let result = Text(config.Text, config.Style)
+            result.Justify(config.Justification)
 
         [<CustomOperation "empty">]
-        member __.Text(text: Text) = text
+        member __.Empty(config: TextConfig) = { config with Text = String.Empty }
 
         [<CustomOperation "text">]
-        member __.Text(_, text: string) = Text(text)
+        member __.Text(config: TextConfig, text: string) = { config with Text = text }
 
-        [<CustomOperation "text_with_style">]
-        member __.TextWithStyle(_, text: string, style: Style) = Text(text, style)
+        [<CustomOperation "style">]
+        member __.Style(config: TextConfig, style: Style) = { config with Style = style }
 
         [<CustomOperation "left_justified">]
-        member __.LeftJustified(text: Text) = text.LeftJustified()
+        member __.LeftJustified(config: TextConfig) =
+            { config with
+                Justification = Justify.Left }
 
         [<CustomOperation "right_justified">]
-        member __.RightJustified(text: Text) = text.RightJustified()
+        member __.RightJustified(config: TextConfig) =
+            { config with
+                Justification = Justify.Right }
 
         [<CustomOperation "centered">]
-        member __.Centered(text: Text) = text.Centered()
+        member __.Centered(config: TextConfig) =
+            { config with
+                Justification = Justify.Center }
 
     let text = TextBuilder()
diff --git a/src/FsSpectre/Widgets/TreeBuilder.fs b/src/FsSpectre/Widgets/TreeBuilder.fs
index a9148c0..fa7c192 100644
--- a/src/FsSpectre/Widgets/TreeBuilder.fs
+++ b/src/FsSpectre/Widgets/TreeBuilder.fs
@@ -7,33 +7,46 @@ open Spectre.Console.Rendering
 [<AutoOpen>]
 module TreeBuilder =
 
+    type TreeConfig =
+        { Label: IRenderable
+          Nodes: TreeNode array }
+
+        static member Default =
+            { Label = Markup(String.Empty)
+              Nodes = Array.empty<TreeNode> }
+
     type TreeBuilder() =
-        member __.Yield _ = Tree(String.Empty)
+        member __.Yield _ = TreeConfig.Default
+
+        member __.Run(config: TreeConfig) = 
+            let result = Tree(config.Label)
+            result.AddNodes(config.Nodes)
+            result
 
         [<CustomOperation "label">]
-        member __.Label(_, label: string) = Tree(label)
+        member __.RootText(config: TreeConfig, text: string) = { config with Label = Markup(text) }
 
         [<CustomOperation "label_renderable">]
-        member __.LabelRenderable(_, renderable: IRenderable) = Tree(renderable)
+        member __.LabelRenderable(config: TreeConfig, renderable: IRenderable) = { config with Label = renderable }
 
         [<CustomOperation "node">]
-        member __.Node(tree: Tree, subNode: TreeNode) =
-            tree.AddNode(subNode) |> ignore
-            tree
+        member __.Node(config: TreeConfig, subNode: TreeNode) =
+            { config with
+                Nodes = Array.append config.Nodes [| subNode |] }
 
         [<CustomOperation "nodes">]
-        member __.Nodes(tree: Tree, subNodes: TreeNode array) =
-            tree.AddNodes(subNodes) |> ignore
-            tree
+        member __.Nodes(config: TreeConfig, subNodes: TreeNode array) =
+            { config with
+                Nodes = Array.append config.Nodes subNodes }
 
         [<CustomOperation "node_renderable">]
-        member __.NodeRenderable(tree: Tree, renderable: IRenderable) =
-            tree.AddNode(renderable) |> ignore
-            tree
+        member __.NodeRenderable(config: TreeConfig, renderable: IRenderable) =
+            { config with
+                Nodes = Array.append config.Nodes [| TreeNode(renderable) |] }
 
         [<CustomOperation "node_text">]
-        member __.NodeText(tree: Tree, text: string) =
-            tree.AddNode(text) |> ignore
-            tree
+        member __.NodeText(config: TreeConfig, text: string) =
+            { config with
+                Nodes = Array.append config.Nodes [| TreeNode(Markup(text)) |] }
 
     let tree = TreeBuilder()
diff --git a/src/FsSpectre/Widgets/TreeNodeBuilder.fs b/src/FsSpectre/Widgets/TreeNodeBuilder.fs
index d462d63..75cfdef 100644
--- a/src/FsSpectre/Widgets/TreeNodeBuilder.fs
+++ b/src/FsSpectre/Widgets/TreeNodeBuilder.fs
@@ -7,33 +7,46 @@ open Spectre.Console.Rendering
 [<AutoOpen>]
 module TreeNodeBuilder =
 
+    type TreeNodeConfig =
+        { Label: IRenderable
+          Nodes: TreeNode array }
+
+        static member Default =
+            { Label = Markup(String.Empty)
+              Nodes = Array.empty<TreeNode> }
+
     type TreeNodeBuilder() =
-        member __.Yield _ = TreeNode(Markup(String.Empty))
+        member __.Yield _ = TreeNodeConfig.Default
 
-        [<CustomOperation "label_renderable">]
-        member __.LabelRenderable(_, renderable: IRenderable) = TreeNode(renderable)
+        member __.Run(config: TreeNodeConfig) = 
+            let result = TreeNode(config.Label)
+            result.AddNodes(config.Nodes)
+            result
 
         [<CustomOperation "label">]
-        member __.RootText(_, text: string) = TreeNode(Markup(text))
+        member __.RootText(config: TreeNodeConfig, text: string) = { config with Label = Markup(text) }
+
+        [<CustomOperation "label_renderable">]
+        member __.LabelRenderable(config: TreeNodeConfig, renderable: IRenderable) = { config with Label = renderable }
 
         [<CustomOperation "node">]
-        member __.Node(node: TreeNode, subNode: TreeNode) =
-            node.AddNode(subNode) |> ignore
-            node
+        member __.Node(config: TreeNodeConfig, subNode: TreeNode) =
+            { config with
+                Nodes = Array.append config.Nodes [| subNode |] }
 
         [<CustomOperation "nodes">]
-        member __.Nodes(node: TreeNode, subNodes: TreeNode array) =
-            node.AddNodes(subNodes) |> ignore
-            node
+        member __.Nodes(config: TreeNodeConfig, subNodes: TreeNode array) =
+            { config with
+                Nodes = Array.append config.Nodes subNodes }
 
         [<CustomOperation "node_renderable">]
-        member __.NodeRenderable(node: TreeNode, renderable: IRenderable) =
-            node.AddNode(renderable) |> ignore
-            node
+        member __.NodeRenderable(config: TreeNodeConfig, renderable: IRenderable) =
+            { config with
+                Nodes = Array.append config.Nodes [| TreeNode(renderable) |] }
 
         [<CustomOperation "node_text">]
-        member __.NodeText(node: TreeNode, text: string) =
-            node.AddNode(text) |> ignore
-            node
+        member __.NodeText(config: TreeNodeConfig, text: string) =
+            { config with
+                Nodes = Array.append config.Nodes [| TreeNode(Markup(text)) |] }
 
     let treeNode: TreeNodeBuilder = TreeNodeBuilder()