Icon Manipulation

Every fluent method on *Icon returns a new instance with deep-copied attributes, so the original is never modified and the same base icon can safely produce multiple variants.

Immutability

Branching from the same base icon produces independent copies:

1
import swarmicons "github.com/frostybee/go-swarm-icons"
2
3
base := swarmicons.New("<path/>", nil)
4
red := base.Fill("red")
5
blue := base.Fill("blue")
6
7
// red has fill="red", blue has fill="blue", base has no fill.

Fluent methods

All methods return a new *Icon. Chain them freely.

Method	Signature	Effect
`Size`	`Size(size int) *Icon`	Sets both `width` and `height` to the same value.
`Width`	`Width(w string) *Icon`	Sets width, derives height from viewBox aspect ratio. Supports CSS units and special values.
`Height`	`Height(h string) *Icon`	Sets height, derives width from viewBox aspect ratio. Same special values as `Width`.
`Class`	`Class(classes ...string) *Icon`	Appends CSS classes to any existing `class` attribute. Does not replace.
`Fill`	`Fill(fill string) *Icon`	Sets the `fill` attribute.
`Stroke`	`Stroke(stroke string) *Icon`	Sets the `stroke` attribute.
`StrokeWidth`	`StrokeWidth(w string) *Icon`	Sets the `stroke-width` attribute.
`Opacity`	`Opacity(o float64) *Icon`	Sets the `opacity` attribute.
`Rotate`	`Rotate(degrees float64) *Icon`	Appends a CSS `rotate(Xdeg)` to the `style` transform.
`Flip`	`Flip(direction string) *Icon`	Appends a CSS scale transform. Accepts `"h"`, `"v"`, `"horizontal"`, `"vertical"`, or `"both"`.
`Title`	`Title(title string) *Icon`	Prepends a `<title>` element (HTML-escaped) for screen-reader accessibility.
`Attr`	`Attr(attrs map[string]string) *Icon`	Merges arbitrary attributes. Empty-string values are ignored.

Chaining

1
import (
2
    "fmt"
3
4
    swarmicons "github.com/frostybee/go-swarm-icons"
5
    "github.com/frostybee/go-swarm-icons/lucide"
6
)
7
8
func main() {
9
    manager := swarmicons.Default("lucide", lucide.Provider())
10
    icon, _ := manager.Get("star")
11
12
    html := icon.Size(24).Class("text-blue").Fill("currentColor").ToHTML()
13
    fmt.Println(html)
14
}

Sizing

`Size` (square)

Size(32) sets both width and height to "32":

1
icon.Size(32).ToHTML()
2
// width="32" height="32"

`Width` and `Height` (aspect-ratio aware)

Width and Height derive the other dimension from the icon's viewBox aspect ratio. They support CSS units:

1
// viewBox is "0 0 20 30" (aspect ratio 2:3)
2
icon.Width("32")    // width="32" height="48"
3
icon.Width("1em")   // width="1em" height="1.5em"
4
icon.Height("48")   // width="32" height="48"

Special values:

Value	Effect
`"auto"`	Resolves to the viewBox width and height.
`"unset"`, `"none"`, `"undefined"`	Removes both `width` and `height` attributes.

1
icon.Width("auto")   // width and height set to viewBox dimensions
2
icon.Width("unset")  // both width and height removed

Rotation and flipping

Rotate and Flip both append CSS transform functions to the style attribute. Chaining them produces a single transform declaration:

1
icon.Rotate(90).Flip("h")
2
// style="transform: rotate(90deg) scaleX(-1)"

The order matters. Rotate(90).Flip("h") applies rotation first, then the flip. Reversing the call order reverses the transform order:

1
icon.Flip("v").Rotate(45)
2
// style="transform: scaleY(-1) rotate(45deg)"

Existing style declarations are preserved. The transform is appended to the existing style string:

1
icon.Attr(map[string]string{"style": "color: red"}).Rotate(90)
2
// style="color: red; transform: rotate(90deg)"

Flip directions

Direction	CSS transform
`"h"` or `"horizontal"`	`scaleX(-1)`
`"v"` or `"vertical"`	`scaleY(-1)`
`"both"`	`scale(-1, -1)`
Any other value	Defaults to `scaleX(-1)`

Accessibility with `Title`

Title prepends a <title> element to the SVG content. The value is HTML-escaped to prevent injection:

1
icon.Title("Home")
2
// <svg ...><title>Home</title><path .../></svg>

Setting a title affects ARIA behavior during attribute rendering: icons with a title that receive an aria-label attribute get role="img" instead of aria-hidden="true". See Attribute Management for the full ARIA injection rules.

Arbitrary attributes with `Attr`

Attr merges a map of key-value pairs into the icon's attributes. Empty-string values are skipped:

1
icon.Attr(map[string]string{
2
    "data-icon": "home",
3
    "tabindex":  "0",
4
    "fill":      "",  // ignored, does not overwrite existing fill
5
})

Output methods

Method	Returns	Description
`ToHTML()`	`string`	Complete `<svg>` element with attributes and inner content.
`String()`	`string`	Same as `ToHTML()`. Implements `fmt.Stringer`.
`Content()`	`string`	SVG inner content without the `<svg>` wrapper.
`Attributes()`	`map[string]string`	Deep copy of the attribute map.
`IsEmpty()`	`bool`	`true` if the icon has no inner content.
`ViewBox()`	`(minX, minY, w, h int)`	Parses the viewBox attribute. Falls back to width/height. Returns `0,0,0,0` if neither is set.
`ViewBoxSize()`	`(w, h int)`	Width and height from the viewBox.

Attribute names are validated against the regex ^[a-zA-Z_:][\w:.\-]*$. Invalid names are silently dropped from ToHTML() output. Attribute values are always HTML-escaped.