output

package module
v0.4.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 16, 2026 License: MIT Imports: 18 Imported by: 0

README

go-output

CI Go Report Card GoDoc

A Go library that formats structured data into 12 output formats — tables, trees, and diagrams — with type-safe enums, branded IDs, and zero-config color support. Write your data once, render it anywhere.

import "github.com/larsartmann/go-output"

Quick Start

Build tabular data once, render it in any format:

data := output.NewTableData([]string{"Name", "Health", "Complexity"})
data.AddRow([]string{"Alpha", "90%", "7/10"})
data.AddRow([]string{"Beta", "75%", "5/10"})

// Markdown table
md := output.NewMarkdownTable()
md.SetHeaders(data.GetHeaders())
for _, row := range data.GetRows() {
    md.AddRow(row)
}
out, _ := md.Render()

// JSON
json, _ := output.MarshalJSONIndent(projects, "", "  ")

// CSV
w := output.NewCSVWriter(os.Stdout)
w.WriteHeader(data.GetHeaders())
for _, row := range data.GetRows() {
    w.WriteRow(row)
}
w.Flush()

Use the Format enum for runtime format selection — perfect for CLI flags:

format, _ := output.ParseFormat("json") // validates input
fmt.Println(format.IsTableFormat())      // true
fmt.Println(format.Category())           // table

Why go-output?

  • 12 formats, one API — Same data, different renderers. No format-specific code paths.
  • Type-safe enums — Format, ColorMode, SortBy — all validated at parse time, never raw strings.
  • Zero lipgloss in root module — go get go-output pulls only go-faster/yaml and x/term. Lipgloss is isolated in the table/ submodule.
  • Branded IDs — Phantom types prevent mixing D2NodeID, TreeNodeID, GraphNodeID at compile time.
  • Streaming — StreamingHTMLRenderer for large datasets with minimal memory.
  • Extensible registry — Register custom renderers for runtime dispatch.

Supported Formats

Category Formats Use Case
Table table, json, csv, tsv, xml, markdown, yaml, d2 Tabular data with rows and columns
Tree tree, html Hierarchical structures
Graph d2, mermaid, dot Network diagrams and flowcharts

All formats implement the Renderer interface:

type Renderer interface {
    Render() (string, error)
}
Table Formats
// JSON
data, _ := output.MarshalJSONIndent(projects, "", "  ")

// CSV
w := output.NewCSVWriter(os.Stdout)
w.WriteHeader([]string{"Name", "Value"})
w.WriteRow([]string{"Item", "123"})
w.Flush()

// TSV
tw := output.NewTSVWriter(os.Stdout)
tw.WriteHeader([]string{"Name", "Value"})
tw.WriteRow([]string{"Item", "123"})
tw.Flush()

// XML
data, _ := output.MarshalXMLFromTableData(tableData)

// YAML
data, _ := output.MarshalYAML(projects)

// Markdown table
md := output.NewMarkdownTable()
md.SetHeaders([]string{"Name", "Health"})
md.AddRow([]string{"Alpha", "90%"})
out, _ := md.Render()

// Terminal table with lipgloss styling (requires go-output/table)
tbl := table.New()
tbl.SetHeaders("Name", "Health")
tbl.AddRow("Alpha", "90%")
out, _ := tbl.Render()
Tree Formats
tree := output.NewASCIITreeRenderer()

root := output.NewTreeNode("root", "Projects")
root.AddChild(output.NewTreeNode("alpha", "Alpha"))
root.AddChild(output.NewTreeNode("beta", "Beta"))

tree.SetRoot(root)
out, _ := tree.Render()
// Projects
// ├── Alpha
// └── Beta
Graph Formats
// DOT / Graphviz
renderer := output.DOTFromTableData(data)
out, _ := renderer.Render()

// Mermaid flowchart
renderer := output.MermaidFlowchartRenderer(data)
out, _ := renderer.Render()

// D2 diagrams (shapes, SQL tables, grid layouts, nested containers)
d2 := output.NewD2Renderer("Architecture")
d2.AddNode(output.D2Node{
    ID:    output.NewBrandedID[output.D2NodeIDBrand]("api"),
    Label: output.NewBrandedID[output.D2NodeLabelBrand]("API Gateway"),
    Shape: output.D2ShapeHexagon,
})
out, _ := d2.Render()

Format Categories

Formats are classified into three categories for programmatic filtering:

format, _ := output.ParseFormat("d2")
fmt.Println(format.IsTableFormat()) // true (D2 supports SQL tables)
fmt.Println(format.IsGraphFormat()) // true (D2 supports node-edge diagrams)
fmt.Println(format.Category())      // graph (graph takes precedence)

for _, f := range output.AllFormats {
    if f.IsTableFormat() {
        fmt.Println(f) // table, json, csv, tsv, xml, markdown, yaml, d2
    }
}

Installation

go get github.com/larsartmann/go-output

For terminal table styling with lipgloss:

go get github.com/larsartmann/go-output/table

Branded IDs

Type-safe identifiers prevent mixing different ID types at compile time:

nodeID := output.NewBrandedID[output.D2NodeIDBrand]("node-1")
treeID := output.NewBrandedID[output.TreeNodeIDBrand]("root")

// nodeID = treeID  // COMPILE ERROR: different branded types

Define your own branded types:

type ProjectIDBrand struct{}
projectID := output.NewBrandedID[ProjectIDBrand]("proj-123")

D2 Advanced Features

D2 diagrams support SQL tables, constraints, grid layouts, and nested containers:

table := output.D2Table{
    Name: "users",
    Columns: []output.D2Column{
        {Name: "id", Type: "INT", Constraint: output.D2ConstraintPrimary},
        {Name: "email", Type: "VARCHAR(255)", Constraint: output.D2ConstraintUnique},
        {Name: "manager_id", Type: "INT", Constraint: output.D2ConstraintForeign},
    },
}

node := output.D2Node{
    ID:          output.NewBrandedID[output.D2NodeIDBrand]("dashboard"),
    Label:       output.NewBrandedID[output.D2NodeLabelBrand]("Dashboard"),
    GridRows:    3,
    GridColumns: 2,
    GridGap:     8,
}

Registry System

Register custom renderers for runtime dispatch:

output.Register(output.Format("custom"), func() output.Renderer {
    return &myCustomRenderer{}
})

renderer, _ := output.Create(output.FormatTable)
formats := output.RegisteredFormats()

Streaming Renderer

For large datasets, stream output incrementally:

renderer := output.NewStreamingHTMLRenderer()
renderer.SetData(tableData)
_ = renderer.Stream(os.Stdout)

Color Modes

Mode Description
auto Respect NO_COLOR, CI env vars, TTY detection
always Force ANSI colors
never Disable colors

Type-Safe Enums

All configuration types provide validation and string conversion:

format, err := output.ParseFormat("json")
if format.IsValid() {
    fmt.Println(format.String()) // "json"
}
allowed := format.AllowedValues() // []string{"table", "json", "csv", ...}

CLI Flag Integration

The cmdguard/ subpackage provides types compatible with cmdguard for type-safe CLI flags:

import (
    "github.com/larsartmann/go-output"
    "github.com/larsartmann/go-output/cmdguard"
)

type ListFlags struct {
    Format output.OutputFormat `flag:"format" default:"table" help:"Output format (table, json, csv, ...)"`
    SortBy output.SortBy       `flag:"sort-by" default:"name" help:"Sort field"`
    Color  output.ColorMode    `flag:"color" default:"auto" help:"Color mode (auto, always, never)"`
}

Escape Functions

The escape/ subpackage provides safe escaping for each format:

import "github.com/larsartmann/go-output/escape"

safe := escape.HTML("<script>alert('xss')</script>")
safeID := escape.D2("my-node.with.dots")
Function Purpose
escape.HTML HTML special characters
escape.XML XML special characters
escape.D2 D2 diagram identifiers
escape.DOT DOT graph identifiers
escape.MermaidID Mermaid node IDs

Dependencies

Root module — zero lipgloss dependencies:

require (
    github.com/go-faster/yaml v0.4.6
    golang.org/x/term v0.42.0
)

Terminal table module (install separately):

require (
    charm.land/lipgloss/v2 v2.0.3
)

Examples

See examples/basic/main.go for a complete example demonstrating all 12 formats:

go run ./examples/basic/main.go markdown

Development

go build ./...                  # Build all workspace modules
go test ./...                   # Test all modules
go test -race ./...             # Race detector
go test -cover ./...            # Coverage report
golangci-lint run --fix ./...   # Lint

License

MIT

Documentation

Overview

Package output provides a registry for dynamically registering renderer factories.

The registry is an opt-in plugin system. By default, formats are used directly via their constructors (NewMarkdownTable, NewD2Diagram, etc.). Use Register/Create when you need runtime-dispatchable format selection, e.g.: 

output.Register(output.FormatJSON, func() output.Renderer { return myCustomJSONRenderer })
renderer, _ := output.Create(output.FormatJSON)

The registry is thread-safe.

Package output provides consistent output formatting for CLI applications.

Index

Constants

View Source 
const (
	OutputFormatTable    = FormatTable
	OutputFormatJSON     = FormatJSON
	OutputFormatCSV      = FormatCSV
	OutputFormatTSV      = FormatTSV
	OutputFormatXML      = FormatXML
	OutputFormatMarkdown = FormatMarkdown
	OutputFormatD2       = FormatD2
	OutputFormatYAML     = FormatYAML
	OutputFormatHTML     = FormatHTML
	OutputFormatTree     = FormatTree
	OutputFormatMermaid  = FormatMermaid
	OutputFormatDOT      = FormatDOT
)

Backward compatibility aliases for format constants.

Variables

View Source 
var AllFormats = []Format{
	FormatTable,
	FormatJSON,
	FormatCSV,
	FormatTSV,
	FormatMarkdown,
	FormatXML,
	FormatD2,
	FormatYAML,
	FormatHTML,
	FormatTree,
	FormatMermaid,
	FormatDOT,
}

AllFormats contains all valid output format values. Use this for testing AllowedValues or generating help text.

View Source 
var ErrFormatAlreadyRegistered = errors.New("format already registered")

ErrFormatAlreadyRegistered is returned when a format is already registered.

View Source 
var ErrInvalidColorMode = errors.New("invalid color mode")

ErrInvalidColorMode is returned when an invalid color mode is provided.

View Source 
var ErrInvalidD2ArrowType = errors.New("invalid D2 arrow type")

ErrInvalidD2ArrowType is returned when an invalid D2 arrow type is provided.

View Source 
var ErrInvalidD2Constraint = errors.New("invalid D2 constraint")

ErrInvalidD2Constraint is returned when an invalid D2 constraint is provided.

View Source 
var ErrInvalidD2Direction = errors.New("invalid D2 direction")

ErrInvalidD2Direction is returned when an invalid D2 direction is provided.

View Source 
var ErrInvalidD2NodeShape = errors.New("invalid D2 node shape")

ErrInvalidD2NodeShape is returned when an invalid D2 node shape is provided.

View Source 
var ErrInvalidGraphShape = errors.New("invalid graph shape")

ErrInvalidGraphShape is returned when an invalid graph shape is provided.

View Source 
var ErrInvalidSortBy = errors.New("invalid sort by")

ErrInvalidSortBy is returned when an invalid sort field is provided.

View Source 
var ErrNoRendererRegistered = errors.New("no renderer registered for format")

ErrNoRendererRegistered is returned when no renderer is registered for a format.

View Source 
var ErrUnsupportedType = errors.New("unsupported type")

ErrUnsupportedType is returned when an unsupported type is provided for TSV marshaling.

Functions

func AddTreeNodes 

func AddTreeNodes(
	nodes *[]GraphNode, edges *[]GraphEdge,
	node *TreeNode, parentID string,
	idFunc TreeNodeIDFunc, shape GraphShape,
)

AddTreeNodes recursively adds tree nodes and edges to the provided graph slices.

func AssertTreeNodeDepth 

func AssertTreeNodeDepth(t *testing.T, root, child, grandchild *TreeNode)

AssertTreeNodeDepth verifies the depth of tree nodes in a hierarchy.

func DefaultGraphNodeLabel 

func DefaultGraphNodeLabel(header, cell string) string

DefaultGraphNodeLabel returns a label in the format "header: cell".

func FilledStrings 

func FilledStrings(n int, value string) []string

FilledStrings returns a slice of n strings, each filled with the given value.

func IsRegistered 

func IsRegistered(format Format) bool

IsRegistered returns true if a format has a registered renderer.

func MarshalJSON 

func MarshalJSON(v any) ([]byte, error)

MarshalJSON encodes v to JSON.

func MarshalJSONIndent 

func MarshalJSONIndent(v any, prefix, indent string) ([]byte, error)

MarshalJSONIndent encodes v to indented JSON.

func MarshalTSV 

func MarshalTSV(data any) ([]byte, error)

MarshalTSV marshals data as TSV.

func MarshalXML 

func MarshalXML(v any) ([]byte, error)

MarshalXML encodes v to XML.

func MarshalXMLFromTableData 

func MarshalXMLFromTableData(data *TableData) ([]byte, error)

MarshalXMLFromTableData marshals TableData to XML.

func MarshalXMLIndent 

func MarshalXMLIndent(v any, prefix, indent string) (result []byte, err error)

MarshalXMLIndent encodes v to indented XML.

func MarshalYAML 

func MarshalYAML(v any) ([]byte, error)

MarshalYAML encodes v to YAML.

func MustRender 

func MustRender(r Renderer) string

MustRender calls Render on the provided Renderer and panics if it returns an error. Useful for tests and examples where rendering failure is unexpected.

func NewBrandedID 

func NewBrandedID[Brand any](value string) id.ID[Brand, string]

NewBrandedID creates a new branded ID from a string value.

func Register 

func Register(format Format, factory RendererFactory) error

Register registers a renderer factory for a format.

func UnmarshalJSON 

func UnmarshalJSON(data []byte, v any) error

UnmarshalJSON decodes JSON data into v.

func UnmarshalYAML 

func UnmarshalYAML(data []byte, v any) error

UnmarshalYAML decodes YAML data into v.

func Unregister 

func Unregister(format Format)

Unregister removes a format from the registry.

Types

type ASCIITreeRenderer 

type ASCIITreeRenderer struct {
	// contains filtered or unexported fields
}

ASCIITreeRenderer implements the TreeOutputRenderer interface for ASCII tree output.

func NewASCIITreeRenderer 

func NewASCIITreeRenderer() *ASCIITreeRenderer

NewASCIITreeRenderer creates a new ASCIITreeRenderer.

func TreeRendererFromTableData 

func TreeRendererFromTableData(data *TableData) *ASCIITreeRenderer

TreeRendererFromTableData converts TableData to a tree using the first column as hierarchy.

func (*ASCIITreeRenderer) Render 

func (r *ASCIITreeRenderer) Render() (string, error)

Render returns the tree as a string.

func (*ASCIITreeRenderer) SetRoot 

func (r *ASCIITreeRenderer) SetRoot(node *TreeNode)

SetRoot sets the root node of the tree.

type Alignment 

type Alignment int

Alignment represents text alignment within a table cell. 

const (
	AlignLeft   Alignment = AlignmentLeft
	AlignRight  Alignment = AlignmentRight
	AlignCenter Alignment = AlignmentCenter
)

Column alignment constants. 

const (
	AlignmentLeft Alignment = iota
	AlignmentRight
	AlignmentCenter
)

Column alignment iota values (unexported).

type BrandedID 

type BrandedID[Brand any] = id.ID[Brand, string]

BrandedID re-export for backward compatibility. Use id.ID[Brand, string] for new code.

type CSVWriter 

type CSVWriter struct {
	// contains filtered or unexported fields
}

CSVWriter writes CSV output.

func NewCSVWriter 

func NewCSVWriter(w io.Writer) *CSVWriter

NewCSVWriter creates a new CSVWriter.

func (*CSVWriter) Error 

func (c *CSVWriter) Error() error

Error returns any error from the writer.

func (*CSVWriter) Flush 

func (c *CSVWriter) Flush()

Flush flushes the writer.

func (*CSVWriter) WriteHeader 

func (c *CSVWriter) WriteHeader(cols []string) error

WriteHeader writes the header row.

func (*CSVWriter) WriteRow 

func (c *CSVWriter) WriteRow(values []string) error

WriteRow writes a single row.

func (*CSVWriter) WriteRows 

func (c *CSVWriter) WriteRows(values [][]string) error

WriteRows writes multiple rows.

type ColorMode 

type ColorMode string

ColorMode controls terminal color output. 

const (
	ColorModeAuto   ColorMode = "auto"
	ColorModeAlways ColorMode = "always"
	ColorModeNever  ColorMode = "never"
)

Terminal color output modes.

func ParseColorMode 

func ParseColorMode(s string) (ColorMode, error)

ParseColorMode converts a string to ColorMode, returning an error if invalid.

func (ColorMode) AllowedValues 

func (c ColorMode) AllowedValues() []string

AllowedValues returns all valid color mode values.

func (ColorMode) IsValid 

func (c ColorMode) IsValid() bool

IsValid checks if the color mode is valid.

func (ColorMode) ShouldColor 

func (c ColorMode) ShouldColor() bool

ShouldColor returns true if colors should be enabled.

func (ColorMode) String 

func (c ColorMode) String() string

String returns the string representation of the color mode.

type D2ArrowType 

type D2ArrowType string

D2ArrowType represents the type of arrow for D2 edges. 

const (
	D2ArrowNone           D2ArrowType = ""
	D2ArrowArrow          D2ArrowType = "arrow"
	D2ArrowTriangle       D2ArrowType = "triangle"
	D2ArrowDiamond        D2ArrowType = "diamond"
	D2ArrowCircle         D2ArrowType = "circle"
	D2ArrowFilled         D2ArrowType = "filled"
	D2ArrowBox            D2ArrowType = "box"
	D2ArrowCross          D2ArrowType = "cross"
	D2ArrowCFOne          D2ArrowType = "cf-one"
	D2ArrowCFMany         D2ArrowType = "cf-many"
	D2ArrowCFOneRequired  D2ArrowType = "cf-one-required"
	D2ArrowCFManyRequired D2ArrowType = "cf-many-required"
)

D2ArrowType constants define the available arrow shapes for D2 edges.

func ParseD2ArrowType 

func ParseD2ArrowType(s string) (D2ArrowType, error)

ParseD2ArrowType converts a string to D2ArrowType, returning an error if invalid.

func (D2ArrowType) AllowedValues 

func (a D2ArrowType) AllowedValues() []string

AllowedValues returns all valid D2 arrow type values for CLI help text.

func (D2ArrowType) IsValid 

func (a D2ArrowType) IsValid() bool

IsValid returns true if the arrow type is a valid D2ArrowType value.

func (D2ArrowType) String 

func (a D2ArrowType) String() string

String returns the string representation of the arrow type.

type D2Column 

type D2Column struct {
	Name       string
	Type       string
	Constraint D2Constraint
}

D2Column represents a column in a D2 SQL table shape.

type D2Constraint 

type D2Constraint string

D2Constraint represents a SQL constraint on a table column. 

const (
	D2ConstraintPrimary D2Constraint = "primary_key"
	D2ConstraintForeign D2Constraint = "foreign_key"
	D2ConstraintUnique  D2Constraint = "unique"
)

D2Constraint constants define the available SQL constraints for D2 table columns.

func AllD2Constraints 

func AllD2Constraints() []D2Constraint

AllD2Constraints returns all valid D2Constraint values.

func ParseD2Constraint 

func ParseD2Constraint(s string) (D2Constraint, error)

ParseD2Constraint converts a string to D2Constraint, returning an error if invalid.

func (D2Constraint) AllowedValues 

func (c D2Constraint) AllowedValues() []string

AllowedValues returns all valid D2Constraint values for CLI help text.

func (D2Constraint) IsValid 

func (c D2Constraint) IsValid() bool

IsValid returns true if the constraint is a valid D2Constraint value.

func (D2Constraint) String 

func (c D2Constraint) String() string

String returns the string representation of the constraint.

type D2Diagram 

type D2Diagram struct {
	// contains filtered or unexported fields
}

D2Diagram builds D2 diagram output with full support for nodes, edges, SQL table shapes, styling, nesting, icons, links, tooltips, classes, and layout configuration.

func D2FromTableData 

func D2FromTableData(data *TableData) *D2Diagram

D2FromTableData converts TableData to a D2 diagram with per-row nodes connected by edges.

func D2FromTree 

func D2FromTree(root *TreeNode) *D2Diagram

D2FromTree converts a TreeNode hierarchy to a D2 diagram.

func NewD2Diagram 

func NewD2Diagram() *D2Diagram

NewD2Diagram creates a new D2Diagram.

func (*D2Diagram) AddClass 

func (d *D2Diagram) AddClass(name string, style D2NodeStyle) *D2Diagram

AddClass adds a reusable style class that can be referenced by nodes.

func (*D2Diagram) AddEdge 

func (d *D2Diagram) AddEdge(edge D2Edge) *D2Diagram

AddEdge adds an edge between two nodes.

func (*D2Diagram) AddEdgeSimple 

func (d *D2Diagram) AddEdgeSimple(from, to string) *D2Diagram

AddEdgeSimple adds a simple edge between two nodes.

func (*D2Diagram) AddLabeledEdge 

func (d *D2Diagram) AddLabeledEdge(from, to, label string) *D2Diagram

AddLabeledEdge adds an edge with a label.

func (*D2Diagram) AddNode 

func (d *D2Diagram) AddNode(node D2Node) *D2Diagram

AddNode adds a node to the diagram.

func (*D2Diagram) AddNodeSimple 

func (d *D2Diagram) AddNodeSimple(id, label string) *D2Diagram

AddNodeSimple adds a simple node with just ID and label.

func (*D2Diagram) AddNodeWithShape 

func (d *D2Diagram) AddNodeWithShape(id, label string, shape D2NodeShape) *D2Diagram

AddNodeWithShape adds a node with a specific shape.

func (*D2Diagram) AddTable 

func (d *D2Diagram) AddTable(name string, columns []D2Column) *D2Diagram

AddTable adds a SQL table shape to the diagram.

func (*D2Diagram) Render 

func (d *D2Diagram) Render() (string, error)

Render returns the D2 diagram as a valid D2 language string.

func (*D2Diagram) SetDirection 

func (d *D2Diagram) SetDirection(dir D2Direction) *D2Diagram

SetDirection sets the layout direction for the diagram.

func (*D2Diagram) SetEdges 

func (d *D2Diagram) SetEdges(edges []GraphEdge)

SetEdges sets graph edges from the generic GraphEdge type, satisfying GraphRenderer.

func (*D2Diagram) SetLayout 

func (d *D2Diagram) SetLayout(engine string) *D2Diagram

SetLayout sets the layout engine (e.g., "elk", "dagre").

func (*D2Diagram) SetNodes 

func (d *D2Diagram) SetNodes(nodes []GraphNode)

SetNodes sets graph nodes from the generic GraphNode type, satisfying GraphRenderer.

func (*D2Diagram) SetTitle 

func (d *D2Diagram) SetTitle(title string) *D2Diagram

SetTitle sets the diagram title.

type D2Direction 

type D2Direction string

D2Direction constants for diagram layout direction. 

const (
	D2DirDown  D2Direction = ""
	D2DirRight D2Direction = "right"
	D2DirLeft  D2Direction = "left"
	D2DirUp    D2Direction = "up"
)

D2 direction constants.

func ParseD2Direction 

func ParseD2Direction(s string) (D2Direction, error)

ParseD2Direction converts a string to D2Direction, returning an error if invalid.

func (D2Direction) AllowedValues 

func (d D2Direction) AllowedValues() []string

AllowedValues returns all valid D2 direction values for CLI help text.

func (D2Direction) IsValid 

func (d D2Direction) IsValid() bool

IsValid returns true if the direction is a valid D2Direction value.

func (D2Direction) String 

func (d D2Direction) String() string

String returns the string representation of the direction.

type D2Edge 

type D2Edge struct {
	From        D2NodeID
	To          D2NodeID
	Label       D2NodeLabel
	Style       D2EdgeStyle
	SourceArrow D2ArrowType
	TargetArrow D2ArrowType
}

D2Edge represents an edge in a D2 diagram.

type D2EdgeStyle 

type D2EdgeStyle struct {
	Stroke      string
	StrokeWidth int
	StrokeDash  int
	Animated    bool
	FontColor   string
	FontSize    int
}

D2EdgeStyle represents styling for a D2 edge.

type D2Node 

type D2Node struct {
	ID          D2NodeID
	Label       D2NodeLabel
	Shape       D2NodeShape
	Style       D2NodeStyle
	Icon        string
	Link        string
	Tooltip     string
	Class       string
	Near        string
	Width       int
	Height      int
	GridRows    int
	GridColumns int
	GridGap     int
	Nested      string
}

D2Node represents a node in a D2 diagram.

type D2NodeID 

type D2NodeID = id.ID[D2NodeIDBrand, string]

D2NodeID is a branded identifier for D2 diagram nodes.

type D2NodeIDBrand 

type D2NodeIDBrand struct{}

D2NodeIDBrand is the brand type for D2 node IDs.

type D2NodeLabel 

type D2NodeLabel = id.ID[D2NodeLabelBrand, string]

D2NodeLabel is a branded identifier for D2 diagram node labels.

type D2NodeLabelBrand 

type D2NodeLabelBrand struct{}

D2NodeLabelBrand is the brand type for D2 node labels.

type D2NodeShape 

type D2NodeShape string

D2NodeShape represents the shape of a D2 node. 

const (
	D2ShapeRectangle     D2NodeShape = "rectangle"
	D2ShapeSquare        D2NodeShape = "square"
	D2ShapeCircle        D2NodeShape = "circle"
	D2ShapeDiamond       D2NodeShape = "diamond"
	D2ShapeHexagon       D2NodeShape = "hexagon"
	D2ShapeCloud         D2NodeShape = "cloud"
	D2ShapeCylinder      D2NodeShape = "cylinder"
	D2ShapePerson        D2NodeShape = "person"
	D2ShapeQueue         D2NodeShape = "queue"
	D2ShapeOval          D2NodeShape = "oval"
	D2ShapeParallelogram D2NodeShape = "parallelogram"
	D2ShapeTriangle      D2NodeShape = "triangle"
	D2ShapeSQLTable      D2NodeShape = "sql_table"
	D2ShapeImage         D2NodeShape = "image"
	D2ShapeCode          D2NodeShape = "code"
	D2ShapeText          D2NodeShape = "text"
	D2ShapeClass         D2NodeShape = "class"
	D2ShapePage          D2NodeShape = "page"
	D2ShapeStep          D2NodeShape = "step"
	D2ShapeStoredData    D2NodeShape = "stored_data"
)

D2NodeShape constants define the available shapes for D2 nodes.

func ParseD2NodeShape 

func ParseD2NodeShape(s string) (D2NodeShape, error)

ParseD2NodeShape converts a string to D2NodeShape, returning an error if invalid.

func (D2NodeShape) AllowedValues 

func (s D2NodeShape) AllowedValues() []string

AllowedValues returns all valid D2 node shape values for CLI help text.

func (D2NodeShape) IsValid 

func (s D2NodeShape) IsValid() bool

IsValid returns true if the shape is a valid D2NodeShape value.

func (D2NodeShape) String 

func (s D2NodeShape) String() string

String returns the string representation of the node shape.

type D2NodeStyle 

type D2NodeStyle struct {
	Fill          string
	Stroke        string
	StrokeWidth   int
	StrokeDash    int
	FontSize      int
	FontColor     string
	Opacity       float64
	Shadow        bool
	BorderRadius  int
	TextTransform string
}

D2NodeStyle represents styling for a D2 node.

type D2Table 

type D2Table struct {
	Name    string
	Columns []D2Column
}

D2Table represents a SQL table shape in D2 diagrams.

type DOTRenderer 

type DOTRenderer struct {
	GraphRendererMixin
	// contains filtered or unexported fields
}

DOTRenderer implements the GraphRenderer interface for DOT/Graphviz output.

func DOTFromTableData 

func DOTFromTableData(data *TableData) *DOTRenderer

DOTFromTableData converts TableData to a DOT graph.

func DOTFromTree 

func DOTFromTree(root *TreeNode) *DOTRenderer

DOTFromTree converts a TreeNode to DOT format.

func NewDOTRenderer 

func NewDOTRenderer() *DOTRenderer

NewDOTRenderer creates a new DOTRenderer for directed graphs.

func NewUndirectedDOTRenderer 

func NewUndirectedDOTRenderer() *DOTRenderer

NewUndirectedDOTRenderer creates a new DOTRenderer for undirected graphs.

func (*DOTRenderer) Render 

func (r *DOTRenderer) Render() (string, error)

Render returns the DOT graph as a string.

func (*DOTRenderer) SetGraphID 

func (r *DOTRenderer) SetGraphID(id string)

SetGraphID sets the graph ID.

type DelimitedWriter 

type DelimitedWriter struct {
	// contains filtered or unexported fields
}

DelimitedWriter handles common logic for CSV and TSV writing.

func NewDelimitedWriter 

func NewDelimitedWriter(w io.Writer, delimiter rune, name string) *DelimitedWriter

NewDelimitedWriter creates a new DelimitedWriter.

func (*DelimitedWriter) Error 

func (d *DelimitedWriter) Error() error

Error returns any error encountered during writing.

func (*DelimitedWriter) Flush 

func (d *DelimitedWriter) Flush()

Flush flushes the writer.

func (*DelimitedWriter) WriteRow 

func (d *DelimitedWriter) WriteRow(cols []string, description string) error

WriteRow writes a single row.

func (*DelimitedWriter) WriteRows 

func (d *DelimitedWriter) WriteRows(values [][]string, description string) error

WriteRows writes multiple rows.

type EdgeStyle 

type EdgeStyle struct {
	Color     string
	Style     string // solid, dashed, dotted
	ArrowHead string
	ArrowTail string
}

EdgeStyle represents styling attributes for an edge.

type ExpectedOutput 

type ExpectedOutput = gentest.ExpectedOutput

Re-export generic helpers from gentest for use by package output tests. This avoids code duplication while maintaining the unexported API.

type Format 

type Format string

Format represents the available output format options for CLI applications. 

const (
	FormatTable    Format = "table"
	FormatJSON     Format = "json"
	FormatCSV      Format = "csv"
	FormatTSV      Format = "tsv"
	FormatMarkdown Format = "markdown"
	FormatXML      Format = "xml"
	FormatD2       Format = "d2"
	FormatYAML     Format = "yaml"
	FormatHTML     Format = "html"
	FormatTree     Format = "tree"
	FormatMermaid  Format = "mermaid"
	FormatDOT      Format = "dot"
)

Output format constants.

func ParseFormat 

func ParseFormat(s string) (Format, error)

ParseFormat converts a string to Format, returning an error if invalid.

func ParseOutputFormat 

func ParseOutputFormat(s string) (Format, error)

ParseOutputFormat is a backward compatibility function that calls ParseFormat.

func RegisteredFormats 

func RegisteredFormats() []Format

RegisteredFormats returns a sorted list of all registered formats.

func (Format) AllowedValues 

func (f Format) AllowedValues() []string

AllowedValues returns all valid output format values for CLI help text.

func (Format) Category 

func (f Format) Category() FormatCategory

Category returns the category of the format.

func (Format) IsGraphFormat 

func (f Format) IsGraphFormat() bool

IsGraphFormat returns true if this is a graph/diagram format.

func (Format) IsTableFormat 

func (f Format) IsTableFormat() bool

IsTableFormat returns true if this is a table-based format.

func (Format) IsTreeFormat 

func (f Format) IsTreeFormat() bool

IsTreeFormat returns true if this is a tree-based format.

func (Format) IsValid 

func (f Format) IsValid() bool

IsValid returns true if the format is a valid Format value.

func (Format) String 

func (f Format) String() string

String returns the string representation of the format.

type FormatCategory 

type FormatCategory int

FormatCategory represents a category for format classification. 

const (
	CategoryTable FormatCategory = iota
	CategoryTree
	CategoryGraph
)

Format category constants for classifying output formats.

func (FormatCategory) String 

func (c FormatCategory) String() string

String returns the string representation of the format category.

type GraphEdge 

type GraphEdge struct {
	From  GraphNodeID
	To    GraphNodeID
	Label GraphNodeLabel
	Style EdgeStyle
}

GraphEdge represents an edge between two nodes.

func NewGraphEdge 

func NewGraphEdge(from, to string) *GraphEdge

NewGraphEdge creates a new GraphEdge.

type GraphNode 

type GraphNode struct {
	ID       GraphNodeID
	Label    GraphNodeLabel
	Shape    GraphShape
	Style    GraphStyle
	Metadata map[string]string
}

GraphNode represents a node in a graph.

func NewGraphNode 

func NewGraphNode(id, label string) *GraphNode

NewGraphNode creates a new GraphNode.

func NodesFromTableData 

func NodesFromTableData(data *TableData, labelFn GraphNodeLabelFunc) []GraphNode

NodesFromTableData creates GraphNodes from TableData using the provided label function.

type GraphNodeID 

type GraphNodeID = id.ID[GraphNodeIDBrand, string]

GraphNodeID is a branded identifier for graph nodes.

type GraphNodeIDBrand 

type GraphNodeIDBrand struct{}

GraphNodeIDBrand is the brand type for graph node IDs.

type GraphNodeLabel 

type GraphNodeLabel = id.ID[GraphNodeLabelBrand, string]

GraphNodeLabel is a branded identifier for graph node labels.

type GraphNodeLabelBrand 

type GraphNodeLabelBrand struct{}

GraphNodeLabelBrand is the brand type for graph node labels.

type GraphNodeLabelFunc 

type GraphNodeLabelFunc func(header, cell string) string

GraphNodeLabelFunc is a function that formats a cell value with its header into a label.

type GraphRenderer 

type GraphRenderer interface {
	Renderer
	// SetNodes sets the graph nodes.
	SetNodes(nodes []GraphNode)
	// SetEdges sets the graph edges.
	SetEdges(edges []GraphEdge)
}

GraphRenderer defines the interface for graph format renderers.

type GraphRendererMixin 

type GraphRendererMixin struct {
	// contains filtered or unexported fields
}

GraphRendererMixin contains shared fields and methods for graph renderers.

D2 does not use this mixin because it has richer domain-specific types (D2Node, D2Edge with classes, SQL tables, shapes, arrow types, etc.) that do not map to the simpler GraphNode/GraphEdge model.

func NewGraphRendererMixin 

func NewGraphRendererMixin() GraphRendererMixin

NewGraphRendererMixin creates a new GraphRendererMixin with initialized slices.

func (*GraphRendererMixin) AddRowEdges 

func (m *GraphRendererMixin) AddRowEdges(data *TableData)

AddRowEdges adds edges from data.CreateRowEdges() to the graph.

func (*GraphRendererMixin) SetEdges 

func (m *GraphRendererMixin) SetEdges(edges []GraphEdge)

SetEdges sets the graph edges.

func (*GraphRendererMixin) SetNodes 

func (m *GraphRendererMixin) SetNodes(nodes []GraphNode)

SetNodes sets the graph nodes.

func (*GraphRendererMixin) SetNodesFromTableData 

func (m *GraphRendererMixin) SetNodesFromTableData(
	data *TableData,
	modifyNode func(i int, n *GraphNode),
)

SetNodesFromTableData creates nodes from TableData, applies per-node modifications, adds them to the graph, and adds row edges.

type GraphShape 

type GraphShape string

GraphShape represents the shape of a graph node. 

const (
	ShapeBox           GraphShape = "box"
	ShapeEllipse       GraphShape = "ellipse"
	ShapeDiamond       GraphShape = "diamond"
	ShapeCircle        GraphShape = "circle"
	ShapeCylinder      GraphShape = "cylinder"
	ShapeHexagon       GraphShape = "hexagon"
	ShapeParallelogram GraphShape = "parallelogram"
	ShapeRect          GraphShape = "rect"
)

GraphShape constants define the available shapes for graph nodes.

func ParseGraphShape 

func ParseGraphShape(s string) (GraphShape, error)

ParseGraphShape converts a string to GraphShape, returning an error if invalid.

func (GraphShape) AllowedValues 

func (s GraphShape) AllowedValues() []string

AllowedValues returns all valid graph shape values.

func (GraphShape) IsValid 

func (s GraphShape) IsValid() bool

IsValid checks if the graph shape is valid.

func (GraphShape) String 

func (s GraphShape) String() string

String returns the string representation of the graph shape.

type GraphStyle 

type GraphStyle struct {
	FillColor   string
	StrokeColor string
	FontColor   string
	FontSize    int
}

GraphStyle represents styling attributes for a graph node.

type HTMLRenderer 

type HTMLRenderer struct {
	// contains filtered or unexported fields
}

HTMLRenderer implements the Renderer interface for HTML table output.

func NewHTMLRenderer 

func NewHTMLRenderer() *HTMLRenderer

NewHTMLRenderer creates a new HTMLRenderer.

func (*HTMLRenderer) AddRow 

func (b *HTMLRenderer) AddRow(row []string)

AddRow adds a data row.

func (*HTMLRenderer) Render 

func (r *HTMLRenderer) Render() (string, error)

Render returns the HTML table as a string.

func (*HTMLRenderer) RenderFullHTML 

func (r *HTMLRenderer) RenderFullHTML(title string) (string, error)

RenderFullHTML returns a complete HTML document with the table.

func (*HTMLRenderer) SetData 

func (b *HTMLRenderer) SetData(data *TableData)

SetData sets the table data directly.

func (*HTMLRenderer) SetHeaders 

func (b *HTMLRenderer) SetHeaders(headers []string)

SetHeaders sets the column headers.

type HTMLTreeRenderer 

type HTMLTreeRenderer struct {
	// contains filtered or unexported fields
}

HTMLTreeRenderer renders a tree structure as HTML with nested lists.

func NewHTMLTreeRenderer 

func NewHTMLTreeRenderer() *HTMLTreeRenderer

NewHTMLTreeRenderer creates a new HTMLTreeRenderer.

func (*HTMLTreeRenderer) Render 

func (r *HTMLTreeRenderer) Render() (string, error)

Render returns the tree as an HTML string.

func (*HTMLTreeRenderer) RenderFullHTML 

func (r *HTMLTreeRenderer) RenderFullHTML(title string) (string, error)

RenderFullHTML returns a complete HTML document with the tree.

func (*HTMLTreeRenderer) SetRoot 

func (r *HTMLTreeRenderer) SetRoot(node *TreeNode)

SetRoot sets the root node of the tree.

type InvalidFormatError 

type InvalidFormatError struct {
	Value   string
	Allowed []Format
}

InvalidFormatError represents an invalid format error.

func (*InvalidFormatError) Error 

func (e *InvalidFormatError) Error() string

Error returns a descriptive error message including allowed values.

type JSONWriter 

type JSONWriter struct {
	Writer io.Writer
}

JSONWriter writes JSON output to an io.Writer.

func NewJSONWriter 

func NewJSONWriter(w io.Writer) *JSONWriter

NewJSONWriter creates a new JSONWriter.

func (*JSONWriter) Encode 

func (j *JSONWriter) Encode(v any) error

Encode writes v as JSON to the underlying writer.

type MarkdownTable 

type MarkdownTable struct {
	// contains filtered or unexported fields
}

MarkdownTable builds Markdown tables.

func NewMarkdownTable 

func NewMarkdownTable() *MarkdownTable

NewMarkdownTable creates a new MarkdownTable.

func NewMarkdownTableFromData 

func NewMarkdownTableFromData(data *TableData) *MarkdownTable

NewMarkdownTableFromData creates a MarkdownTable populated from TableData.

func (*MarkdownTable) AddRow 

func (m *MarkdownTable) AddRow(row []string) *MarkdownTable

AddRow adds a row to the table.

func (*MarkdownTable) Render 

func (m *MarkdownTable) Render() (string, error)

Render returns the Markdown table string.

func (*MarkdownTable) SetAlign 

func (m *MarkdownTable) SetAlign(col int, alignment Alignment) *MarkdownTable

SetAlign sets column alignment.

func (*MarkdownTable) SetHeaders 

func (m *MarkdownTable) SetHeaders(headers []string) *MarkdownTable

SetHeaders sets the table headers.

type MermaidRenderer 

type MermaidRenderer struct {
	GraphRendererMixin
}

MermaidRenderer implements the GraphRenderer interface for Mermaid diagrams.

func MermaidFlowchartRenderer 

func MermaidFlowchartRenderer(data *TableData) *MermaidRenderer

MermaidFlowchartRenderer creates a Mermaid flowchart from table data.

func MermaidTreeRenderer 

func MermaidTreeRenderer(root *TreeNode) *MermaidRenderer

MermaidTreeRenderer converts a TreeNode to Mermaid.

func NewMermaidRenderer 

func NewMermaidRenderer() *MermaidRenderer

NewMermaidRenderer creates a new MermaidRenderer.

func (*MermaidRenderer) Render 

func (r *MermaidRenderer) Render() (string, error)

Render returns the Mermaid diagram as a string.

type OutputFormat deprecated 

type OutputFormat = Format

OutputFormat is a backward compatibility alias for Format.

Deprecated: Use Format directly instead of OutputFormat.

type Renderer 

type Renderer interface {
	// Render returns the formatted output as a string.
	Render() (string, error)
}

Renderer defines the interface for output format renderers.

func Create 

func Create(format Format) (Renderer, error)

Create returns a new Renderer instance for the given format.

type RendererFactory 

type RendererFactory func() Renderer

RendererFactory is a function that creates a Renderer instance.

type RowEdge 

type RowEdge struct {
	From string
	To   string
}

RowEdge represents a directed edge between two row identifiers.

type SortBy 

type SortBy string

SortBy represents the available sort field options for CLI applications. 

const (
	SortByName       SortBy = "name"
	SortByImportance SortBy = "importance"
	SortByCreatedAt  SortBy = "created_at"
	SortByUpdatedAt  SortBy = "updated_at"
	SortByHealth     SortBy = "health"
	SortByComplexity SortBy = "complexity"
)

Sort field constants.

func ParseSortBy 

func ParseSortBy(s string) (SortBy, error)

ParseSortBy converts a string to SortBy, returning an error if invalid.

func (SortBy) AllowedValues 

func (s SortBy) AllowedValues() []string

AllowedValues returns all valid sort field values for CLI help text.

func (SortBy) IsValid 

func (s SortBy) IsValid() bool

IsValid returns true if the sort field is a valid SortBy value.

func (SortBy) String 

func (s SortBy) String() string

String returns the string representation of the sort field.

type StreamingHTMLRenderer 

type StreamingHTMLRenderer struct {
	// contains filtered or unexported fields
}

StreamingHTMLRenderer is a streaming implementation of HTMLRenderer. It writes output incrementally to minimize memory usage.

func NewStreamingHTMLRenderer 

func NewStreamingHTMLRenderer() *StreamingHTMLRenderer

NewStreamingHTMLRenderer creates a new StreamingHTMLRenderer.

func (*StreamingHTMLRenderer) AddRow 

func (b *StreamingHTMLRenderer) AddRow(row []string)

AddRow adds a data row.

func (*StreamingHTMLRenderer) Render 

func (r *StreamingHTMLRenderer) Render() (string, error)

Render returns the HTML table as a string.

func (*StreamingHTMLRenderer) SetData 

func (b *StreamingHTMLRenderer) SetData(data *TableData)

SetData sets the table data directly.

func (*StreamingHTMLRenderer) SetHeaders 

func (b *StreamingHTMLRenderer) SetHeaders(headers []string)

SetHeaders sets the column headers.

func (*StreamingHTMLRenderer) Stream 

func (r *StreamingHTMLRenderer) Stream(w io.Writer) error

Stream writes the HTML table incrementally to an io.Writer.

type StreamingRenderer 

type StreamingRenderer interface {
	Renderer
	// Stream writes the rendered output to an io.Writer in chunks.
	Stream(w io.Writer) error
}

StreamingRenderer is an interface for renderers that support streaming output. This is useful for rendering large datasets without loading everything into memory.

Note: Not all implementations provide true streaming. The adapter returned by StreamingRendererFromRenderer collects output before writing. Only StreamingHTMLRenderer provides genuine streaming behavior.

func StreamingRendererFromRenderer 

func StreamingRendererFromRenderer(r Renderer) StreamingRenderer

StreamingRendererFromRenderer wraps a standard Renderer to implement StreamingRenderer. Note: This adapter does not provide true streaming behavior - it collects all output via Render() and then writes it at once. It exists to satisfy the StreamingRenderer interface for renderers that don't have native streaming support.

type TSVWriter 

type TSVWriter struct {
	// contains filtered or unexported fields
}

TSVWriter writes TSV (Tab-Separated Values) output.

func NewTSVWriter 

func NewTSVWriter(w io.Writer) *TSVWriter

NewTSVWriter creates a new TSVWriter.

func (*TSVWriter) Error 

func (t *TSVWriter) Error() error

Error returns any error from the writer.

func (*TSVWriter) Flush 

func (t *TSVWriter) Flush()

Flush flushes the writer.

func (*TSVWriter) WriteHeader 

func (t *TSVWriter) WriteHeader(cols []string) error

WriteHeader writes the header row.

func (*TSVWriter) WriteRow 

func (t *TSVWriter) WriteRow(values []string) error

WriteRow writes a single row.

func (*TSVWriter) WriteRows 

func (t *TSVWriter) WriteRows(values [][]string) error

WriteRows writes multiple rows.

type TableData 

type TableData struct {
	Headers []string
	Rows    [][]string
}

TableData represents tabular data with headers and rows.

func NewTableData 

func NewTableData(headers []string) *TableData

NewTableData creates a new TableData with the given headers.

func (*TableData) AddRow 

func (d *TableData) AddRow(row []string)

AddRow adds a row to the table data.

func (*TableData) ColCount 

func (d *TableData) ColCount() int

ColCount returns the number of columns (based on headers).

func (*TableData) CreateRowEdges 

func (d *TableData) CreateRowEdges() []RowEdge

CreateRowEdges generates edge data connecting consecutive rows. Used by graph renderers to create edges between table rows.

func (*TableData) GetHeaders 

func (d *TableData) GetHeaders() []string

GetHeaders returns the column headers. Satisfies the table.TableDataProvider interface.

func (*TableData) GetRows 

func (d *TableData) GetRows() [][]string

GetRows returns the data rows. Satisfies the table.TableDataProvider interface.

func (*TableData) RowCount 

func (d *TableData) RowCount() int

RowCount returns the number of data rows.

type TableRenderer 

type TableRenderer interface {
	Renderer
	// SetHeaders sets the column headers.
	SetHeaders(headers []string)
	// AddRow adds a data row.
	AddRow(row []string)
}

TableRenderer defines the interface for table format renderers.

type TreeNode 

type TreeNode struct {
	ID       TreeNodeID
	Label    TreeNodeLabel
	Children []*TreeNode
	Metadata map[string]string
	// contains filtered or unexported fields
}

TreeNode represents a node in a tree structure.

func NewTreeNode 

func NewTreeNode(id, label string) *TreeNode

NewTreeNode creates a new TreeNode with the given ID and label.

func (*TreeNode) AddChild 

func (n *TreeNode) AddChild(child *TreeNode)

AddChild adds a child node to this node.

func (*TreeNode) Depth 

func (n *TreeNode) Depth() int

Depth returns the depth of this node in the tree (root = 0).

func (*TreeNode) Parent 

func (n *TreeNode) Parent() *TreeNode

Parent returns the parent node (nil for root).

type TreeNodeID 

type TreeNodeID = id.ID[TreeNodeIDBrand, string]

TreeNodeID is a branded identifier for tree nodes.

type TreeNodeIDBrand 

type TreeNodeIDBrand struct{}

TreeNodeIDBrand is the brand type for tree node IDs.

type TreeNodeIDFunc 

type TreeNodeIDFunc func(*TreeNode) string

TreeNodeIDFunc resolves a TreeNode's ID for a specific graph format.

type TreeNodeLabel 

type TreeNodeLabel = id.ID[TreeNodeLabelBrand, string]

TreeNodeLabel is a branded identifier for tree node labels.

type TreeNodeLabelBrand 

type TreeNodeLabelBrand struct{}

TreeNodeLabelBrand is the brand type for tree node labels.

type TreeOutputRenderer 

type TreeOutputRenderer interface {
	Renderer
	// SetRoot sets the root node of the tree.
	SetRoot(node *TreeNode)
}

TreeOutputRenderer defines the interface for tree format renderers.

type XMLWriter 

type XMLWriter struct {
	Writer io.Writer
}

XMLWriter writes XML output to an io.Writer.

func NewXMLWriter 

func NewXMLWriter(w io.Writer) *XMLWriter

NewXMLWriter creates a new XMLWriter.

func (*XMLWriter) WriteFooter 

func (x *XMLWriter) WriteFooter() error

WriteFooter writes the closing tags.

func (*XMLWriter) WriteHeader 

func (x *XMLWriter) WriteHeader(cols []string) error

WriteHeader writes the XML header and opening tags.

func (*XMLWriter) WriteRow 

func (x *XMLWriter) WriteRow(values []string) error

WriteRow writes a single row.

func (*XMLWriter) WriteRows 

func (x *XMLWriter) WriteRows(values [][]string) error

WriteRows writes multiple rows.

Source Files

View all Source files

Directories

Path Synopsis
d2 module
daghtml module
delimited module
enum module
envdetect module
escape module
graph module
internal
gentest
testutils
markdown module
markup module
nom module
plantuml module
sort module
table module
testhelpers module
graphtest module
tree module
tui module

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.