svg_path/stroke

Stroke outline construction.

This module turns path geometry into filled outline paths. It delegates the topology work to svg_path/offset, where strokes share the same self-intersection pruning machinery as offset bands. It also exposes SVG-style dash extraction: turning a continuous path into the open subpaths that would be stroked as visible dashes.

Types

Cap

</>

Cap style used at open subpath endpoints.

pub type Cap {
  Butt
  Round
  Square
}

Constructors

```
Butt
```
Connect the two offset sides directly at the endpoint.
```
Round
```
Add a half-circle cap at the endpoint.
```
Square
```
Extend the stroke by half the stroke width before capping.

DashOptions

</>

Options for SVG-style dash extraction.

Dash lengths are already-resolved user-coordinate lengths. CSS parsing, percentages, and pathLength scaling are intentionally outside this type. Empty patterns and all-zero patterns behave like stroke-dasharray: none.

pub type DashOptions {
  DashOptions(
    pattern: List(Float),
    offset: Float,
    length: svg_path.LengthOptions,
  )
}

Constructors

DashOptions(
  pattern: List(Float),
  offset: Float,
  length: svg_path.LengthOptions,
)

Error

</>

Errors returned by stroke helpers.

pub type Error {
  PathError(svg_path.Error)
  OffsetError(offset.Error)
  InvalidWidth(width: Float)
  InvalidDashLength(length: Float)
  InvalidDashOffset(offset: Float)
}

Constructors

```
PathError(svg_path.Error)
```
An underlying path operation failed.
```
OffsetError(offset.Error)
```
An underlying offset operation failed.
```
InvalidWidth(width: Float)
```
Stroke width must be greater than zero.
```
InvalidDashLength(length: Float)
```
Dash lengths must be finite and non-negative.
```
InvalidDashOffset(offset: Float)
```
Dash offset must be finite.

Options

</>

Options for stroke outline construction.

pub type Options {
  Options(width: Float, cap: Cap, offset: offset.Options)
}

Constructors

Options(width: Float, cap: Cap, offset: offset.Options)

Values

default_dash_options

</>

pub fn default_dash_options(
  pattern pattern: List(Float),
  offset offset: Float,
) -> DashOptions

Return default dash extraction options for a pattern and dash offset.

pattern and offset are interpreted as resolved user-coordinate lengths.

default_options

</>

pub fn default_options() -> Options

Return default stroke options.

path

</>

pub fn path(
  path: svg_path.Path,
  width width: Float,
) -> Result(svg_path.Path, Error)

Stroke every subpath in a path using default options with the given width.

path_dashed

</>

pub fn path_dashed(
  path: svg_path.Path,
  width width: Float,
  pattern pattern: List(Float),
  offset offset: Float,
) -> Result(svg_path.Path, Error)

Stroke a path after applying SVG dasharray semantics to each subpath.

The dash pattern resets at the start of each subpath.

path_dashed_with

</>

pub fn path_dashed_with(
  path path: svg_path.Path,
  options options: Options,
  dash_options dash_options: DashOptions,
) -> Result(svg_path.Path, Error)

Stroke a path after applying SVG dasharray semantics using explicit stroke and dash options.

The dash pattern resets at the start of each subpath.

path_dashes

</>

pub fn path_dashes(
  path: svg_path.Path,
  pattern pattern: List(Float),
  offset offset: Float,
) -> Result(svg_path.Path, Error)

Return the visible dash pieces of every subpath in a path.

The dash pattern resets at the start of each subpath.

path_dashes_with

</>

pub fn path_dashes_with(
  path path: svg_path.Path,
  dash_options dash_options: DashOptions,
) -> Result(svg_path.Path, Error)

Return the visible dash pieces of every subpath in a path using explicit dash options.

The dash pattern resets at the start of each subpath.

path_with

</>

pub fn path_with(
  path path: svg_path.Path,
  options options: Options,
) -> Result(svg_path.Path, Error)

Stroke every subpath in a path using explicit options.

segment

</>

pub fn segment(
  segment: svg_path.Segment,
  width width: Float,
) -> Result(svg_path.Path, Error)

Stroke a segment using default options with the given width.

segment_with

</>

pub fn segment_with(
  segment segment: svg_path.Segment,
  options options: Options,
) -> Result(svg_path.Path, Error)

Stroke a segment using explicit options.

subpath

</>

pub fn subpath(
  subpath: svg_path.Subpath,
  width width: Float,
) -> Result(svg_path.Path, Error)

Stroke a subpath using default options with the given width.

subpath_dashed

</>

pub fn subpath_dashed(
  subpath: svg_path.Subpath,
  width width: Float,
  pattern pattern: List(Float),
  offset offset: Float,
) -> Result(svg_path.Path, Error)

Stroke a subpath after applying SVG dasharray semantics.

This first extracts open dash subpaths, then strokes each dash independently.

subpath_dashed_with

</>

pub fn subpath_dashed_with(
  subpath subpath: svg_path.Subpath,
  options options: Options,
  dash_options dash_options: DashOptions,
) -> Result(svg_path.Path, Error)

Stroke a subpath after applying SVG dasharray semantics using explicit stroke and dash options.

This first extracts open dash subpaths, then strokes each dash independently.

subpath_dashes

</>

pub fn subpath_dashes(
  subpath: svg_path.Subpath,
  pattern pattern: List(Float),
  offset offset: Float,
) -> Result(List(svg_path.Subpath), Error)

Return the visible dash pieces of a subpath using SVG dasharray semantics.

Each returned dash is an open subpath preserving the original segment types where possible. Empty and all-zero patterns return the original continuous subpath as a singleton when the subpath has positive length. An active dash pattern on a closed subpath has a visible seam: a dash covering the whole closed subpath is opened at the subpath start so cap styles can apply there.

subpath_dashes_with

</>

pub fn subpath_dashes_with(
  subpath subpath: svg_path.Subpath,
  dash_options dash_options: DashOptions,
) -> Result(List(svg_path.Subpath), Error)

Return the visible dash pieces of a subpath using explicit dash options.

subpath_with

</>

pub fn subpath_with(
  subpath subpath: svg_path.Subpath,
  options options: Options,
) -> Result(svg_path.Path, Error)

Stroke a subpath using explicit options.