PwshSpectreConsole

https://pwshspectreconsole.com
Admin
PwshSpectreConsole is a PowerShell module designed to help users build visually appealing and...
Tokens:31,855
Snippets:256
Trust Score:4.4
Update:11 months ago
Show doc for...
Tokens:
Raw
### Install and Update PwshSpectreConsole

Source: https://pwshspectreconsole.com/guides/upgrading-to-v2

Commands to install the latest version of PwshSpectreConsole or update an existing installation using PowerShell's PackageManagement module.

```powershell
Install-Module PwshSpectreConsole -Scope CurrentUser
Update-Module PwshSpectreConsole -Scope CurrentUser
```

--------------------------------

### Using Renderable Objects in a Table Layout

Source: https://pwshspectreconsole.com/guides/upgrading-to-v2

An example showcasing the use of renderable objects in PwshSpectreConsole v2. It creates a calendar renderable, a table of files, and a bar chart of fruit data, then combines them into a final table layout.

```powershell
# Example of using renderable objects inside a table
$calendar = Write-SpectreCalendar -Date (Get-Date) -PassThru
$files = Get-ChildItem | Format-SpectreTable
$fruits = @(
    (New-SpectreChartItem -Label "Bananas" -Value 2.2 -Color Yellow),
    (New-SpectreChartItem -Label "Oranges" -Value 6.6 -Color Orange1),
    (New-SpectreChartItem -Label "Apples" -Value 1 -Color Red)
) | Format-SpectreBarChart -Width 45


@{ 
    Calendar = $calendar
    Files = $files
    Fruits = $fruits
} | Format-SpectreTable -Color Cyan1

```

--------------------------------

### Run Interactive Demo - PwshSpectreConsole

Source: https://pwshspectreconsole.com/guides/get-started

This command starts an interactive demo of PwshSpectreConsole, showcasing its various functionalities. No specific inputs are required, and the output is the interactive demo itself.

```powershell
PS> Start-SpectreDemo
```

--------------------------------

### Install PwshSpectreConsole Module

Source: https://pwshspectreconsole.com/guides/install

Installs the PwshSpectreConsole module from the PowerShell Gallery. This command requires PowerShell 7+ and installs the module for the current user.

```powershell
Install-Module PwshSpectreConsole -Scope CurrentUser
```

--------------------------------

### Format-SpectrePanel: Combine Text and Images in Columns

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrepanel

This example illustrates combining text and an image side-by-side within a panel using Format-SpectreColumns. Similar to the row example, content is prepared as an array of renderable objects prior to panel formatting.

```powershell
$message = "Thanks Jeff!"
$image = Get-SpectreImage -ImagePath ".\private\images\smiley.png" -MaxWidth 25
@($message, $image) | Format-SpectreColumns | Format-SpectrePanel
```

--------------------------------

### Building a Chat UI Layout with Spectre.Console in PowerShell

Source: https://pwshspectreconsole.com/reference/live/invoke-spectrelive

This example shows how to set up a root layout for a chat application using Spectre.Console. It defines three rows for title, messages, and a text entry component. Each component can update itself by receiving a copy of the context and layout.

```powershell
Set-SpectreColors -AccentColor DeepPink1


# Build root layout scaffolding for:
# +--------------------------------+
# |             Title              |
# |--------------------------------|
# |                                |
# |                                |
# |            Messages            |
# |                                |
# |                                |
# |--------------------------------|
# |        CustomTextEntry         |
# |________________________________|


$layout = New-SpectreLayout -Name "root" -Rows @(
    # Row 1
    (New-SpectreLayout -Name "title" -MinimumSize 5 -Ratio 1 -Data ("empty")),
    # Row 2
    (New-SpectreLayout -Name "messages" -Ratio 10 -Data ("empty")),
    # Row 3
    (New-SpectreLayout -Name "customTextEntry" -MinimumSize 5 -Ratio 1 -Data ("empty"))
)

```

--------------------------------

### Run Get-SpectreDemoFeatures Script - PowerShell

Source: https://pwshspectreconsole.com/reference/demo/get-spectredemofeatures

This script demonstrates the features of Spectre.Console, showcasing its support for various colors, styles, and other advanced terminal output capabilities. It requires the Spectre.Console module to be installed.

```powershell
Get-SpectreDemoFeatures
```

--------------------------------

### PowerShell Multi-Selection Prompt Example

Source: https://pwshspectreconsole.com/reference/prompts/read-spectremultiselection

Demonstrates how to use the `Read-SpectreMultiSelection` function to prompt the user for multiple selections from a list of fruits. It then displays the user's chosen fruits. This function requires the Spectre.Console library to be installed.

```powershell
$fruits = Read-SpectreMultiSelection -Message "Select your favourite fruits" `
                                      -Choices @("apple", "banana", "orange", "pear", "strawberry", "durian", "lemon") `
                                      -PageSize 4
# Type "↓", "<space>", "↓", "↓", "<space>", "↓", "<space>", "↲" to choose banana, pear and strawberry
Write-SpectreHost "Your favourite fruits are $($fruits -join ', ')"
```

--------------------------------

### Stop Spectre Console Recording (PowerShell)

Source: https://pwshspectreconsole.com/reference/config/stop-spectrerecording

This PowerShell snippet demonstrates how to start a Spectre.Console recording in HTML format, perform some console operations, and then stop the recording, displaying the result. It requires the Spectre.Console module to be installed.

```powershell
$recording = Start-SpectreRecording -RecordingType "Html" -CountdownAndClear
# Use spectre console functions, these will be recorded
Write-SpectreHost "Hello [red]world[/]"
# Finish the recording
$result = Stop-SpectreRecording
# Output the results
Write-SpectreHost "Result:`n$result"
```

--------------------------------

### Format-SpectrePanel: Basic Panel with Title and Rounded Border

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrepanel

This example demonstrates how to create a simple panel with a title and a rounded border. The function takes the data, title, and border style as parameters. The output can be directly displayed in the console.

```powershell
Format-SpectrePanel -Data "Hello, world!" -Title "My Panel" -Border "Rounded" -Color "Red"
```

--------------------------------

### Get Chat Response - PowerShell

Source: https://pwshspectreconsole.com/reference/live/invoke-spectrelive

Simulates fetching a chat response from a system. It displays an '...' animation to indicate thinking and then returns a predefined response. This function requires the message stack, live display context, and layout component.

```powershell
function Get-SomeChatResponse {
    param (
        [System.Collections.Stack] $Messages,
        [Spectre.Console.LiveDisplayContext] $Context,
        [Spectre.Console.Layout] $LayoutComponent
    )


    # Pretend to be thinking
    $ellipsisCount = 1
    for ($i = 0; $i -lt 3; $i++) {
        $Messages.Push(@{ Actor = "System"; Message = ("." * $ellipsisCount) })
        $ellipsisCount++

        Update-MessageListComponent -Context $Context -LayoutComponent $LayoutComponent -Messages $Messages
        Start-Sleep -Milliseconds 500

        # Remove the last thinking message
        $null = $Messages.Pop()
    }


    # Return the response
    return @{ Actor = "System"; Message = "I don't understand what you're saying." }
}
```

--------------------------------

### Calculate Spectre.Console Panel Size (PowerShell)

Source: https://pwshspectreconsole.com/reference/measurement/get-spectrerenderablesize

This example demonstrates how to calculate the estimated size (width and height) of a Spectre.Console panel object using the Get-SpectreRenderableSize function. It shows how to create a panel, get its size, and then render it to the console.

```powershell
$panel = "hello`nworld" | Format-SpectrePanel
$panelSize = $panel | Get-SpectreRenderableSize
Write-SpectreHost "Panel width: $($panelSize.Width), height: $($panelSize.Height)"
$panel | Out-SpectreHost
```

--------------------------------

### Format JSON with Borders using Format-SpectrePanel

Source: https://pwshspectreconsole.com/guides/upgrading-to-v2

Illustrates how to wrap JSON output in a border using Format-SpectrePanel in PwshSpectreConsole v2, as direct border parameters for Format-SpectreJson have been deprecated.

```powershell
Format-SpectreJson -Data $data | Format-SpectrePanel
```

--------------------------------

### Format JSON String to Highlighted JSON with Spectre Console

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrejson

This example shows how to display a JSON string with syntax highlighting using the Format-SpectreJson function. The input is a JSON string, which is then piped to the function for formatted output.

```powershell
$jsonString = @{
    Name = 'Alice'
    Age = 30
    Skills = @('PowerShell', 'Spectre.Console')
} | ConvertTo-Json
# Display the JSON string using Format-SpectreJson
$jsonString | Format-SpectreJson


```

--------------------------------

### Write Spectre Renderable to Console Host - PowerShell

Source: https://pwshspectreconsole.com/reference/writing/out-spectrehost

This example demonstrates how to use Out-SpectreHost to write a Spectre.Console Table renderable object directly to the console. It first formats a list of files into a Spectre Table and then pipes it to Out-SpectreHost.

```powershell
$table = Get-ChildItem | Select-Object Name, Length, LastWriteTime | Format-SpectreTable
$table | Out-SpectreHost
```

--------------------------------

### Format Exception with Default Syntax Highlighting

Source: https://pwshspectreconsole.com/reference/formatting/format-spectreexception

This example demonstrates how to format an exception into a Spectre Console Exception with default syntax highlighting. It catches a terminating error from Get-ChildItem and pipes it to Format-SpectreException.

```powershell
try {
    Get-ChildItem -BadParam -ErrorAction Stop
} catch {
    $_ | Format-SpectreException -ExceptionFormat ShortenEverything
}
```

--------------------------------

### Create Layout with Calendar, File List, and Panels in PowerShell

Source: https://pwshspectreconsole.com/reference/formatting/new-spectrelayout

This example demonstrates creating a multi-panel console layout using Spectre.Console in PowerShell. It includes a calendar, a formatted list of recent files, and multiple panels with headers and colors. The layout is constructed using `New-SpectreLayout` and output to the console using `Out-SpectreHost`. No external dependencies are required beyond the Spectre.Console module.

```powershell
$calendar = Write-SpectreCalendar -Date (Get-Date) -PassThru
$files = Get-ChildItem | Select-Object Name, LastWriteTime -First 3 | Format-SpectreTable | Format-SpectreAligned -HorizontalAlignment Right -VerticalAlignment Bottom
$panel1 = $files | Format-SpectrePanel -Header "panel 1 (align bottom right)" -Expand -Color Green
$panel2 = "hello row 2" | Format-SpectrePanel -Header "panel 2" -Expand -Color Blue
$panel3 = $calendar | Format-SpectreAligned | Format-SpectrePanel -Header "panel 3 (align middle center)" -Expand -Color Yellow


$row1 = New-SpectreLayout -Name "row1" -Data $panel1 -Ratio 1
$row2 = New-SpectreLayout -Name "row2" -Columns @($panel2, $panel3) -Ratio 2
$root = New-SpectreLayout -Name "root" -Rows @($row1, $row2)


$root | Out-SpectreHost

```

--------------------------------

### Spectre Console Path Style Example

Source: https://pwshspectreconsole.com/reference/formatting/format-spectretextpath

Illustrates how to define a hashtable for PathStyle to customize the colors used for different parts of a file path when formatting with Format-SpectreTextPath. This allows for granular control over the visual presentation of the path.

```powershell
@{
    RootColor      = [Spectre.Console.Color]::Cyan2
    SeparatorColor = [Spectre.Console.Color]::Aqua
    StemColor      = [Spectre.Console.Color]::Orange1
    LeafColor      = "HotPink"
}
```

--------------------------------

### Format Exception with Custom Styling

Source: https://pwshspectreconsole.com/reference/formatting/format-spectreexception

This example shows how to format an exception using a custom style defined by a hashtable. Each key in the hashtable corresponds to a part of the exception output, and its value defines the color or style.

```powershell
try {
    Get-ChildItem -BadParam -ErrorAction Stop
} catch {
    $_ | Format-SpectreException -ExceptionStyle @{
        Message        = "#00ff00"
        Exception      = "white"
        Method         = "#ff0000 on orange1"
        ParameterType  = "blue"
        ParameterName  = "silver"
        Parenthesis    = "silver"
        Path           = "Yellow"
        LineNumber     = "blue"
        Dimmed         = "grey"
        NonEmphasized  = "silver"
    }
}
```

--------------------------------

### Render Spectre Console Objects with Out-SpectreHost

Source: https://pwshspectreconsole.com/guides/upgrading-to-v2

Demonstrates the use of Out-SpectreHost to render Spectre Console objects without additional whitespace, by piping the formatted output to it. This is necessary in v2 due to changes in how PowerShell handles default host output.

```powershell
$data | Format-SpectrePanel | Out-SpectreHost
```

--------------------------------

### Format-SpectrePanel: Combine Text and Images in Rows

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrepanel

This example demonstrates how to combine text and an image within a single panel, arranging them vertically using Format-SpectreRows. This requires preparing the content as an array of renderable objects before piping to Format-SpectrePanel.

```powershell
$message = "Thanks Jeff!"
$image = Get-SpectreImage -ImagePath ".\private\images\smiley.png" -MaxWidth 25
@($message, $image) | Format-SpectreRows | Format-SpectrePanel
```

--------------------------------

### Format-SpectrePanel: Expanded Panel with Double Border

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrepanel

This example shows how to create a panel that expands to fill the console width, using a double border and a specified color. The pipeline operator is used to pipe the data into the function.

```powershell
"Hello, big panel!" | Format-SpectrePanel -Title "My Big Panel" -Border "Double" -Color "Magenta1" -Expand
```

--------------------------------

### Format JSON Files to Highlighted JSON with Spectre Console

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrejson

This example demonstrates how to display the contents of one or more JSON files directly using Format-SpectreJson. It involves creating temporary JSON files, populating them with JSON data, and then piping the files to the function for formatted output.

```powershell
$executionId = [guid]::NewGuid().ToString()
$tempJson1 = (New-TemporaryFile).FullName -replace '.tmp$', ".$executionId.json"
$tempJson2 = (New-TemporaryFile).FullName -replace '.tmp$', ".$executionId.json"


@{ 
    Name = 'Alice'
    Age = 30
    Skills = @('PowerShell', 'Spectre.Console')
} | ConvertTo-Json | Set-Content -Path $tempJson1


@{ 
    Name = 'Bob'
    Age = 35
    Skills = @('C#', 'JavaScript')
} | ConvertTo-Json | Set-Content -Path $tempJson2


# Display the JSON files directly using Get-ChildItem and Format-SpectreJson
$parent = Split-Path $tempJson1 -Parent
Get-ChildItem $parent -Filter "*.$executionId.json" | Format-SpectreJson


```

--------------------------------

### Configure PowerShell Profile for Full Unicode and Emoji Support

Source: https://pwshspectreconsole.com/guides/install

Enables full Unicode and Emoji support in the PowerShell console by setting the output encoding to UTF8. This line must be the first line in your PowerShell profile file.

```powershell
$OutputEncoding = [console]::InputEncoding = [console]::OutputEncoding = New-Object System.Text.UTF8Encoding
```

--------------------------------

### Create and Display Spectre Console Charts (PowerShell)

Source: https://pwshspectreconsole.com/reference/formatting/new-spectrechartitem

This example demonstrates how to create chart data using New-SpectreChartItem and then render it as both a bar chart and a breakdown chart using Spectre.Console. It shows the flexibility in defining colors using names, hex codes, or Spectre.Console.Color objects.

```powershell
$data = @()
$data += New-SpectreChartItem -Label "Sales" -Value 1000 -Color "green"
$data += New-SpectreChartItem -Label "Expenses" -Value 500 -Color "#ff0000"
$data += New-SpectreChartItem -Label "Profit" -Value 420 -Color ([Spectre.Console.Color]::Blue)
Write-SpectreHost "`nGenerate a bar chart`n"
$data | Format-SpectreBarChart
Write-SpectreHost "`nGenerate a breakdown chart`n"
$data | Format-SpectreBreakdownChart
```

--------------------------------

### PowerShell: Basic Selection Prompt with Read-SpectreSelection

Source: https://pwshspectreconsole.com/reference/prompts/read-spectreselection

This example demonstrates how to use the Read-SpectreSelection function to create a simple selection prompt. It displays a message and a list of color choices, returning the user's selection. The function relies on the Spectre Console library.

```powershell
$color = Read-SpectreSelection -Message "Select your favorite color" -Choices @("Red", "Green", "Blue") -Color "Green"
# Type "↓", "↓", "↓", "↓", "↲" to wrap around the list and choose green
Write-SpectreHost "Your chosen color is '$color'"
```

--------------------------------

### Display Animated GIF using Spectre.Console

Source: https://pwshspectreconsole.com/reference/images/get-spectreimage

This code snippet demonstrates how to display an animated GIF using the Get-SpectreImage cmdlet. It repeatedly renders frames of the GIF to create an animation effect. Ensure the Spectre.Console module is installed. The input is a local path to a GIF file.

```powershell
$image = Get-SpectreImage ".\private\images\lapras-pokemon.gif" -MaxWidth 50
Clear-Host
[Console]::CursorVisible = $false


for($frame = 0; $frame -lt 100; $frame++) {
    [Console]::SetCursorPosition(0, 0)
    $image | Format-SpectrePanel -Title "Frame: $frame" -Color White | Out-SpectreHost
    Start-Sleep -Milliseconds 150
}
```

--------------------------------

### Interacting with Spectre.Console Canvas Widget in PowerShell

Source: https://pwshspectreconsole.com/guides/upgrading-to-v2

Demonstrates how to create and draw shapes on a Canvas widget using C# interop within PowerShell. This is for scenarios where direct PowerShell cmdlets are not available for certain Spectre.Console features.

```powershell
# Create a canvas
$canvas = [Spectre.Console.Canvas]::new(16, 16)


# Draw some shapes
for($i = 0; $i -lt $canvas.Width; $i++) {
    # Cross
    $canvas = $canvas.SetPixel($i, $i, [Spectre.Console.Color]::White)
    $canvas = $canvas.SetPixel($canvas.Width - $i - 1, $i, [Spectre.Console.Color]::White)


    # Border
    $canvas = $canvas.SetPixel($i, 0, [Spectre.Console.Color]::Red)
    $canvas = $canvas.SetPixel(0, $i, [Spectre.Console.Color]::Green)
    $canvas = $canvas.SetPixel($i, $canvas.Height - 1, [Spectre.Console.Color]::Blue)
    $canvas = $canvas.SetPixel($canvas.Width - 1, $i, [Spectre.Console.Color]::Yellow)
}


# Render the canvas
$canvas | Out-SpectreHost

```

--------------------------------

### Display Static Image - PowerShell

Source: https://pwshspectreconsole.com/reference/images/get-spectreimageexperimental

This example shows how to display a static image in the console using the Get-SpectreImageExperimental function. It specifies the image path and the desired width for the display. The function will load the image, scale it to fit the specified width while preserving the aspect ratio, and render it using block characters and ANSI escape codes.

```powershell
Get-SpectreImageExperimental -ImagePath ".\private\images\smiley.png" -Width 80
```

--------------------------------

### Render Image with Spectre.Console in PowerShell

Source: https://pwshspectreconsole.com/reference/images/get-spectreimage

Demonstrates how to render an image using Spectre.Console in PowerShell. If Sixel graphics are not supported, it falls back to using the standard Canvas renderer, which represents the image with character cells. This example requires the Spectre.Console module and a valid image path.

```powershell
Get-SpectreImage -ImagePath ".\private\images\smiley.png" -MaxWidth 40
```

--------------------------------

### Spectre Console Padded Item Syntax Examples

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrepadded

Provides the syntax for using the Format-SpectrePadded function in PowerShell. It shows different ways to invoke the function, including uniform padding, custom side padding, and using the expand switch.

```powershell
Format-SpectrePadded -Data <Object> -Padding <Int32> [<CommonParameters>]
```

```powershell
Format-SpectrePadded -Data <Object> -Top <Int32> -Left <Int32> -Bottom <Int32> -Right <Int32> [<CommonParameters>]
```

```powershell
Format-SpectrePadded -Data <Object> -Expand [<CommonParameters>]
```

--------------------------------

### Format Data with Custom Properties and Markup

Source: https://pwshspectreconsole.com/reference/formatting/format-spectretable

This example showcases how to define custom table properties using script blocks and apply styling (markup) to the table content. It demonstrates dynamic property generation based on object properties and script logic.

```powershell
$Properties = @(
    # foreground + background
    @{'Name'='FileName'; Expression={ "[white on DeepSkyBlue3_1]" + $_.Name + "[/]" }},
    # foreground
    @{'Name'='Last Updated'; Expression={ "[DeepSkyBlue3_1]" + $_.LastWriteTime.ToString() + "[/]" }},
    # background
    @{'Name'='Drive'; Expression={ "[black on LightGreen_1]" + $_.PSDrive.Root + "[/]" }}
)
Get-ChildItem | Format-SpectreTable -Property $Properties -AllowMarkup
```

--------------------------------

### Format-SpectreColumns: Display Panels in Normal Sized Columns (PowerShell)

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrecolumns

This example shows how to display a collection of panels in columns that are expanded but maintain normal sizing. It first formats strings into panels using Format-SpectrePanel with the -Expand parameter and then pipes them to Format-SpectreColumns.

```powershell
@("left", "middle", "right") | Foreach-Object { $_ | Format-SpectrePanel -Expand } | Format-SpectreColumns
```

--------------------------------

### Display Animated GIF with Loop Count - PowerShell

Source: https://pwshspectreconsole.com/reference/images/get-spectreimageexperimental

This example demonstrates how to display an animated GIF in the console using the Get-SpectreImageExperimental function. It specifies the image path, sets the loop count to 4, and defines the display width. The function scales the image to fit the specified width while maintaining its aspect ratio and displays each frame of the GIF sequentially.

```powershell
Get-SpectreImageExperimental -ImagePath ".\private\images\harveyspecter.gif" -LoopCount 4 -Width 82
```

--------------------------------

### Add and Wait for Spectre Jobs with PowerShell

Source: https://pwshspectreconsole.com/reference/live/add-spectrejob

This example demonstrates adding two PowerShell jobs to a Spectre ProgressContext and then waiting for them to complete using Wait-SpectreJobs. The function requires a Spectre ProgressContext object, which is available within Invoke-SpectreCommandWithProgress. The output, showing job details, is then formatted into a Spectre table.

```powershell
$jobOutcomes = Invoke-SpectreCommandWithProgress -ScriptBlock {
    param (
        [Spectre.Console.ProgressContext] $Context
    )
    $jobs = @()
    $jobs += Add-SpectreJob -Context $Context -JobName "job 1" -Job (Start-Job { Start-Sleep -Seconds 2 })
    $jobs += Add-SpectreJob -Context $Context -JobName "job 2" -Job (Start-Job { Start-Sleep -Seconds 4 })
    Wait-SpectreJobs -Context $Context -Jobs $jobs
    return $jobs.Job
}
$jobOutcomes | Format-SpectreTable -Property Id, Name, PSJobTypeName, State, Command
```

--------------------------------

### Get Layout Sizes and Update Content - PowerShell

Source: https://pwshspectreconsole.com/reference/measurement/get-spectrelayoutsizes

This example demonstrates how to get the dimensions of a Spectre Console layout and its children using Get-SpectreLayoutSizes. It then calculates available space by subtracting border sizes and updates the layout content accordingly.

```powershell
$layout = New-SpectreLayout -Name "root" -Rows @(
    # Row 1
    (New-SpectreLayout -Name "title" -Ratio 1 -Data ("Title goes here" | Format-SpectrePanel -Expand)),
    # Row 2
    (New-SpectreLayout -Name "body" -Ratio 3 -Columns @(
        # Column 1
        (New-SpectreLayout -Name "left" -Ratio 1 -Data ("Left goes here" | Format-SpectrePanel -Expand)),
        # Column 2
        (New-SpectreLayout -Name "right" -Ratio 2 -Data ("Right goes here" | Format-SpectrePanel -Expand))
    ))
)


# Get the sizes of the layouts in the layout tree before populating them with data
$sizes = $layout | Get-SpectreLayoutSizes


# Subtract the border sizes!
$titleWidth = $sizes["title"].Width - 2
$titleHeight = $sizes["title"].Height - 2
$leftWidth = $sizes["left"].Width - 2
$leftHeight = $sizes["left"].Height - 2
$rightWidth = $sizes["right"].Width - 2
$rightHeight = $sizes["right"].Height - 2


# Populate the layouts with data that takes up the full height of the layout
$titleContent = ((1..($titleHeight + 1)) | ForEach-Object { "Title line $_" }) -join "`n"
$leftContent = ((1..($leftHeight + 1)) | ForEach-Object { "Left line $_" }) -join "`n"
$rightContent = ((1..($rightHeight + 1)) | ForEach-Object { "Right line $_" }) -join "`n"


$null = $layout["title"].Update(($titleContent | Format-SpectrePanel -Title "I am $titleWidth x $titleHeight" -Expand))
$null = $layout["left"].Update(($leftContent | Format-SpectrePanel -Title "I am $leftWidth x $leftHeight" -Expand))
$null = $layout["right"].Update(($rightContent | Format-SpectrePanel -Title "I am $rightWidth x $rightHeight" -Expand))


$layout | Out-SpectreHost

```

--------------------------------

### PowerShell Live Rendering with Spectre.Console

Source: https://pwshspectreconsole.com/reference/live/invoke-spectrelive

This PowerShell script demonstrates live rendering of a console layout using `Invoke-SpectreLive`. It includes handling user input, displaying messages, and simulating responses. Dependencies include the Spectre.Console library and helper functions like `Update-TitleComponent`, `Update-MessageListComponent`, `Update-CustomTextEntryComponent`, `Get-LastChatKeyPressed`, and `Get-SomeChatResponse`.

```powershell
Invoke-SpectreLive -Data $layout -ScriptBlock {
    param (
        [Spectre.Console.LiveDisplayContext] $Context
    )


    # State
    $messages = [System.Collections.Stack]::new(@(
        @{ Actor = "System"; Message = "👋 Hello, welcome to ChaTTY!" },
        @{ Actor = "System"; Message = "Type your message and press Enter to send it." },
        @{ Actor = "System"; Message = "Use the Up and Down arrow keys to scroll through previous messages." },
        @{ Actor = "System"; Message = "Press 'ctrl-c' to close the chat." }
    ))
    $currentInput = ""


    while ($true) {
        # Update components
        Update-TitleComponent -Context $Context -LayoutComponent $layout["title"]
        Update-MessageListComponent -Context $Context -LayoutComponent $layout["messages"] -Messages $messages
        Update-CustomTextEntryComponent -Context $Context -LayoutComponent $layout["customTextEntry"] -CurrentInput $currentInput


        # Real basic input handling, just add characters and remove if backspace is pressed, submit message if Enter is pressed
        [Console]::TreatControlCAsInput = $true
        $lastKeyPressed = Get-LastChatKeyPressed
        if ($lastKeyPressed.Key -eq "C" -and $lastKeyPressed.Modifiers -eq "Control") {
            # Exit the loop. You have to treat ctrl-c as input to avoid the console readkey blocking the sigint
            return
        } elseif ($lastKeyPressed.Key -eq "Enter") {
            # Add the latest user message to the message stack
            $messages.Push(@{ Actor = ($env:USERNAME + $env:USER); Message = $currentInput })
            $currentInput = ""
            Update-CustomTextEntryComponent -Context $Context -LayoutComponent $layout["customTextEntry"] -CurrentInput $currentInput
            Update-MessageListComponent -Context $Context -LayoutComponent $layout["messages"] -Messages $messages
            $messages.Push((Get-SomeChatResponse -Messages $messages -Context $Context -LayoutComponent $layout["messages"]))
        } elseif($lastKeyPressed.Key -eq "Backspace") {
            # Remove the last character from the current input string
            $currentInput = $currentInput.Substring(0, [Math]::Max(0, $currentInput.Length - 1))
        } elseif ($lastKeyPressed.KeyChar) {
            # Add the character to the current input string
            $currentInput += $lastKeyPressed.KeyChar
        }
    }
}
```

--------------------------------

### Live Rendering File Explorer with Spectre.Console in PowerShell

Source: https://pwshspectreconsole.com/reference/live/invoke-spectrelive

This snippet demonstrates live rendering of a file explorer using Spectre.Console. It handles user input for navigation (up, down, enter, escape) and updates the display dynamically. Dependencies include Spectre.Console and its related modules for input handling.

```powershell
Invoke-SpectreLive -Data $layout -ScriptBlock {
    param (
        [Spectre.Console.LiveDisplayContext] $Context
    )


    # State
    $fileList = @(@{Name = ".."; Fullname = ".."}) + (Get-ChildItem)
    $selectedFile = $fileList[0]


    while ($true) {
        # Handle input
        $lastKeyPressed = Get-LastKeyPressed
        if ($lastKeyPressed -ne $null) {
            if ($lastKeyPressed.Key -eq "DownArrow") {
                $selectedFile = $fileList[($fileList.IndexOf($selectedFile) + 1) % $fileList.Count]
            } elseif ($lastKeyPressed.Key -eq "UpArrow") {
                $selectedFile = $fileList[($fileList.IndexOf($selectedFile) - 1 + $fileList.Count) % $fileList.Count]
            } elseif ($lastKeyPressed.Key -eq "Enter") {
                if ($selectedFile -is [System.IO.DirectoryInfo] -or $selectedFile.Name -eq "..") {
                    $fileList = @(@{Name = ".."; Fullname = ".."}) + (Get-ChildItem -Path $selectedFile.FullName)
                    $selectedFile = $fileList[0]
                } else {
                    notepad $selectedFile.FullName
                    return
                }
            } elseif ($lastKeyPressed.Key -eq "Escape") {
                return
            }
        }


        # Generate new data
        $titlePanel = Get-TitlePanel
        $fileListPanel = Get-FileListPanel -Files $fileList -SelectedFile $selectedFile
        $previewPanel = Get-PreviewPanel -SelectedFile $selectedFile


        # Update layout
        $layout["header"].Update($titlePanel) | Out-Null
        $layout["filelist"].Update($fileListPanel) | Out-Null
        $layout["preview"].Update($previewPanel) | Out-Null


        # Draw changes
        $Context.Refresh()
        Start-Sleep -Milliseconds 200
    }
}
```

--------------------------------

### Format-SpectreException Syntax

Source: https://pwshspectreconsole.com/reference/formatting/format-spectreexception

Provides the general syntax for the Format-SpectreException cmdlet, outlining its parameters and their order.

```powershell
Format-SpectreException [-Exception] <Object> [[-ExceptionFormat] <String>] [[-ExceptionStyle] <Hashtable>] [<CommonParameters>]
```

--------------------------------

### Spectre.Console Emoji Markup Usage Example

Source: https://pwshspectreconsole.com/reference/demo/get-spectredemoemoji

Illustrates how to use emojis within Spectre.Console markup strings. The example shows embedding emoji names like ':grinning_face:' and ':victory_hand:' directly into a string that will be rendered by Write-SpectreHost. This functionality allows for rich text formatting with visual elements.

```powershell
Write-SpectreHost "I am a :grinning_face: Spectre markdown emoji string :victory_hand: !"
```

--------------------------------

### Single Item Selection Prompt - PwshSpectreConsole

Source: https://pwshspectreconsole.com/guides/get-started

This snippet demonstrates how to create a single-item selection prompt using Read-SpectreSelection. It takes an array of choices and a title, returning the user's selected item. Output is the user's choice.

```powershell
# Start by creating your list of items
$items = @("Red", "Green", "Blue")


# Ask the user what they want
$chosenItem = Read-SpectreSelection -Title "Select your favorite color" -Choices $items -Color "Green"


# Do something with the chosen item
Write-SpectreHost "Your chosen color is '$chosenItem'"
```

--------------------------------

### Demonstrate Spectre.Console Emojis with Get-SpectreDemoEmoji

Source: https://pwshspectreconsole.com/reference/demo/get-spectredemoemoji

This example shows how to call the Get-SpectreDemoEmoji function to display a list of built-in Spectre.Console emojis. The function can optionally limit the number of emojis returned using the -Count parameter. Output includes the emoji itself, its name, and usage examples in Spectre.Console markup.

```powershell
Get-SpectreDemoEmoji -Count 5
```

--------------------------------

### Get Last Chat Key Press - PowerShell

Source: https://pwshspectreconsole.com/reference/live/invoke-spectrelive

Captures the last key press from the console without displaying it. This is useful for interactive command-line applications where immediate key input is needed.

```powershell
function Get-LastChatKeyPressed {
    return [Console]::ReadKey($true)
}
```

--------------------------------

### New-SpectreLayout Cmdlet

Source: https://pwshspectreconsole.com/reference/formatting/new-spectrelayout

This section details the parameters available for the New-SpectreLayout cmdlet, used for defining visual layouts in Spectre.Console applications. It covers data, columns, rows, ratio, name, and minimum size configurations.

```APIDOC
## New-SpectreLayout Cmdlet

### Description

This cmdlet is used to define and create layouts within the Spectre.Console framework. Layouts allow for structured arrangement of content, supporting complex visual designs through nested structures and size ratios.

### Method

`New-Object` (PowerShell Cmdlet)

### Endpoint

N/A (This is a cmdlet, not a web endpoint)

### Parameters

#### Path Parameters

None

#### Query Parameters

None

#### Request Body

This cmdlet does not use a request body in the traditional sense. Parameters are passed directly.

- **Data** (`[Object]`) - Optional - The data to be displayed in the layout. Can be used for simple layouts.
- **Columns** (`[Array]`) - Required - Defines the layout structure using columns. Accepts an array of layout definitions.
- **Rows** (`[Array]`) - Required - Defines the layout structure using rows. Accepts an array of layout definitions.
- **Ratio** (`[Int32]`) - Optional - Determines the relative size of this layout compared to other sibling layouts. A higher ratio means a larger proportion.
- **Name** (`[String]`) - Optional - A name for the layout, useful for referencing and updating nested layouts.
- **MinimumSize** (`[Int32]`) - Optional - Specifies the minimum allowed size (width) for this layout.

### Request Example

```powershell
# Example using Columns
New-SpectreLayout -Columns @(
    New-SpectreLayout -Ratio 1 -Name "Column1"
    New-SpectreLayout -Ratio 2 -Name "Column2"
)

# Example using Rows
New-SpectreLayout -Rows @(
    New-SpectreLayout -Ratio 1 -Name "Row1"
    New-SpectreLayout -Ratio 1 -Name "Row2"
)
```

### Response

#### Success Response (200)

This cmdlet returns a `Spectre.Console.Rendering.Layout` object upon successful execution.

- **Layout Object** (`Spectre.Console.Rendering.Layout`) - The newly created layout object.

#### Response Example

```powershell
# The output is a PowerShell object representing the layout
# Example representation:
# Layout {
#   Columns = @(...)
#   Ratio = 1
#   Name = "MyLayout"
# }
```
```

--------------------------------

### Multi-Item Selection Prompt - PwshSpectreConsole

Source: https://pwshspectreconsole.com/guides/get-started

This snippet shows how to implement a multi-item selection prompt using Read-SpectreMultiSelection. It allows users to select multiple items from a provided list. The function returns an array of the chosen items.

```powershell
# Start by creating your list of items
$items = @("apple", "banana", "orange", "pear", "strawberry", "durian", "lemon")


# Ask the user what they want
$chosenItems = Read-SpectreMultiSelection -Title "Select your favourite fruits" -Choices $items


# Do something with the chosen item
Write-SpectreHost "Your favourite fruits are $($chosenItems -join ', ')"
```

--------------------------------

### Format-SpectreColumns: Display Strings in Columns (PowerShell)

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrecolumns

This example demonstrates how to display a collection of strings in columns using Format-SpectreColumns. It pipes an array of strings to Foreach-Object to process each string and then formats them into columns.

```powershell
@("lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit,", "sed", "do", "eiusmod",
  "tempor", "incididunt", "ut", "labore", "et", "dolore", "magna", "aliqua.", "Ut", "enim", "ad", "minim",
  "veniam,", "quis", "nostrud", "exercitation", "ullamco", "laboris", "nisi", "ut", "aliquip", "ex", "ea",
  "commodo", "consequat", "duis", "aute", "irure", "dolor", "in", "reprehenderit", "in", "voluptate", "velit",
  "esse", "cillum", "dolore", "eu", "fugiat", "nulla", "pariatur", "excepteur", "sint", "occaecat",
  "cupidatat", "non", "proident", "sunt", "in", "culpa") | Foreach-Object { $_ } | Format-SpectreColumns
```

--------------------------------

### Format-SpectrePanel: Function Syntax

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrepanel

This snippet displays the general syntax for the Format-SpectrePanel function, outlining its parameters, their types, and whether they are required or positional. It serves as a reference for constructing function calls.

```powershell
Format-SpectrePanel [-Data] <Object> [[-Header] <String>] [[-Border] <String>] [-Expand] [[-Color] <Color>] [[-Width] <Int32>] [[-Height] <Int32>] [<CommonParameters>]
```

--------------------------------

### Format-SpectreTextPath Cmdlet Syntax

Source: https://pwshspectreconsole.com/reference/formatting/format-spectretextpath

Provides the basic syntax for the Format-SpectreTextPath cmdlet, outlining its mandatory and optional parameters. This helps users understand how to call the cmdlet and what arguments are expected.

```powershell
Format-SpectreTextPath [-Path] <String> [[-Alignment] <String>] [[-PathStyle] <Hashtable>] [<CommonParameters>]
```

--------------------------------

### Nesting Renderable Objects in a Table

Source: https://pwshspectreconsole.com/reference/formatting/format-spectretable

This example demonstrates advanced usage by nesting other Spectre Console renderable objects, such as a calendar and a bar chart, within a table. It highlights the flexibility of Format-SpectreTable in composing complex console outputs.

```powershell
$calendar = Write-SpectreCalendar -Date (Get-Date) -PassThru
$fruits = @(
    (New-SpectreChartItem -Label "Bananas" -Value 2.2 -Color Yellow),
    (New-SpectreChartItem -Label "Oranges" -Value 6.6 -Color Orange1),
    (New-SpectreChartItem -Label "Apples" -Value 1 -Color Red)
) | Format-SpectreBarChart -Width 45


@{ 
    Calendar = $calendar
    Fruits = $fruits
} | Format-SpectreTable -Color Cyan1
```

--------------------------------

### Format Spectre Rows within a Panel (PowerShell)

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrerows

Shows how to render multiple, potentially long, renderable items as rows within a Spectre.Console panel. This example highlights handling larger content and nesting widgets.

```powershell
$rows = @()
$bigText = "lorem ipsum dolor sit amet consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur excepteur sint occaecat cupidatat non proident sunt in culpa"
for ($i = 0; $i -lt 12; $i+= 4) {
    $rows += $bigText | Format-SpectrePadded -Left $i -Top 0 -Bottom 0 -Right 0
}
$rows | Format-SpectreRows | Format-SpectrePanel
```

--------------------------------

### Format-SpectreColumns: Display Panels in Expanded Columns (PowerShell)

Source: https://pwshspectreconsole.com/reference/formatting/format-spectrecolumns

This example demonstrates how to display panels in columns that are expanded to fill the entire console width. It uses Format-SpectrePanel with -Expand and then pipes the result to Format-SpectreColumns with the -Expand parameter.

```powershell
@("left", "middle", "right") | Foreach-Object { $_ | Format-SpectrePanel -Expand } | Format-SpectreColumns -Expand
```
Tokens:
Raw