Printer

go get github.com/raystack/salt/cli/printer

import "github.com/raystack/salt/cli/printer"

printer.Success("Operation completed")
printer.Successln("Operation completed")  // With newline
printer.Successf("Processed %d items", count)

printer.Warning("Deprecated feature")
printer.Warningln("Deprecated feature")
printer.Warningf("Retrying in %d seconds", delay)

printer.Error("Failed to connect")
printer.Errorln("Failed to connect")
printer.Errorf("Connection timeout after %d seconds", timeout)

printer.Info("Loading configuration...")
printer.Infoln("Loading configuration...")
printer.Infof("Found %d items", len(items))

// Bold text
bold := printer.Bold("Important")
printer.Boldln("Important")  // With newline
text := printer.Boldf("Status: %s", status)

// Italic text
italic := printer.Italic("Note")
printer.Italicln("Note")
text := printer.Italicf("Version: %s", version)

// Add space
printer.Space()

green := printer.Green("Success")
green := printer.Greenf("Count: %d", n)

yellow := printer.Yellow("Warning")
yellow := printer.Yellowf("Retry: %d", n)

cyan := printer.Cyan("Info")
cyan := printer.Cyanf("Status: %s", status)

red := printer.Red("Error")
red := printer.Redf("Failed: %s", err)

grey := printer.Grey("Disabled")
grey := printer.Greyf("Old version: %s", old)

blue := printer.Blue("Link")
blue := printer.Bluef("URL: %s", url)

magenta := printer.Magenta("Special")
magenta := printer.Magentaf("ID: %s", id)

success := printer.Icon("success") // ✔
failure := printer.Icon("failure") // ✘
info := printer.Icon("info")       // ℹ
warning := printer.Icon("warning") // ⚠

fmt.Printf("%s Operation completed\n", printer.Icon("success"))

import (
    "os"
    "github.com/raystack/salt/cli/printer"
)

rows := [][]string{
    {"ID", "Name", "Status"},
    {"1", "Alice", "Active"},
    {"2", "Bob", "Inactive"},
    {"3", "Charlie", "Active"},
}

printer.Table(os.Stdout, rows)

ID    Name      Status
1     Alice     Active
2     Bob       Inactive
3     Charlie   Active

type User struct {
    ID     int
    Name   string
    Status string
}

users := []User{
    {1, "Alice", "Active"},
    {2, "Bob", "Inactive"},
}

rows := [][]string{{"ID", "Name", "Status"}}
for _, user := range users {
    rows = append(rows, []string{
        fmt.Sprintf("%d", user.ID),
        user.Name,
        user.Status,
    })
}

printer.Table(os.Stdout, rows)

// Start spinner
indicator := printer.Spin("Loading data...")

// Perform operation
time.Sleep(2 * time.Second)

// Stop spinner
indicator.Stop()

func fetchData() error {
    spinner := printer.Spin("Fetching data")
    defer spinner.Stop()

    // Long operation
    data, err := api.FetchAll()
    if err != nil {
        return err
    }

    return process(data)
}

bar := printer.Progress(100, "Downloading files")

for i := 0; i < 100; i++ {
    // Download file
    downloadFile(i)
    
    // Update progress
    bar.Add(1)
}

items := []string{"file1.txt", "file2.txt", "file3.txt"}
bar := printer.Progress(len(items), "Processing files")

for _, item := range items {
    if err := process(item); err != nil {
        log.Printf("Failed to process %s: %v", item, err)
    }
    bar.Add(1)
}

data := map[string]interface{}{
    "name":   "Alice",
    "age":    30,
    "active": true,
}

// Compact JSON
if err := printer.JSON(data); err != nil {
    log.Fatal(err)
}

// Pretty-printed JSON
if err := printer.PrettyJSON(data); err != nil {
    log.Fatal(err)
}

{
	"active": true,
	"age": 30,
	"name": "Alice"
}

config := struct {
    Server struct {
        Host string `yaml:"host"`
        Port int    `yaml:"port"`
    } `yaml:"server"`
}{
    Server: struct {
        Host string `yaml:"host"`
        Port int    `yaml:"port"`
    }{
        Host: "localhost",
        Port: 8080,
    },
}

if err := printer.YAML(config); err != nil {
    log.Fatal(err)
}

server:
  host: localhost
  port: 8080

// Supports: "json", "yaml", "prettyjson"
format := "yaml"
if err := printer.File(data, format); err != nil {
    log.Fatal(err)
}

markdown := `# Welcome

This is **bold** and this is *italic*.

## Features

- Item 1
- Item 2
- Item 3

` + "```go\nfunc main() {\n    fmt.Println(\"Hello\")\n}\n```" + `
`

// Render with colors
rendered, err := printer.Markdown(markdown)
if err != nil {
    log.Fatal(err)
}
fmt.Print(rendered)

// Render with word wrap at 80 characters
rendered, err = printer.MarkdownWithWrap(markdown, 80)
if err != nil {
    log.Fatal(err)
}
fmt.Print(rendered)

package main

import (
    "fmt"
    "os"
    "time"

    "github.com/raystack/salt/cli/printer"
)

type Deployment struct {
    ID      string
    Status  string
    Created time.Time
}

func main() {
    // Show info message
    printer.Infoln("Starting deployment process...")
    fmt.Println()

    // Show spinner during operation
    spinner := printer.Spin("Preparing deployment")
    time.Sleep(1 * time.Second)
    spinner.Stop()

    // Show success
    printer.Successln("Preparation complete")
    fmt.Println()

    // Deploy multiple services with progress
    services := []string{"api", "worker", "frontend", "database"}
    bar := printer.Progress(len(services), "Deploying services")
    
    for _, service := range services {
        time.Sleep(500 * time.Millisecond)
        bar.Add(1)
    }
    fmt.Println()

    // Show results in table
    printer.Boldln("Deployment Results")
    rows := [][]string{
        {"Service", "Status", "Time"},
        {"api", printer.Green("Running"), "1.2s"},
        {"worker", printer.Green("Running"), "0.8s"},
        {"frontend", printer.Green("Running"), "2.1s"},
        {"database", printer.Yellow("Starting"), "0.5s"},
    }
    printer.Table(os.Stdout, rows)
    fmt.Println()

    // Show structured output
    deployment := Deployment{
        ID:      "deploy-123",
        Status:  "success",
        Created: time.Now(),
    }

    printer.Boldln("Deployment Details (JSON):")
    if err := printer.PrettyJSON(deployment); err != nil {
        printer.Errorf("Failed to print JSON: %v\n", err)
        os.Exit(1)
    }

    fmt.Println()
    printer.Successf("%s Deployment completed successfully!\n", 
        printer.Icon("success"))
}