charts.layout

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune

/// The rectangle left for data once the margins are taken off the chart.
///
/// # Panics
/// Panics on a negative margin or margins that leave no room.
pub fn plot_area(width: f64, height: f64, margins: &Margins) -> PlotArea {
    let (top, right, bottom, left) = (margins.top, margins.right, margins.bottom, margins.left);
    if !(top >= 0.0 && right >= 0.0 && bottom >= 0.0 && left >= 0.0) {
        panic!("margins must not be negative");
    }
    let w = width - left - right;
    let h = height - top - bottom;
    // A zero or negative plot would draw nothing, or draw everything flipped.
    if !(w > 0.0 && h > 0.0) {
        panic!("margins leave no room to plot: {} x {} less margins is {} x {}", width, height, w, h);
    }
    PlotArea { x: round_float(left, 2), y: round_float(top, 2), width: round_float(w, 2), height: round_float(h, 2) }
}

pub fn plot_area_to_value(p: &PlotArea) -> Value {
    Value::obj(vec![
        ("x", Value::Float(p.x)),
        ("y", Value::Float(p.y)),
        ("width", Value::Float(p.width)),
        ("height", Value::Float(p.height)),
    ])
}

pub fn margins_from_value(v: &Value) -> Margins {
    Margins {
        top: v.get("top").as_f64(),
        right: v.get("right").as_f64(),
        bottom: v.get("bottom").as_f64(),
        left: v.get("left").as_f64(),
    }
}

pub fn fune_vector(args: &[Value]) -> Value {
    plot_area_to_value(&plot_area(args[0].as_f64(), args[1].as_f64(), &margins_from_value(&args[2])))
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune

// Space between the swatch and its text.
const SWATCH_PADDING: f64 = 4.0;

/// Legend items left to right, wrapping when the next would pass max_width.
/// Text width is estimated as code points times char_width; no font is
/// measured, so the answer is the same in every language.
///
/// # Panics
/// Panics if max_width is not positive or any other size is negative.
pub fn legend_rows(
    labels: &[String],
    max_width: f64,
    char_width: f64,
    swatch_size: f64,
    gap: f64,
    row_height: f64,
) -> Vec<LegendItem> {
    if !(max_width > 0.0) {
        panic!("maxWidth must be greater than zero, received {}", max_width);
    }
    if !(char_width >= 0.0 && swatch_size >= 0.0 && gap >= 0.0 && row_height >= 0.0) {
        panic!("legend sizes must not be negative");
    }
    let mut items = Vec::new();
    let mut row: i64 = 0;
    let mut x = 0.0;
    let mut on_row = 0;
    for label in labels {
        let width = swatch_size + SWATCH_PADDING + label.chars().count() as f64 * char_width;
        if on_row > 0 && x + width > max_width {
            row += 1;
            x = 0.0;
            on_row = 0;
        }
        items.push(LegendItem {
            label: label.clone(),
            row,
            x: round_float(x, 2),
            y: round_float(row as f64 * row_height, 2),
            width: round_float(width, 2),
            text_x: round_float(x + swatch_size + SWATCH_PADDING, 2),
        });
        x = x + width + gap;
        on_row += 1;
    }
    items
}

pub fn legend_item_to_value(item: &LegendItem) -> Value {
    Value::obj(vec![
        ("label", Value::str(&item.label)),
        ("row", Value::Int(item.row)),
        ("x", Value::Float(item.x)),
        ("y", Value::Float(item.y)),
        ("width", Value::Float(item.width)),
        ("textX", Value::Float(item.text_x)),
    ])
}

pub fn fune_vector(args: &[Value]) -> Value {
    let labels: Vec<String> = args[0].as_arr().iter().map(|v| v.as_str().to_string()).collect();
    let items = legend_rows(
        &labels,
        args[1].as_f64(),
        args[2].as_f64(),
        args[3].as_f64(),
        args[4].as_f64(),
        args[5].as_f64(),
    );
    Value::Arr(items.iter().map(legend_item_to_value).collect())
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

/// Which labels to show so none overlap: greedily, highest priority first
/// (then input order), keeping a label only if it clears every kept label by
/// at least padding. Touching is not overlapping. Result in input order.
///
/// # Panics
/// Panics on a negative padding or a box with negative size.
pub fn avoid_collisions(boxes: &[LabelBox], padding: f64) -> Vec<bool> {
    if !(padding >= 0.0) {
        panic!("padding must not be negative, received {}", padding);
    }
    for b in boxes {
        if !(b.width >= 0.0 && b.height >= 0.0) {
            panic!("label boxes must not have negative size");
        }
    }
    let mut order: Vec<usize> = (0..boxes.len()).collect();
    order.sort_by(|&a, &b| boxes[b].priority.cmp(&boxes[a].priority).then(a.cmp(&b)));
    let mut shown = vec![false; boxes.len()];
    let mut kept: Vec<&LabelBox> = Vec::new();
    for i in order {
        let a = &boxes[i];
        let clash = kept.iter().any(|k| {
            a.x < k.x + k.width + padding
                && k.x < a.x + a.width + padding
                && a.y < k.y + k.height + padding
                && k.y < a.y + a.height + padding
        });
        if !clash {
            kept.push(a);
            shown[i] = true;
        }
    }
    shown
}

pub fn fune_vector(args: &[Value]) -> Value {
    let boxes: Vec<LabelBox> = args[0]
        .as_arr()
        .iter()
        .map(|b| LabelBox {
            x: b.get("x").as_f64(),
            y: b.get("y").as_f64(),
            width: b.get("width").as_f64(),
            height: b.get("height").as_f64(),
            priority: b.get("priority").as_i64(),
        })
        .collect();
    Value::Arr(avoid_collisions(&boxes, args[1].as_f64()).into_iter().map(Value::Bool).collect())
}