From d40df118aa13634d849e3f8845988ffeb34ca4b8 Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Thu, 3 Jul 2025 15:23:55 -0700
Subject: [PATCH 01/23] Add Phoenix Playground demo file

---
 demo_live.exs | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 122 insertions(+)
 create mode 100644 demo_live.exs

diff --git a/demo_live.exs b/demo_live.exs
new file mode 100644
index 0000000..b031e41
--- /dev/null
+++ b/demo_live.exs
@@ -0,0 +1,122 @@
+Mix.install([
+  {:phoenix_playground, "~> 0.1.6"},
+  {:plox, path: "."}
+])
+
+defmodule DemoLive do
+  @moduledoc """
+  Example graph rendered within a Phoenix Playground application.
+  """
+  use Phoenix.LiveView
+
+  import Plox
+
+  @impl Phoenix.LiveView
+  def mount(_params, _session, socket) do
+    {:ok, mount_simple_line_graph(socket)}
+  end
+
+  @impl Phoenix.LiveView
+  def render(assigns) do
+    ~H"""
+    <.simple_line_graph simple_graph={@simple_graph} clicked_point={@clicked_point} />
+    """
+  end
+
+  @impl Phoenix.LiveView
+  def handle_event(
+        "toggle_tooltip",
+        %{"id" => point_id, "dataset_id" => dataset_id, "x_pixel" => x_pixel, "y_pixel" => y_pixel},
+        socket
+      ) do
+    {:noreply,
+     assign(socket,
+       clicked_point: %{
+         id: point_id,
+         dataset_id: String.to_existing_atom(dataset_id),
+         x_pixel: x_pixel,
+         y_pixel: y_pixel
+       }
+     )}
+  end
+
+  def handle_event("toggle_tooltip", _params, socket), do: {:noreply, assign(socket, clicked_point: nil)}
+
+  defp mount_simple_line_graph(socket) do
+    simple_data = [
+      %{date: ~D[2023-08-01], value: 45.0},
+      %{date: ~D[2023-08-02], value: 40.0},
+      %{date: ~D[2023-08-03], value: 35.0},
+      %{date: ~D[2023-08-04], value: 60.0},
+      %{date: ~D[2023-08-04], value: 10.0},
+      %{date: ~D[2023-08-05], value: 15.0},
+      %{date: ~D[2023-08-06], value: 25.0},
+      %{date: ~D[2023-08-07], value: 20.0},
+      %{date: ~D[2023-08-08], value: 10.0}
+    ]
+
+    date_scale = date_scale(Date.range(~D[2023-08-01], ~D[2023-08-08]))
+    number_scale = number_scale(0.0, 80.0)
+
+    dataset =
+      dataset(simple_data,
+        x: {date_scale, & &1.date},
+        y: {number_scale, & &1.value}
+      )
+
+    assign(socket,
+      simple_graph:
+        to_graph(
+          scales: [date_scale: date_scale, number_scale: number_scale],
+          datasets: [dataset: dataset]
+        ),
+      clicked_point: nil
+    )
+  end
+
+  defp simple_line_graph(assigns) do
+    ~H"""
+    <h2>Simple line graph with legend and tooltips</h2>
+
+    <.graph :let={graph} id="simple_graph" for={@simple_graph} width="800" height="250">
+      <:legend>
+        <.legend_item color="orange" label="data" />
+        <.legend_item color="green" label="more data" />
+      </:legend>
+
+      <:tooltips :let={graph}>
+        <.tooltip
+          :let={%{value: value, date: date}}
+          :if={!is_nil(@clicked_point)}
+          dataset={graph[@clicked_point.dataset_id]}
+          point_id={@clicked_point.id}
+          x_pixel={@clicked_point.x_pixel}
+          y_pixel={@clicked_point.y_pixel}
+          phx-click-away="toggle_tooltip"
+        >
+          <p>date: {date}</p>
+          <p>value: {value}</p>
+        </.tooltip>
+      </:tooltips>
+
+      <.x_axis :let={date} scale={graph[:date_scale]}>
+        {Calendar.strftime(date, "%-m/%-d")}
+      </.x_axis>
+
+      <.y_axis :let={value} scale={graph[:number_scale]} ticks={5}>
+        {value}
+      </.y_axis>
+
+      <.line_plot dataset={graph[:dataset]} />
+
+      <.points_plot dataset={graph[:dataset]} phx-click="toggle_tooltip" />
+
+      <.marker at={~D[2023-08-03]} scale={graph[:date_scale]}>
+        Important date!
+      </.marker>
+    </.graph>
+    """
+  end
+end
+
+PhoenixPlayground.start(live: DemoLive)

From 49f6ff1e8e6385c7fd189757771baefc2a6a936c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Chris=20Dos=C3=A9?= <chris@xn--dos-dma.com>
Date: Mon, 26 Aug 2024 09:45:35 -0700
Subject: [PATCH 02/23] Handle scale value conversions with Axes + Separate out
 Dimensions

---
 lib/plox.ex             | 635 +++++++++++++++++++++-------------------
 lib/plox/axis.ex        |  25 ++
 lib/plox/color_axis.ex  |  22 ++
 lib/plox/data_point.ex  |  40 +--
 lib/plox/dataset.ex     |  33 ++-
 lib/plox/dimensions.ex  |  13 +-
 lib/plox/graph.ex       |  40 ---
 lib/plox/graph_scale.ex |  26 +-
 lib/plox/linear_axis.ex |  26 ++
 lib/plox/x_axis.ex      |  29 ++
 lib/plox/y_axis.ex      |  29 ++
 11 files changed, 532 insertions(+), 386 deletions(-)
 create mode 100644 lib/plox/axis.ex
 create mode 100644 lib/plox/color_axis.ex
 delete mode 100644 lib/plox/graph.ex
 create mode 100644 lib/plox/linear_axis.ex
 create mode 100644 lib/plox/x_axis.ex
 create mode 100644 lib/plox/y_axis.ex

diff --git a/lib/plox.ex b/lib/plox.ex
index 447bbe6..38f0544 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -6,215 +6,356 @@ defmodule Plox do
   use Phoenix.Component
 
   alias Phoenix.LiveView.JS
+  alias Plox.Axis
   alias Plox.Dataset
   alias Plox.DateScale
   alias Plox.DateTimeScale
   alias Plox.Dimensions
   alias Plox.FixedColorsScale
   alias Plox.FixedValuesScale
-  alias Plox.Graph
   alias Plox.GraphDataset
   alias Plox.GraphScale
   alias Plox.NumberScale
+  alias Plox.Scale
+  alias Plox.XAxis
+  alias Plox.YAxis
+
+  # copied from SVG spec: https://svgwg.org/svg2-draft/styling.html#TermPresentationAttribute
+  @svg_presentation_globals ~w(alignment-baseline baseline-shift clip-path clip-rule color color-interpolation color-interpolation-filters cursor direction display dominant-baseline fill-opacity fill-rule filter flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-orientation-horizontal glyph-orientation-vertical image-rendering letter-spacing lighting-color marker-end marker-mid marker-start mask mask-type opacity overflow paint-order pointer-events shape-rendering stop-color stop-opacity stroke stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-overflow text-rendering transform-origin unicode-bidi vector-effect visibility white-space word-spacing writing-mode)
 
   @doc """
-  Entrypoint component for rendering graphs and plots
+  Entrypoint component for rendering graphs and plots.
   """
   @doc type: :component
 
-  attr :for, Graph, required: true
-
-  attr :id, :string, required: true
-  attr :width, :any, required: true, doc: "The total width of the rendered graph in pixels"
-  attr :height, :any, required: true, doc: "The total height of the rendered graph in pixels"
-
-  attr :margin, :any,
-    default: {35, 70},
-    doc: """
-    The amount of space around the plotting area of the graph in which the axis labels are
-    rendered. Accepts one, two, three or four values and interprets them the same was as in
-    CSS.
-    """
-
-  attr :padding, :any,
-    default: 0,
-    doc: """
-    The amount of space inside the plotting area of the graph from the edges to where plotting
-    begins. Accepts one, two, three or four values and interprets them the same was as in CSS.
-    """
+  attr :dimensions, Dimensions, required: true
+  # FIXME:
+  attr :rest, :global
 
   slot :legend
   slot :tooltips
   slot :inner_block, required: true
 
   def graph(assigns) do
-    assigns =
-      assign(assigns,
-        for: nil,
-        graph: Graph.put_dimensions(assigns.for, Dimensions.new(assigns))
-      )
+    # assigns =
+    #   assign(assigns,
+    #     for: nil,
+    #     graph: Graph.put_dimensions(assigns.for, Dimensions.new(assigns))
+    #   )
 
     ~H"""
-    <div id={@id}>
-      <div style={"display: flex; flex-direction: column; align-items: flex-end; max-width: #{@graph.dimensions.width - @graph.dimensions.margin.right}px"}>
+    <div {@rest}>
+      <%!-- <div style={"display: flex; flex-direction: column; align-items: flex-end; max-width: #{@graph.width - @graph.margin.right}px"}>
         <.legend :for={legend <- @legend}>
           {render_slot(legend)}
         </.legend>
-      </div>
-      <div style={"position: relative; width: #{@width}px; height: #{@height}px"}>
-        <svg viewBox={"0 0 #{@width} #{@height}"} xmlns="http://www.w3.org/2000/svg">
-          {render_slot(@inner_block, @graph)}
+      </div> --%>
+      <div style={"position: relative; width: #{@dimensions.width}px; height: #{@dimensions.height}px"}>
+        <svg
+          viewBox={"0 0 #{@dimensions.width} #{@dimensions.height}"}
+          xmlns="http://www.w3.org/2000/svg"
+        >
+          {render_slot(@inner_block)}
         </svg>
-
-        <%= for tooltip <- @tooltips do %>
-          {render_slot(tooltip, @graph)}
-        <% end %>
+        <%!-- <%= for tooltip <- @tooltips do %>
+          <%= render_slot(tooltip) %>
+        <% end %> --%>
       </div>
     </div>
     """
   end
 
   @doc """
-  Y-axis labels along the left or right side of the graph
+  X-axis labels along the bottom or top of the graph.
+
+  See `x_axis_label/1` for more details on the accepted attributes.
   """
   @doc type: :component
 
-  attr :scale, :any, required: true
+  attr :axis, XAxis, required: true
   attr :ticks, :any
   attr :step, :any
+  attr :rest, :global, include: ~w(gap rotation position) ++ @svg_presentation_globals
 
-  attr :position, :atom, values: [:left, :right], default: :left
+  slot :inner_block, required: true
 
-  attr :label_color, :string, default: "#18191A"
-  attr :label_rotation, :integer, default: nil
+  def x_axis_labels(assigns) do
+    ~H"""
+    <%= for value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step])) do %>
+      <.x_axis_label axis={@axis} value={value} {@rest}>
+        {render_slot(@inner_block, value)}
+      </.x_axis_label>
+    <% end %>
+    """
+  end
 
-  attr :grid_lines, :boolean, default: true
-  attr :line_width, :string, default: "1"
-  attr :line_color, :string, default: "#F2F4F5"
+  @doc """
+  An X-axis label at the bottom or top of the graph.
+  """
+  @doc type: :component
+
+  attr :axis, XAxis, required: true
+  attr :value, :any, required: true
+  attr :position, :atom, values: [:top, :bottom], default: :bottom
+  attr :gap, :integer, default: 16
+  attr :rotation, :integer, default: nil
+  attr :"dominant-baseline", :any, default: nil
+  attr :"text-anchor", :any, default: nil
+  attr :rest, :global, include: @svg_presentation_globals
 
   slot :inner_block, required: true
 
-  def y_axis(assigns) do
+  def x_axis_label(%{position: :bottom} = assigns) do
     ~H"""
-    <%= for y_value <- GraphScale.values(@scale, scale_opts(assigns)), y_pixel = GraphScale.to_graph_y(@scale, y_value) do %>
-      <.y_label
-        dimensions={@scale.dimensions}
-        y_pixel={y_pixel}
-        position={@position}
-        color={@label_color}
-        rotation={@label_rotation}
-      >
-        {render_slot(@inner_block, y_value)}
-      </.y_label>
-      <.horizontal_line
-        :if={@grid_lines}
-        dimensions={@scale.dimensions}
-        y_pixel={y_pixel}
-        width={@line_width}
-        color={@line_color}
-      />
-    <% end %>
+    <text
+      x={x = Axis.to_graph(@axis, @value)}
+      y={@axis.dimensions.height - @axis.dimensions.margin.bottom + @gap}
+      dominant-baseline={assigns[:"dominant-baseline"] || "hanging"}
+      text-anchor={assigns[:"text-anchor"] || "middle"}
+      transform={
+        if @rotation,
+          do:
+            "rotate(#{@rotation}, #{x}, #{@axis.dimensions.height - @axis.dimensions.margin.bottom + @gap})"
+      }
+      {@rest}
+    >
+      {render_slot(@inner_block)}
+    </text>
+    """
+  end
+
+  def x_axis_label(%{position: :top} = assigns) do
+    ~H"""
+    <text
+      x={x = Axis.to_graph(@axis, @value)}
+      y={@axis.dimensions.margin.bottom - @gap}
+      dominant-baseline={assigns[:"dominant-baseline"] || "text-bottom"}
+      text-anchor={assigns[:"text-anchor"] || "middle"}
+      transform={
+        if @rotation,
+          do: "rotate(#{@rotation}, #{x}, #{@axis.dimensions.margin.bottom - @gap})"
+      }
+      {@rest}
+    >
+      {render_slot(@inner_block)}
+    </text>
     """
   end
 
   @doc """
-  X-axis labels along the bottom or top of the graph
+  Y-axis labels along the left or right side of the graph.
+
+  See `y_axis_label/1` for more details on the accepeted attributes.
   """
   @doc type: :component
 
-  attr :scale, :any, required: true
+  attr :axis, YAxis, required: true
   attr :ticks, :any
   attr :step, :any
+  attr :rest, :global, include: ~w(gap rotation position) ++ @svg_presentation_globals
 
-  attr :position, :atom, values: [:top, :bottom], default: :bottom
+  slot :inner_block, required: true
 
-  attr :label_color, :string, default: "#18191A"
-  attr :label_rotation, :integer, default: nil
+  def y_axis_labels(assigns) do
+    ~H"""
+    <%= for value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step])) do %>
+      <.y_axis_label axis={@axis} value={value} {@rest}>
+        {render_slot(@inner_block, value)}
+      </.y_axis_label>
+    <% end %>
+    """
+  end
+
+  @doc """
+  A Y-axis label at the left or right side of the graph.
+  """
+  @doc type: :component
 
-  attr :grid_lines, :boolean, default: true
-  attr :line_width, :string, default: "1"
-  attr :line_color, :string, default: "#F2F4F5"
+  attr :axis, YAxis, required: true
+  attr :value, :any, required: true
+  attr :position, :atom, values: [:left, :right], default: :left
+  attr :gap, :integer, default: 16
+  attr :rotation, :integer, default: nil
+  attr :"dominant-baseline", :any, default: nil
+  attr :"text-anchor", :any, default: nil
+  attr :rest, :global, include: @svg_presentation_globals
 
   slot :inner_block, required: true
 
-  def x_axis(assigns) do
+  def y_axis_label(%{position: :left} = assigns) do
     ~H"""
-    <%= for x_value <- GraphScale.values(@scale, scale_opts(assigns)), x_pixel = GraphScale.to_graph_x(@scale, x_value) do %>
-      <.x_label
-        dimensions={@scale.dimensions}
-        x_pixel={x_pixel}
-        position={@position}
-        color={@label_color}
-        rotation={@label_rotation}
-      >
-        {render_slot(@inner_block, x_value)}
-      </.x_label>
-      <.vertical_line
-        :if={@grid_lines}
-        dimensions={@scale.dimensions}
-        x_pixel={x_pixel}
-        width={@line_width}
-        color={@line_color}
-      />
-    <% end %>
+    <text
+      x={@axis.dimensions.margin.left - @gap}
+      y={y = Axis.to_graph(@axis, @value)}
+      dominant-baseline={assigns[:"dominant-baseline"] || "middle"}
+      text-anchor={assigns[:"text-anchor"] || "end"}
+      transform={
+        if @rotation,
+          do: "rotate(#{@rotation}, #{@axis.dimensions.margin.left - @gap}, #{y})"
+      }
+      {@rest}
+    >
+      {render_slot(@inner_block)}
+    </text>
     """
   end
 
-  defp scale_opts(assigns), do: Map.take(assigns, [:ticks, :step])
+  def y_axis_label(%{position: :right} = assigns) do
+    ~H"""
+    <text
+      x={@axis.dimensions.width - @axis.dimensions.margin.right + @gap}
+      y={y = Axis.to_graph(@axis, @value)}
+      dominant-baseline={assigns[:"dominant-baseline"] || "middle"}
+      text-anchor={assigns[:"text-anchor"] || "start"}
+      transform={
+        if @rotation,
+          do:
+            "rotate(#{@rotation}, #{@axis.dimensions.width - @axis.dimensions.margin.right + @gap}, #{y})"
+      }
+      {@rest}
+    >
+      {render_slot(@inner_block)}
+    </text>
+    """
+  end
 
   @doc """
-  A connected line plot
+  X-axis grid lines.
   """
   @doc type: :component
 
-  attr :dataset, :any, required: true
+  attr :axis, XAxis, required: true
+  attr :ticks, :any
+  attr :step, :any
+  attr :rest, :global, include: @svg_presentation_globals
 
-  attr :x, :atom, default: :x, doc: "The dataset axis key to use for x values"
-  attr :y, :atom, default: :y, doc: "The dataset axis key to use for y values"
+  def x_axis_grid_lines(assigns) do
+    ~H"""
+    <%= for value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step])) do %>
+      <.x_axis_grid_line axis={@axis} value={value} {@rest} />
+    <% end %>
+    """
+  end
+
+  @doc """
+  A single X-axis grid line.
+  """
+  @doc type: :component
 
-  attr :width, :string, examples: ["1.5", "4"], default: "2"
-  attr :line_style, :atom, values: [:solid, :dashed, :dotted], default: :solid
-  attr :color, :string, default: "#FF9330"
-  attr :type, :atom, values: [:line, :step_line], default: :line
+  attr :axis, XAxis, required: true
+  attr :value, :any, required: true
+  attr :top_overdraw, :integer, default: 0
+  attr :bottom_overdraw, :integer, default: 0
+  attr :rest, :global, include: @svg_presentation_globals
 
-  def line_plot(%{type: :line} = assigns) do
+  def x_axis_grid_line(assigns) do
     ~H"""
-    <polyline
-      points={@dataset |> GraphDataset.to_graph_points(@x, @y) |> polyline_points()}
-      fill="none"
-      stroke={@color}
-      stroke-width={@width}
-      stroke-dasharray={stroke_dasharray(@line_style)}
+    <line
+      x1={x = Axis.to_graph(@axis, @value)}
+      y1={@axis.dimensions.margin.top - @top_overdraw}
+      x2={x}
+      y2={@axis.dimensions.height - @axis.dimensions.margin.bottom + @bottom_overdraw}
+      {@rest}
     />
     """
   end
 
-  def line_plot(%{type: :step_line} = assigns) do
+  @doc """
+  Y-axis grid lines.
+  """
+  @doc type: :component
+
+  attr :axis, YAxis, required: true
+  attr :ticks, :any
+  attr :step, :any
+  attr :rest, :global, include: @svg_presentation_globals
+
+  def y_axis_grid_lines(assigns) do
+    ~H"""
+    <%= for value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step])) do %>
+      <.y_axis_grid_line axis={@axis} value={value} {@rest} />
+    <% end %>
+    """
+  end
+
+  @doc """
+  A single Y-axis grid line.
+  """
+  @doc type: :component
+
+  attr :axis, YAxis, required: true
+  attr :value, :any, required: true
+  attr :rest, :global, include: @svg_presentation_globals
+
+  def y_axis_grid_line(assigns) do
     ~H"""
-    <polyline
-      points={@dataset |> step_points(@x, @y) |> polyline_points()}
-      fill="none"
-      stroke={@color}
-      stroke-width={@width}
-      stroke-dasharray={stroke_dasharray(@line_style)}
+    <line
+      x1={@axis.dimensions.margin.left}
+      y1={y = Axis.to_graph(@axis, @value)}
+      x2={@axis.dimensions.width - @axis.dimensions.margin.right}
+      y2={y}
+      {@rest}
     />
     """
   end
 
-  defp step_points(%GraphDataset{} = graph_dataset, x_key, y_key) do
-    graph_dataset
-    |> GraphDataset.to_graph_points(x_key, y_key)
+  @doc """
+  A connected line plot.
+  """
+  @doc type: :component
+
+  attr :dataset, Dataset, required: true
+
+  attr :x, :atom, default: :x, doc: "The dataset axis key to use for x values"
+  attr :y, :atom, default: :y, doc: "The dataset axis key to use for y values"
+  attr :fill, :any, default: "none"
+  attr :rest, :global, include: @svg_presentation_globals
+
+  def line_plot(assigns) do
+    ~H"""
+    <polyline points={line_points(@dataset, @x, @y)} fill={@fill} {@rest} />
+    """
+  end
+
+  defp line_points(dataset, x_key, y_key) do
+    dataset.data
+    |> Enum.map(fn data_point -> %{x: data_point.graph[x_key], y: data_point.graph[y_key]} end)
+    |> polyline_points()
+  end
+
+  @doc """
+  A connected step line plot.
+  """
+  @doc type: :component
+
+  attr :dataset, Dataset, required: true
+
+  attr :x, :atom, default: :x, doc: "The dataset axis key to use for x values"
+  attr :y, :atom, default: :y, doc: "The dataset axis key to use for y values"
+  attr :fill, :any, default: "none"
+  attr :rest, :global, include: @svg_presentation_globals
+
+  def step_line_plot(assigns) do
+    ~H"""
+    <polyline points={step_line_points(@dataset, @x, @y)} fill={@fill} {@rest} />
+    """
+  end
+
+  defp step_line_points(dataset, x_key, y_key) do
+    dataset.data
+    |> Enum.map(fn data_point -> %{x: data_point.graph[x_key], y: data_point.graph[y_key]} end)
     |> Enum.chunk_every(2, 1)
     |> Enum.flat_map(fn
       [point1, point2] -> [point1, %{point2 | y: point1.y}]
       [point] -> [point]
     end)
+    |> polyline_points()
   end
 
   defp polyline_points(points), do: Enum.map_join(points, " ", &"#{&1.x},#{&1.y}")
 
   @doc """
-  Points plot
+  Points plot.
   """
   @doc type: :component
 
@@ -223,39 +364,30 @@ defmodule Plox do
   attr :x, :atom, default: :x, doc: "The dataset axis key to use for x values"
   attr :y, :atom, default: :y, doc: "The dataset axis key to use for y values"
 
-  attr :radius, :string, examples: ["8", "24.5"], default: "4"
-  attr :color, :any, examples: ["red", "#FF9330", :color_axis], default: "#FF9330"
-  attr :"phx-click", :any, default: nil
-  attr :"phx-target", :any, default: nil
+  attr :r, :any, examples: ["8", "24.5", :radius_axis], default: "4"
+  attr :fill, :any, examples: ["red", "#FF9330", :color_axis], default: nil
+  attr :rest, :global, include: @svg_presentation_globals
+  # attr :"phx-click", :any, default: nil
+  # attr :"phx-target", :any, default: nil
 
   def points_plot(assigns) do
     ~H"""
     <circle
-      :for={point <- GraphDataset.to_graph_points(@dataset, @x, @y)}
-      phx-click={
-        if assigns[:"phx-click"],
-          do:
-            JS.push(assigns[:"phx-click"],
-              value: %{
-                id: point.data_point.id,
-                dataset_id: @dataset.id,
-                x_pixel: point.x,
-                y_pixel: point.y
-              }
-            )
-      }
-      phx-target={assigns[:"phx-target"]}
-      style={if assigns[:"phx-click"], do: "cursor: pointer;"}
-      fill={GraphDataset.to_color(@dataset, @color, point.data_point)}
-      cx={point.x}
-      cy={point.y}
-      r={@radius}
+      :for={data_point <- @dataset.data}
+      fill={maybe_graph(@fill, data_point)}
+      cx={data_point.graph[@x]}
+      cy={data_point.graph[@y]}
+      r={maybe_graph(@r, data_point)}
+      {@rest}
     />
     """
   end
 
+  defp maybe_graph(assign, data_point) when is_atom(assign), do: data_point.graph[assign]
+  defp maybe_graph(assign, _data_point), do: assign
+
   @doc """
-  Bar plot
+  Bar plot.
   """
   @doc type: :component
 
@@ -311,7 +443,7 @@ defmodule Plox do
   defp bar_style(:square), do: "butt"
 
   @doc """
-  Tooltip
+  Tooltip.
   """
   @doc type: :component
 
@@ -386,7 +518,7 @@ defmodule Plox do
   end
 
   @doc """
-  One-dimensional shaded areas, either horizontal or vertical
+  One-dimensional shaded areas, either horizontal or vertical.
   """
   @doc type: :component
 
@@ -478,148 +610,8 @@ defmodule Plox do
     |> Enum.chunk_every(2, 1, :discard)
   end
 
-  attr :dimensions, :map, required: true
-  attr :y_pixel, :float, required: true, doc: "Y pixel value for rendering this label"
-  attr :position, :atom, required: true, values: [:left, :right]
-
-  attr :color, :string, required: true
-  attr :style, :string, default: "font-size: 0.75rem; line-height: 1rem"
-  attr :rotation, :integer, default: nil
-
-  slot :inner_block, required: true
-
-  defp y_label(%{position: :left} = assigns) do
-    ~H"""
-    <text
-      x={@dimensions.margin.left - 16}
-      y={@y_pixel}
-      fill={@color}
-      dominant-baseline="middle"
-      text-anchor="end"
-      style={@style}
-      transform={
-        if @rotation,
-          do: "rotate(#{@rotation}, #{@dimensions.margin.left - 16}, #{@y_pixel})"
-      }
-    >
-      {render_slot(@inner_block)}
-    </text>
-    """
-  end
-
-  defp y_label(%{position: :right} = assigns) do
-    ~H"""
-    <text
-      x={@dimensions.width - @dimensions.margin.right + 16}
-      y={@y_pixel}
-      fill={@color}
-      dominant-baseline="middle"
-      text-anchor="start"
-      style={@style}
-      transform={
-        if @rotation,
-          do:
-            "rotate(#{@rotation}, #{@dimensions.width - @dimensions.margin.right + 16}, #{@y_pixel})"
-      }
-    >
-      {render_slot(@inner_block)}
-    </text>
-    """
-  end
-
-  attr :dimensions, :map, required: true
-  attr :x_pixel, :float, required: true, doc: "X pixel value for rendering this label"
-  attr :position, :atom, required: true, values: [:top, :bottom]
-
-  attr :color, :string, required: true
-  attr :style, :string, default: "font-size: 0.75rem; line-height: 1rem"
-  attr :rotation, :integer, default: nil
-
-  slot :inner_block, required: true
-
-  defp x_label(%{position: :bottom} = assigns) do
-    ~H"""
-    <text
-      x={@x_pixel}
-      y={@dimensions.height - @dimensions.margin.bottom + 16}
-      fill={@color}
-      dominant-baseline="hanging"
-      text-anchor="middle"
-      style={@style}
-      transform={
-        if @rotation,
-          do:
-            "rotate(#{@rotation}, #{@x_pixel}, #{@dimensions.height - @dimensions.margin.bottom + 16})"
-      }
-    >
-      {render_slot(@inner_block)}
-    </text>
-    """
-  end
-
-  defp x_label(%{position: :top} = assigns) do
-    ~H"""
-    <text
-      x={@x_pixel}
-      y={@dimensions.margin.bottom - 16}
-      fill={@color}
-      dominant-baseline="text-bottom"
-      text-anchor="middle"
-      style={@style}
-      transform={
-        if @rotation,
-          do: "rotate(#{@rotation}, #{@x_pixel}, #{@dimensions.margin.bottom - 16})"
-      }
-    >
-      {render_slot(@inner_block)}
-    </text>
-    """
-  end
-
-  attr :dimensions, :map, required: true
-  attr :y_pixel, :float, required: true
-  attr :width, :string, required: true
-
-  attr :line_style, :atom, values: [:solid, :dashed, :dotted], default: :solid
-  attr :color, :string, required: true
-
-  defp horizontal_line(assigns) do
-    ~H"""
-    <line
-      x1={@dimensions.margin.left}
-      y1={@y_pixel}
-      x2={@dimensions.width - @dimensions.margin.right}
-      y2={@y_pixel}
-      stroke={@color}
-      stroke-width={@width}
-      stroke-dasharray={stroke_dasharray(@line_style)}
-    />
-    """
-  end
-
-  attr :dimensions, :map, required: true
-  attr :x_pixel, :float, required: true
-  attr :width, :string, required: true
-
-  attr :line_style, :atom, values: [:solid, :dashed, :dotted], default: :solid
-  attr :color, :string, required: true
-
-  defp vertical_line(assigns) do
-    ~H"""
-    <line
-      x1={@x_pixel}
-      y1={@dimensions.margin.top}
-      x2={@x_pixel}
-      y2={@dimensions.height - @dimensions.margin.bottom}
-      stroke={@color}
-      stroke-width={@width}
-      stroke-dasharray={stroke_dasharray(@line_style)}
-    />
-    """
-  end
-
   @doc """
-  A horizontal or vertical marker line with a label
+  A horizontal or vertical marker line with a label.
   """
   @doc type: :component
 
@@ -699,7 +691,54 @@ defmodule Plox do
   end
 
   @doc """
-  Legend row
+  A horizontal or vertical marker line with a label.
+  """
+  @doc type: :component
+
+  attr :axis, XAxis, required: true
+  attr :value, :any, required: true
+
+  attr :width, :string, default: "1.5"
+  attr :orientation, :atom, values: [:vertical, :horizontal], default: :vertical
+
+  attr :line_style, :atom, values: [:solid, :dashed, :dotted], default: :dotted
+  attr :line_color, :string, default: "#18191A"
+  attr :label_color, :string, default: "#18191A"
+  attr :label_style, :string, default: "font-size: 0.75rem; line-height: 1rem"
+  attr :label_rotation, :integer, default: nil
+
+  slot :inner_block, required: true
+
+  def x_marker(assigns) do
+    ~H"""
+    <line
+      x1={x = Axis.to_graph(@axis, @value)}
+      y1={@axis.dimensions.margin.top - 12}
+      x2={x}
+      y2={@axis.dimensions.height - @axis.dimensions.margin.bottom}
+      stroke={@line_color}
+      stroke-width={@width}
+      stroke-dasharray={stroke_dasharray(@line_style)}
+    />
+    <text
+      x={x}
+      y={@axis.dimensions.margin.top - 24}
+      fill={@label_color}
+      dominant-baseline="middle"
+      text-anchor="middle"
+      style={@label_style}
+      transform={
+        if @label_rotation,
+          do: "rotate(#{@label_rotation}, #{x}, #{@axis.dimensions.margin.top - 24})"
+      }
+    >
+      {render_slot(@inner_block)}
+    </text>
+    """
+  end
+
+  @doc """
+  Legend row.
   """
   @doc type: :component
 
@@ -714,7 +753,7 @@ defmodule Plox do
   end
 
   @doc """
-  Legend item
+  Legend item.
   """
   @doc type: :component
 
@@ -731,7 +770,7 @@ defmodule Plox do
   end
 
   @doc """
-  A colored circle for legends
+  A colored circle for legends.
   """
   @doc type: :component
 
@@ -747,11 +786,17 @@ defmodule Plox do
   defp stroke_dasharray(:dotted), do: "2"
   defp stroke_dasharray(:dashed), do: "6"
 
-  defdelegate to_graph(scales_and_datasets), to: Graph, as: :new
-  defdelegate date_scale(range), to: DateScale, as: :new
-  defdelegate datetime_scale(first, last), to: DateTimeScale, as: :new
-  defdelegate number_scale(first, last), to: NumberScale, as: :new
-  defdelegate fixed_colors_scale(color_mapping), to: FixedColorsScale, as: :new
-  defdelegate fixed_values_scale(values), to: FixedValuesScale, as: :new
-  defdelegate dataset(data, aces), to: Dataset, as: :new
+  # def date_scale(graph, range), do: GraphScale.new(graph, DateScale.new(range))
+
+  # def number_scale(graph, first, last), do: GraphScale.new(graph, NumberScale.new(first, last))
+
+  # def dataset(data, axes), do: Dataset.new(data, axes)
+
+  # defdelegate graph(width, height, opts \\ []), to: Graph, as: :new
+  # # defdelegate date_scale(range), to: DateScale, as: :new
+  # defdelegate datetime_scale(first, last), to: DateTimeScale, as: :new
+  # # defdelegate number_scale(first, last), to: NumberScale, as: :new
+  # defdelegate fixed_colors_scale(color_mapping), to: FixedColorsScale, as: :new
+  # defdelegate fixed_values_scale(values), to: FixedValuesScale, as: :new
+  # # defdelegate dataset(data, aces), to: Dataset, as: :new
 end
diff --git a/lib/plox/axis.ex b/lib/plox/axis.ex
new file mode 100644
index 0000000..70f528e
--- /dev/null
+++ b/lib/plox/axis.ex
@@ -0,0 +1,25 @@
+defprotocol Plox.Axis do
+  @moduledoc """
+  A protocol for graph axes.
+
+  TODO: docs
+  """
+
+  @typedoc """
+  Any struct that implements this protocol
+
+  Built in implementations are:
+
+  * `Plox.XAxis`
+  * `Plox.YAxis`
+  * `Plox.RadiusAxis`
+  * `Plox.ColorAxis`
+  """
+  @type t :: any()
+
+  @doc """
+  Converts a specific scale value to a value usable by the graph components
+  """
+  @spec to_graph(axis :: t(), any()) :: any()
+  def to_graph(axis, value)
+end
diff --git a/lib/plox/color_axis.ex b/lib/plox/color_axis.ex
new file mode 100644
index 0000000..141b05c
--- /dev/null
+++ b/lib/plox/color_axis.ex
@@ -0,0 +1,22 @@
+defmodule Plox.ColorAxis do
+  @moduledoc """
+  TODO: this is a public module that graph component implementers will interact
+  with, so it should be documented
+  """
+
+  alias Plox.ColorScale
+
+  defstruct [:scale]
+
+  def new(scale) do
+    %__MODULE__{scale: scale}
+  end
+
+  # def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
+
+  defimpl Plox.Axis do
+    def to_graph(%{scale: scale}, value) do
+      ColorScale.convert_to_color(scale, value)
+    end
+  end
+end
diff --git a/lib/plox/data_point.ex b/lib/plox/data_point.ex
index 169d4df..e3ec10b 100644
--- a/lib/plox/data_point.ex
+++ b/lib/plox/data_point.ex
@@ -6,31 +6,31 @@ defmodule Plox.DataPoint do
   alias Plox.GraphScalar
   alias Plox.GraphScale
 
-  defstruct [:id, :original, :mapped]
+  defstruct [:original, :graph]
 
-  def new(id, original, mapped) do
-    %__MODULE__{id: id, original: original, mapped: mapped}
+  def new(original, graph) do
+    %__MODULE__{original: original, graph: graph}
   end
 
-  def to_graph_point(%__MODULE__{} = data_point, x_scale, x_key, y_scale, y_key) do
-    x_value = data_point.mapped[x_key]
-    y_value = data_point.mapped[y_key]
+  # def to_graph_point(%__MODULE__{} = data_point, x_scale, x_key, y_scale, y_key) do
+  #   x_value = data_point.mapped[x_key]
+  #   y_value = data_point.mapped[y_key]
 
-    x = GraphScale.to_graph_x(x_scale, x_value)
-    y = GraphScale.to_graph_y(y_scale, y_value)
+  #   x = GraphScale.to_graph_x(x_scale, x_value)
+  #   y = GraphScale.to_graph_y(y_scale, y_value)
 
-    GraphPoint.new(x, y, data_point)
-  end
+  #   GraphPoint.new(x, y, data_point)
+  # end
 
-  def to_graph_x(%__MODULE__{} = data_point, scale, key) do
-    scale
-    |> GraphScale.to_graph_x(data_point.mapped[key])
-    |> GraphScalar.new(data_point)
-  end
+  # def to_graph_x(%__MODULE__{} = data_point, scale, key) do
+  #   scale
+  #   |> GraphScale.to_graph_x(data_point.mapped[key])
+  #   |> GraphScalar.new(data_point)
+  # end
 
-  def to_graph_y(%__MODULE__{} = data_point, scale, key) do
-    scale
-    |> GraphScale.to_graph_y(data_point.mapped[key])
-    |> GraphScalar.new(data_point)
-  end
+  # def to_graph_y(%__MODULE__{} = data_point, scale, key) do
+  #   scale
+  #   |> GraphScale.to_graph_y(data_point.mapped[key])
+  #   |> GraphScalar.new(data_point)
+  # end
 end
diff --git a/lib/plox/dataset.ex b/lib/plox/dataset.ex
index 6170b7e..5e8d4bc 100644
--- a/lib/plox/dataset.ex
+++ b/lib/plox/dataset.ex
@@ -2,27 +2,34 @@ defmodule Plox.Dataset do
   @moduledoc """
   A collection of data points and some metadata for a graph
   """
+  alias Plox.Axis
   alias Plox.DataPoint
 
-  defstruct [:data, :scales]
-
-  def new(original_data, axes) do
-    scales = Map.new(axes, fn {key, {scale, _fun}} -> {key, scale} end)
+  # defstruct [:data, :axes]
+  defstruct [:data]
 
+  def new(original_data, axis_fns) do
     data =
       original_data
-      |> Enum.with_index()
-      |> Enum.map(fn {original, idx} ->
-        id = Map.get(original, :id, idx)
-
-        mapped =
-          Map.new(axes, fn {key, {_scale, fun}} ->
-            {key, fun.(original)}
+      |> Enum.map(fn original ->
+        graph =
+          Map.new(axis_fns, fn {key, {axis, fun}} ->
+            {key, Axis.to_graph(axis, fun.(original))}
           end)
 
-        DataPoint.new(id, original, mapped)
+        DataPoint.new(original, graph)
       end)
 
-    %__MODULE__{data: data, scales: scales}
+    # axes = Map.new(axis_fns, fn {key, {scale, _fun}} -> {key, scale} end)
+
+    %__MODULE__{data: data}
+  end
+
+  def get_graph_values(%__MODULE__{data: data}, key_mapping) do
+    Enum.map(data, fn data_point ->
+      Map.new(key_mapping, fn {requested_key, axis_key} ->
+        {requested_key, Map.get(data_point.graph, axis_key)}
+      end)
+    end)
   end
 end
diff --git a/lib/plox/dimensions.ex b/lib/plox/dimensions.ex
index 5ad7d78..ffa0176 100644
--- a/lib/plox/dimensions.ex
+++ b/lib/plox/dimensions.ex
@@ -8,12 +8,15 @@ defmodule Plox.Dimensions do
 
   defstruct [:width, :height, :margin, :padding]
 
-  def new(attrs) do
+  def new(width, height, opts \\ []) do
+    margin = Keyword.get(opts, :margin, {35, 70})
+    padding = Keyword.get(opts, :margin, 0)
+
     %__MODULE__{
-      width: number(attrs.width),
-      height: number(attrs.height),
-      margin: Box.new(attrs.margin),
-      padding: Box.new(attrs.padding)
+      width: number(width),
+      height: number(height),
+      margin: Box.new(margin),
+      padding: Box.new(padding)
     }
   end
 
diff --git a/lib/plox/graph.ex b/lib/plox/graph.ex
deleted file mode 100644
index 29915eb..0000000
--- a/lib/plox/graph.ex
+++ /dev/null
@@ -1,40 +0,0 @@
-defmodule Plox.Graph do
-  @moduledoc """
-  TODO: docs
-  """
-
-  alias Plox.Dataset
-  alias Plox.Dimensions
-  alias Plox.GraphDataset
-  alias Plox.GraphScale
-
-  defstruct datasets: %{}, scales: %{}, color_scales: %{}, dimensions: nil
-
-  def new(scales_and_datasets) do
-    scales = scales_and_datasets |> Keyword.get(:scales, []) |> Map.new()
-    color_scales = scales_and_datasets |> Keyword.get(:color_scales, []) |> Map.new()
-    datasets = scales_and_datasets |> Keyword.get(:datasets, []) |> Map.new()
-
-    # TODO: you could theoretically check that all scales that appear in the
-    # datasets, were also given in the `scales` input
-
-    %__MODULE__{scales: scales, color_scales: color_scales, datasets: datasets}
-  end
-
-  def put_dimensions(%__MODULE__{} = graph, %Dimensions{} = dimensions) do
-    %{graph | dimensions: dimensions}
-  end
-
-  # Access behaviour
-
-  def fetch(%__MODULE__{} = graph, key) do
-    with :error <- Map.fetch(graph.datasets, key),
-         :error <- Map.fetch(graph.scales, key) do
-      raise ArgumentError,
-            "accessing a graph with graph[key] requires the key to be the ID of a dataset or scale got: #{inspect(key)}"
-    else
-      {:ok, %Dataset{} = dataset} -> {:ok, GraphDataset.new(key, dataset, graph.dimensions)}
-      {:ok, scale} -> {:ok, GraphScale.new(key, scale, graph.dimensions)}
-    end
-  end
-end
diff --git a/lib/plox/graph_scale.ex b/lib/plox/graph_scale.ex
index 48bd01b..4b8f935 100644
--- a/lib/plox/graph_scale.ex
+++ b/lib/plox/graph_scale.ex
@@ -6,33 +6,33 @@ defmodule Plox.GraphScale do
 
   alias Plox.Scale
 
-  defstruct [:id, :scale, :dimensions]
+  defstruct [:scale, :graph]
 
-  def new(id, scale, dimensions) do
-    %__MODULE__{id: id, scale: scale, dimensions: dimensions}
+  def new(graph, scale) do
+    %__MODULE__{scale: scale, graph: graph}
   end
 
   def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
 
-  def to_graph_x(%__MODULE__{scale: scale, dimensions: dimensions}, value) do
+  def to_graph_x(%__MODULE__{scale: scale, graph: graph}, value) do
     Scale.convert_to_range(
       scale,
       value,
-      (dimensions.margin.left +
-         dimensions.padding.left)..(dimensions.width -
-                                      dimensions.margin.right -
-                                      dimensions.padding.right)
+      (graph.margin.left +
+         graph.padding.left)..(graph.width -
+                                 graph.margin.right -
+                                 graph.padding.right)
     )
   end
 
-  def to_graph_y(%__MODULE__{scale: scale, dimensions: dimensions}, value) do
+  def to_graph_y(%__MODULE__{scale: scale, graph: graph}, value) do
     Scale.convert_to_range(
       scale,
       value,
-      (dimensions.height -
-         dimensions.margin.bottom -
-         dimensions.padding.bottom)..(dimensions.margin.top +
-                                        dimensions.padding.top)
+      (graph.height -
+         graph.margin.bottom -
+         graph.padding.bottom)..(graph.margin.top +
+                                   graph.padding.top)
     )
   end
 end
diff --git a/lib/plox/linear_axis.ex b/lib/plox/linear_axis.ex
new file mode 100644
index 0000000..3e44ed3
--- /dev/null
+++ b/lib/plox/linear_axis.ex
@@ -0,0 +1,26 @@
+defmodule Plox.LinearAxis do
+  @moduledoc """
+  TODO: this is a public module that graph component implementers will interact
+  with, so it should be documented
+  """
+
+  alias Plox.Scale
+
+  defstruct [:scale, :min, :max]
+
+  def new(scale, opts \\ []) do
+    Keyword.validate!(opts, [:min, :max])
+    min = Keyword.fetch!(opts, :min)
+    max = Keyword.fetch!(opts, :max)
+
+    %__MODULE__{scale: scale, min: min, max: max}
+  end
+
+  def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
+
+  defimpl Plox.Axis do
+    def to_graph(%{scale: scale, min: min, max: max}, value) do
+      Scale.convert_to_range(scale, value, min..max)
+    end
+  end
+end
diff --git a/lib/plox/x_axis.ex b/lib/plox/x_axis.ex
new file mode 100644
index 0000000..4889fe5
--- /dev/null
+++ b/lib/plox/x_axis.ex
@@ -0,0 +1,29 @@
+defmodule Plox.XAxis do
+  @moduledoc """
+  TODO: this is a public module that graph component implementers will interact
+  with, so it should be documented
+  """
+
+  alias Plox.Scale
+
+  defstruct [:scale, :dimensions]
+
+  def new(scale, dimensions) do
+    %__MODULE__{scale: scale, dimensions: dimensions}
+  end
+
+  def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
+
+  defimpl Plox.Axis do
+    def to_graph(%{scale: scale, dimensions: dimensions}, value) do
+      Scale.convert_to_range(
+        scale,
+        value,
+        (dimensions.margin.left +
+           dimensions.padding.left)..(dimensions.width -
+                                        dimensions.margin.right -
+                                        dimensions.padding.right)
+      )
+    end
+  end
+end
diff --git a/lib/plox/y_axis.ex b/lib/plox/y_axis.ex
new file mode 100644
index 0000000..8f2e7b9
--- /dev/null
+++ b/lib/plox/y_axis.ex
@@ -0,0 +1,29 @@
+defmodule Plox.YAxis do
+  @moduledoc """
+  TODO: this is a public module that graph component implementers will interact
+  with, so it should be documented
+  """
+
+  alias Plox.Scale
+
+  defstruct [:scale, :dimensions]
+
+  def new(scale, dimensions) do
+    %__MODULE__{scale: scale, dimensions: dimensions}
+  end
+
+  def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
+
+  defimpl Plox.Axis do
+    def to_graph(%{scale: scale, dimensions: dimensions}, value) do
+      Scale.convert_to_range(
+        scale,
+        value,
+        (dimensions.height -
+           dimensions.margin.bottom -
+           dimensions.padding.bottom)..(dimensions.margin.top +
+                                          dimensions.padding.top)
+      )
+    end
+  end
+end

From 5248c28fc91e6067e497e73a6be706aa8bbebe9c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Chris=20Dos=C3=A9?= <chris@xn--dos-dma.com>
Date: Mon, 26 Aug 2024 22:33:06 -0700
Subject: [PATCH 03/23] Update DateTimeScale + Add basic tests

---
 lib/plox.ex                           | 48 ++++++++++++++++++---------
 lib/plox/dataset.ex                   | 11 ------
 lib/plox/date_time_scale.ex           | 24 ++++++++++----
 test/plox/box_test.exs                | 19 +++++++++++
 test/plox/color_scale_test.exs        | 11 ++++++
 test/plox/data_point_test.exs         | 14 ++++++++
 test/plox/dataset_test.exs            | 22 ++++++++++++
 test/plox/date_scale_test.exs         | 17 ++++++++++
 test/plox/date_time_scale_test.exs    | 17 ++++++++++
 test/plox/dimensions_test.exs         | 17 ++++++++++
 test/plox/fixed_colors_scale_test.exs |  9 +++++
 test/plox/fixed_values_scale_test.exs |  9 +++++
 test/plox/graph_dataset_test.exs      |  9 +++++
 test/plox/graph_point_test.exs        |  9 +++++
 test/plox/graph_scalar_test.exs       |  9 +++++
 test/plox/graph_scale_test.exs        |  9 +++++
 test/plox/graph_test.exs              |  9 +++++
 test/plox/number_scale_test.exs       | 14 ++++++++
 test/plox/scale_test.exs              |  9 +++++
 test/plox_test.exs                    |  6 ++++
 20 files changed, 258 insertions(+), 34 deletions(-)
 create mode 100644 test/plox/box_test.exs
 create mode 100644 test/plox/color_scale_test.exs
 create mode 100644 test/plox/data_point_test.exs
 create mode 100644 test/plox/dataset_test.exs
 create mode 100644 test/plox/date_scale_test.exs
 create mode 100644 test/plox/date_time_scale_test.exs
 create mode 100644 test/plox/dimensions_test.exs
 create mode 100644 test/plox/fixed_colors_scale_test.exs
 create mode 100644 test/plox/fixed_values_scale_test.exs
 create mode 100644 test/plox/graph_dataset_test.exs
 create mode 100644 test/plox/graph_point_test.exs
 create mode 100644 test/plox/graph_scalar_test.exs
 create mode 100644 test/plox/graph_scale_test.exs
 create mode 100644 test/plox/graph_test.exs
 create mode 100644 test/plox/number_scale_test.exs
 create mode 100644 test/plox/scale_test.exs

diff --git a/lib/plox.ex b/lib/plox.ex
index 38f0544..93b65e7 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -75,17 +75,21 @@ defmodule Plox do
   attr :axis, XAxis, required: true
   attr :ticks, :any
   attr :step, :any
+  attr :start, :any
   attr :rest, :global, include: ~w(gap rotation position) ++ @svg_presentation_globals
 
   slot :inner_block, required: true
 
   def x_axis_labels(assigns) do
     ~H"""
-    <%= for value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step])) do %>
-      <.x_axis_label axis={@axis} value={value} {@rest}>
-        {render_slot(@inner_block, value)}
-      </.x_axis_label>
-    <% end %>
+    <.x_axis_label
+      :for={value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step, :start]))}
+      axis={@axis}
+      value={value}
+      {@rest}
+    >
+      {render_slot(@inner_block, value)}
+    </.x_axis_label>
     """
   end
 
@@ -152,17 +156,21 @@ defmodule Plox do
   attr :axis, YAxis, required: true
   attr :ticks, :any
   attr :step, :any
+  attr :start, :any
   attr :rest, :global, include: ~w(gap rotation position) ++ @svg_presentation_globals
 
   slot :inner_block, required: true
 
   def y_axis_labels(assigns) do
     ~H"""
-    <%= for value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step])) do %>
-      <.y_axis_label axis={@axis} value={value} {@rest}>
-        {render_slot(@inner_block, value)}
-      </.y_axis_label>
-    <% end %>
+    <.y_axis_label
+      :for={value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step, :start]))}
+      axis={@axis}
+      value={value}
+      {@rest}
+    >
+      {render_slot(@inner_block, value)}
+    </.y_axis_label>
     """
   end
 
@@ -227,13 +235,17 @@ defmodule Plox do
   attr :axis, XAxis, required: true
   attr :ticks, :any
   attr :step, :any
+  attr :start, :any
   attr :rest, :global, include: @svg_presentation_globals
 
   def x_axis_grid_lines(assigns) do
     ~H"""
-    <%= for value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step])) do %>
-      <.x_axis_grid_line axis={@axis} value={value} {@rest} />
-    <% end %>
+    <.x_axis_grid_line
+      :for={value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step, :start]))}
+      axis={@axis}
+      value={value}
+      {@rest}
+    />
     """
   end
 
@@ -268,13 +280,17 @@ defmodule Plox do
   attr :axis, YAxis, required: true
   attr :ticks, :any
   attr :step, :any
+  attr :start, :any
   attr :rest, :global, include: @svg_presentation_globals
 
   def y_axis_grid_lines(assigns) do
     ~H"""
-    <%= for value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step])) do %>
-      <.y_axis_grid_line axis={@axis} value={value} {@rest} />
-    <% end %>
+    <.y_axis_grid_line
+      :for={value <- Scale.values(@axis.scale, Map.take(assigns, [:ticks, :step, :start]))}
+      axis={@axis}
+      value={value}
+      {@rest}
+    />
     """
   end
 
diff --git a/lib/plox/dataset.ex b/lib/plox/dataset.ex
index 5e8d4bc..002491e 100644
--- a/lib/plox/dataset.ex
+++ b/lib/plox/dataset.ex
@@ -5,7 +5,6 @@ defmodule Plox.Dataset do
   alias Plox.Axis
   alias Plox.DataPoint
 
-  # defstruct [:data, :axes]
   defstruct [:data]
 
   def new(original_data, axis_fns) do
@@ -20,16 +19,6 @@ defmodule Plox.Dataset do
         DataPoint.new(original, graph)
       end)
 
-    # axes = Map.new(axis_fns, fn {key, {scale, _fun}} -> {key, scale} end)
-
     %__MODULE__{data: data}
   end
-
-  def get_graph_values(%__MODULE__{data: data}, key_mapping) do
-    Enum.map(data, fn data_point ->
-      Map.new(key_mapping, fn {requested_key, axis_key} ->
-        {requested_key, Map.get(data_point.graph, axis_key)}
-      end)
-    end)
-  end
 end
diff --git a/lib/plox/date_time_scale.ex b/lib/plox/date_time_scale.ex
index 9d0d35b..c9ca141 100644
--- a/lib/plox/date_time_scale.ex
+++ b/lib/plox/date_time_scale.ex
@@ -20,10 +20,12 @@ defmodule Plox.DateTimeScale do
   @spec new(first :: datetime(), last :: datetime()) :: t()
   def new(first, last)
 
-  def new(%date_time_module{} = first, %date_time_module{} = last) when date_time_module in [DateTime, NaiveDateTime] do
+  def new(%date_time_module{} = first, %date_time_module{} = last)
+      when date_time_module in [DateTime, NaiveDateTime] do
     if date_time_module.diff(last, first) <= 0 do
       raise ArgumentError,
-        message: "Invalid DateTimeScale: The range must be at least 1 second long and `first` must come before `last`."
+        message:
+          "Invalid DateTimeScale: The range must be at least 1 second long and `first` must come before `last`."
     end
 
     %__MODULE__{first: first, last: last}
@@ -35,7 +37,8 @@ defmodule Plox.DateTimeScale do
   end
 
   defimpl Plox.Scale do
-    def values(%{first: %DateTime{time_zone: tz}} = scale, %{step: {step_days, :day}}) when tz != "Etc/UTC" do
+    def values(%{first: %DateTime{time_zone: tz}} = scale, %{step: {step_days, :day}})
+        when tz != "Etc/UTC" do
       scale.first
       |> Stream.unfold(fn current_dt ->
         if DateTime.after?(current_dt, scale.last) do
@@ -66,17 +69,23 @@ defmodule Plox.DateTimeScale do
         end)
       end
 
-      total_seconds = date_time_module.diff(scale.last, scale.first)
+      first_value = Map.get(opts, :start, scale.first)
+
+      total_seconds = date_time_module.diff(scale.last, first_value)
       ticks = trunc(total_seconds / step_seconds)
 
       0..ticks
-      |> Enum.map_reduce(scale.first, fn _i, acc ->
+      |> Enum.map_reduce(first_value, fn _i, acc ->
         {acc, date_time_module.add(acc, step_seconds)}
       end)
       |> elem(0)
     end
 
-    def convert_to_range(%{first: %date_time_module{}} = scale, %date_time_module{} = value, to_range)
+    def convert_to_range(
+          %{first: %date_time_module{}} = scale,
+          %date_time_module{} = value,
+          to_range
+        )
         when date_time_module in [DateTime, NaiveDateTime] do
       if date_time_module.compare(value, scale.first) == :lt or
            date_time_module.compare(value, scale.last) == :gt do
@@ -104,7 +113,8 @@ defmodule Plox.DateTimeScale do
     defp shift_by(%DateTime{} = datetime, 0, :days), do: datetime
 
     # Positive shifts
-    defp shift_by(%DateTime{year: year, month: month, day: day} = datetime, value, :days) when value > 0 do
+    defp shift_by(%DateTime{year: year, month: month, day: day} = datetime, value, :days)
+         when value > 0 do
       ldom = :calendar.last_day_of_the_month(year, month)
 
       cond do
diff --git a/test/plox/box_test.exs b/test/plox/box_test.exs
new file mode 100644
index 0000000..95dc902
--- /dev/null
+++ b/test/plox/box_test.exs
@@ -0,0 +1,19 @@
+defmodule Plox.BoxTest do
+  use ExUnit.Case
+
+  alias Plox.Box
+
+  doctest Box
+
+  test "new/1" do
+    assert Box.new(1) == %Box{top: 1, right: 1, bottom: 1, left: 1}
+    assert Box.new({1}) == %Box{top: 1, right: 1, bottom: 1, left: 1}
+    assert Box.new({1, 2}) == %Box{top: 1, right: 2, bottom: 1, left: 2}
+    assert Box.new({1, 2, 3}) == %Box{top: 1, right: 2, bottom: 3, left: 2}
+    assert Box.new({1, 2, 3, 4}) == %Box{top: 1, right: 2, bottom: 3, left: 4}
+    assert Box.new("1") == %Box{top: 1, right: 1, bottom: 1, left: 1}
+    assert Box.new("1 2") == %Box{top: 1, right: 2, bottom: 1, left: 2}
+    assert Box.new("1 2 3") == %Box{top: 1, right: 2, bottom: 3, left: 2}
+    assert Box.new("1 2 3 4") == %Box{top: 1, right: 2, bottom: 3, left: 4}
+  end
+end
diff --git a/test/plox/color_scale_test.exs b/test/plox/color_scale_test.exs
new file mode 100644
index 0000000..0036b30
--- /dev/null
+++ b/test/plox/color_scale_test.exs
@@ -0,0 +1,11 @@
+defmodule Plox.ColorScaleTest do
+  use ExUnit.Case
+
+  alias Plox.ColorScale
+
+  doctest ColorScale
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
+end
diff --git a/test/plox/data_point_test.exs b/test/plox/data_point_test.exs
new file mode 100644
index 0000000..6a4505f
--- /dev/null
+++ b/test/plox/data_point_test.exs
@@ -0,0 +1,14 @@
+defmodule Plox.DataPointTest do
+  use ExUnit.Case
+
+  alias Plox.DataPoint
+
+  doctest DataPoint
+
+  test "new/3" do
+    data_point = DataPoint.new(1, %{foo: 1, bar: 2}, %{x: 1, y: 2})
+    assert data_point.id == 1
+    assert data_point.original == %{foo: 1, bar: 2}
+    assert data_point.mapped == %{x: 1, y: 2}
+  end
+end
diff --git a/test/plox/dataset_test.exs b/test/plox/dataset_test.exs
new file mode 100644
index 0000000..d5947b2
--- /dev/null
+++ b/test/plox/dataset_test.exs
@@ -0,0 +1,22 @@
+defmodule Plox.DatasetTest do
+  use ExUnit.Case
+
+  alias Plox.DataPoint
+  alias Plox.Dataset
+
+  doctest Dataset
+
+  test "new/2" do
+    scale = Plox.number_scale(0, 10)
+    axes = %{x: {scale, & &1.foo}, y: {scale, & &1.bar}}
+    data = [%{foo: 1, bar: 2}, %{foo: 2, bar: 3}]
+    dataset = Dataset.new(data, axes)
+
+    assert dataset.scales == %{x: scale, y: scale}
+
+    assert dataset.data == [
+             %DataPoint{id: 0, original: %{foo: 1, bar: 2}, mapped: %{x: 1, y: 2}},
+             %DataPoint{id: 1, original: %{foo: 2, bar: 3}, mapped: %{x: 2, y: 3}}
+           ]
+  end
+end
diff --git a/test/plox/date_scale_test.exs b/test/plox/date_scale_test.exs
new file mode 100644
index 0000000..eedc203
--- /dev/null
+++ b/test/plox/date_scale_test.exs
@@ -0,0 +1,17 @@
+defmodule Plox.DateScaleTest do
+  use ExUnit.Case
+
+  alias Plox.DateScale
+
+  doctest DateScale
+
+  test "new/2" do
+    scale = DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-03]))
+    assert scale.range == Date.range(~D[2019-01-01], ~D[2019-01-03])
+  end
+
+  test "new/2 given a range with a step it reduces it to 1" do
+    scale = DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-03], 2))
+    assert scale.range == Date.range(~D[2019-01-01], ~D[2019-01-03])
+  end
+end
diff --git a/test/plox/date_time_scale_test.exs b/test/plox/date_time_scale_test.exs
new file mode 100644
index 0000000..71d234a
--- /dev/null
+++ b/test/plox/date_time_scale_test.exs
@@ -0,0 +1,17 @@
+defmodule Plox.DateTimeScaleTest do
+  use ExUnit.Case
+
+  alias Plox.DateTimeScale
+
+  doctest DateTimeScale
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
+
+  test "new/2" do
+    scale = DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-03 00:00:00])
+    assert scale.first == ~N[2019-01-01 00:00:00]
+    assert scale.last == ~N[2019-01-03 00:00:00]
+  end
+end
diff --git a/test/plox/dimensions_test.exs b/test/plox/dimensions_test.exs
new file mode 100644
index 0000000..85d3b40
--- /dev/null
+++ b/test/plox/dimensions_test.exs
@@ -0,0 +1,17 @@
+defmodule Plox.DimensionsTest do
+  use ExUnit.Case
+
+  alias Plox.Box
+  alias Plox.Dimensions
+
+  doctest Dimensions
+
+  test "new/1" do
+    assert Dimensions.new(%{width: 100, height: 100, margin: 0, padding: 0}) == %Dimensions{
+             width: 100,
+             height: 100,
+             margin: %Box{top: 0, right: 0, bottom: 0, left: 0},
+             padding: %Box{top: 0, right: 0, bottom: 0, left: 0}
+           }
+  end
+end
diff --git a/test/plox/fixed_colors_scale_test.exs b/test/plox/fixed_colors_scale_test.exs
new file mode 100644
index 0000000..c16e8c5
--- /dev/null
+++ b/test/plox/fixed_colors_scale_test.exs
@@ -0,0 +1,9 @@
+defmodule Plox.FixedColorsScaleTest do
+  use ExUnit.Case
+
+  doctest Plox.FixedColorsScale
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
+end
diff --git a/test/plox/fixed_values_scale_test.exs b/test/plox/fixed_values_scale_test.exs
new file mode 100644
index 0000000..b77871c
--- /dev/null
+++ b/test/plox/fixed_values_scale_test.exs
@@ -0,0 +1,9 @@
+defmodule Plox.FixedValuesScaleTest do
+  use ExUnit.Case
+
+  doctest Plox.FixedValuesScale
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
+end
diff --git a/test/plox/graph_dataset_test.exs b/test/plox/graph_dataset_test.exs
new file mode 100644
index 0000000..c1f96ab
--- /dev/null
+++ b/test/plox/graph_dataset_test.exs
@@ -0,0 +1,9 @@
+defmodule Plox.GraphDatasetTest do
+  use ExUnit.Case
+
+  doctest Plox.GraphDataset
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
+end
diff --git a/test/plox/graph_point_test.exs b/test/plox/graph_point_test.exs
new file mode 100644
index 0000000..e6ef63a
--- /dev/null
+++ b/test/plox/graph_point_test.exs
@@ -0,0 +1,9 @@
+defmodule Plox.GraphPointTest do
+  use ExUnit.Case
+
+  doctest Plox.GraphPoint
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
+end
diff --git a/test/plox/graph_scalar_test.exs b/test/plox/graph_scalar_test.exs
new file mode 100644
index 0000000..24877e6
--- /dev/null
+++ b/test/plox/graph_scalar_test.exs
@@ -0,0 +1,9 @@
+defmodule Plox.GraphScalarTest do
+  use ExUnit.Case
+
+  doctest Plox.GraphScalar
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
+end
diff --git a/test/plox/graph_scale_test.exs b/test/plox/graph_scale_test.exs
new file mode 100644
index 0000000..f1a19b5
--- /dev/null
+++ b/test/plox/graph_scale_test.exs
@@ -0,0 +1,9 @@
+defmodule Plox.GraphScaleTest do
+  use ExUnit.Case
+
+  doctest Plox.GraphScale
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
+end
diff --git a/test/plox/graph_test.exs b/test/plox/graph_test.exs
new file mode 100644
index 0000000..1092785
--- /dev/null
+++ b/test/plox/graph_test.exs
@@ -0,0 +1,9 @@
+defmodule Plox.GraphTest do
+  use ExUnit.Case
+
+  doctest Plox.Graph
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
+end
diff --git a/test/plox/number_scale_test.exs b/test/plox/number_scale_test.exs
new file mode 100644
index 0000000..ff35095
--- /dev/null
+++ b/test/plox/number_scale_test.exs
@@ -0,0 +1,14 @@
+defmodule Plox.NumberScaleTest do
+  use ExUnit.Case
+
+  doctest Plox.NumberScale
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
+
+  test "scale" do
+    scale = Plox.NumberScale.new(0, 100)
+    Plox.Scale.convert_to_range(scale, 200, 0..1000)
+  end
+end
diff --git a/test/plox/scale_test.exs b/test/plox/scale_test.exs
new file mode 100644
index 0000000..420e508
--- /dev/null
+++ b/test/plox/scale_test.exs
@@ -0,0 +1,9 @@
+defmodule Plox.ScaleTest do
+  use ExUnit.Case
+
+  doctest Plox.Scale
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
+end
diff --git a/test/plox_test.exs b/test/plox_test.exs
index 0dd049c..cd25a17 100644
--- a/test/plox_test.exs
+++ b/test/plox_test.exs
@@ -1,3 +1,9 @@
 defmodule PloxTest do
   use ExUnit.Case
+
+  doctest Plox
+
+  test "the truth" do
+    assert 1 + 1 == 2
+  end
 end

From 7018fd068f9634f01e712d69805f464ccb9d5dcc Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Thu, 17 Oct 2024 16:29:12 -0400
Subject: [PATCH 04/23] Change points_plot to circles + Update icon SVG

---
 README.md            |  2 +-
 images/plox-icon.svg |  2 +-
 lib/plox.ex          | 24 ++++++++++++++++++------
 lib/plox/dataset.ex  | 18 ++++++++++--------
 4 files changed, 30 insertions(+), 16 deletions(-)

diff --git a/README.md b/README.md
index f230fd1..3453b21 100644
--- a/README.md
+++ b/README.md
@@ -76,6 +76,6 @@ Finally, render the `Plox.Graph` directly within your HEEx template:
 
   <.line_plot dataset={graph[:dataset]} color="#EC7E16" />
 
-  <.points_plot dataset={graph[:dataset]} color="#EC7E16" />
+  <.circles dataset={graph[:dataset]} color="#EC7E16" />
 </.graph>
 ```
diff --git a/images/plox-icon.svg b/images/plox-icon.svg
index 9c4dc53..a693c38 100644
--- a/images/plox-icon.svg
+++ b/images/plox-icon.svg
@@ -76,6 +76,6 @@
 
 
   <!-- <Plox.line_plot> lib/plox.ex:161 --><polyline points="16.333333333333332,8.666666666666666 31.666666666666668,16.333333333333332 16.333333333333332,24.0 16.333333333333332,39.333333333333336" fill="none" stroke="#FF9330" stroke-width="3"></polyline><!-- </Plox.line_plot> -->
-  <!-- <Plox.points_plot> lib/plox.ex:207 --><circle style="" fill="#FF9330" cx="16.333333333333332" cy="8.666666666666666" r="4"></circle><circle style="" fill="#FF9330" cx="31.666666666666668" cy="16.333333333333332" r="4"></circle><circle style="" fill="#FF9330" cx="16.333333333333332" cy="24.0" r="4"></circle><circle style="" fill="#FF9330" cx="16.333333333333332" cy="39.333333333333336" r="4"></circle><!-- </Plox.points_plot> -->
+  <!-- <Plox.circles> lib/plox.ex:207 --><circle style="" fill="#FF9330" cx="16.333333333333332" cy="8.666666666666666" r="4"></circle><circle style="" fill="#FF9330" cx="31.666666666666668" cy="16.333333333333332" r="4"></circle><circle style="" fill="#FF9330" cx="16.333333333333332" cy="24.0" r="4"></circle><circle style="" fill="#FF9330" cx="16.333333333333332" cy="39.333333333333336" r="4"></circle><!-- </Plox.circles> -->
 
     </svg>
diff --git a/lib/plox.ex b/lib/plox.ex
index 93b65e7..4c6a382 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -58,7 +58,7 @@ defmodule Plox do
           {render_slot(@inner_block)}
         </svg>
         <%!-- <%= for tooltip <- @tooltips do %>
-          <%= render_slot(tooltip) %>
+          {render_slot(tooltip)}
         <% end %> --%>
       </div>
     </div>
@@ -377,8 +377,8 @@ defmodule Plox do
 
   attr :dataset, :any, required: true
 
-  attr :x, :atom, default: :x, doc: "The dataset axis key to use for x values"
-  attr :y, :atom, default: :y, doc: "The dataset axis key to use for y values"
+  attr :cx, :atom, default: :x, doc: "The dataset axis key to use for x values"
+  attr :cy, :atom, default: :y, doc: "The dataset axis key to use for y values"
 
   attr :r, :any, examples: ["8", "24.5", :radius_axis], default: "4"
   attr :fill, :any, examples: ["red", "#FF9330", :color_axis], default: nil
@@ -386,13 +386,22 @@ defmodule Plox do
   # attr :"phx-click", :any, default: nil
   # attr :"phx-target", :any, default: nil
 
-  def points_plot(assigns) do
+  def circles(assigns) do
     ~H"""
+    <%!-- <circle
+      :for={data_point <- @dataset.data}
+      fill={maybe_graph(@fill, data_point)}
+      cx={data_point.graph[@cx]}
+      cy={data_point.graph[@cy]}
+      r={maybe_graph(@r, data_point)}
+      {@rest}
+    /> --%>
+
     <circle
       :for={data_point <- @dataset.data}
       fill={maybe_graph(@fill, data_point)}
-      cx={data_point.graph[@x]}
-      cy={data_point.graph[@y]}
+      cx={maybe_axis(@cx, @dataset, data_point)}
+      cy={maybe_axis(@cy, @dataset, data_point)}
       r={maybe_graph(@r, data_point)}
       {@rest}
     />
@@ -402,6 +411,9 @@ defmodule Plox do
   defp maybe_graph(assign, data_point) when is_atom(assign), do: data_point.graph[assign]
   defp maybe_graph(assign, _data_point), do: assign
 
+  defp maybe_axis({axis_name, value}, dataset, _data_point), do: Axis.to_graph(dataset.axes[axis_name], value)
+  defp maybe_axis(axis_name, _dataset, data_point), do: data_point.graph[axis_name]
+
   @doc """
   Bar plot.
   """
diff --git a/lib/plox/dataset.ex b/lib/plox/dataset.ex
index 002491e..42f0963 100644
--- a/lib/plox/dataset.ex
+++ b/lib/plox/dataset.ex
@@ -5,20 +5,22 @@ defmodule Plox.Dataset do
   alias Plox.Axis
   alias Plox.DataPoint
 
-  defstruct [:data]
+  defstruct [:data, :axes]
 
   def new(original_data, axis_fns) do
     data =
-      original_data
-      |> Enum.map(fn original ->
-        graph =
-          Map.new(axis_fns, fn {key, {axis, fun}} ->
-            {key, Axis.to_graph(axis, fun.(original))}
-          end)
+      Enum.map(original_data, fn original ->
+        graph = Map.new(axis_fns, fn {key, {axis, fun}} -> {key, Axis.to_graph(axis, fun.(original))} end)
 
         DataPoint.new(original, graph)
       end)
 
-    %__MODULE__{data: data}
+    # %{axis_name => {axis, function}, etc.}
+    axes =
+      Map.new(axis_fns, fn {key, {axis, _fun}} ->
+        {key, axis}
+      end)
+
+    %__MODULE__{data: data, axes: axes}
   end
 end

From 5a85816378ff361e5391418c6de3e932910c02cd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Chris=20Dos=C3=A9?= <chris@xn--dos-dma.com>
Date: Thu, 17 Oct 2024 17:06:53 -0700
Subject: [PATCH 05/23] Implement Access and Enumberable protocols for Datasets

---
 lib/plox.ex                 | 100 ++++++++++++++++++++++++++----------
 lib/plox/dataset.ex         |  63 ++++++++++++++++++++++-
 lib/plox/date_time_scale.ex |  18 ++-----
 3 files changed, 141 insertions(+), 40 deletions(-)

diff --git a/lib/plox.ex b/lib/plox.ex
index 4c6a382..e733e30 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -371,48 +371,96 @@ defmodule Plox do
   defp polyline_points(points), do: Enum.map_join(points, " ", &"#{&1.x},#{&1.y}")
 
   @doc """
-  Points plot.
+  Draws a single or set of SVG <circle> elements.
   """
   @doc type: :component
 
-  attr :dataset, :any, required: true
-
-  attr :cx, :atom, default: :x, doc: "The dataset axis key to use for x values"
-  attr :cy, :atom, default: :y, doc: "The dataset axis key to use for y values"
-
-  attr :r, :any, examples: ["8", "24.5", :radius_axis], default: "4"
-  attr :fill, :any, examples: ["red", "#FF9330", :color_axis], default: nil
+  # TODO: I wonder if we can more dynamically determine all "dynamic"-possible attributes
+  attr :cx, :any, required: true
+  attr :cy, :any, required: true
+  attr :r, :any, required: true
+  attr :fill, :any, default: nil
+  attr :stroke, :any, default: nil
+  attr :"stroke-width", :any, default: nil
   attr :rest, :global, include: @svg_presentation_globals
-  # attr :"phx-click", :any, default: nil
-  # attr :"phx-target", :any, default: nil
 
-  def circles(assigns) do
+  def circle(assigns) do
+    assigns
+    |> assign(dataset: validate_zero_or_one_dataset(Map.take(assigns, [:cx, :cy, :r, :fill])))
+    |> do_circle()
+  end
+
+  defp do_circle(%{dataset: :none} = assigns) do
     ~H"""
-    <%!-- <circle
-      :for={data_point <- @dataset.data}
-      fill={maybe_graph(@fill, data_point)}
-      cx={data_point.graph[@cx]}
-      cy={data_point.graph[@cy]}
-      r={maybe_graph(@r, data_point)}
-      {@rest}
-    /> --%>
+    <circle cx={@cx} cy={@cy} r={@r} fill={@fill} {@rest} />
+    """
+  end
 
+  defp do_circle(%{dataset: _dataset} = assigns) do
+    ~H"""
     <circle
       :for={data_point <- @dataset.data}
-      fill={maybe_graph(@fill, data_point)}
-      cx={maybe_axis(@cx, @dataset, data_point)}
-      cy={maybe_axis(@cy, @dataset, data_point)}
+      cx={maybe_graph(@cx, data_point)}
+      cy={maybe_graph(@cy, data_point)}
       r={maybe_graph(@r, data_point)}
+      fill={maybe_graph(@fill, data_point)}
+      stroke={maybe_graph(@stroke, data_point)}
+      stroke-width={maybe_graph(assigns[:"stroke-width"], data_point)}
       {@rest}
     />
     """
   end
 
-  defp maybe_graph(assign, data_point) when is_atom(assign), do: data_point.graph[assign]
-  defp maybe_graph(assign, _data_point), do: assign
+  defp validate_zero_or_one_dataset(assigns) do
+    datasets =
+      assigns
+      |> Enum.flat_map(fn
+        {_key, %Plox.DatasetAxis{} = dataset_axis} -> [dataset_axis.dataset]
+        {_key, _} -> []
+      end)
+      |> Enum.uniq()
+
+    case datasets do
+      [] -> :none
+      [dataset] -> dataset
+      _ -> raise "all dynamic values must be from the same dataset"
+    end
+  end
+
+  # TODO: can we make this work elegantly?
+  # would it be cool to allow mixed datasets?
+  # defp collect_values(values) do
+  #   {dynamics, constants} =
+  #     Enum.split_with(values, fn
+  #       {_key, %Plox.DatasetAxis{}} -> true
+  #       {_key, _value} -> false
+  #     end)
+
+  #   grouped_dynamics = dynamics |> Enum.group_by(fn {_key, value} -> value.dataset end, fn {key, value} -> {value.key, key} end) |> Enum.to_list()
+
+  #   constants_map = Map.new(constants)
+
+  #   case length(grouped_dynamics) do
+  #     0 ->
+  #       [constants_map]
+
+  #     1 ->
+  #       [{dataset, keys}] = grouped_dynamics
+  #       for data_point <- dataset.data do
+
+  #       end
+  #     _ ->
+  #       raise "all dynamic values must be from the same dataset"
+  #   end
+  # end
+
+  # TODO: a huge "dataset axis" struct just to get the key...
+  # I think this can be made way more elegant
+  defp maybe_graph(%Plox.DatasetAxis{key: key}, data_point), do: data_point.graph[key]
+  defp maybe_graph(value, _data_point), do: value
 
-  defp maybe_axis({axis_name, value}, dataset, _data_point), do: Axis.to_graph(dataset.axes[axis_name], value)
-  defp maybe_axis(axis_name, _dataset, data_point), do: data_point.graph[axis_name]
+  # defp maybe_axis({axis_name, value}, dataset, _data_point), do: Axis.to_graph(dataset.axes[axis_name], value)
+  # defp maybe_axis(axis_name, _dataset, data_point), do: data_point.graph[axis_name]
 
   @doc """
   Bar plot.
diff --git a/lib/plox/dataset.ex b/lib/plox/dataset.ex
index 42f0963..3e498f4 100644
--- a/lib/plox/dataset.ex
+++ b/lib/plox/dataset.ex
@@ -1,7 +1,52 @@
+defmodule Plox.DatasetAxis do
+  @moduledoc false
+  @behaviour Access
+
+  defstruct [:dataset, :axis, :key]
+
+  @impl Access
+  def fetch(%__MODULE__{axis: axis}, value) do
+    {:ok, Plox.Axis.to_graph(axis, value)}
+  end
+
+  @impl Access
+  def pop(_axis, _key) do
+    raise "Not implemented"
+  end
+
+  # TODO: not currently being used, but maybe we can?
+  @impl Access
+  def get_and_update(_axis, _key, _function) do
+    raise "Not implemented"
+  end
+
+  defimpl Enumerable do
+    def slice(_) do
+      {:error, Plox.DatasetAxis}
+    end
+
+    def member?(_, _) do
+      {:error, Plox.DatasetAxis}
+    end
+
+    def count(_) do
+      {:error, Plox.DatasetAxis}
+    end
+
+    def reduce(dataset_axis, acc, fun) do
+      dataset_axis.dataset.data
+      |> Enum.map(& &1.graph[dataset_axis.key])
+      |> Enumerable.List.reduce(acc, fun)
+    end
+  end
+end
+
 defmodule Plox.Dataset do
   @moduledoc """
   A collection of data points and some metadata for a graph
   """
+  @behaviour Access
+
   alias Plox.Axis
   alias Plox.DataPoint
 
@@ -15,7 +60,6 @@ defmodule Plox.Dataset do
         DataPoint.new(original, graph)
       end)
 
-    # %{axis_name => {axis, function}, etc.}
     axes =
       Map.new(axis_fns, fn {key, {axis, _fun}} ->
         {key, axis}
@@ -23,4 +67,21 @@ defmodule Plox.Dataset do
 
     %__MODULE__{data: data, axes: axes}
   end
+
+  @impl Access
+  def fetch(%__MODULE__{} = dataset, key) do
+    with {:ok, axis} <- Map.fetch(dataset.axes, key) do
+      {:ok, %Plox.DatasetAxis{dataset: dataset, axis: axis, key: key}}
+    end
+  end
+
+  @impl Access
+  def pop(_dataset, _key) do
+    raise "Not implemented"
+  end
+
+  @impl Access
+  def get_and_update(_dataset, _key, _function) do
+    raise "Not implemented"
+  end
 end
diff --git a/lib/plox/date_time_scale.ex b/lib/plox/date_time_scale.ex
index c9ca141..d5fffb8 100644
--- a/lib/plox/date_time_scale.ex
+++ b/lib/plox/date_time_scale.ex
@@ -20,12 +20,10 @@ defmodule Plox.DateTimeScale do
   @spec new(first :: datetime(), last :: datetime()) :: t()
   def new(first, last)
 
-  def new(%date_time_module{} = first, %date_time_module{} = last)
-      when date_time_module in [DateTime, NaiveDateTime] do
+  def new(%date_time_module{} = first, %date_time_module{} = last) when date_time_module in [DateTime, NaiveDateTime] do
     if date_time_module.diff(last, first) <= 0 do
       raise ArgumentError,
-        message:
-          "Invalid DateTimeScale: The range must be at least 1 second long and `first` must come before `last`."
+        message: "Invalid DateTimeScale: The range must be at least 1 second long and `first` must come before `last`."
     end
 
     %__MODULE__{first: first, last: last}
@@ -37,8 +35,7 @@ defmodule Plox.DateTimeScale do
   end
 
   defimpl Plox.Scale do
-    def values(%{first: %DateTime{time_zone: tz}} = scale, %{step: {step_days, :day}})
-        when tz != "Etc/UTC" do
+    def values(%{first: %DateTime{time_zone: tz}} = scale, %{step: {step_days, :day}}) when tz != "Etc/UTC" do
       scale.first
       |> Stream.unfold(fn current_dt ->
         if DateTime.after?(current_dt, scale.last) do
@@ -81,11 +78,7 @@ defmodule Plox.DateTimeScale do
       |> elem(0)
     end
 
-    def convert_to_range(
-          %{first: %date_time_module{}} = scale,
-          %date_time_module{} = value,
-          to_range
-        )
+    def convert_to_range(%{first: %date_time_module{}} = scale, %date_time_module{} = value, to_range)
         when date_time_module in [DateTime, NaiveDateTime] do
       if date_time_module.compare(value, scale.first) == :lt or
            date_time_module.compare(value, scale.last) == :gt do
@@ -113,8 +106,7 @@ defmodule Plox.DateTimeScale do
     defp shift_by(%DateTime{} = datetime, 0, :days), do: datetime
 
     # Positive shifts
-    defp shift_by(%DateTime{year: year, month: month, day: day} = datetime, value, :days)
-         when value > 0 do
+    defp shift_by(%DateTime{year: year, month: month, day: day} = datetime, value, :days) when value > 0 do
       ldom = :calendar.last_day_of_the_month(year, month)
 
       cond do

From e765b3bfb28369b73170e6331aef5f6545b27d55 Mon Sep 17 00:00:00 2001
From: Kurtis Rainbolt-Greene <kurtis@rainbolt-greene.online>
Date: Wed, 29 Jan 2025 10:23:39 -0800
Subject: [PATCH 06/23] Fetch padding from dimensions options instead of margin
 (#14)

---
 lib/plox/dimensions.ex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/plox/dimensions.ex b/lib/plox/dimensions.ex
index ffa0176..2de6d30 100644
--- a/lib/plox/dimensions.ex
+++ b/lib/plox/dimensions.ex
@@ -10,7 +10,7 @@ defmodule Plox.Dimensions do
 
   def new(width, height, opts \\ []) do
     margin = Keyword.get(opts, :margin, {35, 70})
-    padding = Keyword.get(opts, :margin, 0)
+    padding = Keyword.get(opts, :padding, 0)
 
     %__MODULE__{
       width: number(width),

From 5733d69d2520d6e3f61b0278cfcf29f778723380 Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Thu, 3 Jul 2025 16:43:43 -0700
Subject: [PATCH 07/23] Update demo with new example graph

---
 demo_live.exs | 146 ++++++++++++++++++++++++--------------------------
 lib/plox.ex   |  10 ++--
 2 files changed, 75 insertions(+), 81 deletions(-)

diff --git a/demo_live.exs b/demo_live.exs
index b031e41..a58d220 100644
--- a/demo_live.exs
+++ b/demo_live.exs
@@ -19,101 +19,95 @@ defmodule DemoLive do
   @impl Phoenix.LiveView
   def render(assigns) do
     ~H"""
-    <.simple_line_graph simple_graph={@simple_graph} clicked_point={@clicked_point} />
+    <.simple_line_graph {@graph} />
     """
   end
 
-  @impl Phoenix.LiveView
-  def handle_event(
-        "toggle_tooltip",
-        %{"id" => point_id, "dataset_id" => dataset_id, "x_pixel" => x_pixel, "y_pixel" => y_pixel},
-        socket
-      ) do
-    {:noreply,
-     assign(socket,
-       clicked_point: %{
-         id: point_id,
-         dataset_id: String.to_existing_atom(dataset_id),
-         x_pixel: x_pixel,
-         y_pixel: y_pixel
-       }
-     )}
-  end
+  defp mount_simple_line_graph(socket) do
+    data =
+      [
+        %{date: ~D[2023-08-01], value: 35.0, intensity: 10, temperature: :cold},
+        %{date: ~D[2023-08-02], value: 60.0, intensity: 20, temperature: :cold},
+        %{date: ~D[2023-08-03], value: 65.0, intensity: 25, temperature: :normal},
+        %{date: ~D[2023-08-04], value: 10.0, intensity: 45, temperature: :warm},
+        %{date: ~D[2023-08-05], value: 50.0, intensity: 15, temperature: :warm}
+      ]
 
-  def handle_event("toggle_tooltip", _params, socket), do: {:noreply, assign(socket, clicked_point: nil)}
+    dimensions = Plox.Dimensions.new(670, 250)
 
-  defp mount_simple_line_graph(socket) do
-    simple_data = [
-      %{date: ~D[2023-08-01], value: 45.0},
-      %{date: ~D[2023-08-02], value: 40.0},
-      %{date: ~D[2023-08-03], value: 35.0},
-      %{date: ~D[2023-08-04], value: 60.0},
-      %{date: ~D[2023-08-04], value: 10.0},
-      %{date: ~D[2023-08-05], value: 15.0},
-      %{date: ~D[2023-08-06], value: 25.0},
-      %{date: ~D[2023-08-07], value: 20.0},
-      %{date: ~D[2023-08-08], value: 10.0}
-    ]
-
-    date_scale = date_scale(Date.range(~D[2023-08-01], ~D[2023-08-08]))
-    number_scale = number_scale(0.0, 80.0)
+    x_axis =
+      Plox.XAxis.new(Plox.DateScale.new(Date.range(~D[2023-08-01], ~D[2023-08-05])), dimensions)
+
+    y_axis = Plox.YAxis.new(Plox.NumberScale.new(0.0, 80.0), dimensions)
+    radius_axis = Plox.LinearAxis.new(Plox.NumberScale.new(10, 45), min: 4, max: 10)
+
+    color_axis =
+      Plox.ColorAxis.new(Plox.FixedColorsScale.new(%{cold: "#1E88E5", normal: "#43A047", warm: "#FFC107"}))
 
     dataset =
-      dataset(simple_data,
-        x: {date_scale, & &1.date},
-        y: {number_scale, & &1.value}
+      Plox.Dataset.new(data,
+        x: {x_axis, & &1.date},
+        y: {y_axis, & &1.value},
+        radius: {radius_axis, & &1.intensity},
+        color: {color_axis, & &1.temperature}
       )
 
     assign(socket,
-      simple_graph:
-        to_graph(
-          scales: [date_scale: date_scale, number_scale: number_scale],
-          datasets: [dataset: dataset]
-        ),
-      clicked_point: nil
+      graph: %{
+        x_axis: x_axis,
+        y_axis: y_axis,
+        dataset: dataset,
+        dimensions: dimensions
+      }
     )
   end
 
   defp simple_line_graph(assigns) do
     ~H"""
-    <h2>Simple line graph with legend and tooltips</h2>
-
-    <.graph :let={graph} id="simple_graph" for={@simple_graph} width="800" height="250">
-      <:legend>
-        <.legend_item color="orange" label="data" />
-        <.legend_item color="green" label="more data" />
-      </:legend>
-
-      <:tooltips :let={graph}>
-        <.tooltip
-          :let={%{value: value, date: date}}
-          :if={!is_nil(@clicked_point)}
-          dataset={graph[@clicked_point.dataset_id]}
-          point_id={@clicked_point.id}
-          x_pixel={@clicked_point.x_pixel}
-          y_pixel={@clicked_point.y_pixel}
-          phx-click-away="toggle_tooltip"
-        >
-          <p>date: {date}</p>
-          <p>value: {value}</p>
-        </.tooltip>
-      </:tooltips>
-
-      <.x_axis :let={date} scale={graph[:date_scale]}>
-        {Calendar.strftime(date, "%-m/%-d")}
-      </.x_axis>
+    <h2>Example graph</h2>
 
-      <.y_axis :let={value} scale={graph[:number_scale]} ticks={5}>
-        {value}
-      </.y_axis>
+    <.graph dimensions={@dimensions}>
+      <.x_axis_labels :let={date} axis={@x_axis} class="text-sm">
+        {Calendar.strftime(date, "%-m/%-d")}
+      </.x_axis_labels>
 
-      <.line_plot dataset={graph[:dataset]} />
+      <%!-- this wraps text... why does it take in `axis`?? if we want to follow the SVG, we need to pass in `x` --%>
+      <.x_axis_label
+        axis={@x_axis}
+        value={~D[2023-08-02]}
+        position={:top}
+        class="text-sm fill-red-600 dark:fill-red-500"
+      >
+        {"Important Day"}
+      </.x_axis_label>
 
-      <.points_plot dataset={graph[:dataset]} phx-click="toggle_tooltip" />
+      <.x_axis_grid_lines axis={@x_axis} stroke="grey" />
 
-      <.marker at={~D[2023-08-03]} scale={graph[:date_scale]}>
-        Important date!
-      </.marker>
+      <.y_axis_labels :let={value} axis={@y_axis} ticks={5} class="text-sm">
+        {value}
+      </.y_axis_labels>
+
+      <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="grey" />
+
+      <.line_plot dataset={@dataset} stroke="orange" stroke-width={2} />
+
+      <%!-- Access behavior with axes --%>
+      <%!-- <.polyline points={{@dataset[:x], @dataset[:y]}} class="stroke-orange-500 dark:stroke-orange-400 stroke-2" /> --%>
+      <%!-- constant y = 40 --%>
+      <%!-- <.polyline points={{@dataset[:x], @dataset[:y][40]}} class="stroke-orange-500 dark:stroke-orange-400 stroke-2" /> --%>
+      <%!-- <.circles dataset={@dataset} cx={:x} cy={:y} fill={:color} r={:radius} /> --%>
+      <%!-- use the Access behavior --%>
+      <.circle
+        cx={@dataset[:x]}
+        cy={@dataset[:y]}
+        stroke={@dataset[:color]}
+        fill="none"
+        stroke-width="2px"
+        r={@dataset[:radius]}
+      />
+
+      <%!-- pass in constant y-axis and color value --%>
+      <.circle cx={@dataset[:x]} cy={@dataset[:y][40]} fill="red" r={@dataset[:radius]} />
     </.graph>
     """
   end
diff --git a/lib/plox.ex b/lib/plox.ex
index e733e30..370e957 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -8,14 +8,14 @@ defmodule Plox do
   alias Phoenix.LiveView.JS
   alias Plox.Axis
   alias Plox.Dataset
-  alias Plox.DateScale
-  alias Plox.DateTimeScale
+  # alias Plox.DateScale
+  # alias Plox.DateTimeScale
   alias Plox.Dimensions
-  alias Plox.FixedColorsScale
-  alias Plox.FixedValuesScale
+  # alias Plox.FixedColorsScale
+  # alias Plox.FixedValuesScale
   alias Plox.GraphDataset
   alias Plox.GraphScale
-  alias Plox.NumberScale
+  # alias Plox.NumberScale
   alias Plox.Scale
   alias Plox.XAxis
   alias Plox.YAxis

From 8dd415e735b282c02287c481cfcedd97214765b9 Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Mon, 7 Jul 2025 14:51:57 -0700
Subject: [PATCH 08/23] Add logo example graph + Add animated example graph

---
 animated_demo_live.exs | 221 +++++++++++++++++++++++++++++++++++++++++
 demo_live.exs          | 131 ++++++++++++++++++++++--
 2 files changed, 343 insertions(+), 9 deletions(-)
 create mode 100644 animated_demo_live.exs

diff --git a/animated_demo_live.exs b/animated_demo_live.exs
new file mode 100644
index 0000000..23904fe
--- /dev/null
+++ b/animated_demo_live.exs
@@ -0,0 +1,221 @@
+Mix.install([
+  {:phoenix_playground, "~> 0.1.6"},
+  {:plox, path: "."}
+])
+
+defmodule AnimatedDemoLive do
+  @moduledoc """
+  Example animated graph rendered within a Phoenix Playground application.
+  """
+  use Phoenix.LiveView
+
+  import Plox
+
+  @interval 1000
+
+  @impl Phoenix.LiveView
+  def mount(_params, _session, socket) do
+    dimensions = Plox.Dimensions.new(1_000, 250)
+
+    if connected?(socket) do
+      Process.send_after(self(), :tick, @interval)
+      Process.send_after(self(), :add_point, :rand.uniform(10) * 1_000)
+    end
+
+    now = DateTime.truncate(DateTime.utc_now(), :second)
+    soon = DateTime.add(now, 5, :second)
+    start = DateTime.add(soon, -60, :second)
+    nearest_5_second = get_nearest_5_second(start)
+
+    x_axis =
+      Plox.XAxis.new(
+        Plox.DateTimeScale.new(
+          start,
+          soon
+        ),
+        dimensions
+      )
+
+    y_axis = Plox.YAxis.new(Plox.NumberScale.new(0, 100), dimensions)
+
+    radius_axis = Plox.LinearAxis.new(Plox.NumberScale.new(1, 100), min: 5, max: 15)
+
+    color_axis =
+      Plox.ColorAxis.new(Plox.FixedColorsScale.new(%{cold: "#1E88E5AA", normal: "#43A047AA", warm: "#FFC107AA"}))
+
+    {data1, dataset1} = init_line_data(now, x_axis, y_axis)
+    {data2, dataset2} = init_line_data(now, x_axis, y_axis)
+    {data3, dataset3} = init_line_data(now, x_axis, y_axis)
+
+    points = []
+
+    points_dataset =
+      Plox.Dataset.new(points,
+        x: {x_axis, & &1.x},
+        y: {y_axis, & &1.y},
+        r: {radius_axis, & &1.size},
+        color: {color_axis, & &1.temperature}
+      )
+
+    {:ok,
+     assign(socket,
+       now: now,
+       data1: data1,
+       dataset1: dataset1,
+       data2: data2,
+       dataset2: dataset2,
+       data3: data3,
+       dataset3: dataset3,
+       points: points,
+       points_dataset: points_dataset,
+       x_axis: x_axis,
+       y_axis: y_axis,
+       radius_axis: radius_axis,
+       color_axis: color_axis,
+       dimensions: dimensions,
+       nearest_5_second: nearest_5_second
+     )}
+  end
+
+  @impl Phoenix.LiveView
+  def render(assigns) do
+    ~H"""
+    <.graph dimensions={@dimensions}>
+      <.y_axis_labels :let={value} axis={@y_axis} ticks={5}>
+        {value}
+      </.y_axis_labels>
+
+      <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="grey" />
+
+      <.x_axis_labels :let={datetime} axis={@x_axis} step={5} start={@nearest_5_second}>
+        {Calendar.strftime(datetime, "%-I:%M:%S")}
+      </.x_axis_labels>
+
+      <.x_axis_grid_lines axis={@x_axis} step={5} start={@nearest_5_second} stroke="grey" />
+      <.x_axis_grid_line axis={@x_axis} value={@x_axis.scale.first} stroke="grey" />
+      <.x_axis_grid_line axis={@x_axis} value={@x_axis.scale.last} stroke="grey" />
+
+      <.x_axis_label axis={@x_axis} value={@now} position={:top} fill="red">
+        Now ({Calendar.strftime(@now, "%-I:%M:%S")})
+      </.x_axis_label>
+
+      <.x_axis_grid_line axis={@x_axis} value={@now} stroke="red" />
+
+      <.polyline dataset={@dataset1} stroke="orange" stroke-width="2" />
+      <.polyline dataset={@dataset2} stroke="blue" stroke-width="2" />
+      <.polyline dataset={@dataset3} stroke="green" stroke-width="2" />
+      <%!-- <.circles dataset={@points_dataset} r={:r} fill={:color} /> --%>
+    </.graph>
+    """
+  end
+
+  @impl Phoenix.LiveView
+  def handle_info(:tick, socket) do
+    Process.send_after(self(), :tick, @interval)
+
+    now = DateTime.truncate(DateTime.utc_now(), :second)
+    soon = DateTime.add(now, 5, :second)
+    start = DateTime.add(soon, -60, :second)
+    nearest_5_second = get_nearest_5_second(start)
+
+    x_axis =
+      Plox.XAxis.new(
+        Plox.DateTimeScale.new(
+          start,
+          soon
+        ),
+        socket.assigns.dimensions
+      )
+
+    {data1, dataset1} = update_line_data(socket.assigns.data1, now, x_axis, socket.assigns.y_axis)
+    {data2, dataset2} = update_line_data(socket.assigns.data2, now, x_axis, socket.assigns.y_axis)
+    {data3, dataset3} = update_line_data(socket.assigns.data3, now, x_axis, socket.assigns.y_axis)
+
+    points =
+      Enum.take_while(socket.assigns.points, fn %{x: time} ->
+        DateTime.compare(time, x_axis.scale.first) != :lt
+      end)
+
+    points_dataset =
+      Plox.Dataset.new(points,
+        x: {socket.assigns.x_axis, & &1.x},
+        y: {socket.assigns.y_axis, & &1.y},
+        r: {socket.assigns.radius_axis, & &1.size},
+        color: {socket.assigns.color_axis, & &1.temperature}
+      )
+
+    {:noreply,
+     assign(socket,
+       now: now,
+       data1: data1,
+       dataset1: dataset1,
+       data2: data2,
+       dataset2: dataset2,
+       data3: data3,
+       dataset3: dataset3,
+       points: points,
+       points_dataset: points_dataset,
+       x_axis: x_axis,
+       nearest_5_second: nearest_5_second
+     )}
+  end
+
+  def handle_info(:add_point, socket) do
+    Process.send_after(self(), :add_point, :rand.uniform(10) * 1_000)
+
+    new_point = %{
+      x: socket.assigns.now,
+      y: :rand.uniform(100),
+      size: :rand.uniform(100),
+      temperature: Enum.random(~w(cold normal warm)a)
+    }
+
+    points = [new_point | socket.assigns.points]
+
+    {:noreply, assign(socket, points: points)}
+  end
+
+  defp get_nearest_5_second(datetime) do
+    seconds = datetime.second
+
+    diff = ceil(seconds / 5) * 5 - seconds
+
+    DateTime.add(datetime, diff)
+  end
+
+  defp init_line_data(now, x_axis, y_axis) do
+    data = [%{x: now, y: :rand.uniform(100)}]
+
+    dataset = Plox.Dataset.new(data, x: {x_axis, & &1.x}, y: {y_axis, & &1.y})
+
+    {data, dataset}
+  end
+
+  defp update_line_data(data, now, x_axis, y_axis) do
+    [previous | _] = data
+
+    diff =
+      case previous.y do
+        100 -> :rand.uniform(10) - 10
+        0 -> :rand.uniform(10)
+        _ -> :rand.uniform(20) - 10
+      end
+
+    new = min(max(previous.y + diff, 0), 100)
+
+    data =
+      Enum.take_while([%{x: now, y: new} | data], fn %{x: time} ->
+        DateTime.compare(time, x_axis.scale.first) != :lt
+      end)
+
+    dataset =
+      Plox.Dataset.new(data,
+        x: {x_axis, & &1.x},
+        y: {y_axis, & &1.y}
+      )
+
+    {data, dataset}
+  end
+end
+
+PhoenixPlayground.start(live: AnimatedDemoLive)
diff --git a/demo_live.exs b/demo_live.exs
index a58d220..e6afa86 100644
--- a/demo_live.exs
+++ b/demo_live.exs
@@ -13,13 +13,17 @@ defmodule DemoLive do
 
   @impl Phoenix.LiveView
   def mount(_params, _session, socket) do
-    {:ok, mount_simple_line_graph(socket)}
+    {:ok, socket |> mount_simple_line_graph() |> mount_logo_graph()}
   end
 
   @impl Phoenix.LiveView
   def render(assigns) do
     ~H"""
     <.simple_line_graph {@graph} />
+
+    <hr />
+
+    <.logo_graph {@logo_graph} />
     """
   end
 
@@ -67,23 +71,18 @@ defmodule DemoLive do
     <h2>Example graph</h2>
 
     <.graph dimensions={@dimensions}>
-      <.x_axis_labels :let={date} axis={@x_axis} class="text-sm">
+      <.x_axis_labels :let={date} axis={@x_axis}>
         {Calendar.strftime(date, "%-m/%-d")}
       </.x_axis_labels>
 
       <%!-- this wraps text... why does it take in `axis`?? if we want to follow the SVG, we need to pass in `x` --%>
-      <.x_axis_label
-        axis={@x_axis}
-        value={~D[2023-08-02]}
-        position={:top}
-        class="text-sm fill-red-600 dark:fill-red-500"
-      >
+      <.x_axis_label axis={@x_axis} value={~D[2023-08-02]} position={:top} fill="red">
         {"Important Day"}
       </.x_axis_label>
 
       <.x_axis_grid_lines axis={@x_axis} stroke="grey" />
 
-      <.y_axis_labels :let={value} axis={@y_axis} ticks={5} class="text-sm">
+      <.y_axis_labels :let={value} axis={@y_axis} ticks={5}>
         {value}
       </.y_axis_labels>
 
@@ -111,6 +110,120 @@ defmodule DemoLive do
     </.graph>
     """
   end
+
+  defp mount_logo_graph(socket) do
+    dimensions = Plox.Dimensions.new(440, 250)
+    x_axis = Plox.XAxis.new(Plox.NumberScale.new(0.0, 10.0), dimensions)
+    y_axis = Plox.YAxis.new(Plox.NumberScale.new(0.0, 6.0), dimensions)
+
+    # Letter "P"
+    p_data = [
+      %{x: 1, y: 5},
+      %{x: 2.5, y: 4},
+      %{x: 1, y: 3},
+      %{x: 1, y: 1}
+    ]
+
+    p_dataset =
+      Plox.Dataset.new(p_data,
+        x: {x_axis, & &1.x},
+        y: {y_axis, & &1.y}
+      )
+
+    # Letter "L"
+    l_data = [
+      %{x: 3.5, y: 4.5},
+      %{x: 3.5, y: 1}
+    ]
+
+    l_dataset =
+      Plox.Dataset.new(l_data,
+        x: {x_axis, & &1.x},
+        y: {y_axis, & &1.y}
+      )
+
+    # Letter "O"
+    o_data = [
+      %{x: 4.5, y: 2},
+      %{x: 5.5, y: 3},
+      %{x: 6.5, y: 2},
+      %{x: 5.5, y: 1},
+      %{x: 4.5, y: 2}
+    ]
+
+    o_dataset =
+      Plox.Dataset.new(o_data,
+        x: {x_axis, & &1.x},
+        y: {y_axis, & &1.y}
+      )
+
+    # Letter "X"
+    x1_data = [
+      %{x: 7, y: 3},
+      %{x: 9, y: 1}
+    ]
+
+    x1_dataset =
+      Plox.Dataset.new(x1_data,
+        x: {x_axis, & &1.x},
+        y: {y_axis, & &1.y}
+      )
+
+    x2_data = [
+      %{x: 7, y: 1},
+      %{x: 9, y: 3}
+    ]
+
+    x2_dataset =
+      Plox.Dataset.new(x2_data,
+        x: {x_axis, & &1.x},
+        y: {y_axis, & &1.y}
+      )
+
+    assign(socket,
+      logo_graph: %{
+        dimensions: dimensions,
+        x_axis: x_axis,
+        y_axis: y_axis,
+        p_dataset: p_dataset,
+        l_dataset: l_dataset,
+        o_dataset: o_dataset,
+        x1_dataset: x1_dataset,
+        x2_dataset: x2_dataset
+      }
+    )
+  end
+
+  defp logo_graph(assigns) do
+    ~H"""
+    <h2>Logo graph</h2>
+
+    <.graph dimensions={@dimensions}>
+      <.x_axis_labels :let={value} axis={@x_axis}>
+        {value}
+      </.x_axis_labels>
+
+      <.y_axis_labels :let={value} axis={@y_axis} ticks={7}>
+        {value}
+      </.y_axis_labels>
+
+      <.x_axis_grid_lines axis={@x_axis} stroke="grey" />
+
+      <.y_axis_grid_lines axis={@y_axis} ticks={7} stroke="grey" />
+
+      <.line_plot dataset={@p_dataset} stroke-width="5" stroke="#FF9330" />
+      <%!-- <.circles dataset={@p_dataset} r="8" fill="#FF9330" /> --%>
+      <.line_plot dataset={@l_dataset} stroke-width="5" stroke="#78C348" />
+      <%!-- <.circles dataset={@l_dataset} r="8" fill="#78C348" /> --%>
+      <.line_plot dataset={@o_dataset} stroke-width="5" stroke="#71AEFF" />
+      <%!-- <.circles dataset={@o_dataset} r="8" fill="#71AEFF" /> --%>
+      <.line_plot dataset={@x1_dataset} stroke-width="5" stroke="#FF7167" />
+      <%!-- <.circles dataset={@x1_dataset} r="8" fill="#FF7167" /> --%>
+      <.line_plot dataset={@x2_dataset} stroke-width="5" stroke="#FF7167" />
+      <%!-- <.circles dataset={@x2_dataset} r="8" fill="#FF7167" /> --%>
+    </.graph>
+    """
+  end
 end
 
 PhoenixPlayground.start(live: DemoLive)

From b56fc77cdc24630f4bf2d34a7bd794cdf34772e1 Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Tue, 8 Jul 2025 16:21:03 -0700
Subject: [PATCH 09/23] Update README and add migration_guide

---
 README.md                         |  53 +++++++-------
 demo_live.exs                     |   4 +-
 images/readme-example-plot@2x.png | Bin 56884 -> 31206 bytes
 lib/plox.ex                       |  14 ----
 migration_guide.md                | 110 ++++++++++++++++++++++++++++++
 5 files changed, 136 insertions(+), 45 deletions(-)
 create mode 100644 migration_guide.md

diff --git a/README.md b/README.md
index 3453b21..72d85d8 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ installed by adding `plox` to your list of dependencies in `mix.exs`:
 ```elixir
 def deps do
   [
-    {:plox, "~> 0.1.0"}
+    {:plox, "~> 0.2.0"}
   ]
 end
 ```
@@ -27,7 +27,7 @@ Documentation is published on [HexDocs](https://hexdocs.pm) and can be found at
 
 <img width="740" src="images/readme-example-plot@2x.png" alt="Example screenshot">
 
-Start by setting up your data, scales, and dataset:
+Start by setting up your data, dimensions, axes, and dataset:
 
 ```elixir
 data = [
@@ -38,44 +38,39 @@ data = [
   %{date: ~D[2023-08-05], value: 50.0}
 ]
 
-date_scale = date_scale(Date.range(~D[2023-08-01], ~D[2023-08-05]))
-number_scale = number_scale(0.0, 80.0)
+dimensions = Plox.Dimensions.new(800, 250)
 
-dataset =
-  dataset(data,
-    x: {date_scale, & &1.date},
-    y: {number_scale, & &1.value}
-  )
-```
+x_axis = Plox.XAxis.new(
+  Plox.DateScale.new(Date.range(~D[2023-08-01], ~D[2023-08-05])),
+  dimensions
+)
 
-Once you have those, you can build a `Plox.Graph` struct:
+y_axis = Plox.YAxis.new(Plox.NumberScale.new(0.0, 80.0), dimensions)
 
-```elixir
-example_graph =
-  to_graph(
-    scales: [date_scale: date_scale, number_scale: number_scale],
-    datasets: [dataset: dataset]
+dataset =
+  Plox.Dataset.new(data,
+    x: {x_axis, & &1.date},
+    y: {y_axis, & &1.value}
   )
 ```
 
-Finally, render the `Plox.Graph` directly within your HEEx template:
+Once you have those, you can render a `graph` component within your HEEx template:
 
 ```html
-<.graph :let={graph} id="example_graph" for={@example_graph} width="800" height="250">
-  <:legend>
-    <.legend_item color="#EC7E16" label="Data" />
-  </:legend>
+<.graph id="example_graph" dimensions={@dimensions}>
+  <.x_axis_labels :let={date} axis={@x_axis}>
+    {Calendar.strftime(date, "%-m/%-d")}
+  </.x_axis_labels>
 
-  <.x_axis :let={date} scale={graph[:date_scale]}>
-    <%= Calendar.strftime(date, "%-m/%-d") %>
-  </.x_axis>
+  <.y_axis_labels :let={value} axis={@y_axis} ticks={5}>
+    {value}
+  </.y_axis_labels>
 
-  <.y_axis :let={value} scale={graph[:number_scale]} ticks={5}>
-    <%= value %>
-  </.y_axis>
+  <.x_axis_grid_lines axis={@x_axis} stroke="#D3D3D3" />
+  <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="#D3D3D3" />
 
-  <.line_plot dataset={graph[:dataset]} color="#EC7E16" />
+  <.polyline dataset={@dataset} stroke="#EC7E16" stroke-width={2} />
 
-  <.circles dataset={graph[:dataset]} color="#EC7E16" />
+  <.circle cx={@dataset[:x]} cy={@dataset[:y]} r={3} fill="#EC7E16" />
 </.graph>
 ```
diff --git a/demo_live.exs b/demo_live.exs
index e6afa86..a27e66f 100644
--- a/demo_live.exs
+++ b/demo_live.exs
@@ -1,5 +1,5 @@
 Mix.install([
-  {:phoenix_playground, "~> 0.1.6"},
+  {:phoenix_playground, "~> 0.1.7"},
   {:plox, path: "."}
 ])
 
@@ -76,7 +76,7 @@ defmodule DemoLive do
       </.x_axis_labels>
 
       <%!-- this wraps text... why does it take in `axis`?? if we want to follow the SVG, we need to pass in `x` --%>
-      <.x_axis_label axis={@x_axis} value={~D[2023-08-02]} position={:top} fill="red">
+      <.x_axis_label axis={@x_axis} value={~D[2023-08-02]} position={:top} color="red">
         {"Important Day"}
       </.x_axis_label>
 
diff --git a/images/readme-example-plot@2x.png b/images/readme-example-plot@2x.png
index a5b028dfaf1d2d965660fcd0308fa4e6b8dc17ce..1f683b324e364b95bf83d3c7c34f870aa5063274 100644
GIT binary patch
literal 31206
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
LNizHT{b&CN<M_Jc

literal 56884
zcmeFZby(D07dFZef~bh3G$M_H(j|?Qgmj})BHdkL0n!X1sWdn=3|)ehba!`m4t#s`
zdEeLXI(nV|&w0EqhnZpc{q|ma?R(wpUTcrPl7iF?Y*K6#6qFk>(h|xjC>Sj$D5w%x
zSHL?ov(4%#DA+}2;^Im&;^NdwcGf0l7RD$j(*DqBOjQ*b;^w95{l{`5BC^XAE9jwk
zZp+pFveKyNVpvy2CD-rePHQXOf*4C`ND^463J~49haE6XZ1hw~i1-?}Y7HiN!=~4U
z$5DLi`J|`wh5eQQ$I>{8NYArC2~<sp&y(lDybWCul*CCQ%{L%ej40$bS4u5{B^s|^
zyN3Fq<A-<2&7;tljhmWJULn@bE?))cCcZ&KA$VuQuF=pcaZJE2WFs+4j-n)mTRRy}
z-a|X}IEMZ)p2YEyj6%YqVnn=P)5~4eC#r9V8yrx!jktB<u~A0Iclzx4vOeIr7G7bw
z6U`>UOZ6Q7<HtSL22)(_$1fzX6jwRIFH<8<i93v9>EjZZ=T@}SuWxlke?VV1zFb;5
zo{C}$?OcEU;kw<YVPVwRl2B_W;kztK-y7ybyGa)9GiEb*<yWa5eIxhRXt-`aGU;1b
z@;Wq`L}BKv(1@S!YbME}j0cUWW<24YF&4@7rugTjE=~q!kBfgKeK%~~-|PMI!jw0f
z3ZMO3_{WyIk=tys2KRzO7rO9IT{}0|SaKez>}I%~+#4B<FJ|=C+E^bscNJUwnog?_
zMHaoZ!9j+9KahCArR@;!YJ<^^pl{L-w$`9XScfRi{QBsF5uPWem~T2Bd_ec8!w{^4
zSWsVam<|$@^TEOjHJ!h`upPDdglGXur%k_@k-pF!+hRG_qa_xc#y9c3?K_T7Yo&lE
z=j2<(2^r}$!$J5a4~lM=;*%%wi3b?*nA2r<Q5vJPk{+U!N716>me{1uj+;@r?P8*R
z5TWe$Aq_8}d~k)R?g}po@ifFk1O*G@DK+Iiv0X*9SZNG75g|=9Y|)3qs7^k1N*IT}
z;?s=0kWY0aHn(&!c<L>?(I|a|9$@MFKHY|V6vutz$B0X)>{omTt>t>5@9j{sc{B{s
zTS|hF=xJhN(%1{)YsoJ%(V5>Lig9(@W@1!e>AkN=##9pKyk7mbrj9Y@dfzkoVcbMa
zj%W1bSW@-ZW>k5}I{mIq%iECX-k|a&n+e>OFT>pQGpILY^r88zs>IKDjR0-oEw&_G
zva-^Pep%I9*#v4q+2SQ%MxQz>d1l_~H{~Rfm+b2ydP!U?%um`OYMP?)h389q&-?D6
z<@RNPWv_k4Q-OD{d+K7I$3MLHgq)tR2wmj^Qxka|=d;{rZV&uoZff3B$1s26*m!C<
zSFkd?FdQ^IG3>UEVL|MKBJl3pOuvl@uZAvTa8P?a;jGh4@O0-~g{@ziq6?lrnYG_h
z6T|e|<C0_L^XKP$9y}KqUh&By52$(Z#jff$us4`Ac!{yh5IqllprA@idP~p$X`{m|
z=?jvAV3)VYF~`9YG%Mlp(lfL|W?Wex9X>h)^(&q}QKyLuuWs=-Vsgblp*}%9ft*mh
z6?>TKqJ+oD7bzb}+D6x=(#F7-9iK)n7t8{e%@xainya%}A}Bg3lE_pmEu>hZdXaj5
z|Kt|N>(`%ON2BUIPZN797ATh25JRKZqy13zp^9zF?DM9z0C8DfI&nHGx?E-7UZFHO
zSu|AwwUAZG1*M^<M=E(rm}Z)vZUsroWf1lS_wt*iw8^$PwLNT;gR(?+F&||mt6o>r
zWJZN{Ff*ubW_iS>@V)1I&tv*6zJhPUUMRa$?LcWEizsU_=P=XjX-dvXrg5gFnz^$3
zmtb`swVN6SUuvWf0jDjxqq@=M@#T{Cia$IvA?7i!BwpSd8qVnX{4hN$Z6$-LcRbBi
z#$G~BvR#}-&%APw5BA(LyEKm5z`gR&btBrrm_LFwIl70fPs)+g;oLEm-`$bl@w;P?
zLyF_j>foAC&)wCB`^x*JYb7f|tLAH%YfEcGtHPYrw;x>Zz3xO>Oy<GK$^MZ`*Lv89
z*C_Q>BYPW1HkX^llZQ?`o!q(HHRi9mp2rx)taF!JV#kffrN^qrOtSlRkpDO~sqCou
z@o-ULQEczkp8mB$j6Ry7FN0sEl$+RF>|n+b3u~^Ydw7eM2}43#mC$Nv-K*MxyXJIj
zC~GByut96fCzib2gxt=SOr<rYITmr2Q^T<%JL`wT6Yz{t%&|PUb<ySG^fI+mru}WF
ze&;84UmezsyKg`L81&Ix;WmR}hMIzDypVtZ?-Fm4&BeE-2D)zx`R&~vDJNAYXG=HB
zRx1kijw%kzdnUriy`0wUhipwNH7bSoy7#8t$hTeUIiII<ggh{C*LDqfL?$Tg#^(;(
zu9yzmJ=|m6-Q0h=>wm~}<hq)(7PqRiCa`L{1s~sfE&N@$+dIdbO)jG8`9S_-G;%a`
zbX^=;%*R)vFomwM-@wBxx$><ZQa|>Z>iz9ESmK|=L>XBebe1C?q~x#X_stA%=WhpW
zFWnlvb#iMXtiPox?EPI~3D?J#!EOYW<oAQD0>eUNK4$r!++L&5!5bsyVY8AP?{GPA
z@$#@oWxYc`BhoO8nuH-hbe(>bfrx%m=Vh_YO2b-UKk-$f1igE;G1bRLc=Sx%D>l6v
zPK=eG9!33-&3!_-;9~1!r*HeHY^?m7poad{Ey)0LS(!GaZ1dI9{u$1r;@;w0HN>^?
zm-G|D)yxRP$1lIvf4nOCHCYHhDK>J1MitKli_O%`_<qMKUaUX1q~}QIh(MuKlkY4V
zo^+v7Z@jqpr&OG*f_+Rg?_3=#$;}M9hjI$6YP!t2qXj=4M&22-?RxBaX$9+dYE4Gv
zMby&QdSlo(O+vfd=Ao83`|5;WNp&~ir`@EppFVQc=9Xyd6docfh8<xTpD=Q+UGdsJ
z`&_D&tE4+zIce-U5VA~lBJ5<9Kap?#?TE&zC+J1aZ0~Fy86TPTxe-ETL=ituncLCI
zX}HStnp2=ndo^rR=O&afY94ys;@ae3Swc<q%d<0zKxbXH5*FB~%sA7;hz61BV3nNr
zP?VlQdtaM7vmnbV3l}qws@HhO#6)$op`sqtM9p>}I_X4sYHAG*FBr|QaG-KB*sNJP
zGdzS}HXNrd`kVrTOyOYPJfsNVbtwN{kiMAzeWs(t23G8JEIk`GCRH86J*3sY0n^B0
z6S@*C6H+ah=x{#iUx#nWK*F%5KoXyAk<3lNB^K09DizoJ>GacFT%|Uu_Nca=HkpD>
zqL9nur6)~V3q^5Vx4H=9<9L&tz1CkZH?%bM2clU9j#26bR5~2l9WQjU_-f?p9aOtz
zC5(7od|E5v7)r>4k3SoKS+QbMRPe1PWk%!7fQ+AlpUj$X@>R`-LuHA%*HF3D(Pp4?
z)s}8`dxd)uLu$sF{(kjYwSTqeQTfq(N-WAM*O)V#^Pbh_m}W^ug2YIn0T*pVT&wkg
zCyuA-S@oGfqNI>JXB~;lLFN2Wo*zaRQ<t2<%i2tmLK1$CbpemFh1b!3c@lZwrLZqQ
zABVIJea}-w%<M=tzZ_qlCfkYghm%cZRSO(XZhDSs4iER;jHUW6OysG2=CI5$XMYww
z%*OUT+M~(y{+Y=x?7)5cs2M*NAD^Z)=FtFlawsGt6=nO78YR*NB~#i!LHEIgjv@&s
z!uwf3o%ig@g?k%0N@fZKSLn3^Pc;hpSV(c{hZ+wWl;;E}U*b_L%vs1dJhxT5a8Tmz
z<86N%#xjhrt1VdZx=?hz^t=+0?KHi$Ck$~szfp>1ko6s~SOsHE854PV6lU-o3k4lQ
zih=>2LBM|@2-$z1KZY=(p#6Lw74TpDf1V>h_3K|K_<?-&^Cw;2AQK9T2#Sn^sHzKO
zed21ou3GH&Wkz;IHhkUP^zNAgH3apc`>>b|1VTZ`BhpXuG?qB}XyEC*+Ql9ffkd}0
zK|kb;D3Pdf`{NeWRJ5x`7<hOsgClT-j7oFQuJQr3tj+Ar)!f`{cg2A`p`^r$cD|$d
zvq#Q2J1c!%j*|US$J9P3s91k|P%=W@q^UHpB8H&jilF@QLCyz-?<VSB{@zFADK;)O
zTif%c^jm-VdvvVOz3YFxIdW74X(*80FXT>Eq<_3Q7!|mE*WZT!@9qEpZTv`r1wH$|
zKfAV%NFq8-n6$DSYc$KsZOmOZ5g)<J#o`Zt_9aOgB?AMt5JcA;)0R4B>x32DVWn5{
zdk_T+K7)d^7AqNM^gS(RuCpUK85w_%#U!DGAUUE&F04@E#s_xze;z@oLh|!2H@@<j
zyx!w_x2u%G7KCgoJyNpo<-@EZ@}dgsReJSka+VI-c9j@u85H6}xdsLbtq^YI$FnEw
z`Ps}l8_R(SUtv%YYU=uD57vgbPhO+9$WuN#4gT{SHt=|l&qGqJ5OOlce$6<t+rx5$
z<!wySa<y-rX`!uyzM^QDZC|xGVC@O~Y7A$u4qIowNf~WTR;wrLV&)ro?9jz>*{6S`
ze8jBNVVA%SHZI)v8`GbG;ekQ&Vo#p*x6T`8))JWA=D|bK1E$_dr55xU<CGz)s;Zi5
z2hO!#p0EuY-g|P<_ai1Mk2KG63_R7YTwi9>t8|io^%%1!XDAmc{vIcAYAbqkqOyH^
z=9^J}OPG2^)X>n^um}bP+2~xo`MZ4?I%aCzR>O>rj*f#R``HJQfke%D0#@g|B>YCw
z9tPIr!d_yNE_?EPuDfrr$KR(}Cke5;{dm~}@j_^Q?Jbc|O~SlENsG@g&wBskfM)RJ
zO~@`en!W3vXO^!hl1FZ>Xd^f%uBSfKx*)r&sZ(H`@cz74jx}t_z(w?MOPHGfS<Q<D
z=5o6k!UCGXqs{~Y;}aGZ+MTqd426V3_2fK#MD~va0jbHUiyF@Cy7Hm564d!K^TT$^
z60t`+5oHD=X@y!o9s}6}yOX7s{!MA>X{IBeM+b+hPFHhOslDNjHJ=N5j#0`hM-mGC
z{=C{)1Rs1l`4X97vK3=}jt&zZ-VUL<nC%Bk-JiufP-om6UE8N!w6tO)qoTAI9J@VE
zb~PIF)MFUDDje5LVA>&i8cBUQLx#eh{j1x<QcI$W*MrxhKdjoFHYJ{>Xygea_6-c1
zuFb{~&SO0MIFA1308mWO%{KpIKV@z4EG@z9ty5m&qlN9TyMxTT2uvL50UyX04SzPR
z?A}kA)MXd@YeR}e`UTXKPlkNgYA@%g)L%tL9SPXYWAz9tULKG*UX(2-9|?P&s@xB3
z9dw=y>xhFlh9q&g7REbI_8-@Hg)J9(pSjmp&qol>@7ys#`*X;^mPy|6`=R0MoNi@$
zz4B=JR-V^>%Tx18w+*tLX_q|x>iHB6){mIYju4iERy7To=(aYOiD0WL#9=J?Mg+aQ
z1rhnsP;Yr>Ud<~0>{HkNYb)YDRiTd~+(rKwAbrb3wvT6youqj9Rp2R>bWvM9DefNd
zLseKwwfE)4ae)?x>329j&wktXwRF8umrU`o48^3<wl&pzeXP=+6o}q#QNJ&2tLxoO
z6uL1e<$jp&bMO2yV2jvZT~?(pP&Dofut^Y;^mf>;aNg1{=#!cH*2&MZqUny)_<F9w
z;%mp?Y6A2*8BDKha}K>_gAy_-_2-etV@2-s?xD5?b9cv9P*}1QobSw;qRv;lA1Mez
zxvTy4C3F3jDG-gQ+ZFojX-P1>6vaTH67|l=If^0nh0bM$KRX3MiO5Pm6Umgf>8i=-
z%Llh34V#0t1|0L<MJ_J}o$hVHag5g3VV(*D16piH78@Ss&6SR8M8b}{^R35D*+Cm)
zQ;Lqm!-nWBK@|M_f5AG-s}6A<jyf4*f<v(tmilEu5pq$i5lW0k(B-}iMGr0)V@b)X
zL4mC*vMH<b0^|0msQ05Kd44+u)Kvg%-o1OLzP2$@2_LYhPox&Hn$7Gn{WBU!vnX-9
z1gI*M3tE;(VK`9e@failL<@|*2lYHV)RJHIIru?B<<BGheD=-p;V92!C>kbC<B=g5
z)#fN&91on5IwVcsUxFq)#$HfexKvwjOZZ^lfbQXj?AIUWdDW~^aq4Bw!Lb*5FHUcC
zd;fV1BFS97Ue~rlKh1IV=G%*#OMaqYBNNhcNYM3o%`7Q<@2#w*C5)WkK{J^A5i=JT
z*A8^9Vj_^WLdorLon)(F_@Uwag!5FyxA!*#acpY0XXV(9TAq<Saw}G|K0DkfH0{z~
z)2&ht3}V%*Xn8siby0QPE64u40exk(BxhfFBQiR=ecaW4!Ji?Kp!#)HLBUhX%XWNr
zkKqR-DWijslLV^u;?uF&!tYxZ1TPzpE2ppgg-ZHzqvHr&-p$gvR3@Wq)V56An0E2>
ztQI^J4uOwYts8;JiUiGfI3#!i{p)9~8HrJ)c5l{nXZarm;MloW>z|w-Bn1u$+iWKb
z9*ytqAcnsW7Z@6Sm->=30D>q(qDQt?zK}ZW;iFgc(jymMoHxrA(DrshJUN}(TCA17
z-sZD#_zTVCr%6VeQZqP*5u&rLj3_pyiKVPcS+7MhpX!$S%~g08^wVdZlC~ozs@<K-
zr_c9bK2GNKwtANl8U}QTfj|Mr>c$Y9cQ;8nrE^c_2VkW`wFbh-U|PcdsGz2K!`~oV
zY=M6Wveg*v^j#qe3T;jG$2UG)*D4UthAkpKBt3ZPM>v1w29ciRA9pGQ-9Z^QA#vf@
zf6i`D%Ty+-E83AD!O!FJ0uAr_6{8s0lJMKAU2cZl`k^T0LC2gye+e1X&yrA>)YpqL
zjQ`?kC=fCXtkAI!ihm<jD5!^5ajD^5iBW&$`xXRXN8J^YzxziJ10x$|5b+roa@T(R
zm$~BRKlS;4od(42Y~76H&k+Dur0y{Ub)I{+kMqw6MeXC`i3*_cUqk$Bi2rc+e?8)#
zB>i7Q{A-B+8#e#-h<`oe|KSmIhg=g?3*Wy#)+&A(W-(m$bTH3b?$xVTMzf9ncAMo(
zE&GA2;Y=#&oO#_ZtXsqBl&hU!Uv=P<*#gFG<#wI(_D1!u+l^a7@7$Non3~9co^sEi
zMt9Qf?EXlVYv4x;0ri6!-B=Fy(kBW0TnG$C-@j3s>6Z`<3D5P-nXnY8h3{n6kzD54
zIvZ^p@Jr1ax4jOTCC4Lgr=^75HG@m~m3Sc~EiEQ*_d}A{2hYXY_Oftlwi^QN{8kms
zlg_p(6?4lMBVY-Oy#M!X|95L22x>4^XjcrMoYVU7bK8}H5e?QVvBw{8GqGsEB2AMJ
zapZh<jr>OuN#m?M-U}=pnp-tXl;vx=NjlB%a449QPJRf>git=}&)(|TZMo}R8oWk*
z5}*;)UgwJzHy~e9<aY3?{IEi?Y0Yy*&VaxZ@Xez(znd4LtE;PD?QaV2PuaE7MW<Gv
zH~)oWL(s3|=06g-0I~wRX{T=Bs;Mv{Yux5rbX)-jDx`dIbj=7Rn`C!55@FOM$JW%f
zW<SU9r1<sV>3C6>Aj`sn@y;Gnty#;vtSY(uMs+T7v0!k)=apL$6lZ;reU6~I%vaFJ
zbFJ2Li$a_owMS+xX)P^wCfp5qbo$afdgkwj`-WlREwhx9S3}BhI=&=CHWh5?0vLUp
ze2)VI8IKiSLNMK-R)L+dhvX4#s-{HC29!`;E<DPoUtjw=8zOY5`Bgh-syUb<5VQF}
z_8_Xf9rOBaYPi?gm^xyi-QX6*gQdUeB-GE+eKsJwlhtlb3$n7>uBMsoglsBL^>0n-
zm%m6W(Nj~Si#G7mI(M1<K2&?iWv-E7Gg4%#IGdHavASBaW5_e<BJLqzd)M~u+3JAl
z>ob4j;lDChn;PV;VnN0aP4u35d+cN(Ui)S*D<iScN%*iQgj<KM=CTg5c6@9**SMkJ
z$@1-80%2t&xsV5MO~R|W>Cb*U-|lOKG%M_{^fkNfWK0S>94oCqnEDS#`JW^H^X%Q#
z)L`bN9eR-IF&SLgac-4$UV2_4YNHYaoC6e`3#}&j%XiY_=F_5yv>sJloUX+ktasPH
z6sgo`VBR;u=nt;(T905A@mf~moSvw3wzj4FsvR;A;<>hWYQL;B207Ant@$g_k7wwX
zRfsru+V4z4sM0IMP{Tc!1a^xAwu-&*+>_CI6@_+)Nix&}7`$Gvv=~Cx8tn@<HYeO0
zx%+adg<WS;)k+O&y>|Gsxc8ZNfg;#ipH8@*)n;@3ucUqiwKR`<NbvM+bZx~}je1%z
zIUkMp<(Y75K|#R)J1pU);T;!csK|p*hmUA~HQ8IHXJ^>EFdcZCsnD60+|hawL+erP
zrDwU#C@0jsN*5=afLT%KB(mho`KJ437&J${mBZVUKhe6%dP?YvK}}X)LGdA<*SX7i
zr2fgoAVXBPBz$a;!KuRwaRyhrXT9`lO<@UkpH%EG*$o~>g}OTJCTWQ!7{=83qVWCv
z&*Jaf3@E*I7rWw2tI<_z9qj9TAiF`<=Yi*&wO-~>tx6}@J*`4oobfyZP7%-f<(}h$
zC^DcJf1rBBLKw)}54SeR`Kn)#Yk)I4x+J3V3M%CJrMyLlB|2mdy?O8R6S6;Bqx+Lj
z>qFTwjZlr8WcY>0`5aXQ<)hB|Yl@9EyKO9Um0(|nx3gCM7|m0LI3Rl14lFi`Ot&VF
zvx*_RLOm$uxygRh{327kDQKHWX?8|aq}rH7;86bJeh`Izu|EoG(_P%N5Y9cLosWFZ
z0Vt>x_|Fp8V~Epki6kGR$1nt1|0p*^$6byQu}ECkyuTD#>WSe>joWdir>;Jj9iT6-
zucc*{aPx}ajvdf+;H8eApoA>y-$NLz1h?zZ26Od43mLV9Hmb;sEhTyDpAU=Qd_+E_
zFz#|ZBQ;w|tmpFFBksmu^V}kIi<_Zrn)!8jI)yI&v{!2JNv7P^V8_`TVD~mEb|eTe
zQ1aHEC05dr<1}}z1o2FH^tnMYColRla`80+d7KjY9c7aOy!QjP<=CqGM=vL~yxF8e
zxVtR%b#z#2tB&;7&fgL%MAZ9XHm?=_HF`aZLIOs)y@}2X>uN-)$C3L~#PGETh96Il
zHEItJhI4`R8LKwwHgK|(S3AiMH<2&Vbv$5Lu!T0CHxV0z8;pCxJ@yT$LWa)f2Q-@D
z2j77&*BbA~6zm4+SeZGUpLR(a+|KUH{E^5ZMd`79v+!jP%}HO<1#Psho0g!`Wg44T
zmewPuzlM_^cs5zlPfIVj+XTl0^|>xmsHRxGfv3O*9hjkeopH>M+z-Pk1SW|S>;(@`
zBAD$@7JAO-3JfbQEa9F~Kq)eK@jkpJ$?KFU)~iQyXYSzO2K$Tomg5Tn9k}$-=EU6D
zP2t@S9!Hf^fuJ4Zcqhc0*5GVaLx-}|SU76#{dh&`b{``u)@|xKL9;sQ9!YfEd^I1}
zUUe^0AZnrkFS>D?wgMD&O0i>v6y2;es01(^y><fG64^Z6j-rMP3=Co27u(<Tb~h`x
z+Q4GKa)U@7X<zI{HyfYsbBJzgCOLW{dOLm9(9(3^R(7(m^Fg-WekLWM9e>4^OXsC7
zqt*Vbg4sd%kPeNz(-zRAdD@}Zh_zQV@UF!prD^ZUlfeVA&&dNJJ9EwL4J^5#-iRTc
z1z=)_7q&WZggoE4oTt9dndltYggz=5F$@X(?EBXs=<zglf-8|>$y8X>)2fg~nT+7;
z2ml%xSYRTfHLnG2sSjQp0#MGWJ0Rk-+4ezlqVFMO43FIQrSC<RSW-wU>hdL)TwB@^
zOTT<aAEL_n76nz3xlT|k6|Kwiu8&A1xYwAxq$oNrqcUW%m4?E_iVT82djHv}pjPju
zK!>;}0<QyLkG8Pu%g*Cz7om?Y|01d5GO9wx40^RP^T&z*N{xzuawOpHu}tx|PlyDA
zlF|}ZR6EVzlp$UnAp8_Hzn}cG01krQytEIBYw)x3dw;u$&%eX?&AR_u<Dbm!Ctv#4
z8vk13U)=cr8j8x=Iq0zl{*w^>B)T|6A2<`k>uTV%x<v!4X|=DaTrd+^a(h{EHo5e~
z|HsRzD?t&UXsvbNH}+#wEK*kbm~`^k`fAmYY?0TXH9?k!RF&bP^vH<;f%8zd$<oMg
zh2Ugd5cP;>Gwl?Aqu8mq+grL!H`=$tJ{Y`jQ1Nz{7CaU$iR`FW^Y~_(#@hJwH&%)*
z;X^);!5%t(<u}i?y!s~CBH~oixs-%FWMBy506Gz7e#>t~?py<nKl42clfRApB_1zg
zc7vi6JSy_*zQ_J;KrytS;*#3)CGWTQjHtVhH?QFdITnB8`j!#=A-5g#e~Fi`7$LQY
ze&*eF&)*_(H!bdXIlp0GXMac8Q|8}-cqjuzzc-fQ<)_~aLrsPnCgLYSs>qG#mn|#c
zu9!%!#rGmr$nu!Wkmz?VJIw#k4t=`!`O|%pffT&o=1z}=OU?5<a{2Cm-xI07`erSJ
z2cy_Azmlm1R;zQRf=n%W>@+Jv+SAemhvZ7Lqv7e>1drcr0r(2){9FFQ-{^`+CkBmg
zAF~U^4V(95FMK!C)yDa|H$pI~QbeuHR7I^2DeAs)yS687Pga-_6903O<Zr-91fD#`
z`0t|mis54oQ3PKpf)S20cf*t;B+w?A^CxV?HioiP>G-E%M*|_FA)J|p=^ixMDY3?y
zw-g5?R5ruCeluD3b1*;(`V`dv&eCTNo#r{q4H?b6;b4sNICUqfBS$5jyzN1jGRN4L
z$vUd1q0-%3Wn*SJ;;h!OWwI=i{UJHUfn{wK*<0yU=9O`yTlAZ6HtKSRQlB?jk5*XZ
zEa^f$bsjZe{qMjb=ue12ZSEAS_rI0qWFK@I2w}dJDoZIWery#ZQhgMUVpttw$ubSA
zbp+41)!C9iE-W6#MHJF<>*lf(P9J6^u@la#Prbk>cdV<dB-~cGZX@M4&AhBP$)R2?
zK9x2nOn>2cd3Q!dN<dYS7{|i(sY1@c5+O(Jz)XeeZ(V|QE2z02PI;>%_VXNlM=SaU
zTXUg=Fyh(kz$QwKs6Qek1&_xoJW*$o-@w#H<@w4TL&s$0@oqS*CBqvJ9kavJso|X2
z9+NYno`}w5<7l`lMv<e94n`@AaN-pmT)%vy@2p@W-MTt^4EuEs;UqtG;*#QW3pd}v
zJP(J}z=Zn;Rs9QmTW46?F{vtY#h(yNPesrNlX^Zz@%2FF6L{2JOMT&frBA$3>_r;r
zfD+<s0>;(BJ1m-vhI)&zOugP58by1t+d3@Aa3E`Cj^W%VYeg|Vm{V?8UXJ!I?Vhc>
z#B5IaLADh|_h3$iV>Vv(7oCk}<(N!rxPrl#qXTSf+pLN!p63D@vfp+q2V6?3XD8KW
zRgM;w+3+nboSa$n6x$Xj=xb(*K2ew=Hz=bK<l>Q5OG<n79Ul>H^e0ISS3^zbnDTc>
z(}jJwdwW2|lfWNk&nWCVCwwGZgmxHLUZ%JBi+}}20lvDEP7d5WP8qtqPgg)Vaj^P{
z9`X6J90sf%1|8uqyRW_q*4|3H)e^Qi$O2FC-FR6iK)UP%jVxK!_`uLm!qvO|J&AUE
zG9VJZM8Toc)_EEJp;AJDtwvl7vy=h4r%?8U*<}0$REED52_?yO=*LG!zBd@*0J^k@
zA9yCxiX<LL(bN)iA|OBVh+tp_53wI863t~2Pd}0pQx6p&*QuYtZSSFw*TVCs(qO58
z_0zdYIwxrNz+O+Jr`>zX65Unhql{VR7;JSwp)&wOn{YFB?#s4vj>U0X6M-veeZe!{
zGlTmmSmF=E^+^w{OI9Oq+-95fRrzYb+{pGNvHElsv+;6}V@JH;hH`Er?J-ztF=DXn
zZ-pAhsZg;T)a&+L!%<vKlThN;;x14|e@N{CZ$w9W<Aatf6JKz&rOpe86<7CZnd>Op
zn=I3qdYbz~N=9`s%3uQ%%xuod8xFS>?%J$G(z$WLOWbranEkJmr;V&yQk)M8%hy}2
z>GG)4jy;Ikh-E-?ACyIeduw!=>?3#ztitW+=<9jF`W1?}FSd%+cyHbSW|U?C`I?N6
z-~^VydDY6z<ZrGkl;ATyV2vTyzw}w%nGac<AM~|kA%^Rh!2Blp^I`V(Yo5@MN+w5{
zb&SZc$IwDrJg3o#;t{H7Ma=Snz&gidomvOwrG?Vhqw@6|>ClNm=FMYU!tKK-xT~H5
zzg%+lo>AE*E|W$)m&5)Q2>LE<_oOSk;>2eXu&Q;osOeo1=q(gS(vDxnfzwe`>c}E%
z{S?GN-6_+0+OOpMilPiBhgeA)V!>i8W3f<r8k}*@zs7^TB3mbKSv{v*9Fp=umog9A
zMkBM%>7JU5O7fVj7M@NM#WfdajfIL2l`9L8vvy>Tc@EqhzBnBb{0nWQP`d?7<y@n5
z`TOX&51uBA@1^?lNGBn;qyloQ@-vIn7`5VQRk`?o^_;sgQsJ2M5hVJZkB)T97ov2G
z`ZL2UaiF<6zp4=W$U;S1r2RsC>r%^WjOg~zJL02X<5uV2-5@hQ*<IKj9J6j+?9ee<
zA1)Z=TKbWAUnN69Uacw05KOo<xd$i`1W>R7&u==@DpBc`Sf<gM$?APkw@;E$=_S}N
z)qg?)yz}+A7Xnq*Pl#E`vKn}8d7M7KtBIO3r@X&FVunCPo`%O7bYgag#399D0LS;q
zVk;87y+*nQE-%CEnt~su$fM)7<cZMl8F{%&n}gWxQ;oDes6a^3+&WpPK5FwmZ`Oka
zFIr#j@$C95deE#?<(>fnHqzkolt*T1-?yzz_GGN6tL4pAeC0$%$L+Vo`jKQ-RSyT4
z)`k&B6AVMTd#&nSOM7otZax!&y#%U6fC^Aod~9!G#wkZNqK>(#IjcO=@m%Yt!@K6T
zMm~vzh;{XP+dh4fmHR4?&Gbk*^?V(SB12zGisMp!-jRKna+HLDNLE`W`J@MK3sfY1
zkCsWpj*CVY^q9xfhpq^&6rUvvgUN{GBGHTD7B%Puykxvw!W1t4zHCT!7NeW<x(ji7
z0D5aY)h^DL4GRsMan{Do^Kzq}e|yJ8)?T?)F11;)wlr9P6i!Wr_7r<lq;8h1x)%xV
zwj{yk_@!%Rp$qIb({(0}DjQ$*tF?2hH&u4r3{HEAB@LWG!|U#}pLb{l|H0D0>fW~a
z<^5<~JO2{PrOSs1NO50qDbOc*fwHv6)d?VekS$q|<c8B43LKiA$~0^Vn-0dPa}3qN
zsCINk;O{TxL}-~cyFrX&0d7{iC}R}C#>e?TOc1P>s=MR}j;q({q}`Kod6-t#-_CME
zJ^jE}p(8@Q4LX$*$<jqX0j)g3&8j+QnBCNdIs_wCYabcZgij3e6;DrrVv1$N2zI}j
zyN@6NcB_=hk4U6WeuKwD>tc(-`NNne{nUc{SZQlKpFM2mq|@0d!n^ul@K_0ydPszy
ze<3UuI$M|7UFYbMb#>J`KkqeepFdp_w%)kh#uN_qK8f}YPBOQgTa2q^_P%Tu{@OQS
zu5TTcXnc8rU^iZM9V{=mUurQ75gHve-gO$^$9!O|#Q6qjOmw)pu(0np6lL;FQr?8D
z7j8~WxMxPHCfrYp$h)K2_q`AIDz|36`I>Qrd=C8J8sps?{y7zD`c~#@aBM3bUu%lx
zK_)pGOWhH(3|)C9IaQxZCQE;4VWV5md@SKOD>QJ-vN}c?vq}v`_cAj61pcmXGvI<c
z)L(@A;*m@n^vQe{2q@`TMuv%;3;HX_F2qoOpOw8-prjhJ)!s`w8$XCb{G%^Md>73y
z&;o^?C!aWFymlkT=9ci$roCOZMayRcFm~(<f<nA!nYD84B0_FI6jRUBCJ~6=Jp+AZ
z?9XRu*Ty>xPGpNpUl2Nw#<+W($eBAMDtL^6I$xkt>VXUouOFv?@X(EVkh6t<nZ7hu
zB{h}GlIHQ9XY`)ozD&s%l?*!nbfzBPjW^S!j=Hrj$`pZltLhLdXoUo6Kirl{&SOy4
zsz=nKI($sK1O`8NWmTPrI<^CyD2SxvABL$!m3^c%;SUihMK3(qk^%T<E>VVqip48W
zt+SWfw;6bW%;-n(Ky1C&N+gj!q*Y`Rq;{~HlP60;KEzOqfLUt^-yiE1wMS%SXNR}5
z)qY(tGrwFjIQv9MJ!GbRxIS{%5A&vimIBq+TzxWO=eZ!BMr5-p^O2^H$HA%wMMR)r
zL5Kws-<z0~&gMH_H63pj!?&jP<4Y>4)=Dm+rC$>;9J;kJ;otc6{Bi7bnB-oV$@asA
zE5Zdxu{0o7EIjaR{FlW=V-!{Z<iG6NHLKf6sYGW+%W+p5v6Jo(`dSfg5As#OpyRKM
z;ip9KjmyZDZG<ue<RCU0hfvm}<Fx)f8HIAZ;X>(GH!bKEWIy8w9RaNqY!>iv``)v&
z%WT2?OP?klvssC&SNsZP7I5-%bAkBlt>;mrOd{+RubXY>nc>#Dc!AbaG1nYq9u-Ar
zEBNk)085Sg@%9Wi+C1h>ijUD0?4X@oz&1rONoX)o*pYQt{QXV3#1}v`{n=4gZCCZE
zen*qoag|Un!{ht?0&%{R!7P~ueo24A`N1i-gVNI;zB0cKw2}G=>v$P05DwxFZBO>E
zF%Gm@R0oV<o2(Iz^WXQ!d9`MVNKuJud_C@Fu&{g>73Y+*571E?U&-~bo$d5f<aI%*
z)o6rnhhxSZ-2u7hs(+r$NYz*)kB9m>@9(voVWwy9K2;{(L5`Q8zdqDD8#?QaSmWpr
zO!Pd|Iyv&byj&<9yNHH*k1z1=Ep@-gd5kt%4NA=F47M4jU5Pt-6x7yhpwRcL_$OnL
zVNBsUi5*Jy>dfu_T0scX#GzympzP~uLsjpu@q_(sDZt>`LZw%4iBX;cNXIaRK{c!|
zf)k?#7OlDp9Y2k^Fq0nmni5hj>+x#A$yLQIT+>IVHdGm-1Qtmr?^@>AUCGqFG05~p
zbz4W*bn?#Za$KrCxQ#tzt9xa(d=qYWnnoqJ+}-Ko9_C}PN<6_-e>Ga>?F9y%HwGU3
z`Tqp!I!eeG+PwSWddcQ_GknSlBf&9u8{-;LX0#zr6zI)urMlRbT08FYzPLv6(BsXr
z>b(L*3yg9cP55Dt@6j-Wp3nKbe}sCE7vi)jJN0}pr{zFS@+LRznWEMQzn`w<ivMza
z+vvMxg8sR8(}eTKlI$_rr!UgD{I8Tr!aP2{c}-$4RvN&pv{9%WwOmXmU%z&oy}7(<
z=^V>%wXhfrTMS-YB7zT<TJ=2ubRo(IFqmuuNtIlSW1XV7y9=@$IKP!$EC@i^p0d)p
zn&!-q3XwVPzQvYSb^aqs+j{}jZ?kiRnfTuy*CLjs3T<Wxm9@1=bD|Cfp4YpM7WzJ;
zwj{y+xfgg9sWpop&MB-wgZy*IIBJw|m@BFPlDxujz9%Uom`|b8N`VlHD3!pdswU)H
zz7dVgdf0K5SQ^_iy!B+SB*?WvuODZ={?Fc`4s}Nwd7>hl*n-P*v-VO5>a2?}b8g76
zo~qfk7C!&%aq^CAz9sDL?#z3twwQ;8U-5wH3s9FprCu(x$7An!XKn}0ZNXV5Ni#dj
zPd-aWn}w{>r1k=#!xDZpR{(EXtbR_490fUbci8xx>z0-OX<Dv!$9*AaoDOF00sJ7P
zH#+l~^M0AE;ukw7DSKxr0|h4Ii8x2DFNgbzqag;+?WER|xKcq3kpBD9`^I0m7asA^
zXiVNMJXZ)yq59ro$fThVlE{*{SIazWc2SEli!p*sLdmH^`&@e=M^ePdKYT%$FDx>t
zhk@F^wA;=mhaKE}W#N3UE6}p7Gl8lRZ60wdiPkR_Oc|79U2Y3HT#i4NDi<t^@!!r9
z=EtS-m(cDI_ey3ekxdeUWjGbEHeUXeLRtz$Bxo>smP&6VXy{aX^kQ3qBn7TaBSf(r
zd<8zie^h$0!;MjS(9Q(2=U;}so|#|h+&H#z1Pu3aom!8S?zIc?hP6xD!h^Ra2q#M&
z))~L85AKt-{thJF>*NBz0PyF^&nwp*qMU%RW!w}1?Y(<P!=;@p_p2)8U3!Q?^)SO>
z7AY>Gd9O3URR0`bfcR{(i09Ls?pDT)&?EmVEsk0g=v3Vfp4C)m%RZF~m?^>qK5pyr
z2~&D3YWeSOBGYkN)Oti5ZN6bS`lJC}Sf8oatxv5RmCO|Z*1H2ex)X!#^p31n2}wG&
z$;xRgJ)%}ZU~D3gYmMp>iyKoBMYT-6&xvW%bi?q^=yu0p%G_JrJ2#Tl>So7DQL$p^
zLyug0IjK*9h$qR08^<93R;hh<9q}aoLH%kSvZr2&F|v?jtkg1uD#_z;WM^Xq90?lZ
z7cR#s%sBm73!VW?Fq_yLM@Eg->z-}eDY6tSoLIKA{Vk-?nXO{G;h6guZk7{bQF>{t
z8eGEqFHY>0kJg<VYj?^Oz-f?>>boW~BYa6=y|z?@Qy=(dDLB;xtEB=f%?ayw#&MW5
zq)>cmh_-POSoLzxU@oUP*6Fy4<%PReVcoHBA9i3D{I1UtVSwtg0qE5k+*qbQN}}@Q
zTp4u8j!3$kB_6b`4%fx3FiZmEO4`ElWa4Q2{)`Q;Q`@Q6UI!0IJ~X~=D0;3|q((A<
z!$hyt_4BZ5_j~1FhP7vit%c>D#qthwbMuAhqe=6G+U*82c9-pGlY?KHWJ|8d@-j|V
z-bHo4(4l0O`|8-N_nFq!B-t?a9KF_Zl_QwLZb_D+4FNKuQD>lTw$=0kOv<XAJ#kSM
z@Vy_Hc9@kXS5`{DLXP>Hn%0u;v*dKpx`-j*1`7zl2FI*YK_{0&)IBYlQ;Zl;kIZK+
za$FPGt={rfjAGS$wc)*0IR!QAOK*x}WMaC7c-_gPO6`#+n^tJIz-(KohdgrNdT8w(
zVLiUv;WCmm<ruxcKEhFRiP*Zd2K_2|Etpgu)YphvKT_qXX2~YHE^1vxN8LT13z0K3
z%L3gp(t7S`9(y`d>SOO=g~I3cH;u;2Y<Jw8ERWTM4>J0fN^-6hBNbsIHEIXDJZ*}L
z;{LpIC}*y_uGkq|Hud4B(d?3Uf@qKZD|HO~<N15F!y=nKBZva5`<s}$Y;l2g7>OV{
zmyfb0`=%-Ed|gh1BByh?UJbZB=%h5ugw_eLeaLBkwzDtD;uVi<F`%A8E$xgrsnHrm
zs>|%SfQ~t25soHkI!F6z1~3N&1?|3N^C}qNWU6QzsyS6V0cGw;Re{^r+x}A|5ASTk
z5k%~(up_<%zNl0-n4-S>IQZjMZINT3!`9@Zn#=9GAuZ0eXVu4E?KdWFPEav;yx{ZN
zjpFFN$|Fw&w3cb~hK$2N@39w96^}GP%B_YFE5hw;Bz!=aV7ujPOqHXs5y1nmtN{tf
zirdE4=m61MB=Ct5*|gO%9C%+-V5<-pdmlc<HlJXVrRp(HMnh?E=O)I{I}}tLLYp?h
z6(!0FB<cD9i1uC7`BT1L-%Vu0+xe0B&DN;<I$w#O2LlGZ_#+k^*fXG|s@`o&C15I8
zQp`|yT`#x{L$a}KaNZAOF#Za@c9X74?F@M}vh)h^w^>LpFAm|>C9hXCvIpjF3T~er
z?+m|F=qP--^TKs5sHD(#jvlbMDqWk46T6+Jy@kSd)<D7{#MnM&x047zV1cDTA;t;x
zKEu0OQ%hs~fL5(}y!w5B^ZdP?Aa&6l)*fOm_&tr<Q=uJex0;0+lQXvkmy?e=pC}A}
zN^0s5DTF&ax$0Kjal)zGms*A!?<<!?vZ`h?1_fxs73{#8;<kMDNm*<qpJa$eHh-}b
zBA57yPt^j-GO?4JU}Dt!q6%*i7fe{1i`;eu^?rbCN%09MzyzFISVL4QIgQaW&(7?w
zQh@VTi=`DAXf*mI%Huh&XA`abMwv;4GwcVstz48}bCJ!lv>gQOgl88?E|CwhP0#;?
z6<k7_*;)p)O8tn_w97lUyv2*2+qruF1ET}$yvR@>!io{ktGKx9Rn83%yZb4mZ%L;4
zN{awLZj<)pK4!jVbI{r2<QR0C8w^dg;+RbXvOAxg`(YVf>kFHcc}$*d9#Cf|myEI)
z27x9ia6p6+6_U{zk*dq|`hAFwL>(^j)w}H;ph<w=fNP`9zY|Uca>%>AK2LPqmy*=8
zc`Bki3q8=;v(n5MmojL$DNbeOp}MFoRLD3IJK%`Yb5Vi;4laLH8bmlo7l>3BG84X3
zX41F_<HSkTm7$pd4mK}c*Ry97yczqmPk`dqPu*}btjFn@Rv(oJW_T|hSPdm=yv*pj
zPC{nJi^4aDR>}`|ltx*~S=?n?Kak9-iSC4Z&Gkifr2>hD{#Cyyi0^n0o+r{S$Ub}&
zHqL_Di4R^mB$7T7`}rHBFllw%_v#ewC9m*=RPr(gP5qUt9{Jh}gc^KJ&b4%5N)KTE
zIbY%;uU~#BQLZwo8!>BlE(I4i#mE9I`7P_SHbIb>ih1Le3!}%gfLANJqHbX4fZrg+
zyYX#?e&DM%Q6>oRodCbS3&5))M8p>R&H3!*HWwj*21}DOELyrdX|P^xP!dLv#99-!
zmufU!o?XRanP5TqEb&Ja?GTuV7~z9giN(sf=jv&?uB>Lf(&gb24M_hC_j$T!6a}n?
z<O6@UnlxQ9DxUAefVz_4alN)bI;jfumD3M3?OgQ$16qATf+L(y*)L`jO_ugbz6r*%
znT-Mxqk{1yo&k;OYxrrjH`4JqoT7&qjQ6bYr?#~^f{T#e>F~I&(Y27{NKOwxVRFhZ
zc~F3V7Kg?96m9u|LIwDcKWbPg`e9Yp>)CeNvLbDaJFECz>ElkW?W#)WuU{&8Y-7-D
zhDR>!x`w*4Cyf>ZprOZ(;a3c|Yii6061odoIJ5RrV@LPF`K>1eKRv=~RwcUIw2!Lp
zjm~p?AT3ejUX^<`r32hgz#u|eTyIn#q#(0=YaT3&n*wWMV0P)Sh%TVxp7f{xlo0Ed
zUBe?;=!NX|Ng#9R9}^jZ`qIB)Q9t_vqy$=s9ez^98zGS5(~o1vfp=3xY%U+~SnDv?
z-vmS6Z!Lag>smES!Y_%@v=m@HEF~eBX0|qrY)xWy9R;VjRM4@J4i~_rNQRK8d*Uk=
z!_X0#F$As@@ay_2iN)%tW~XSwZI-sTfyPRWD_Ew6Iu@NZFq;GJ;4(_2XBFb|F5VEM
zsrs9Vze2`~hWD<$Z=QY$0oTY7`TPTH&4N9qFP7-oI>}0ltqqiPn>Y~k^?$6h)EDu#
zRNfn<NTiMqtO^?H=euK#d9P>dk2GY<4y8vwsVjMO)9wU+Vo_Hb*N80*?gL6Zzoo=7
zpnJUX$;pc{33dx5Qvu$6_A);<6VcLk1CjzN&DDDOaF7mWd6l4FaAYvZ4%`y##$TfO
zJG8CHR{#+dY*VR_D)#a*B~)mEj*!6M&I~?g-&A({{lx4YW=0_?kGo5O?RCj6v-0eU
z^sn-f=hbMh5zHbt(Y);<7Kq%eN+0%&7D@Y&xj{I_&oT!?NY+y+P>Km^NH4;=O$$V*
zTbJ&Es;2~m1j40x6px&<l8-e3)|6rg7~IP(wA#ote0*zBhU2@xJ`M7m(_4PU)kqdc
zwhPS$DJQxaHwIm1LaLK@Ztvf*{o*^mQOM7fRw*7LW#uQo?rO@vi<4yv92xg<g|CPx
z)*D3%RhA}VDZg2!*N`l$-ac=DZCy`un%Ib(UAt5zKMH>rG&{$&16p3Fq3`QNhHt*<
zK<Z;)0{14owu!3<7nND!1t!Fz#U|JnjCD!*sjiUxQ*W}FPEhUuSiuy$j|MhhLq<qu
z{H&bXX`}|NgN;<B)we$9n8;=5Yzix(vvHEsz{7Ifz0}qesi|8c)KsWV4-`v3*`+mt
z9cqo-p(n}dfS){2O}@P-BmVxK)m<MS@n1C~fqBukVluE;v6DOpxQr&g(%)=Z7%96&
zcMxNvk~5o+BmfA})$}kkP8y3;t`f-J0VN3%nN5&@+tDfA+cSz|()eybL&#xuXF)cX
zl07%jX9l&2U6EAii31e`-QpiNock6Ll#X=6=XG4Tj8}Z64PnR5Rrh>1+Ubh7C>-0v
zis2iZPmLD{j)KdJGcP^jUD-EM#DGsR+WCI@#2{0yJg+DK4-qjzmE=-1c`N~TE~DLl
zqEFp_qK_Rj?#__E_Y(G1D{rmW?mRg$F1(iRn^p+m93{#g{T@5}q+z8V4+)+n-h20S
zkrD{J9H>pa0AA8K6t6qpVifXy5fA!NBY*aze*C#XcRN4UpsjwoK;icZWu=~G^p#E)
zMWy=sA(vpPNVKU@-0W;=vv&+Tz+I{%B3#I@H;SzkfJ+ni>^K{MMAc-?B_P*1?8|%>
zL~UYG`U;w0gL$37X=Vx}b)XfQ?78Kv=?Vhcd)r<L^z~a<TmhGU8fr@C##cA=*+9Ut
z6xJntq<R_&!Wm1G+^M{@PEE`;P%PV9w%-EboznM9B7<5Rv@h=>1D(4zRAOP1Pl=gm
z{As^gTeuRhk4P9c!2xImH0(sS0yh6zbZ3hy3XM_VUAD;%SiT-tGcQFqFSi}9Rsmq3
zs$mLC7Pf594X{#Xx2SOINyiSj$*Ti(PJ@X<z&1)mMWVYUXjFXaU0ou(YH;yZ;`~NO
zzAl{*Q=E6)@w={9PVp3Ad00WO;Vh~3CJ_Xk|5x~{nls$YMAj#R8&Wy2=C!HGBkK}N
zKolyohb=oWuL$K9$}*7%>A{GS7$$v}vSZ2w^awlQxX%(TAPuZYG9%{W%8o781|_<A
zr4ox87gU-)s^lY^YEystS)!e02j5E&zk@j+Nm7gZN=u`<4{>2M4N0f&IE-E^mu&}Z
z=UR&BPW@6=av6gq1$HrOo#05t4O3*AbH7e7cAH$2Ny95eIkzgt=0OF(AzC~fY9&r&
z-H)Sx9MpS$D)FEW_s!Q?mJ6&~25;|8^g<Tgu<06j)8z&G)lC<9nj0Ct`jZRy0S~&S
zs^pRD^8N|FZFDM3-1qP**qL4a${>}l0@rLcv`*92I<!9+(hurT0B%TvDS$-~1Q<on
zbuJzt{Qn6Kd@ZohkF4=7od^l0%C%`S6w|9yFQ`Tmi_)``k3Du09K(P&_6>d(X$Fm-
z0#=W~&i}a>{c{w#6AX@Q2ni(a5pD<9N`Nvg&Fl_c!W=LmK_a;AOc0YZkoHG@IcMU;
z(w!|04p5~PxP5~r)Yy0Wvomcz!Wgh?*#<|cKK+RWrdwU1OoOtvQ`;n~-kQ<rV2+(&
zj!vB+qhOB5V2+j_A2Ml-*3A%rHgM3CDrne|K;r{8^3Uoa2bptoKRW{AaGjO{SxX1e
zDTSrUQK{-sY4j5-TuRW7A<#KeHi_M$6nKcoE(2I1VRLQJAIkwI*B3&@q|r<E6cwZ|
zU`zjMgaI8VKQCRhLon=e1FR6)%1csT9MDR$^%MYhPPAoi==Kg`Wvyadnf+yWWM*=i
zbs2WR8FSyzX9)#R@3C)alLW}%1D=lY#8_tNmTRWzp3s9yNXamve+13zoK`K%K+Bug
z`W5dIsbVa6Kxl}uyqWu6gc}1?$Y-a3xYlG4w%t>`!UhBMKHC;)qz~n@%p0F-aOmuS
z+r`?yAO&9c4Y^7Wd_Zk;)j;l9yPOPk{1K*X(`$joK1-#aVb*5^n9(GJsv1ZS<JW%m
zBOo}!`-qVJ2m#-kZncO|d#onQCKYm$5(u9^ugsm!BF(W2=(;u4;yTN`)|1Om(3S*N
z_u{MBRS5bI0DtSpWnp${b0+;Fbw*$-M@WU#0C>nn-~ZC^tDs|ep0>C-DV~<PYQdD?
z5mZ*GzL350)gT(hbx>x{UGzdc!N6LZ<%#e1%3Wsai$dAYg}P#xQ`STBZXij<qadK-
zG8iYU9#eZSc8K*radb{02hf#ZFa{Gt$u{VZ@yxeA{$N)BbXn+P_vh6pp2sCx7hU~t
z;bblnl$R6O@kkE+E|pBNq)NUJf8Zo1uEhz+*=PFv=_pc)7Uo~sr3I*73M-Lww3k`C
zN*xKfXy<KAHvkHqfGw{#4uk!?sllW{M5p&Al0}A=T%=AD%-HaKa4?uL4*IL4DlORU
zsfk>cHNpkGJVc%ow4?|ZVkdA=)XjbQxf7KpnvvA^L#+ZvQ*;(|mY=akt*P;w+1A8_
zc|HjEL{l+xYDyj=qq_t)U<0M@eSbrF$H%7#IFEoZ<!SWhjl6M|FcHI|KtMy4xi7g7
z8aDqS%qC!;eB#pI2LNfu(47dKyRUO3ubrtLKGnOMpK^FLRNxga|0KzU_=GLTD}rbd
zS|v8$gglA9jP;4s7qg#>Q8p>n0BHlsW7SKR`_XeCD)4)KSf&Oi>+b>YN`O!=$U2di
zW1}j71$UUu>}CKI4Gz96M*nR21_{^LL6NtOgTik3$ISp)kT?4HA=4c|(n#c!3eRAN
z7)_N2Dtt|*+I&rqsvq+oZ!QCk?w7p$v~I#N*#R++uyb>?YlGGerYTo?=cwK*^E0Rs
zu-#t9|L23Lgh=IllpRLc?U+y%5Rc+&ez(~c5D_`*dE!gV95p4~>X-IIZvJmj&Ca$q
zd*v{iO#Pkv1({YjxGi0OY1uznCU#l1^20UtotuI@ObfEd!$Mi^vq>`Lz4X)!{~SxI
z%R;UH6hz{DU$cm5uHqz9+DDM8tr&Pg`7JC=y8JaqsD>^^ldx{iuGeW_>0I_Q>*OsC
z5C|^t`=T-c`u&_3GFzUKK4?GkGECb{OUjJa+z8MJK}RUpE-PFOuGM5V@la`;3rsTn
zZ~4In^k^9Th+U<`yL=S6S~bxOzBS<yYB5L#DeynMq0M)PX)|3Eq6=q6eW<-->8atW
z0Rr5FY?87vm)5V43Zf}eS3ok6RNa-2l#c&Q2*vjte8WOl64!mu9+Qq5mXCf2E9%Wa
zcdlU#dsk7cVFy(Ma4)%P9JkjfU=tAFUkM=pzY_^n^F2(}jorJy7JaN`86EiF_B|~k
z8|N)HK*K>31}GJMTwTb)gY0_9^nq%kgAz4O{ihqVQ#DUsBa<gj%h6L-gL3Qu#lR~~
zm`Q*fBo;d|A}Q-nYk>fsXt&TrC3Czy>0%Eu_%vr3rTgf>>*C*nnDcX5HlZTN{SdQE
zFQta&qa0p26YnqsWyey#O~!H-^p*&DUQlD;#zwzs5mk2>O_y&7l~72M9>WJcT(a-<
zaBl?MjHRD7(UuE*j5N_t{iRZbbD_<8en003faR>o24*QMbQGbJ_M)C*c7;20gztaF
z6ajRa3w|?~y*pPe+!SbLLRZC1>TM^EdRvD^ZLe)uMMx`GW-)>@BjtEN4E{faeRn+7
zfBSz#86{+-kn9nP%H~wIjEpF&L<q^Tx1)*3mQ6NMwv$<rm3i!0$KKhS-*xD7-`)53
z_x=6;O6qaW`~7-f<9R)==XJfiNqmnF8*+hK4RdXTd(p>ql4|vR(<b(u3k5%@?EZBD
zPoI0aaGBP8@T9I(-0%9`P(DpK;=lOh#oM`%&m4Pq8|2ZHLjP({S&|bSPkt~Gf;HTK
zE`4^U#g6IQMu~O%4G^1&+A<t}f@Yo`sq$z`aUkjFiY-!v$yhVflfD;zo<Oy>ttU-s
z0LlI<<T%Em;ULf20(e1V8Lr*bV>2<IQ9A%E^|rX@Q2@}Tw@5Xo`K5&xq6`A8j_%MR
zZ3vR>B?yVg06^JQF|~qnvF;f{dS`(*_<P~0!p}}^gSH9soIN?h0rQ`lC5Be}hQ|^Y
zVlBLnI8W?Yer)ngw>pn6+KPv2tuLo^vd(qs9VZDZ&1APyj_7BJ`(m0EhMks){`SbP
zQAtgl_bg#B#JmvsgOcV7BuUHfLBp|uQYH=5gT%X12nBTT@UMic(A|W8QhqrC=ztR+
zC1H{BYxOv*o3VC-F4A#|Err(Yy4yoOjR}4ALz+&~q_^ifbX;+LR((0o(@c&lzmpf}
z_Y+mDrHNgkE&{SM`XD37IixMTY2;;l#;#bOj>evol+&wdSh43sA<p4Y$j_%FU_)x~
z<C@g5y>&wsMf7{u6ifpsZ1xrtk3*7Lg7t)mM3UzL^MPAh>k8@Pv7yD2+`P2Ip)<*|
zmSHys=B)0p>*=!ipNk8<-}K$7Ozz{EZvN2@k=od}J8X-OhypntpDBT3J4s)_Jc%rs
z{{$IX+WT>e6SOfM26C0ekJds4fx6cyu0*l4D2Ysl+zgkNw_`Yg=&0d=IiNSW9AmzM
z-%$okfr@~2!$@Gjx5^mxJL71(+O8KtQMRJ<xh?*!@{pX+yo~N*9@&QnqOh@t_nWT+
z)Ui#TG8aWX-MtK^oANkigNIV|lZ3v_Oqprb8EUF{79f*qw7Qb??Kz(#<Z!ryTNc)z
zabAOjc-&u@OPl`689PFhARLnE#U21z`Gm~=h3%i_DGohIts#0bAdbxh^MuMVVvnmO
zP1Nk*>pRoW+5ywq%Jlei)D5Qgr|LUm;TcsW_qd+yil}Tk?g1tU3=V=DpEk15UQw~p
zBD)Z%59PtE3-T&_y*PaRgnvdD(qxmLjdDe3hMr41%I4EE#1L52vaIq=D4}^!PZ4LY
zNpkJ2s>&zlN}BKhqEeS!romNoOK!TymE$>-`aX*^;{qKoA^1HcvK(NU*b1!u(hWt5
zE(RAY%-e=L$u$EJtkhx6w9OVf@lPaU@~Wc4!(pW<iF+Vp)c-2C{#|v_%XzoGl(ob<
zR`bV3>g!rssoH;OvjZ=Z<2Z-p+^q}5-3-c-*#RZ4r^535o=`6QBvp^&fBEbKlaO1e
z^8QKxUpq3GUHJq9d@=3xgpEeZzS4|Nsc#AdHtT1pPWryB=t!p(WF0!%|Kb9G<1-_5
z`e20faNoA3{Zl+Mp*&d&Ayr*$3K7V4dd~mg4SI28U=D}&O~@2P1P<Ct-=dCpl3sC4
zv24}vRZ>iI|KmtpjRoroI4WytEui3LV<c3vp<z$BQ1YK}b?hAx905FNt-wlkYX&=i
zxe8aw>T}02K0C;Zn-DvGyb`bicu<c+R_7(ubA&zLOg?ykt3lT`kd8!DQ3uT?LwiFF
z?t#%#+pusy>jryuhqc1Tn<YYM#4$NwZ4`2Yza(f7qP(fqvO;&xSEPDl!8~(T6`c7s
z28&BA453{St{DG*pUO!ylbQbC;{3_yh`vxB*Wpm#$YJI&MUFQaI5`wt&J_MHjpNCQ
zTX@8lx?xLq^nfJe(C0GI_(-d5-W_V<yUN5<ck;Y5#`ESwVb2G4QuI{2rb42ej63(U
zrSbjE7a9jsB0}H1;{v{ue@cuG2RH7g0f39$DgYXa9pXXMB}HX-9L1^#HCj}Mxq1$3
z(9<KR4*=U9`3I9iS|%g-w|nGthL#Mq38q-~DNmO_-L-8!N^wAri#T6ga=Z=v<c>m{
zy5K=YI`sNjjpH4q>iDgb-+k=$s0VArjAXBH4tc6$xr!*B7Qj^`y?O<v?1dX_WVl4c
zFpJNnElMP7Lm<ipfnEWT3DETk!B;%<o{i*<ZmA1F-#cs=R6B*a;+_4RT>R^l&qw7v
z2G{fri;-m1qsKc=Ed7<TXZ?<b+Rjy<D;+6wF<E7PI2Joh5)eMUR)sCUm3%)Fu6O<?
z(YBKWBH4H;{``jXKI-+xur8~A=P8Afd9#LXyLCox6WSrpp$i!GxQY9=cy|JY)-OG2
zSs89UbNq?kD;COuN`;;N@XQr1ZcdLa<36#c|H3P_HDXUQ|G_INP`KGGO|}XVkU#Z?
z8$T_3;hQ9U^-bZ-3$2$SMg%zD2C^5)k)Sbp?Sr!#l&&e3)qflKa&cYTfmXMnwm#+=
zunXhz(Vdu|U$QBCDsE-d7^Zk*YcUQ(V>}VT4>0eqFJ7Qc7wHHoA|oWfBm*>UXwdt3
zC`}^ZyY-iPExIeMa<6<Sk(wf$$)Su7ZQ2aqvZ&hZwRppGLG3wsfQ<0ufB-((X(EQf
z3#(c4A!<!xT(0B)WQkb|nSr5D6Qpx1ToDxy+D)|N8oo0X5kqh49bf*Cp8;W%ITFD|
zIE}ivX)OPis$Ka_e$CUInCthh{2T6)QT_I>&=hyCZJeqpR>GmHQ!LjjJNV0$ybm3L
za&ZGY(eux<nji%(GVtZ}an?^(S`E#g2N)Ms^f*l>+zs?n^fkhN-FJbflO}|;BL-&}
zG1EILN-J6+2i0lt&ut!7H|+gB#u+W?xI~Q(#YJbVn1$#*3s?3TLXzuV&UxgrL9W1o
z>H#S{t}fKl%|50W_r*L%2kg?%BpIzr5W_-l{vqt8(E0GH@d-9cvXt3(jw`pgq8&m?
zN>@~!CF60CnK*D_*}VR`E<79&Caw*omlhTuA}$lysqOSs6s%`?MxQwe#p=SRNGvy(
zlI|<uB7z|;UhrpM2Y86ag`gLi<=w!dm+uuAIKfkRA(T2mfgeEqALvTM0i$tMrNMNF
zInIDZJ+62J7xhG_XPq9Koko$7{2^?!Vju$#HTa#O<Tod*Ij&5(zzJOOhNX>j<7w6W
ze{W1vs{%aE_4CVE*MU=zXfhe`zO?+{ArHid#!yn}x*AvMZ`nn%$nYic<ASvJ37y9s
z0@BU5tj*|AldUSxRnJrGucdIiH$V<9VR7fzf3kQYCcztPTO(wYQ{omjHKT@)VupLW
z=zV>h2KWXIxUX2Ot%FG{(xejrm+4(~sloqZ0uZ*~5#x-r5PKX5@k_H(9yC46=6h|Y
zy%yYVZb&}-u2J(_&g`|gl&r{usfG4u_q$DiC746nB1`>s<8JdC>ToCS_V;%xt9Cjq
z21N2#JOF%hx7eXGksQB<6;jZxq^5G<XV~FtBGV(aUWM{J@~17g|5t6RMueZ3B$n*a
z=}wvH%rQ1sqS#m?G$zU=wtbJHSjdDfjs6Ponl-)}ajaXn3-BpCV>gBk*@5Uy3Nd1h
z>G~>ozW_MJ1};ftMM<M;DzEB4$R5lLOD!Ld96OouZj*Nvf4v<mgKa*nhU!B8lo1Ht
z0KKq0nb>RHVm67PvFpw@VGhc7Up|9mNa*Y!vFvdbY&^vA(yJ?Hh&z<-Pw=!QYz!%9
zR|E;?mc~_lOEK=CU-bVh4b;SG)m(VkRuJcl4!7GPAg<H2J-iQGPl_UX3E8e(TDl(L
z`$7sNTEQod!;>1NgKL~6l0FNdwdobxr_IefBS7FD#C+_0yOfy!_!M{QzAMZP#4(2I
zU400Y5D%@KflvqMUTju}-!;gz`ZKz*Cr)qY7*_pc5Yb)9JP*8uPa13zK{<er6`l4q
z0$^MKhhHPK0`^yNc_KgzNUvTIsmCm8EBL>>u2?#$?^sJf$lnU3{~H9AVNOL!ss<a?
zOsSsP71Tv2d+(hx)V{uGLb>%cR@!^7V0~o%c8WnkMtj<u3Z3kqbTNlwsejIY@-;$y
ztU*aC`1fLzlh&?v=N8m+Px-mDv7DBN)o~!mm=3Ck=~t|Jj#tLCpt&yJ`$EXav92I=
zLgd|fh%*zlBBt5z_RdAceCcui^;8YtwF}DBM#=&79cI+af^r+j84flU(+nX>LjW13
zDF@HrtP+QUvpI3AA|S!tjTy;V5T&#X-0G}^oWCfEKj16|XtkeM<}v~KYtlbp2dW0g
z9Ubh;(!7XJm2Gd|qxz|2rIf04Xsd%>YhCU9tu$ykv<&$C(w(k}Lb=a;SmFA@@G(Ow
zQY3cm<$%7+-Rm|B>CWoyrj|h8z_a}UVNK9Bi3S4DTezadH})2eiVb01#=-#zO)uwQ
z4m_Bf=OGvUd~;fRkRvh5QT>h$z@3GGnPkhQLgpvd4Fc?phvx62%HZzs8X@hyE#&Lj
zFHoqyqvg}lojMnh^}f_e?uQzerlwliesaMW*T3p%0Dd`y(8slSkaHlpRGa)yh=c0`
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

diff --git a/lib/plox.ex b/lib/plox.ex
index 370e957..9dcfef5 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -37,19 +37,8 @@ defmodule Plox do
   slot :inner_block, required: true
 
   def graph(assigns) do
-    # assigns =
-    #   assign(assigns,
-    #     for: nil,
-    #     graph: Graph.put_dimensions(assigns.for, Dimensions.new(assigns))
-    #   )
-
     ~H"""
     <div {@rest}>
-      <%!-- <div style={"display: flex; flex-direction: column; align-items: flex-end; max-width: #{@graph.width - @graph.margin.right}px"}>
-        <.legend :for={legend <- @legend}>
-          {render_slot(legend)}
-        </.legend>
-      </div> --%>
       <div style={"position: relative; width: #{@dimensions.width}px; height: #{@dimensions.height}px"}>
         <svg
           viewBox={"0 0 #{@dimensions.width} #{@dimensions.height}"}
@@ -57,9 +46,6 @@ defmodule Plox do
         >
           {render_slot(@inner_block)}
         </svg>
-        <%!-- <%= for tooltip <- @tooltips do %>
-          {render_slot(tooltip)}
-        <% end %> --%>
       </div>
     </div>
     """
diff --git a/migration_guide.md b/migration_guide.md
new file mode 100644
index 0000000..2f4f8c0
--- /dev/null
+++ b/migration_guide.md
@@ -0,0 +1,110 @@
+# Plox Migration Guide (0.2.0 to 0.3.0)
+
+Plox has gone through a major philosophical rewrite since its initial publication. This
+guide will help users convert their current Plox graphs over to the new approach.
+
+## Example of 0.2.0 usage
+
+1. Set up data, scales, and dataset:
+
+```elixir
+data = [
+  %{date: ~D[2023-08-01], value: 35.0},
+  %{date: ~D[2023-08-02], value: 60.0},
+  %{date: ~D[2023-08-03], value: 65.0},
+  %{date: ~D[2023-08-04], value: 10.0},
+  %{date: ~D[2023-08-05], value: 50.0}
+]
+
+date_scale = date_scale(Date.range(~D[2023-08-01], ~D[2023-08-05]))
+number_scale = number_scale(0.0, 80.0)
+
+dataset =
+  dataset(data,
+    x: {date_scale, & &1.date},
+    y: {number_scale, & &1.value}
+  )
+```
+
+2. Build a `Plox.Graph` struct:
+
+```elixir
+example_graph =
+  to_graph(
+    scales: [date_scale: date_scale, number_scale: number_scale],
+    datasets: [dataset: dataset]
+  )
+```
+
+3. Render the `Plox.Graph` within your HEEx template:
+
+```html
+<.graph :let={graph} id="example_graph" for={@example_graph} width="800" height="250">
+  <.x_axis :let={date} scale={graph[:date_scale]}>
+    {Calendar.strftime(date, "%-m/%-d")}
+  </.x_axis>
+
+  <.y_axis :let={value} scale={graph[:number_scale]} ticks={5}>
+    {value}
+  </.y_axis>
+
+  <.polyline dataset={graph[:dataset]} color="#EC7E16" />
+
+  <.circles dataset={graph[:dataset]} color="#EC7E16" />
+</.graph>
+```
+
+## Example of 0.3.0 usage
+
+1. Set up data, dimensions, axes, and dataset:
+
+```elixir
+data = [
+  %{date: ~D[2023-08-01], value: 35.0},
+  %{date: ~D[2023-08-02], value: 60.0},
+  %{date: ~D[2023-08-03], value: 65.0},
+  %{date: ~D[2023-08-04], value: 10.0},
+  %{date: ~D[2023-08-05], value: 50.0}
+]
+
+# Instead of passing the height and width via the `graph` component,
+# create Dimensions and pass them to each Axis
+dimensions = Plox.Dimensions.new(800, 250)
+
+# Instead of creating separate Scales, we need them when creating our Axes
+x_axis = Plox.XAxis.new(
+  Plox.DateScale.new(Date.range(~D[2023-08-01], ~D[2023-08-05])),
+  dimensions
+)
+
+y_axis = Plox.YAxis.new(Plox.NumberScale.new(0.0, 80.0), dimensions)
+
+# Create a Dataset with our Axes
+dataset =
+  Plox.Dataset.new(data,
+    x: {x_axis, & &1.date},
+    y: {y_axis, & &1.value}
+  )
+```
+
+2. Render the `graph` component within your HEEx template:
+
+```html
+<.graph id="example_graph" dimensions={@dimensions}>
+  <!-- Render axis labels and lines individually -->
+  <.x_axis_labels :let={date} axis={@x_axis}>
+    {Calendar.strftime(date, "%-m/%-d")}
+  </.x_axis_labels>
+
+  <.y_axis_labels :let={value} axis={@y_axis} ticks={5}>
+    {value}
+  </.y_axis_labels>
+
+  <.x_axis_grid_lines axis={@x_axis} stroke="#D3D3D3" />
+  <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="#D3D3D3" />
+
+  <.polyline dataset={@dataset} stroke="#EC7E16" stroke-width={2} />
+
+  <.circle cx={@dataset[:x]} cy={@dataset[:y]} r={3} fill="#EC7E16" />
+</.graph>
+```
\ No newline at end of file

From 26b9a9ac8d871ad8d298842a66b39afab03c1968 Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Tue, 8 Jul 2025 16:33:16 -0700
Subject: [PATCH 10/23] Rename line_points to polyline and pass list of tuples
 for points

---
 demo_live.exs | 34 +++++++++++++++++++---------------
 lib/plox.ex   | 30 +++++++++++++++++-------------
 2 files changed, 36 insertions(+), 28 deletions(-)

diff --git a/demo_live.exs b/demo_live.exs
index a27e66f..3f2e335 100644
--- a/demo_live.exs
+++ b/demo_live.exs
@@ -80,15 +80,16 @@ defmodule DemoLive do
         {"Important Day"}
       </.x_axis_label>
 
-      <.x_axis_grid_lines axis={@x_axis} stroke="grey" />
+      <.x_axis_grid_lines axis={@x_axis} stroke="#D3D3D3" />
 
       <.y_axis_labels :let={value} axis={@y_axis} ticks={5}>
         {value}
       </.y_axis_labels>
 
-      <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="grey" />
+      <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="#D3D3D3" />
 
-      <.line_plot dataset={@dataset} stroke="orange" stroke-width={2} />
+      <%!-- <.polyline dataset={@dataset} stroke="orange" stroke-width={2} /> --%>
+      <.polyline points={Enum.zip(@dataset[:x], @dataset[:y])} stroke="orange" stroke-width={2} />
 
       <%!-- Access behavior with axes --%>
       <%!-- <.polyline points={{@dataset[:x], @dataset[:y]}} class="stroke-orange-500 dark:stroke-orange-400 stroke-2" /> --%>
@@ -207,20 +208,23 @@ defmodule DemoLive do
         {value}
       </.y_axis_labels>
 
-      <.x_axis_grid_lines axis={@x_axis} stroke="grey" />
+      <.x_axis_grid_lines axis={@x_axis} stroke="#D3D3D3" />
 
-      <.y_axis_grid_lines axis={@y_axis} ticks={7} stroke="grey" />
+      <.y_axis_grid_lines axis={@y_axis} ticks={7} stroke="#D3D3D3" />
 
-      <.line_plot dataset={@p_dataset} stroke-width="5" stroke="#FF9330" />
-      <%!-- <.circles dataset={@p_dataset} r="8" fill="#FF9330" /> --%>
-      <.line_plot dataset={@l_dataset} stroke-width="5" stroke="#78C348" />
-      <%!-- <.circles dataset={@l_dataset} r="8" fill="#78C348" /> --%>
-      <.line_plot dataset={@o_dataset} stroke-width="5" stroke="#71AEFF" />
-      <%!-- <.circles dataset={@o_dataset} r="8" fill="#71AEFF" /> --%>
-      <.line_plot dataset={@x1_dataset} stroke-width="5" stroke="#FF7167" />
-      <%!-- <.circles dataset={@x1_dataset} r="8" fill="#FF7167" /> --%>
-      <.line_plot dataset={@x2_dataset} stroke-width="5" stroke="#FF7167" />
-      <%!-- <.circles dataset={@x2_dataset} r="8" fill="#FF7167" /> --%>
+      <.polyline points={Enum.zip(@p_dataset[:x], @p_dataset[:y])} stroke-width="5" stroke="#FF9330" />
+      <.polyline points={Enum.zip(@l_dataset[:x], @l_dataset[:y])} stroke-width="5" stroke="#78C348" />
+      <.polyline points={Enum.zip(@o_dataset[:x], @o_dataset[:y])} stroke-width="5" stroke="#71AEFF" />
+      <.polyline
+        points={Enum.zip(@x1_dataset[:x], @x1_dataset[:y])}
+        stroke-width="5"
+        stroke="#FF7167"
+      />
+      <.polyline
+        points={Enum.zip(@x2_dataset[:x], @x2_dataset[:y])}
+        stroke-width="5"
+        stroke="#FF7167"
+      />
     </.graph>
     """
   end
diff --git a/lib/plox.ex b/lib/plox.ex
index 9dcfef5..71939d0 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -306,23 +306,27 @@ defmodule Plox do
   """
   @doc type: :component
 
-  attr :dataset, Dataset, required: true
-
-  attr :x, :atom, default: :x, doc: "The dataset axis key to use for x values"
-  attr :y, :atom, default: :y, doc: "The dataset axis key to use for y values"
+  attr :points, :any, required: true, doc: "String of coordinates or list of {x, y} tuples"
   attr :fill, :any, default: "none"
   attr :rest, :global, include: @svg_presentation_globals
 
-  def line_plot(assigns) do
-    ~H"""
-    <polyline points={line_points(@dataset, @x, @y)} fill={@fill} {@rest} />
-    """
+  def polyline(%{points: points} = assigns) when is_binary(points), do: do_polyline(assigns)
+
+  def polyline(assigns) do
+    points =
+      assigns.points
+      |> Enum.map(fn {x, y} -> %{x: x, y: y} end)
+      |> polyline_points()
+
+    assigns
+    |> assign(points: points)
+    |> do_polyline()
   end
 
-  defp line_points(dataset, x_key, y_key) do
-    dataset.data
-    |> Enum.map(fn data_point -> %{x: data_point.graph[x_key], y: data_point.graph[y_key]} end)
-    |> polyline_points()
+  defp do_polyline(assigns) do
+    ~H"""
+    <polyline points={@points} fill={@fill} {@rest} />
+    """
   end
 
   @doc """
@@ -337,7 +341,7 @@ defmodule Plox do
   attr :fill, :any, default: "none"
   attr :rest, :global, include: @svg_presentation_globals
 
-  def step_line_plot(assigns) do
+  def step_polyline(assigns) do
     ~H"""
     <polyline points={step_line_points(@dataset, @x, @y)} fill={@fill} {@rest} />
     """

From a35760b13eb23a4cc9b808da761cc8facc119ffa Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Tue, 8 Jul 2025 16:39:20 -0700
Subject: [PATCH 11/23] Update demo files with new polyline component

---
 README.md              |   2 +-
 animated_demo_live.exs |  17 +++---
 demo_live.exs          | 123 +----------------------------------------
 migration_guide.md     |   4 +-
 4 files changed, 13 insertions(+), 133 deletions(-)

diff --git a/README.md b/README.md
index 72d85d8..451d1aa 100644
--- a/README.md
+++ b/README.md
@@ -69,7 +69,7 @@ Once you have those, you can render a `graph` component within your HEEx templat
   <.x_axis_grid_lines axis={@x_axis} stroke="#D3D3D3" />
   <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="#D3D3D3" />
 
-  <.polyline dataset={@dataset} stroke="#EC7E16" stroke-width={2} />
+  <.polyline points={points(@dataset[:x], @dataset[:y])} stroke="#EC7E16" stroke-width={2} />
 
   <.circle cx={@dataset[:x]} cy={@dataset[:y]} r={3} fill="#EC7E16" />
 </.graph>
diff --git a/animated_demo_live.exs b/animated_demo_live.exs
index 23904fe..7dc5e40 100644
--- a/animated_demo_live.exs
+++ b/animated_demo_live.exs
@@ -85,25 +85,24 @@ defmodule AnimatedDemoLive do
         {value}
       </.y_axis_labels>
 
-      <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="grey" />
+      <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="#D3D3D3" />
 
       <.x_axis_labels :let={datetime} axis={@x_axis} step={5} start={@nearest_5_second}>
         {Calendar.strftime(datetime, "%-I:%M:%S")}
       </.x_axis_labels>
 
-      <.x_axis_grid_lines axis={@x_axis} step={5} start={@nearest_5_second} stroke="grey" />
-      <.x_axis_grid_line axis={@x_axis} value={@x_axis.scale.first} stroke="grey" />
-      <.x_axis_grid_line axis={@x_axis} value={@x_axis.scale.last} stroke="grey" />
-
-      <.x_axis_label axis={@x_axis} value={@now} position={:top} fill="red">
+      <.x_axis_grid_lines axis={@x_axis} step={5} start={@nearest_5_second} stroke="#D3D3D3" />
+      <.x_axis_grid_line axis={@x_axis} value={@x_axis.scale.first} stroke="#D3D3D3" />
+      <.x_axis_grid_line axis={@x_axis} value={@x_axis.scale.last} stroke="#D3D3D3" />
+      <.x_axis_label axis={@x_axis} value={@now} position={:top} color="red">
         Now ({Calendar.strftime(@now, "%-I:%M:%S")})
       </.x_axis_label>
 
       <.x_axis_grid_line axis={@x_axis} value={@now} stroke="red" />
 
-      <.polyline dataset={@dataset1} stroke="orange" stroke-width="2" />
-      <.polyline dataset={@dataset2} stroke="blue" stroke-width="2" />
-      <.polyline dataset={@dataset3} stroke="green" stroke-width="2" />
+      <.polyline points={Enum.zip(@dataset1[:x], @dataset1[:y])} stroke="orange" stroke-width="2" />
+      <.polyline points={Enum.zip(@dataset2[:x], @dataset2[:y])} stroke="blue" stroke-width="2" />
+      <.polyline points={Enum.zip(@dataset3[:x], @dataset3[:y])} stroke="green" stroke-width="2" />
       <%!-- <.circles dataset={@points_dataset} r={:r} fill={:color} /> --%>
     </.graph>
     """
diff --git a/demo_live.exs b/demo_live.exs
index 3f2e335..7877793 100644
--- a/demo_live.exs
+++ b/demo_live.exs
@@ -13,17 +13,13 @@ defmodule DemoLive do
 
   @impl Phoenix.LiveView
   def mount(_params, _session, socket) do
-    {:ok, socket |> mount_simple_line_graph() |> mount_logo_graph()}
+    {:ok, mount_simple_line_graph(socket)}
   end
 
   @impl Phoenix.LiveView
   def render(assigns) do
     ~H"""
     <.simple_line_graph {@graph} />
-
-    <hr />
-
-    <.logo_graph {@logo_graph} />
     """
   end
 
@@ -111,123 +107,6 @@ defmodule DemoLive do
     </.graph>
     """
   end
-
-  defp mount_logo_graph(socket) do
-    dimensions = Plox.Dimensions.new(440, 250)
-    x_axis = Plox.XAxis.new(Plox.NumberScale.new(0.0, 10.0), dimensions)
-    y_axis = Plox.YAxis.new(Plox.NumberScale.new(0.0, 6.0), dimensions)
-
-    # Letter "P"
-    p_data = [
-      %{x: 1, y: 5},
-      %{x: 2.5, y: 4},
-      %{x: 1, y: 3},
-      %{x: 1, y: 1}
-    ]
-
-    p_dataset =
-      Plox.Dataset.new(p_data,
-        x: {x_axis, & &1.x},
-        y: {y_axis, & &1.y}
-      )
-
-    # Letter "L"
-    l_data = [
-      %{x: 3.5, y: 4.5},
-      %{x: 3.5, y: 1}
-    ]
-
-    l_dataset =
-      Plox.Dataset.new(l_data,
-        x: {x_axis, & &1.x},
-        y: {y_axis, & &1.y}
-      )
-
-    # Letter "O"
-    o_data = [
-      %{x: 4.5, y: 2},
-      %{x: 5.5, y: 3},
-      %{x: 6.5, y: 2},
-      %{x: 5.5, y: 1},
-      %{x: 4.5, y: 2}
-    ]
-
-    o_dataset =
-      Plox.Dataset.new(o_data,
-        x: {x_axis, & &1.x},
-        y: {y_axis, & &1.y}
-      )
-
-    # Letter "X"
-    x1_data = [
-      %{x: 7, y: 3},
-      %{x: 9, y: 1}
-    ]
-
-    x1_dataset =
-      Plox.Dataset.new(x1_data,
-        x: {x_axis, & &1.x},
-        y: {y_axis, & &1.y}
-      )
-
-    x2_data = [
-      %{x: 7, y: 1},
-      %{x: 9, y: 3}
-    ]
-
-    x2_dataset =
-      Plox.Dataset.new(x2_data,
-        x: {x_axis, & &1.x},
-        y: {y_axis, & &1.y}
-      )
-
-    assign(socket,
-      logo_graph: %{
-        dimensions: dimensions,
-        x_axis: x_axis,
-        y_axis: y_axis,
-        p_dataset: p_dataset,
-        l_dataset: l_dataset,
-        o_dataset: o_dataset,
-        x1_dataset: x1_dataset,
-        x2_dataset: x2_dataset
-      }
-    )
-  end
-
-  defp logo_graph(assigns) do
-    ~H"""
-    <h2>Logo graph</h2>
-
-    <.graph dimensions={@dimensions}>
-      <.x_axis_labels :let={value} axis={@x_axis}>
-        {value}
-      </.x_axis_labels>
-
-      <.y_axis_labels :let={value} axis={@y_axis} ticks={7}>
-        {value}
-      </.y_axis_labels>
-
-      <.x_axis_grid_lines axis={@x_axis} stroke="#D3D3D3" />
-
-      <.y_axis_grid_lines axis={@y_axis} ticks={7} stroke="#D3D3D3" />
-
-      <.polyline points={Enum.zip(@p_dataset[:x], @p_dataset[:y])} stroke-width="5" stroke="#FF9330" />
-      <.polyline points={Enum.zip(@l_dataset[:x], @l_dataset[:y])} stroke-width="5" stroke="#78C348" />
-      <.polyline points={Enum.zip(@o_dataset[:x], @o_dataset[:y])} stroke-width="5" stroke="#71AEFF" />
-      <.polyline
-        points={Enum.zip(@x1_dataset[:x], @x1_dataset[:y])}
-        stroke-width="5"
-        stroke="#FF7167"
-      />
-      <.polyline
-        points={Enum.zip(@x2_dataset[:x], @x2_dataset[:y])}
-        stroke-width="5"
-        stroke="#FF7167"
-      />
-    </.graph>
-    """
-  end
 end
 
 PhoenixPlayground.start(live: DemoLive)
diff --git a/migration_guide.md b/migration_guide.md
index 2f4f8c0..74a17a7 100644
--- a/migration_guide.md
+++ b/migration_guide.md
@@ -103,8 +103,10 @@ dataset =
   <.x_axis_grid_lines axis={@x_axis} stroke="#D3D3D3" />
   <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="#D3D3D3" />
 
-  <.polyline dataset={@dataset} stroke="#EC7E16" stroke-width={2} />
+  <!-- Use the `points/2` helper to generate a list of {x, y} tuples from our Dataset -->
+  <.polyline points={points(@dataset[:x], @dataset[:y])} stroke="#EC7E16" stroke-width={2} />
 
+  <!-- Pass all the `x` values and the `y` values to render circles at each datapoint -->
   <.circle cx={@dataset[:x]} cy={@dataset[:y]} r={3} fill="#EC7E16" />
 </.graph>
 ```
\ No newline at end of file

From 211078bdeb7d71a13ba6db771a816fe853ab3be6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Chris=20Dos=C3=A9?= <chris@xn--dos-dma.com>
Date: Wed, 9 Jul 2025 11:13:43 -0700
Subject: [PATCH 12/23] Simplify the way we generate multiple values from
 datasets (#18)

---
 animated_demo_live.exs |  6 +--
 lib/plox.ex            | 94 +++++++++++++++---------------------------
 2 files changed, 36 insertions(+), 64 deletions(-)

diff --git a/animated_demo_live.exs b/animated_demo_live.exs
index 7dc5e40..bdd3e37 100644
--- a/animated_demo_live.exs
+++ b/animated_demo_live.exs
@@ -100,9 +100,9 @@ defmodule AnimatedDemoLive do
 
       <.x_axis_grid_line axis={@x_axis} value={@now} stroke="red" />
 
-      <.polyline points={Enum.zip(@dataset1[:x], @dataset1[:y])} stroke="orange" stroke-width="2" />
-      <.polyline points={Enum.zip(@dataset2[:x], @dataset2[:y])} stroke="blue" stroke-width="2" />
-      <.polyline points={Enum.zip(@dataset3[:x], @dataset3[:y])} stroke="green" stroke-width="2" />
+      <.polyline points={points(@dataset1[:x], @dataset1[:y])} stroke="orange" stroke-width="2" />
+      <.polyline points={points(@dataset2[:x], @dataset2[:y])} stroke="blue" stroke-width="2" />
+      <.polyline points={points(@dataset3[:x], @dataset3[:y])} stroke="green" stroke-width="2" />
       <%!-- <.circles dataset={@points_dataset} r={:r} fill={:color} /> --%>
     </.graph>
     """
diff --git a/lib/plox.ex b/lib/plox.ex
index 71939d0..bd517cc 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -375,82 +375,54 @@ defmodule Plox do
   attr :rest, :global, include: @svg_presentation_globals
 
   def circle(assigns) do
-    assigns
-    |> assign(dataset: validate_zero_or_one_dataset(Map.take(assigns, [:cx, :cy, :r, :fill])))
-    |> do_circle()
-  end
-
-  defp do_circle(%{dataset: :none} = assigns) do
-    ~H"""
-    <circle cx={@cx} cy={@cy} r={@r} fill={@fill} {@rest} />
-    """
-  end
-
-  defp do_circle(%{dataset: _dataset} = assigns) do
     ~H"""
     <circle
-      :for={data_point <- @dataset.data}
-      cx={maybe_graph(@cx, data_point)}
-      cy={maybe_graph(@cy, data_point)}
-      r={maybe_graph(@r, data_point)}
-      fill={maybe_graph(@fill, data_point)}
-      stroke={maybe_graph(@stroke, data_point)}
-      stroke-width={maybe_graph(assigns[:"stroke-width"], data_point)}
+      :for={{cx, cy, r, fill, stroke, stroke_width} <- values([@cx, @cy, @r, @fill, @stroke, assigns[:"stroke-width"]])}
+      cx={cx}
+      cy={cy}
+      r={r}
+      fill={fill}
+      stroke={stroke}
+      stroke-width={stroke_width}
       {@rest}
     />
     """
   end
 
-  defp validate_zero_or_one_dataset(assigns) do
-    datasets =
-      assigns
-      |> Enum.flat_map(fn
-        {_key, %Plox.DatasetAxis{} = dataset_axis} -> [dataset_axis.dataset]
-        {_key, _} -> []
-      end)
-      |> Enum.uniq()
-
-    case datasets do
+  defp validate_zero_or_one_dataset(data) do
+    data
+    |> Enum.flat_map(fn
+      %Plox.DatasetAxis{} = dataset_axis -> [dataset_axis.dataset]
+      _ -> []
+    end)
+    |> Enum.uniq()
+    |> case do
       [] -> :none
-      [dataset] -> dataset
+      [_dataset] -> :ok
       _ -> raise "all dynamic values must be from the same dataset"
     end
   end
 
-  # TODO: can we make this work elegantly?
-  # would it be cool to allow mixed datasets?
-  # defp collect_values(values) do
-  #   {dynamics, constants} =
-  #     Enum.split_with(values, fn
-  #       {_key, %Plox.DatasetAxis{}} -> true
-  #       {_key, _value} -> false
-  #     end)
-
-  #   grouped_dynamics = dynamics |> Enum.group_by(fn {_key, value} -> value.dataset end, fn {key, value} -> {value.key, key} end) |> Enum.to_list()
-
-  #   constants_map = Map.new(constants)
-
-  #   case length(grouped_dynamics) do
-  #     0 ->
-  #       [constants_map]
-
-  #     1 ->
-  #       [{dataset, keys}] = grouped_dynamics
-  #       for data_point <- dataset.data do
+  def points(x, y) do
+    values([x, y])
+  end
 
-  #       end
-  #     _ ->
-  #       raise "all dynamic values must be from the same dataset"
-  #   end
-  # end
+  def values(data) do
+    case validate_zero_or_one_dataset(data) do
+      :none ->
+        [List.to_tuple(data)]
 
-  # TODO: a huge "dataset axis" struct just to get the key...
-  # I think this can be made way more elegant
-  defp maybe_graph(%Plox.DatasetAxis{key: key}, data_point), do: data_point.graph[key]
-  defp maybe_graph(value, _data_point), do: value
+      :ok ->
+        enumerables =
+          data
+          |> Enum.map(fn
+            %Plox.DatasetAxis{} = axis -> axis
+            constant -> Stream.repeatedly(fn -> constant end)
+          end)
 
-  # defp maybe_axis({axis_name, value}, dataset, _data_point), do: Axis.to_graph(dataset.axes[axis_name], value)
-  # defp maybe_axis(axis_name, _dataset, data_point), do: data_point.graph[axis_name]
+        Enum.zip(enumerables)
+    end
+  end
 
   @doc """
   Bar plot.

From 076be7655454d8b216526caa114ee57d7e857561 Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Wed, 9 Jul 2025 11:36:20 -0700
Subject: [PATCH 13/23] Add docs to points and values + Update demo_live

---
 demo_live.exs | 10 +++----
 lib/plox.ex   | 79 +++++++++++++++++++++++++++++++++++++--------------
 2 files changed, 61 insertions(+), 28 deletions(-)

diff --git a/demo_live.exs b/demo_live.exs
index 7877793..a3514ef 100644
--- a/demo_live.exs
+++ b/demo_live.exs
@@ -84,14 +84,12 @@ defmodule DemoLive do
 
       <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="#D3D3D3" />
 
-      <%!-- <.polyline dataset={@dataset} stroke="orange" stroke-width={2} /> --%>
-      <.polyline points={Enum.zip(@dataset[:x], @dataset[:y])} stroke="orange" stroke-width={2} />
+      <%!-- <.polyline points={Enum.zip(@dataset[:x], @dataset[:y])} stroke="orange" stroke-width={2} /> --%>
+      <.polyline points={points(@dataset[:x], @dataset[:y])} stroke="orange" stroke-width={2} />
 
-      <%!-- Access behavior with axes --%>
-      <%!-- <.polyline points={{@dataset[:x], @dataset[:y]}} class="stroke-orange-500 dark:stroke-orange-400 stroke-2" /> --%>
       <%!-- constant y = 40 --%>
-      <%!-- <.polyline points={{@dataset[:x], @dataset[:y][40]}} class="stroke-orange-500 dark:stroke-orange-400 stroke-2" /> --%>
-      <%!-- <.circles dataset={@dataset} cx={:x} cy={:y} fill={:color} r={:radius} /> --%>
+      <.polyline points={points(@dataset[:x], @dataset[:y][40])} stroke="purple" stroke-width="2" />
+
       <%!-- use the Access behavior --%>
       <.circle
         cx={@dataset[:x]}
diff --git a/lib/plox.ex b/lib/plox.ex
index bd517cc..805afab 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -377,7 +377,10 @@ defmodule Plox do
   def circle(assigns) do
     ~H"""
     <circle
-      :for={{cx, cy, r, fill, stroke, stroke_width} <- values([@cx, @cy, @r, @fill, @stroke, assigns[:"stroke-width"]])}
+      :for={
+        {cx, cy, r, fill, stroke, stroke_width} <-
+          values([@cx, @cy, @r, @fill, @stroke, assigns[:"stroke-width"]])
+      }
       cx={cx}
       cy={cy}
       r={r}
@@ -389,38 +392,70 @@ defmodule Plox do
     """
   end
 
-  defp validate_zero_or_one_dataset(data) do
-    data
-    |> Enum.flat_map(fn
-      %Plox.DatasetAxis{} = dataset_axis -> [dataset_axis.dataset]
-      _ -> []
-    end)
-    |> Enum.uniq()
-    |> case do
-      [] -> :none
-      [_dataset] -> :ok
-      _ -> raise "all dynamic values must be from the same dataset"
-    end
-  end
+  @doc """
+  Returns a list of points as tuples for use in polyline or other SVG elements.
+
+  ## Example
 
+    iex> Plox.points(1, 2)
+    [{1, 2}]
+
+    iex> Plox.points([1, 2], [3, 4])
+    [{1, 3}, {2, 4}]
+
+    iex> Plox.points([1, 2], %Plox.DatasetAxis{values: [3, 4]})
+    [{1, 3}, {2, 4}]
+
+    iex> Plox.points(%Plox.DatasetAxis{values: [1, 2]}, %Plox.DatasetAxis{values: [3, 4]})
+    [{1, 3}, {2, 4}]
+  """
   def points(x, y) do
     values([x, y])
   end
 
+  @doc """
+  Returns a list of tuples for use in polyline or other SVG elements.
+
+  ## Example
+
+    iex> Plox.values([1, 2])
+    [{1, 2}]
+
+    iex> Plox.values([1, 2], [3, 4])
+    [{1, 3}, {2, 4}]
+
+    iex> Plox.values([1, 2], %Plox.DatasetAxis{values: [3, 4]})
+    [{1, 3}, {2, 4}]
+
+    iex> Plox.values(%Plox.DatasetAxis{values: [1, 2]}, %Plox.DatasetAxis{values: [3, 4]})
+    [{1, 3}, {2, 4}]
+  """
   def values(data) do
     case validate_zero_or_one_dataset(data) do
       :none ->
         [List.to_tuple(data)]
 
       :ok ->
-        enumerables =
-          data
-          |> Enum.map(fn
-            %Plox.DatasetAxis{} = axis -> axis
-            constant -> Stream.repeatedly(fn -> constant end)
-          end)
-
-        Enum.zip(enumerables)
+        data
+        |> Enum.map(fn
+          %Plox.DatasetAxis{} = axis -> axis
+          constant -> Stream.repeatedly(fn -> constant end)
+        end)
+        |> Enum.zip()
+    end
+  end
+
+  defp validate_zero_or_one_dataset(data) do
+    data
+    |> Enum.flat_map(fn
+      %Plox.DatasetAxis{} = dataset_axis -> [dataset_axis.dataset]
+      _ -> []
+    end)
+    |> Enum.uniq()
+    |> case do
+      [] -> :none
+      [_dataset] -> :ok
+      _ -> raise "all dynamic values must be from the same dataset"
     end
   end
 

From a2fc0efa237924e31a121994ab7700d0aa86a5dc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Chris=20Dos=C3=A9?= <chris@xn--dos-dma.com>
Date: Wed, 9 Jul 2025 15:44:50 -0700
Subject: [PATCH 14/23] Refactor Axis protocol and add Axis using macro so that
 axes can be accessed too (#19)

---
 lib/plox.ex               | 21 +++++++-------------
 lib/plox/axis.ex          | 40 +++++++++++++++++++--------------------
 lib/plox/axis/protocol.ex | 25 ++++++++++++++++++++++++
 lib/plox/color_axis.ex    |  4 +++-
 lib/plox/dataset.ex       |  5 ++---
 lib/plox/linear_axis.ex   |  4 +++-
 lib/plox/x_axis.ex        |  4 +++-
 lib/plox/y_axis.ex        |  4 +++-
 8 files changed, 65 insertions(+), 42 deletions(-)
 create mode 100644 lib/plox/axis/protocol.ex

diff --git a/lib/plox.ex b/lib/plox.ex
index 805afab..3b766de 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -6,16 +6,9 @@ defmodule Plox do
   use Phoenix.Component
 
   alias Phoenix.LiveView.JS
-  alias Plox.Axis
-  alias Plox.Dataset
-  # alias Plox.DateScale
-  # alias Plox.DateTimeScale
   alias Plox.Dimensions
-  # alias Plox.FixedColorsScale
-  # alias Plox.FixedValuesScale
   alias Plox.GraphDataset
   alias Plox.GraphScale
-  # alias Plox.NumberScale
   alias Plox.Scale
   alias Plox.XAxis
   alias Plox.YAxis
@@ -98,7 +91,7 @@ defmodule Plox do
   def x_axis_label(%{position: :bottom} = assigns) do
     ~H"""
     <text
-      x={x = Axis.to_graph(@axis, @value)}
+      x={x = @axis[@value]}
       y={@axis.dimensions.height - @axis.dimensions.margin.bottom + @gap}
       dominant-baseline={assigns[:"dominant-baseline"] || "hanging"}
       text-anchor={assigns[:"text-anchor"] || "middle"}
@@ -117,7 +110,7 @@ defmodule Plox do
   def x_axis_label(%{position: :top} = assigns) do
     ~H"""
     <text
-      x={x = Axis.to_graph(@axis, @value)}
+      x={x = @axis[@value]}
       y={@axis.dimensions.margin.bottom - @gap}
       dominant-baseline={assigns[:"dominant-baseline"] || "text-bottom"}
       text-anchor={assigns[:"text-anchor"] || "middle"}
@@ -180,7 +173,7 @@ defmodule Plox do
     ~H"""
     <text
       x={@axis.dimensions.margin.left - @gap}
-      y={y = Axis.to_graph(@axis, @value)}
+      y={y = @axis[@value]}
       dominant-baseline={assigns[:"dominant-baseline"] || "middle"}
       text-anchor={assigns[:"text-anchor"] || "end"}
       transform={
@@ -198,7 +191,7 @@ defmodule Plox do
     ~H"""
     <text
       x={@axis.dimensions.width - @axis.dimensions.margin.right + @gap}
-      y={y = Axis.to_graph(@axis, @value)}
+      y={y = @axis[@value]}
       dominant-baseline={assigns[:"dominant-baseline"] || "middle"}
       text-anchor={assigns[:"text-anchor"] || "start"}
       transform={
@@ -249,7 +242,7 @@ defmodule Plox do
   def x_axis_grid_line(assigns) do
     ~H"""
     <line
-      x1={x = Axis.to_graph(@axis, @value)}
+      x1={x = @axis[@value]}
       y1={@axis.dimensions.margin.top - @top_overdraw}
       x2={x}
       y2={@axis.dimensions.height - @axis.dimensions.margin.bottom + @bottom_overdraw}
@@ -293,7 +286,7 @@ defmodule Plox do
     ~H"""
     <line
       x1={@axis.dimensions.margin.left}
-      y1={y = Axis.to_graph(@axis, @value)}
+      y1={y = @axis[@value]}
       x2={@axis.dimensions.width - @axis.dimensions.margin.right}
       y2={y}
       {@rest}
@@ -785,7 +778,7 @@ defmodule Plox do
   def x_marker(assigns) do
     ~H"""
     <line
-      x1={x = Axis.to_graph(@axis, @value)}
+      x1={x = @axis[@value]}
       y1={@axis.dimensions.margin.top - 12}
       x2={x}
       y2={@axis.dimensions.height - @axis.dimensions.margin.bottom}
diff --git a/lib/plox/axis.ex b/lib/plox/axis.ex
index 70f528e..791bb54 100644
--- a/lib/plox/axis.ex
+++ b/lib/plox/axis.ex
@@ -1,25 +1,23 @@
-defprotocol Plox.Axis do
-  @moduledoc """
-  A protocol for graph axes.
+defmodule Plox.Axis do
+  @moduledoc false
+  defmacro __using__(_opts) do
+    quote do
+      @behaviour Access
 
-  TODO: docs
-  """
+      @impl Access
+      def fetch(axis, value) do
+        {:ok, Plox.Axis.Protocol.to_graph(axis, value)}
+      end
 
-  @typedoc """
-  Any struct that implements this protocol
+      @impl Access
+      def pop(_axis, _key) do
+        raise "Not implemented"
+      end
 
-  Built in implementations are:
-
-  * `Plox.XAxis`
-  * `Plox.YAxis`
-  * `Plox.RadiusAxis`
-  * `Plox.ColorAxis`
-  """
-  @type t :: any()
-
-  @doc """
-  Converts a specific scale value to a value usable by the graph components
-  """
-  @spec to_graph(axis :: t(), any()) :: any()
-  def to_graph(axis, value)
+      @impl Access
+      def get_and_update(_axis, _key, _function) do
+        raise "Not implemented"
+      end
+    end
+  end
 end
diff --git a/lib/plox/axis/protocol.ex b/lib/plox/axis/protocol.ex
new file mode 100644
index 0000000..27bfd70
--- /dev/null
+++ b/lib/plox/axis/protocol.ex
@@ -0,0 +1,25 @@
+defprotocol Plox.Axis.Protocol do
+  @moduledoc """
+  A protocol for graph axes.
+
+  TODO: docs
+  """
+
+  @typedoc """
+  Any struct that implements this protocol
+
+  Built in implementations are:
+
+  * `Plox.XAxis`
+  * `Plox.YAxis`
+  * `Plox.RadiusAxis`
+  * `Plox.ColorAxis`
+  """
+  @type t :: any()
+
+  @doc """
+  Converts a specific scale value to a value usable by the graph components
+  """
+  @spec to_graph(axis :: t(), any()) :: any()
+  def to_graph(axis, value)
+end
diff --git a/lib/plox/color_axis.ex b/lib/plox/color_axis.ex
index 141b05c..b948b7f 100644
--- a/lib/plox/color_axis.ex
+++ b/lib/plox/color_axis.ex
@@ -4,6 +4,8 @@ defmodule Plox.ColorAxis do
   with, so it should be documented
   """
 
+  use Plox.Axis
+
   alias Plox.ColorScale
 
   defstruct [:scale]
@@ -14,7 +16,7 @@ defmodule Plox.ColorAxis do
 
   # def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
 
-  defimpl Plox.Axis do
+  defimpl Plox.Axis.Protocol do
     def to_graph(%{scale: scale}, value) do
       ColorScale.convert_to_color(scale, value)
     end
diff --git a/lib/plox/dataset.ex b/lib/plox/dataset.ex
index 3e498f4..f2edc1b 100644
--- a/lib/plox/dataset.ex
+++ b/lib/plox/dataset.ex
@@ -6,7 +6,7 @@ defmodule Plox.DatasetAxis do
 
   @impl Access
   def fetch(%__MODULE__{axis: axis}, value) do
-    {:ok, Plox.Axis.to_graph(axis, value)}
+    {:ok, axis[value]}
   end
 
   @impl Access
@@ -47,7 +47,6 @@ defmodule Plox.Dataset do
   """
   @behaviour Access
 
-  alias Plox.Axis
   alias Plox.DataPoint
 
   defstruct [:data, :axes]
@@ -55,7 +54,7 @@ defmodule Plox.Dataset do
   def new(original_data, axis_fns) do
     data =
       Enum.map(original_data, fn original ->
-        graph = Map.new(axis_fns, fn {key, {axis, fun}} -> {key, Axis.to_graph(axis, fun.(original))} end)
+        graph = Map.new(axis_fns, fn {key, {axis, fun}} -> {key, axis[fun.(original)]} end)
 
         DataPoint.new(original, graph)
       end)
diff --git a/lib/plox/linear_axis.ex b/lib/plox/linear_axis.ex
index 3e44ed3..66c7721 100644
--- a/lib/plox/linear_axis.ex
+++ b/lib/plox/linear_axis.ex
@@ -4,6 +4,8 @@ defmodule Plox.LinearAxis do
   with, so it should be documented
   """
 
+  use Plox.Axis
+
   alias Plox.Scale
 
   defstruct [:scale, :min, :max]
@@ -18,7 +20,7 @@ defmodule Plox.LinearAxis do
 
   def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
 
-  defimpl Plox.Axis do
+  defimpl Plox.Axis.Protocol do
     def to_graph(%{scale: scale, min: min, max: max}, value) do
       Scale.convert_to_range(scale, value, min..max)
     end
diff --git a/lib/plox/x_axis.ex b/lib/plox/x_axis.ex
index 4889fe5..582f347 100644
--- a/lib/plox/x_axis.ex
+++ b/lib/plox/x_axis.ex
@@ -4,6 +4,8 @@ defmodule Plox.XAxis do
   with, so it should be documented
   """
 
+  use Plox.Axis
+
   alias Plox.Scale
 
   defstruct [:scale, :dimensions]
@@ -14,7 +16,7 @@ defmodule Plox.XAxis do
 
   def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
 
-  defimpl Plox.Axis do
+  defimpl Plox.Axis.Protocol do
     def to_graph(%{scale: scale, dimensions: dimensions}, value) do
       Scale.convert_to_range(
         scale,
diff --git a/lib/plox/y_axis.ex b/lib/plox/y_axis.ex
index 8f2e7b9..150c0b4 100644
--- a/lib/plox/y_axis.ex
+++ b/lib/plox/y_axis.ex
@@ -4,6 +4,8 @@ defmodule Plox.YAxis do
   with, so it should be documented
   """
 
+  use Plox.Axis
+
   alias Plox.Scale
 
   defstruct [:scale, :dimensions]
@@ -14,7 +16,7 @@ defmodule Plox.YAxis do
 
   def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
 
-  defimpl Plox.Axis do
+  defimpl Plox.Axis.Protocol do
     def to_graph(%{scale: scale, dimensions: dimensions}, value) do
       Scale.convert_to_range(
         scale,

From 19ca435fa04368263f9e9fbdf57267c4be7486d1 Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Wed, 9 Jul 2025 17:08:00 -0700
Subject: [PATCH 15/23] Update step_polyline to follow polyline component

---
 demo_live.exs |  9 +++++++++
 lib/plox.ex   | 38 +++++++++++++++++++++++++++-----------
 2 files changed, 36 insertions(+), 11 deletions(-)

diff --git a/demo_live.exs b/demo_live.exs
index a3514ef..a5c174a 100644
--- a/demo_live.exs
+++ b/demo_live.exs
@@ -90,6 +90,15 @@ defmodule DemoLive do
       <%!-- constant y = 40 --%>
       <.polyline points={points(@dataset[:x], @dataset[:y][40])} stroke="purple" stroke-width="2" />
 
+      <%!-- <.step_polyline dataset={@dataset} x={:x} y={:y} stroke="pink" stroke-width="2" /> --%>
+      <.step_polyline points={points(@dataset[:x], @dataset[:y])} stroke="pink" stroke-width="2" />
+
+      <%!-- you can manually add points like how the polyline SVG accepts them, but it'll turn them into a step line --%>
+      <%!-- <.step_polyline points="50,60 100,20 150,40" stroke="pink" stroke-width="2" /> --%>
+
+      <%!-- you can also manually build a list of {x, y} tuples and pass that in --%>
+      <%!-- <.step_polyline points={@step_points} stroke="green" stroke-width="2" /> --%>
+
       <%!-- use the Access behavior --%>
       <.circle
         cx={@dataset[:x]}
diff --git a/lib/plox.ex b/lib/plox.ex
index 3b766de..0aeb2a4 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -299,7 +299,7 @@ defmodule Plox do
   """
   @doc type: :component
 
-  attr :points, :any, required: true, doc: "String of coordinates or list of {x, y} tuples"
+  attr :points, :any, required: true, doc: "String of coordinates (x1,y1 x2,y2...) or list of {x, y} tuples"
   attr :fill, :any, default: "none"
   attr :rest, :global, include: @svg_presentation_globals
 
@@ -327,22 +327,38 @@ defmodule Plox do
   """
   @doc type: :component
 
-  attr :dataset, Dataset, required: true
-
-  attr :x, :atom, default: :x, doc: "The dataset axis key to use for x values"
-  attr :y, :atom, default: :y, doc: "The dataset axis key to use for y values"
+  attr :points, :any, required: true, doc: "String of coordinates (x1,y1 x2,y2...) or list of {x, y} tuples"
   attr :fill, :any, default: "none"
   attr :rest, :global, include: @svg_presentation_globals
 
+  def step_polyline(%{points: points} = assigns) when is_binary(points) do
+    points =
+      points
+      |> String.split(" ")
+      |> Enum.map(fn point ->
+        [x, y] = String.split(point, ",")
+        %{x: String.to_integer(x), y: String.to_integer(y)}
+      end)
+      |> step_line_points()
+
+    assigns
+    |> assign(points: points)
+    |> do_polyline()
+  end
+
   def step_polyline(assigns) do
-    ~H"""
-    <polyline points={step_line_points(@dataset, @x, @y)} fill={@fill} {@rest} />
-    """
+    points =
+      assigns.points
+      |> Enum.map(fn {x, y} -> %{x: x, y: y} end)
+      |> step_line_points()
+
+    assigns
+    |> assign(points: points)
+    |> do_polyline()
   end
 
-  defp step_line_points(dataset, x_key, y_key) do
-    dataset.data
-    |> Enum.map(fn data_point -> %{x: data_point.graph[x_key], y: data_point.graph[y_key]} end)
+  defp step_line_points(points) do
+    points
     |> Enum.chunk_every(2, 1)
     |> Enum.flat_map(fn
       [point1, point2] -> [point1, %{point2 | y: point1.y}]

From 4c0bdd594ef90c718bab8fcdfd3ddd414e01cbf4 Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Wed, 9 Jul 2025 17:38:13 -0700
Subject: [PATCH 16/23] Remove unneeded marker components + Update docs and
 animated demo

---
 animated_demo_live.exs |  11 ++-
 lib/plox.ex            | 155 ++---------------------------------------
 2 files changed, 14 insertions(+), 152 deletions(-)

diff --git a/animated_demo_live.exs b/animated_demo_live.exs
index bdd3e37..226c848 100644
--- a/animated_demo_live.exs
+++ b/animated_demo_live.exs
@@ -94,7 +94,9 @@ defmodule AnimatedDemoLive do
       <.x_axis_grid_lines axis={@x_axis} step={5} start={@nearest_5_second} stroke="#D3D3D3" />
       <.x_axis_grid_line axis={@x_axis} value={@x_axis.scale.first} stroke="#D3D3D3" />
       <.x_axis_grid_line axis={@x_axis} value={@x_axis.scale.last} stroke="#D3D3D3" />
-      <.x_axis_label axis={@x_axis} value={@now} position={:top} color="red">
+
+      <%!-- vertical marker for "now" with a label --%>
+      <.x_axis_label axis={@x_axis} value={@now} position={:top} stroke="red">
         Now ({Calendar.strftime(@now, "%-I:%M:%S")})
       </.x_axis_label>
 
@@ -103,7 +105,12 @@ defmodule AnimatedDemoLive do
       <.polyline points={points(@dataset1[:x], @dataset1[:y])} stroke="orange" stroke-width="2" />
       <.polyline points={points(@dataset2[:x], @dataset2[:y])} stroke="blue" stroke-width="2" />
       <.polyline points={points(@dataset3[:x], @dataset3[:y])} stroke="green" stroke-width="2" />
-      <%!-- <.circles dataset={@points_dataset} r={:r} fill={:color} /> --%>
+      <.circle
+        cx={@points_dataset[:x]}
+        cy={@points_dataset[:y]}
+        r={@points_dataset[:r]}
+        fill={@points_dataset[:color]}
+      />
     </.graph>
     """
   end
diff --git a/lib/plox.ex b/lib/plox.ex
index 0aeb2a4..3b6c776 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -1,6 +1,7 @@
 defmodule Plox do
   @moduledoc """
-  TODO:
+  Composable, customizable, and flexible SVG graphing components rendered server-side
+  for Phoenix and LiveView.
   """
 
   use Phoenix.Component
@@ -8,7 +9,6 @@ defmodule Plox do
   alias Phoenix.LiveView.JS
   alias Plox.Dimensions
   alias Plox.GraphDataset
-  alias Plox.GraphScale
   alias Plox.Scale
   alias Plox.XAxis
   alias Plox.YAxis
@@ -295,7 +295,7 @@ defmodule Plox do
   end
 
   @doc """
-  A connected line plot.
+  Draws a SVG `<polyline>` element connecting a series of points.
   """
   @doc type: :component
 
@@ -323,7 +323,7 @@ defmodule Plox do
   end
 
   @doc """
-  A connected step line plot.
+  Draws a SVG `<polyline>` element connecting a series of points in the form of a stepped line.
   """
   @doc type: :component
 
@@ -370,7 +370,7 @@ defmodule Plox do
   defp polyline_points(points), do: Enum.map_join(points, " ", &"#{&1.x},#{&1.y}")
 
   @doc """
-  Draws a single or set of SVG <circle> elements.
+  Draws a single or set of SVG `<circle>` elements.
   """
   @doc type: :component
 
@@ -692,133 +692,6 @@ defmodule Plox do
     |> Enum.chunk_every(2, 1, :discard)
   end
 
-  @doc """
-  A horizontal or vertical marker line with a label.
-  """
-  @doc type: :component
-
-  attr :at, :any, required: true
-  attr :scale, :any, required: true
-  attr :width, :string, default: "1.5"
-  attr :orientation, :atom, values: [:vertical, :horizontal], default: :vertical
-
-  attr :line_style, :atom, values: [:solid, :dashed, :dotted], default: :dotted
-  attr :line_color, :string, default: "#18191A"
-  attr :label_color, :string, default: "#18191A"
-  attr :label_style, :string, default: "font-size: 0.75rem; line-height: 1rem"
-  attr :label_rotation, :integer, default: nil
-
-  slot :inner_block, required: true
-
-  def marker(%{orientation: :vertical} = assigns) do
-    x_pixel = GraphScale.to_graph_x(assigns.scale, assigns.at)
-    assigns = assign(assigns, dimensions: assigns.scale.dimensions, x_pixel: x_pixel)
-
-    ~H"""
-    <line
-      x1={@x_pixel}
-      y1={@dimensions.margin.top - 12}
-      x2={@x_pixel}
-      y2={@dimensions.height - @dimensions.margin.bottom}
-      stroke={@line_color}
-      stroke-width={@width}
-      stroke-dasharray={stroke_dasharray(@line_style)}
-    />
-    <text
-      x={@x_pixel}
-      y={@dimensions.margin.top - 24}
-      fill={@label_color}
-      dominant-baseline="middle"
-      text-anchor="middle"
-      style={@label_style}
-      transform={
-        if @label_rotation,
-          do: "rotate(#{@label_rotation}, #{@x_pixel}, #{@dimensions.margin.top - 24})"
-      }
-    >
-      {render_slot(@inner_block)}
-    </text>
-    """
-  end
-
-  def marker(%{orientation: :horizontal} = assigns) do
-    y_pixel = GraphScale.to_graph_y(assigns.scale, assigns.at)
-    assigns = assign(assigns, dimensions: assigns.scale.dimensions, y_pixel: y_pixel)
-
-    ~H"""
-    <line
-      x1={@dimensions.margin.left - 12}
-      y1={@y_pixel}
-      x2={@dimensions.width - @dimensions.margin.right}
-      y2={@y_pixel}
-      stroke={@line_color}
-      stroke-width={@width}
-      stroke-dasharray={stroke_dasharray(@line_style)}
-    />
-    <text
-      x={@dimensions.margin.left - 24}
-      y={@y_pixel}
-      fill={@label_color}
-      dominant-baseline="middle"
-      text-anchor="middle"
-      style={@label_style}
-      transform={
-        if @label_rotation,
-          do: "rotate(#{@label_rotation}, #{@dimensions.margin.left - 24}, #{@y_pixel})"
-      }
-    >
-      {render_slot(@inner_block)}
-    </text>
-    """
-  end
-
-  @doc """
-  A horizontal or vertical marker line with a label.
-  """
-  @doc type: :component
-
-  attr :axis, XAxis, required: true
-  attr :value, :any, required: true
-
-  attr :width, :string, default: "1.5"
-  attr :orientation, :atom, values: [:vertical, :horizontal], default: :vertical
-
-  attr :line_style, :atom, values: [:solid, :dashed, :dotted], default: :dotted
-  attr :line_color, :string, default: "#18191A"
-  attr :label_color, :string, default: "#18191A"
-  attr :label_style, :string, default: "font-size: 0.75rem; line-height: 1rem"
-  attr :label_rotation, :integer, default: nil
-
-  slot :inner_block, required: true
-
-  def x_marker(assigns) do
-    ~H"""
-    <line
-      x1={x = @axis[@value]}
-      y1={@axis.dimensions.margin.top - 12}
-      x2={x}
-      y2={@axis.dimensions.height - @axis.dimensions.margin.bottom}
-      stroke={@line_color}
-      stroke-width={@width}
-      stroke-dasharray={stroke_dasharray(@line_style)}
-    />
-    <text
-      x={x}
-      y={@axis.dimensions.margin.top - 24}
-      fill={@label_color}
-      dominant-baseline="middle"
-      text-anchor="middle"
-      style={@label_style}
-      transform={
-        if @label_rotation,
-          do: "rotate(#{@label_rotation}, #{x}, #{@axis.dimensions.margin.top - 24})"
-      }
-    >
-      {render_slot(@inner_block)}
-    </text>
-    """
-  end
-
   @doc """
   Legend row.
   """
@@ -863,22 +736,4 @@ defmodule Plox do
     <div style={"background-color: #{@color}; height: 0.5rem; width: 0.5rem; flex: none; border-radius: 9999px;"} />
     """
   end
-
-  defp stroke_dasharray(:solid), do: false
-  defp stroke_dasharray(:dotted), do: "2"
-  defp stroke_dasharray(:dashed), do: "6"
-
-  # def date_scale(graph, range), do: GraphScale.new(graph, DateScale.new(range))
-
-  # def number_scale(graph, first, last), do: GraphScale.new(graph, NumberScale.new(first, last))
-
-  # def dataset(data, axes), do: Dataset.new(data, axes)
-
-  # defdelegate graph(width, height, opts \\ []), to: Graph, as: :new
-  # # defdelegate date_scale(range), to: DateScale, as: :new
-  # defdelegate datetime_scale(first, last), to: DateTimeScale, as: :new
-  # # defdelegate number_scale(first, last), to: NumberScale, as: :new
-  # defdelegate fixed_colors_scale(color_mapping), to: FixedColorsScale, as: :new
-  # defdelegate fixed_values_scale(values), to: FixedValuesScale, as: :new
-  # # defdelegate dataset(data, aces), to: Dataset, as: :new
 end

From 7772660012dca246d9c6311293c95d8ff561d7a3 Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Thu, 10 Jul 2025 09:50:39 -0700
Subject: [PATCH 17/23] Organize demos and migration guide into subfolders

---
 migration_guide.md => docs/migration_guide.md             | 0
 animated_demo_live.exs => examples/animated_demo_live.exs | 0
 demo_live.exs => examples/demo_live.exs                   | 0
 3 files changed, 0 insertions(+), 0 deletions(-)
 rename migration_guide.md => docs/migration_guide.md (100%)
 rename animated_demo_live.exs => examples/animated_demo_live.exs (100%)
 rename demo_live.exs => examples/demo_live.exs (100%)

diff --git a/migration_guide.md b/docs/migration_guide.md
similarity index 100%
rename from migration_guide.md
rename to docs/migration_guide.md
diff --git a/animated_demo_live.exs b/examples/animated_demo_live.exs
similarity index 100%
rename from animated_demo_live.exs
rename to examples/animated_demo_live.exs
diff --git a/demo_live.exs b/examples/demo_live.exs
similarity index 100%
rename from demo_live.exs
rename to examples/demo_live.exs

From 28902b5dd00bfbbd2007f22d99845a3199b883fd Mon Sep 17 00:00:00 2001
From: "Nikki (she/her)" <nikki-kyllonen@comcast.net>
Date: Thu, 17 Jul 2025 13:04:45 -0700
Subject: [PATCH 18/23] Update tests and docs (#20)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Add DatasetAxis and Dataset tests

* Fix values/2 bug + Add Plox docs and tests for points/2 and values/1

* Add XAxis and YAxis docs and tests

* Update docs and tests for Dimensions, Box, and DataPoint

* Update Axis Protocol and ColorAxis docs + Add ColorAxis tests

* Remove old unused graph_ files and tests

* Add LinearAxis docs and tests

* Update Scale + Remove Protocol test files

* Adds docs and tests for all Scales

* Add DateTimeScale docs and tests

* Explicitly document which fns raise errors

* Add DateScale docs and tests

* Move protocol fn docs into moduledocs for doctests and visibility

---------

Co-authored-by: Chris Dosé <chris@xn--dos-dma.com>
---
 examples/animated_demo_live.exs       |   4 +-
 examples/demo_live.exs                |   2 +
 lib/plox.ex                           | 523 +++++++++++++-------------
 lib/plox/axis/protocol.ex             |  11 +-
 lib/plox/box.ex                       |  26 +-
 lib/plox/color_axis.ex                |  42 ++-
 lib/plox/data_point.ex                |  31 +-
 lib/plox/dataset.ex                   |  43 ++-
 lib/plox/date_scale.ex                |  55 ++-
 lib/plox/date_time_scale.ex           |  51 ++-
 lib/plox/dimensions.ex                |  22 +-
 lib/plox/fixed_colors_scale.ex        |  32 +-
 lib/plox/fixed_values_scale.ex        |  40 +-
 lib/plox/graph_dataset.ex             |  77 ----
 lib/plox/graph_point.ex               |  12 -
 lib/plox/graph_scalar.ex              |  12 -
 lib/plox/graph_scale.ex               |  38 --
 lib/plox/linear_axis.ex               |  46 ++-
 lib/plox/number_scale.ex              |  80 +++-
 lib/plox/scale.ex                     |   6 +-
 lib/plox/x_axis.ex                    |  63 +++-
 lib/plox/y_axis.ex                    |  65 +++-
 mix.exs                               |  16 +-
 test/plox/color_axis_test.exs         |  32 ++
 test/plox/color_scale_test.exs        |  11 -
 test/plox/data_point_test.exs         |   5 +-
 test/plox/dataset_test.exs            |  97 ++++-
 test/plox/date_scale_test.exs         |  77 +++-
 test/plox/date_time_scale_test.exs    | 121 +++++-
 test/plox/dimensions_test.exs         |   2 +-
 test/plox/fixed_colors_scale_test.exs |  36 +-
 test/plox/fixed_values_scale_test.exs |  45 ++-
 test/plox/graph_dataset_test.exs      |   9 -
 test/plox/graph_point_test.exs        |   9 -
 test/plox/graph_scalar_test.exs       |   9 -
 test/plox/graph_scale_test.exs        |   9 -
 test/plox/graph_test.exs              |   9 -
 test/plox/linear_axis_test.exs        |  34 ++
 test/plox/number_scale_test.exs       |  79 +++-
 test/plox/scale_test.exs              |   9 -
 test/plox/x_axis_test.exs             |  36 ++
 test/plox/y_axis_test.exs             |  38 ++
 test/plox_test.exs                    |  50 ++-
 43 files changed, 1396 insertions(+), 618 deletions(-)
 delete mode 100644 lib/plox/graph_dataset.ex
 delete mode 100644 lib/plox/graph_point.ex
 delete mode 100644 lib/plox/graph_scalar.ex
 delete mode 100644 lib/plox/graph_scale.ex
 create mode 100644 test/plox/color_axis_test.exs
 delete mode 100644 test/plox/color_scale_test.exs
 delete mode 100644 test/plox/graph_dataset_test.exs
 delete mode 100644 test/plox/graph_point_test.exs
 delete mode 100644 test/plox/graph_scalar_test.exs
 delete mode 100644 test/plox/graph_scale_test.exs
 delete mode 100644 test/plox/graph_test.exs
 create mode 100644 test/plox/linear_axis_test.exs
 delete mode 100644 test/plox/scale_test.exs
 create mode 100644 test/plox/x_axis_test.exs
 create mode 100644 test/plox/y_axis_test.exs

diff --git a/examples/animated_demo_live.exs b/examples/animated_demo_live.exs
index 226c848..d073039 100644
--- a/examples/animated_demo_live.exs
+++ b/examples/animated_demo_live.exs
@@ -1,11 +1,13 @@
 Mix.install([
-  {:phoenix_playground, "~> 0.1.6"},
+  {:phoenix_playground, "~> 0.1.7"},
   {:plox, path: "."}
 ])
 
 defmodule AnimatedDemoLive do
   @moduledoc """
   Example animated graph rendered within a Phoenix Playground application.
+
+  $ iex animated_demo_live.exs
   """
   use Phoenix.LiveView
 
diff --git a/examples/demo_live.exs b/examples/demo_live.exs
index a5c174a..6fc618e 100644
--- a/examples/demo_live.exs
+++ b/examples/demo_live.exs
@@ -6,6 +6,8 @@ Mix.install([
 defmodule DemoLive do
   @moduledoc """
   Example graph rendered within a Phoenix Playground application.
+
+  $ iex demo_live.exs
   """
   use Phoenix.LiveView
 
diff --git a/lib/plox.ex b/lib/plox.ex
index 3b6c776..6b55a5b 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -6,9 +6,7 @@ defmodule Plox do
 
   use Phoenix.Component
 
-  alias Phoenix.LiveView.JS
   alias Plox.Dimensions
-  alias Plox.GraphDataset
   alias Plox.Scale
   alias Plox.XAxis
   alias Plox.YAxis
@@ -402,7 +400,7 @@ defmodule Plox do
   end
 
   @doc """
-  Returns a list of points as tuples for use in polyline or other SVG elements.
+  Returns a list of tuples for use in polyline or other SVG elements.
 
   ## Example
 
@@ -412,11 +410,19 @@ defmodule Plox do
     iex> Plox.points([1, 2], [3, 4])
     [{1, 3}, {2, 4}]
 
-    iex> Plox.points([1, 2], %Plox.DatasetAxis{values: [3, 4]})
-    [{1, 3}, {2, 4}]
-
-    iex> Plox.points(%Plox.DatasetAxis{values: [1, 2]}, %Plox.DatasetAxis{values: [3, 4]})
-    [{1, 3}, {2, 4}]
+    iex> dataset = %Plox.Dataset{
+    ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
+    ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
+    ...>}
+    iex> Plox.points([1, 2], dataset[:x])
+    [{1, 10}, {2, 30}]
+
+    iex> dataset = %Plox.Dataset{
+    ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
+    ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
+    ...>}
+    iex> Plox.points(dataset[:x], dataset[:y])
+    [{10, 20}, {30, 40}]
   """
   def points(x, y) do
     values([x, y])
@@ -433,264 +439,259 @@ defmodule Plox do
     iex> Plox.values([1, 2], [3, 4])
     [{1, 3}, {2, 4}]
 
-    iex> Plox.values([1, 2], %Plox.DatasetAxis{values: [3, 4]})
-    [{1, 3}, {2, 4}]
-
-    iex> Plox.values(%Plox.DatasetAxis{values: [1, 2]}, %Plox.DatasetAxis{values: [3, 4]})
-    [{1, 3}, {2, 4}]
+    iex> dataset = %Plox.Dataset{
+    ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
+    ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
+    ...>}
+    iex> Plox.values([[1, 2], dataset[:x]])
+    [{1, 10}, {2, 30}]
+
+    iex> dataset = %Plox.Dataset{
+    ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
+    ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
+    ...>}
+    iex> Plox.values([dataset[:x], dataset[:y]])
+    [{10, 20}, {30, 40}]
   """
   def values(data) do
-    case validate_zero_or_one_dataset(data) do
-      :none ->
-        [List.to_tuple(data)]
-
-      :ok ->
-        data
-        |> Enum.map(fn
-          %Plox.DatasetAxis{} = axis -> axis
-          constant -> Stream.repeatedly(fn -> constant end)
-        end)
-        |> Enum.zip()
-    end
-  end
-
-  defp validate_zero_or_one_dataset(data) do
-    data
-    |> Enum.flat_map(fn
-      %Plox.DatasetAxis{} = dataset_axis -> [dataset_axis.dataset]
-      _ -> []
-    end)
-    |> Enum.uniq()
-    |> case do
-      [] -> :none
-      [_dataset] -> :ok
-      _ -> raise "all dynamic values must be from the same dataset"
+    if Enum.any?(data, &Enumerable.impl_for/1) do
+      data
+      |> Enum.map(fn value ->
+        if Enumerable.impl_for(value) do
+          value
+        else
+          Stream.repeatedly(fn -> value end)
+        end
+      end)
+      |> Enum.zip()
+    else
+      [List.to_tuple(data)]
     end
   end
 
-  @doc """
-  Bar plot.
-  """
-  @doc type: :component
-
-  attr :dataset, :any, required: true
-
-  attr :x, :atom, default: :x, doc: "The dataset axis key to use for x values"
-  attr :y, :atom, default: :y, doc: "The dataset axis key to use for y values"
-
-  attr :width, :string, examples: ["1.5", "4"], default: "16"
-  attr :bar_style, :atom, values: [:round, :square], default: :round
-  attr :color, :any, examples: ["red", "#FF9330", :color_axis], default: "#FF9330"
-
-  attr :"phx-click", :any, default: nil
-  attr :"phx-target", :any, default: nil
-
-  # TODO:
-  # support for several groups of bars
-
-  def bar_plot(assigns) do
-    ~H"""
-    <%= for point <- GraphDataset.to_graph_points(@dataset, @x, @y) do %>
-      <line
-        phx-click={
-          if assigns[:"phx-click"],
-            do:
-              JS.push(assigns[:"phx-click"],
-                value: %{
-                  id: point.data_point.id,
-                  dataset_id: @dataset.id,
-                  x_pixel: point.x,
-                  y_pixel: point.y
-                }
-              )
-        }
-        phx-target={assigns[:"phx-target"]}
-        style={if assigns[:"phx-click"], do: "cursor: pointer;"}
-        x1={point.x}
-        y1={point.y}
-        x2={point.x}
-        y2={
-          @dataset.dimensions.height - @dataset.dimensions.margin.bottom -
-            @dataset.dimensions.padding.bottom
-        }
-        stroke={GraphDataset.to_color(@dataset, @color, point.data_point)}
-        stroke-width={@width}
-        stroke-linecap={bar_style(@bar_style)}
-      />
-    <% end %>
-    """
-  end
-
-  defp bar_style(:round), do: "round"
-  defp bar_style(:square), do: "butt"
-
-  @doc """
-  Tooltip.
-  """
-  @doc type: :component
-
-  attr :dataset, :any, required: true
-  attr :point_id, :any, required: true
-  attr :x, :atom, default: :x, doc: "The dataset axis key to use for x values"
-  attr :y, :atom, default: :y, doc: "The dataset axis key to use for y values"
-
-  attr :x_pixel, :any, required: true
-  attr :y_pixel, :any, required: true
-
-  attr :"phx-click-away", :any
-  attr :"phx-target", :any, default: nil
-
-  slot :inner_block, required: true
-
-  def tooltip(%{x_pixel: x_pixel, y_pixel: y_pixel} = assigns) do
-    height = assigns.dataset.dimensions.height
-    width = assigns.dataset.dimensions.width
-
-    {bubble_classes_lr, caret_classes_lr} =
-      if x_pixel < width / 2 do
-        # left half of the graph, move caret and bubble right of point
-        {"left: #{x_pixel + 10}px;", "left: #{x_pixel + 4}px;"}
-      else
-        # right half of the graph, move caret and bubble left of point
-        {"right: #{width - x_pixel + 10}px;", "right: #{width - x_pixel + 4}px;"}
-      end
-
-    bubble_classes_tb =
-      if y_pixel < height / 2 do
-        # top half of the graph, move bubble up 20px
-        "top: #{y_pixel - 20}px;"
-      else
-        # bottom half of the graph, move bubble below 20px
-        "bottom: #{height - y_pixel - 20}px;"
-      end
-
-    assigns =
-      assign(assigns,
-        data_point: GraphDataset.get_point(assigns.dataset, assigns.point_id),
-        bubble_classes_lr: bubble_classes_lr,
-        caret_classes_lr: caret_classes_lr,
-        bubble_classes_tb: bubble_classes_tb
-      )
-
-    ~H"""
-    <div>
-      <%!-- caret --%>
-      <div style={[
-        "position: absolute; z-index: 10; width: 1rem; height: 1rem; background: #4B4C4D;",
-        "top: #{@y_pixel - 8}px; transform: rotate(45deg);",
-        @caret_classes_lr
-      ]} />
-
-      <%!-- bubble --%>
-      <div
-        style={[
-          "position: absolute; z-index: 15; padding: 1rem; border-radius: 0.75rem; width: max-content;",
-          "background: #4B4C4D; color: #CACBCC ; font-size: 0.75rem;",
-          "box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1);",
-          @bubble_classes_lr,
-          @bubble_classes_tb
-        ]}
-        phx-click-away={assigns[:"phx-click-away"]}
-        phx-target={assigns[:"phx-target"]}
-      >
-        {render_slot(@inner_block, @data_point.original)}
-      </div>
-    </div>
-    """
-  end
-
-  @doc """
-  One-dimensional shaded areas, either horizontal or vertical.
-  """
-  @doc type: :component
-
-  attr :dataset, :any, required: true
-
-  attr :area, :atom, required: true, doc: "The dataset axis key to use for the area plots"
-  attr :color, :atom, required: true, doc: "The dataset axis key to use for colors"
-
-  attr :orientation, :atom, values: [:vertical, :horizontal], default: :horizontal
-
-  attr :"phx-click", :any, default: nil
-  attr :"phx-target", :any, default: nil
-
-  def area_plot(%{orientation: :horizontal} = assigns) do
-    ~H"""
-    <%= for [scalar1, scalar2] <- area_points(@dataset, @area, @orientation), rect_color = GraphDataset.to_color(@dataset, @color, scalar1.data_point) do %>
-      <rect
-        :if={!is_nil(rect_color)}
-        fill={rect_color}
-        height={
-          @dataset.dimensions.height - @dataset.dimensions.margin.top -
-            @dataset.dimensions.margin.bottom
-        }
-        width={scalar2.value - scalar1.value}
-        x={scalar1.value}
-        y={@dataset.dimensions.margin.top}
-        phx-click={
-          if assigns[:"phx-click"],
-            do:
-              JS.push(assigns[:"phx-click"],
-                value: %{
-                  start_area_point_id: scalar1.data_point.id,
-                  end_area_point_id: scalar2.data_point.id,
-                  dataset_id: @dataset.id,
-                  x_pixel: scalar1.value + (scalar2.value - scalar1.value) / 2,
-                  y_pixel: @dataset.dimensions.margin.top + @dataset.dimensions.height / 2
-                }
-              )
-        }
-        style={if assigns[:"phx-click"], do: "cursor: pointer;"}
-        phx-target={assigns[:"phx-target"]}
-      />
-    <% end %>
-    """
-  end
-
-  def area_plot(%{orientation: :vertical} = assigns) do
-    ~H"""
-    <%= for [scalar1, scalar2] <- area_points(@dataset, @area, @orientation), rect_color = GraphDataset.to_color(@dataset, @color, scalar1.data_point) do %>
-      <rect
-        :if={!is_nil(rect_color)}
-        fill={rect_color}
-        height={scalar1.value - scalar2.value}
-        width={
-          @dataset.dimensions.width - @dataset.dimensions.margin.left -
-            @dataset.dimensions.margin.right
-        }
-        x={@dataset.dimensions.margin.left}
-        y={scalar1.value - (scalar1.value - scalar2.value)}
-        phx-click={
-          if assigns[:"phx-click"],
-            do:
-              JS.push(assigns[:"phx-click"],
-                value: %{
-                  start_area_point_id: scalar1.data_point.id,
-                  end_area_point_id: scalar2.data_point.id,
-                  dataset_id: @dataset.id,
-                  x_pixel: @dataset.dimensions.margin.left + @dataset.dimensions.width / 2,
-                  y_pixel: scalar2.value + (scalar1.value - scalar2.value) / 2
-                }
-              )
-        }
-        style={if assigns[:"phx-click"], do: "cursor: pointer;"}
-        phx-target={assigns[:"phx-target"]}
-      />
-    <% end %>
-    """
-  end
-
-  defp area_points(%GraphDataset{} = graph_dataset, key, :horizontal) do
-    graph_dataset
-    |> GraphDataset.to_graph_xs(key)
-    |> Enum.chunk_every(2, 1, :discard)
-  end
-
-  defp area_points(%GraphDataset{} = graph_dataset, key, :vertical) do
-    graph_dataset
-    |> GraphDataset.to_graph_ys(key)
-    |> Enum.chunk_every(2, 1, :discard)
-  end
+  # @doc """
+  # Bar plot.
+  # """
+  # @doc type: :component
+
+  # attr :dataset, :any, required: true
+
+  # attr :x, :atom, default: :x, doc: "The dataset axis key to use for x values"
+  # attr :y, :atom, default: :y, doc: "The dataset axis key to use for y values"
+
+  # attr :width, :string, examples: ["1.5", "4"], default: "16"
+  # attr :bar_style, :atom, values: [:round, :square], default: :round
+  # attr :color, :any, examples: ["red", "#FF9330", :color_axis], default: "#FF9330"
+
+  # attr :"phx-click", :any, default: nil
+  # attr :"phx-target", :any, default: nil
+
+  # # TODO:
+  # # support for several groups of bars
+
+  # def bar_plot(assigns) do
+  #   ~H"""
+  #   <%= for point <- GraphDataset.to_graph_points(@dataset, @x, @y) do %>
+  #     <line
+  #       phx-click={
+  #         if assigns[:"phx-click"],
+  #           do:
+  #             JS.push(assigns[:"phx-click"],
+  #               value: %{
+  #                 id: point.data_point.id,
+  #                 dataset_id: @dataset.id,
+  #                 x_pixel: point.x,
+  #                 y_pixel: point.y
+  #               }
+  #             )
+  #       }
+  #       phx-target={assigns[:"phx-target"]}
+  #       style={if assigns[:"phx-click"], do: "cursor: pointer;"}
+  #       x1={point.x}
+  #       y1={point.y}
+  #       x2={point.x}
+  #       y2={
+  #         @dataset.dimensions.height - @dataset.dimensions.margin.bottom -
+  #           @dataset.dimensions.padding.bottom
+  #       }
+  #       stroke={GraphDataset.to_color(@dataset, @color, point.data_point)}
+  #       stroke-width={@width}
+  #       stroke-linecap={bar_style(@bar_style)}
+  #     />
+  #   <% end %>
+  #   """
+  # end
+
+  # defp bar_style(:round), do: "round"
+  # defp bar_style(:square), do: "butt"
+
+  # @doc """
+  # Tooltip.
+  # """
+  # @doc type: :component
+
+  # attr :dataset, :any, required: true
+  # attr :point_id, :any, required: true
+  # attr :x, :atom, default: :x, doc: "The dataset axis key to use for x values"
+  # attr :y, :atom, default: :y, doc: "The dataset axis key to use for y values"
+
+  # attr :x_pixel, :any, required: true
+  # attr :y_pixel, :any, required: true
+
+  # attr :"phx-click-away", :any
+  # attr :"phx-target", :any, default: nil
+
+  # slot :inner_block, required: true
+
+  # def tooltip(%{x_pixel: x_pixel, y_pixel: y_pixel} = assigns) do
+  #   height = assigns.dataset.dimensions.height
+  #   width = assigns.dataset.dimensions.width
+
+  #   {bubble_classes_lr, caret_classes_lr} =
+  #     if x_pixel < width / 2 do
+  #       # left half of the graph, move caret and bubble right of point
+  #       {"left: #{x_pixel + 10}px;", "left: #{x_pixel + 4}px;"}
+  #     else
+  #       # right half of the graph, move caret and bubble left of point
+  #       {"right: #{width - x_pixel + 10}px;", "right: #{width - x_pixel + 4}px;"}
+  #     end
+
+  #   bubble_classes_tb =
+  #     if y_pixel < height / 2 do
+  #       # top half of the graph, move bubble up 20px
+  #       "top: #{y_pixel - 20}px;"
+  #     else
+  #       # bottom half of the graph, move bubble below 20px
+  #       "bottom: #{height - y_pixel - 20}px;"
+  #     end
+
+  #   assigns =
+  #     assign(assigns,
+  #       data_point: GraphDataset.get_point(assigns.dataset, assigns.point_id),
+  #       bubble_classes_lr: bubble_classes_lr,
+  #       caret_classes_lr: caret_classes_lr,
+  #       bubble_classes_tb: bubble_classes_tb
+  #     )
+
+  #   ~H"""
+  #   <div>
+  #     <%!-- caret --%>
+  #     <div style={[
+  #       "position: absolute; z-index: 10; width: 1rem; height: 1rem; background: #4B4C4D;",
+  #       "top: #{@y_pixel - 8}px; transform: rotate(45deg);",
+  #       @caret_classes_lr
+  #     ]} />
+
+  #     <%!-- bubble --%>
+  #     <div
+  #       style={[
+  #         "position: absolute; z-index: 15; padding: 1rem; border-radius: 0.75rem; width: max-content;",
+  #         "background: #4B4C4D; color: #CACBCC ; font-size: 0.75rem;",
+  #         "box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1);",
+  #         @bubble_classes_lr,
+  #         @bubble_classes_tb
+  #       ]}
+  #       phx-click-away={assigns[:"phx-click-away"]}
+  #       phx-target={assigns[:"phx-target"]}
+  #     >
+  #       {render_slot(@inner_block, @data_point.original)}
+  #     </div>
+  #   </div>
+  #   """
+  # end
+
+  # @doc """
+  # One-dimensional shaded areas, either horizontal or vertical.
+  # """
+  # @doc type: :component
+
+  # attr :dataset, :any, required: true
+
+  # attr :area, :atom, required: true, doc: "The dataset axis key to use for the area plots"
+  # attr :color, :atom, required: true, doc: "The dataset axis key to use for colors"
+
+  # attr :orientation, :atom, values: [:vertical, :horizontal], default: :horizontal
+
+  # attr :"phx-click", :any, default: nil
+  # attr :"phx-target", :any, default: nil
+
+  # def area_plot(%{orientation: :horizontal} = assigns) do
+  #   ~H"""
+  #   <%= for [scalar1, scalar2] <- area_points(@dataset, @area, @orientation), rect_color = GraphDataset.to_color(@dataset, @color, scalar1.data_point) do %>
+  #     <rect
+  #       :if={!is_nil(rect_color)}
+  #       fill={rect_color}
+  #       height={
+  #         @dataset.dimensions.height - @dataset.dimensions.margin.top -
+  #           @dataset.dimensions.margin.bottom
+  #       }
+  #       width={scalar2.value - scalar1.value}
+  #       x={scalar1.value}
+  #       y={@dataset.dimensions.margin.top}
+  #       phx-click={
+  #         if assigns[:"phx-click"],
+  #           do:
+  #             JS.push(assigns[:"phx-click"],
+  #               value: %{
+  #                 start_area_point_id: scalar1.data_point.id,
+  #                 end_area_point_id: scalar2.data_point.id,
+  #                 dataset_id: @dataset.id,
+  #                 x_pixel: scalar1.value + (scalar2.value - scalar1.value) / 2,
+  #                 y_pixel: @dataset.dimensions.margin.top + @dataset.dimensions.height / 2
+  #               }
+  #             )
+  #       }
+  #       style={if assigns[:"phx-click"], do: "cursor: pointer;"}
+  #       phx-target={assigns[:"phx-target"]}
+  #     />
+  #   <% end %>
+  #   """
+  # end
+
+  # def area_plot(%{orientation: :vertical} = assigns) do
+  #   ~H"""
+  #   <%= for [scalar1, scalar2] <- area_points(@dataset, @area, @orientation), rect_color = GraphDataset.to_color(@dataset, @color, scalar1.data_point) do %>
+  #     <rect
+  #       :if={!is_nil(rect_color)}
+  #       fill={rect_color}
+  #       height={scalar1.value - scalar2.value}
+  #       width={
+  #         @dataset.dimensions.width - @dataset.dimensions.margin.left -
+  #           @dataset.dimensions.margin.right
+  #       }
+  #       x={@dataset.dimensions.margin.left}
+  #       y={scalar1.value - (scalar1.value - scalar2.value)}
+  #       phx-click={
+  #         if assigns[:"phx-click"],
+  #           do:
+  #             JS.push(assigns[:"phx-click"],
+  #               value: %{
+  #                 start_area_point_id: scalar1.data_point.id,
+  #                 end_area_point_id: scalar2.data_point.id,
+  #                 dataset_id: @dataset.id,
+  #                 x_pixel: @dataset.dimensions.margin.left + @dataset.dimensions.width / 2,
+  #                 y_pixel: scalar2.value + (scalar1.value - scalar2.value) / 2
+  #               }
+  #             )
+  #       }
+  #       style={if assigns[:"phx-click"], do: "cursor: pointer;"}
+  #       phx-target={assigns[:"phx-target"]}
+  #     />
+  #   <% end %>
+  #   """
+  # end
+
+  # defp area_points(%GraphDataset{} = graph_dataset, key, :horizontal) do
+  #   graph_dataset
+  #   |> GraphDataset.to_graph_xs(key)
+  #   |> Enum.chunk_every(2, 1, :discard)
+  # end
+
+  # defp area_points(%GraphDataset{} = graph_dataset, key, :vertical) do
+  #   graph_dataset
+  #   |> GraphDataset.to_graph_ys(key)
+  #   |> Enum.chunk_every(2, 1, :discard)
+  # end
 
   @doc """
   Legend row.
diff --git a/lib/plox/axis/protocol.ex b/lib/plox/axis/protocol.ex
index 27bfd70..7309d17 100644
--- a/lib/plox/axis/protocol.ex
+++ b/lib/plox/axis/protocol.ex
@@ -1,8 +1,7 @@
 defprotocol Plox.Axis.Protocol do
   @moduledoc """
-  A protocol for graph axes.
-
-  TODO: docs
+  A protocol for graph axes. Requires axes to implement a method to convert scale values
+  to graphable values.
   """
 
   @typedoc """
@@ -10,15 +9,15 @@ defprotocol Plox.Axis.Protocol do
 
   Built in implementations are:
 
+  * `Plox.ColorAxis`
+  * `Plox.LinearAxis`
   * `Plox.XAxis`
   * `Plox.YAxis`
-  * `Plox.RadiusAxis`
-  * `Plox.ColorAxis`
   """
   @type t :: any()
 
   @doc """
-  Converts a specific scale value to a value usable by the graph components
+  Converts a specific scale value to a graphable value.
   """
   @spec to_graph(axis :: t(), any()) :: any()
   def to_graph(axis, value)
diff --git a/lib/plox/box.ex b/lib/plox/box.ex
index 8a30513..fe61d5a 100644
--- a/lib/plox/box.ex
+++ b/lib/plox/box.ex
@@ -1,11 +1,33 @@
 defmodule Plox.Box do
   @moduledoc """
-  TODO: this is a public module that graph component implementers will interact
-  with, so it should be documented
+  Data structure for defining a rectangular box with top, right, bottom, and
+  left sides.
   """
 
   defstruct [:top, :right, :bottom, :left]
 
+  @doc """
+  Creates a new `Plox.Box` struct from a string, number, or tuple. This is
+  useful for specifying margins and paddings in a format similar to CSS margin
+  and padding properties.
+
+  ## Examples
+
+    iex> Plox.Box.new(10)
+    %Plox.Box{top: 10, right: 10, bottom: 10, left: 10}
+
+    iex> Plox.Box.new({5, 15})
+    %Plox.Box{top: 5, right: 15, bottom: 5, left: 15}
+
+    iex> Plox.Box.new({5, 15, 10})
+    %Plox.Box{top: 5, right: 15, bottom: 10, left: 15}
+
+    iex> Plox.Box.new({5, 15, 10, 20})
+    %Plox.Box{top: 5, right: 15, bottom: 10, left: 20}
+
+    iex> Plox.Box.new("5 15 10 20")
+    %Plox.Box{top: 5, right: 15, bottom: 10, left: 20}
+  """
   def new(string) when is_binary(string) do
     string
     |> String.split(" ", trim: true)
diff --git a/lib/plox/color_axis.ex b/lib/plox/color_axis.ex
index b948b7f..a0b33e6 100644
--- a/lib/plox/color_axis.ex
+++ b/lib/plox/color_axis.ex
@@ -1,7 +1,29 @@
 defmodule Plox.ColorAxis do
   @moduledoc """
-  TODO: this is a public module that graph component implementers will interact
-  with, so it should be documented
+  ColorAxis converts `Plox.ColorScale` values to graphable colors.
+
+  This module implements the `Access` behaviour, allowing access to graphable
+  values using the `[]` syntax.
+
+  ## Example
+
+      iex> color_scale = Plox.FixedColorsScale.new(%{red: "#ff0000", green: "#00ff00", blue: "#0000ff"})
+      iex> color_axis = Plox.ColorAxis.new(color_scale)
+      iex> color_axis[:green]
+      "#00ff00"
+
+  This is useful when rendering graph elements in a more intuitive way:
+
+      <!-- Draw a red circle (at the given coordinates) -->
+      <.circle cx={50.0} cy={75.0} fill={color_axis[:red]} r="3" />
+
+  This module implements the `Plox.Axis.Protocol` and defines the `Plox.Axis.Protocol.to_graph/2`
+  function. This function is called by the `Access` behaviour:
+
+      iex> color_scale = Plox.FixedColorsScale.new(%{red: "#ff0000", green: "#00ff00", blue: "#0000ff"})
+      iex> color_axis = Plox.ColorAxis.new(color_scale)
+      iex> color_axis[:blue] == Plox.Axis.Protocol.to_graph(color_axis, :blue)
+      true
   """
 
   use Plox.Axis
@@ -10,13 +32,25 @@ defmodule Plox.ColorAxis do
 
   defstruct [:scale]
 
+  @doc """
+  Creates a new `Plox.ColorAxis` struct.
+
+  Accepts a `Plox.ColorScale` struct.
+
+  ## Example
+
+      iex> color_scale = Plox.FixedColorsScale.new(%{red: "#ff0000", green: "#00ff00", blue: "#0000ff"})
+      iex> Plox.ColorAxis.new(color_scale)
+      %Plox.ColorAxis{scale: color_scale}
+  """
   def new(scale) do
     %__MODULE__{scale: scale}
   end
 
-  # def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
-
   defimpl Plox.Axis.Protocol do
+    @doc """
+    Converts the given `value` to a graphable color.
+    """
     def to_graph(%{scale: scale}, value) do
       ColorScale.convert_to_color(scale, value)
     end
diff --git a/lib/plox/data_point.ex b/lib/plox/data_point.ex
index e3ec10b..ff0bd7b 100644
--- a/lib/plox/data_point.ex
+++ b/lib/plox/data_point.ex
@@ -1,36 +1,11 @@
 defmodule Plox.DataPoint do
-  @moduledoc false
-  # TODO: I dunno about docs yet
-
-  alias Plox.GraphPoint
-  alias Plox.GraphScalar
-  alias Plox.GraphScale
+  @moduledoc """
+  Data structure for containing raw data and its mapped values for graphing.
+  """
 
   defstruct [:original, :graph]
 
   def new(original, graph) do
     %__MODULE__{original: original, graph: graph}
   end
-
-  # def to_graph_point(%__MODULE__{} = data_point, x_scale, x_key, y_scale, y_key) do
-  #   x_value = data_point.mapped[x_key]
-  #   y_value = data_point.mapped[y_key]
-
-  #   x = GraphScale.to_graph_x(x_scale, x_value)
-  #   y = GraphScale.to_graph_y(y_scale, y_value)
-
-  #   GraphPoint.new(x, y, data_point)
-  # end
-
-  # def to_graph_x(%__MODULE__{} = data_point, scale, key) do
-  #   scale
-  #   |> GraphScale.to_graph_x(data_point.mapped[key])
-  #   |> GraphScalar.new(data_point)
-  # end
-
-  # def to_graph_y(%__MODULE__{} = data_point, scale, key) do
-  #   scale
-  #   |> GraphScale.to_graph_y(data_point.mapped[key])
-  #   |> GraphScalar.new(data_point)
-  # end
 end
diff --git a/lib/plox/dataset.ex b/lib/plox/dataset.ex
index f2edc1b..e0e7698 100644
--- a/lib/plox/dataset.ex
+++ b/lib/plox/dataset.ex
@@ -43,7 +43,29 @@ end
 
 defmodule Plox.Dataset do
   @moduledoc """
-  A collection of data points and some metadata for a graph
+  A collection of `Plox.DataPoint`s and `Plox.Axis` implementations to convert
+  the `Plox.DataPoint`s to graphable values.
+
+  This module implements the `Access` behaviour, allowing access to each axis
+  using the `[]` syntax.
+
+  ## Example
+
+      iex> dataset = %Plox.Dataset{data: [], axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}}
+      iex> dataset[:x]
+      %Plox.DatasetAxis{axis: %Plox.XAxis{}, key: :x}
+
+      iex> dataset = %Plox.Dataset{data: [], axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}}
+      iex> dataset[:y]
+      %Plox.DatasetAxis{axis: %Plox.YAxis{}, key: :y}
+
+  Since `Plox.Axis` also implements the `Access` behaviour, you can access
+  the graphable values more ergonomically when rendering elements in a graph:
+
+  ## Example
+
+      <!-- Draw red circles for every x value, but only at y = 40 on the graph -->
+      <.circle cx={@dataset[:x]} cy={@dataset[:y][40]} fill="red" r="3" />
   """
   @behaviour Access
 
@@ -51,6 +73,25 @@ defmodule Plox.Dataset do
 
   defstruct [:data, :axes]
 
+  @doc """
+  Creates a new `Plox.Dataset` struct.
+
+  Accepts an enumerable of raw data and a mapping of axis keys to tuples
+  containing the axis and a function to extract the value from the raw data.
+
+  ## Example
+
+      iex> data = [%{foo: 1, bar: 2}, %{foo: 2, bar: 3}]
+      iex> axis_fns = %{x: {%Plox.XAxis{}, & &1.foo}, y: {%Plox.YAxis{}, & &1.bar}}
+      iex> dataset = Plox.Dataset.new(data, axis_fns)
+      %Plox.Dataset{
+        data: [
+          %Plox.DataPoint{original: %{foo: 1, bar: 2}, graph: %{x: ..., y: ...}},
+          %Plox.DataPoint{original: %{foo: 2, bar: 3}, graph: %{x: ..., y: ...}}
+        ],
+        axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
+      }
+  """
   def new(original_data, axis_fns) do
     data =
       Enum.map(original_data, fn original ->
diff --git a/lib/plox/date_scale.ex b/lib/plox/date_scale.ex
index 4b901b4..72c8928 100644
--- a/lib/plox/date_scale.ex
+++ b/lib/plox/date_scale.ex
@@ -1,18 +1,46 @@
 defmodule Plox.DateScale do
   @moduledoc """
-  A scale for elixir `Date` values
+  A scale of date values (`t:Date.t/0`).
 
   This struct implements the `Plox.Scale` protocol.
+
+  `Plox.Scale.values/2` returns a `t:Date.Range.t/0` enumerable:
+
+    iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-01], ~D[2020-01-10], 1))
+    iex> scale |> Plox.Scale.values(%{step: 2}) |> Enum.to_list()
+    [~D[2020-01-01], ~D[2020-01-03], ~D[2020-01-05], ~D[2020-01-07], ~D[2020-01-09]]
+
+    iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-10], ~D[2020-01-01], -1))
+    iex> scale |> Plox.Scale.values(%{step: 3}) |> Enum.to_list()
+    [~D[2020-01-10], ~D[2020-01-07], ~D[2020-01-04], ~D[2020-01-01]]
+
+  `Plox.Scale.convert_to_range/3` returns a number in the given range:
+
+    iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-01], ~D[2020-01-09], 1))
+    iex> Plox.Scale.convert_to_range(scale, ~D[2020-01-05], 0..100)
+    50.0
+
+    iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-09], ~D[2020-01-01], -1))
+    iex> Plox.Scale.convert_to_range(scale, ~D[2020-01-07], 0..100)
+    25.0
   """
   defstruct [:range]
 
   @type t :: %__MODULE__{}
 
   @doc """
-  Creates a new `Plox.DateScale` struct
+  Creates a new `Plox.DateScale` struct.
+
+  Raises if `range` is not a `t:Date.Range.t/0` struct or if it does not contain at least
+  two dates. The step is ignored. Supports forward and backward ranges.
 
-  Accepts an elixir `Date.Range` struct. The range must contain at least two
-  dates. The step is ignored. Supports forward and backward ranges.
+  ## Example
+
+      iex> Plox.DateScale.new(Date.range(~D[2020-01-01], ~D[2020-01-10], 1))
+      %Plox.DateScale{range: Date.range(~D[2020-01-01], ~D[2020-01-10], 1)}
+
+      iex> Plox.DateScale.new(Date.range(~D[2020-01-10], ~D[2020-01-01], -1))
+      %Plox.DateScale{range: Date.range(~D[2020-01-10], ~D[2020-01-01], -1)}
   """
   @spec new(range :: Date.Range.t()) :: t()
   def new(%Date.Range{} = range) do
@@ -26,19 +54,36 @@ defmodule Plox.DateScale do
     %__MODULE__{range: range}
   end
 
-  defp reduce_step(%Date.Range{step: step} = range) when step > 0, do: Date.range(range.first, range.last, 1)
+  def new(_range) do
+    raise ArgumentError,
+      message: "Invalid DateScale: must be a Date.Range struct with at least two dates"
+  end
 
+  defp reduce_step(%Date.Range{step: step} = range) when step > 0, do: Date.range(range.first, range.last, 1)
   defp reduce_step(%Date.Range{step: step} = range) when step < 0, do: Date.range(range.first, range.last, -1)
 
   defimpl Plox.Scale do
+    @doc """
+    Returns a `t:Date.Range.t/0` of all `t:Date.t/0` values in the scale,
+    stepping by the given interval.
+
+    Accepts a `step` option as a number of days. The default step is 1 day.
+    Raises if given `step` is not a positive integer greater than 1.
+    """
     def values(scale, opts) do
       case Map.fetch(opts, :step) do
         :error -> scale.range
+        {:ok, step} when step < 1 -> raise ArgumentError, message: "Step must be a positive integer"
         {:ok, step} when scale.range.step > 0 -> %{scale.range | step: step}
         {:ok, step} when scale.range.step < 0 -> %{scale.range | step: -step}
       end
     end
 
+    @doc """
+    Converts a date `value` from the scale to a number in the given `to_range`.
+
+    Raises if `value` is not a valid date included in the scale.
+    """
     def convert_to_range(scale, %Date{} = value, to_range) do
       range = scale.range
 
diff --git a/lib/plox/date_time_scale.ex b/lib/plox/date_time_scale.ex
index d5fffb8..336c5d4 100644
--- a/lib/plox/date_time_scale.ex
+++ b/lib/plox/date_time_scale.ex
@@ -1,8 +1,24 @@
 defmodule Plox.DateTimeScale do
   @moduledoc """
-  A scale made of elixir `DateTime` or `NaiveDateTime` values
+  A scale of datetime values (`t:DateTime.t/0` or `t:NaiveDateTime.t/0`).
 
   This struct implements the `Plox.Scale` protocol.
+
+  `Plox.Scale.values/2` returns a list of all datetime values:
+
+      iex> scale = Plox.DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-01 00:03:00])
+      iex> Plox.Scale.values(scale)
+      [~N[2019-01-01 00:00:00], ~N[2019-01-01 00:01:00], ~N[2019-01-01 00:02:00], ~N[2019-01-01 00:03:00]]
+
+      iex> scale = Plox.DateTimeScale.new(~U[2019-01-01 00:00:00Z], ~U[2019-01-03 00:00:00Z])
+      iex> Plox.Scale.values(scale, %{step: {1, :day}})
+      [~U[2019-01-01 00:00:00Z], ~U[2019-01-02 00:00:00Z], ~U[2019-01-03 00:00:00Z]]
+
+  `Plox.Scale.convert_to_range/3` returns a number in the given range:
+
+    iex> scale = Plox.DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-03 00:00:00])
+    iex> Plox.Scale.convert_to_range(scale, ~N[2019-01-02 00:00:00], 0..100)
+    50.0
   """
   require Logger
 
@@ -12,10 +28,19 @@ defmodule Plox.DateTimeScale do
   @type datetime :: DateTime.t() | NaiveDateTime.t()
 
   @doc """
-  Creates a new `Plox.DateTimeScale` struct
+  Creates a new `Plox.DateTimeScale` struct.
 
-  Accepts 2 elixir `DateTime` or `NaiveDateTime` structs as `first` and `last`.
+  Accepts 2 datetime structs as `first` and `last` (`t:DateTime.t/0` or `t:NaiveDateTime.t/0`).
+  Raises if `first` and `last` are not the same struct or if `first` is not before `last`.
   Negative ranges are not currently supported.
+
+  ## Example
+
+      iex> Plox.DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-03 00:00:00])
+      %Plox.DateTimeScale{first: ~N[2019-01-01 00:00:00], last: ~N[2019-01-03 00:00:00]}
+
+      iex> Plox.DateTimeScale.new(~U[2019-01-01 00:00:00Z], ~U[2019-01-03 00:00:00Z])
+      %Plox.DateTimeScale{first: ~U[2019-01-01 00:00:00Z], last: ~U[2019-01-03 00:00:00Z]}
   """
   @spec new(first :: datetime(), last :: datetime()) :: t()
   def new(first, last)
@@ -23,7 +48,7 @@ defmodule Plox.DateTimeScale do
   def new(%date_time_module{} = first, %date_time_module{} = last) when date_time_module in [DateTime, NaiveDateTime] do
     if date_time_module.diff(last, first) <= 0 do
       raise ArgumentError,
-        message: "Invalid DateTimeScale: The range must be at least 1 second long and `first` must come before `last`."
+        message: "Invalid DateTimeScale: The range must be at least 1 second long and `first` must come before `last`"
     end
 
     %__MODULE__{first: first, last: last}
@@ -31,10 +56,17 @@ defmodule Plox.DateTimeScale do
 
   def new(_first, _last) do
     raise ArgumentError,
-      message: "Invalid DateTimeScale: First and last must be DateTime or NaiveDateTime structs."
+      message: "Invalid DateTimeScale: First and last must both be DateTime or NaiveDateTime structs"
   end
 
   defimpl Plox.Scale do
+    @doc """
+    Returns a list of all `DateTime` or `NaiveDateTime` values in the scale,
+    stepping by the given interval.
+
+    Accepts a `:step` option, which can be a number of seconds, minutes, hours,
+    or days. The default step is 60 seconds.
+    """
     def values(%{first: %DateTime{time_zone: tz}} = scale, %{step: {step_days, :day}}) when tz != "Etc/UTC" do
       scale.first
       |> Stream.unfold(fn current_dt ->
@@ -47,9 +79,7 @@ defmodule Plox.DateTimeScale do
       |> Enum.to_list()
     end
 
-    def values(scale, opts) do
-      %{first: %date_time_module{}} = scale
-
+    def values(%{first: %date_time_module{}} = scale, opts) do
       step_seconds =
         case Map.get(opts, :step, {60, :second}) do
           seconds when is_integer(seconds) -> seconds
@@ -78,6 +108,11 @@ defmodule Plox.DateTimeScale do
       |> elem(0)
     end
 
+    @doc """
+    Converts a datetime `value` from the scale to a number in the given `to_range`.
+
+    Raises if `value` is not a valid datetime included in the scale.
+    """
     def convert_to_range(%{first: %date_time_module{}} = scale, %date_time_module{} = value, to_range)
         when date_time_module in [DateTime, NaiveDateTime] do
       if date_time_module.compare(value, scale.first) == :lt or
diff --git a/lib/plox/dimensions.ex b/lib/plox/dimensions.ex
index 2de6d30..f65c1d1 100644
--- a/lib/plox/dimensions.ex
+++ b/lib/plox/dimensions.ex
@@ -1,13 +1,31 @@
 defmodule Plox.Dimensions do
   @moduledoc """
-  TODO: this is a public module that graph component implementers will interact
-  with, so it should be documented
+  Data structure for defining the dimensions of a graph, including width,
+  height, margin, and padding.
   """
 
   alias Plox.Box
 
   defstruct [:width, :height, :margin, :padding]
 
+  @doc """
+  Creates a new `Plox.Dimensions` struct.
+
+  Accepts width and height as numbers or strings, and optional keyword
+  arguments for margin and padding. Default margin is `{35, 70}` and
+  default padding is `0`. See `Plox.Box` for more information on how
+  margins and padding may be input.
+
+  ## Example
+
+      iex> Plox.Dimensions.new(800, 600, margin: {20, 30}, padding: 10)
+      %Plox.Dimensions{
+        width: 800,
+        height: 600,
+        margin: %Plox.Box{top: 20, right: 30, bottom: 20, left: 30},
+        padding: %Plox.Box{top: 10, right: 10, bottom: 10, left: 10}
+      }
+  """
   def new(width, height, opts \\ []) do
     margin = Keyword.get(opts, :margin, {35, 70})
     padding = Keyword.get(opts, :padding, 0)
diff --git a/lib/plox/fixed_colors_scale.ex b/lib/plox/fixed_colors_scale.ex
index dd46e4c..9108237 100644
--- a/lib/plox/fixed_colors_scale.ex
+++ b/lib/plox/fixed_colors_scale.ex
@@ -2,15 +2,45 @@ defmodule Plox.FixedColorsScale do
   @moduledoc """
   A color scale for mapping a set of known fixed values to a set of known fixed
   colors.
+
+  This struct implements the `Plox.ColorScale` protocol.
+
+  `Plox.ColorScale.convert_to_color/2` returns the color for a given value:
+
+      iex> scale = Plox.FixedColorsScale.new(%{red: "#ff0000", green: "#00ff00", blue: "#0000ff"})
+      iex> Plox.ColorScale.convert_to_color(scale, :red)
+      "#ff0000"
   """
 
   defstruct [:mapping]
 
-  def new(mapping) do
+  @doc """
+  Creates a new `Plox.FixedColorsScale` struct.
+
+  Raises if the given `mapping` is not a map or contains fewer than two entries.
+
+  ## Example
+
+      iex> Plox.FixedColorsScale.new(%{red: "#ff0000", green: "#00ff00", blue: "#0000ff"})
+      %Plox.FixedColorsScale{
+        mapping: %{red: "#ff0000", green: "#00ff00", blue: "#0000ff"}
+      }
+  """
+  def new(mapping) when is_non_struct_map(mapping) and map_size(mapping) >= 2 do
     %__MODULE__{mapping: mapping}
   end
 
+  def new(_mapping) do
+    raise ArgumentError,
+      message: "Invalid FixedColorsScale: must be a map with at least two entries"
+  end
+
   defimpl Plox.ColorScale do
+    @doc """
+    Converts a given `value` from the scale to its corresponding color.
+
+    Raises if `value` is not a key within the scale.
+    """
     def convert_to_color(scale, value) do
       case Map.fetch(scale.mapping, value) do
         {:ok, color} ->
diff --git a/lib/plox/fixed_values_scale.ex b/lib/plox/fixed_values_scale.ex
index 75b9e03..8682670 100644
--- a/lib/plox/fixed_values_scale.ex
+++ b/lib/plox/fixed_values_scale.ex
@@ -5,15 +5,43 @@ defmodule Plox.FixedValuesScale do
   It places the values in the given order with equal distance between them.
 
   This struct implements the `Plox.Scale` protocol.
+
+  `Plox.Scale.values/2` returns an enumerable of the `values` in the scale:
+
+      iex> scale = Plox.FixedValuesScale.new([1, 2, 3, 4])
+      iex> Plox.Scale.values(scale)
+      [1, 2, 3, 4]
+
+  `Plox.Scale.convert_to_range/3` returns a number in the given range:
+
+      iex> scale = Plox.FixedValuesScale.new([:a, :b, :c])
+      iex> Plox.Scale.convert_to_range(scale, :b, 0..100)
+      50.0
   """
   defstruct [:values, :index_map, :max_index]
 
   @type t :: %__MODULE__{}
 
   @doc """
-  Creates a new `Plox.FixedValuesScale` struct
+  Creates a new `Plox.FixedValuesScale` struct.
 
-  Accepts any enumerable.
+  Raises if given an enumerable with less than two values.
+
+  ## Example
+
+      iex> Plox.FixedValuesScale.new([1, 2, 3, 4])
+      %Plox.FixedValuesScale{
+        values: [1, 2, 3, 4],
+        index_map: %{1 => 0, 2 => 1, 3 => 2, 4 => 3},
+        max_index: 3
+      }
+
+      iex> Plox.FixedValuesScale.new(["a", "b", "c"])
+      %Plox.FixedValuesScale{
+        values: ["a", "b", "c"],
+        index_map: %{"a" => 0, "b" => 1, "c" => 2},
+        max_index: 2
+      }
   """
   @spec new(values :: Enumerable.t()) :: t()
   def new(values) do
@@ -35,8 +63,16 @@ defmodule Plox.FixedValuesScale do
   end
 
   defimpl Plox.Scale do
+    @doc """
+    Returns an enumerable of the `values` in the scale.
+    """
     def values(scale, _opts), do: scale.values
 
+    @doc """
+    Converts a given `value` from the scale to a number in the given `to_range`.
+
+    Raises if `value` is not within the scale.
+    """
     def convert_to_range(scale, value, to_range) do
       case Map.fetch(scale.index_map, value) do
         {:ok, value_index} ->
diff --git a/lib/plox/graph_dataset.ex b/lib/plox/graph_dataset.ex
deleted file mode 100644
index b7043b3..0000000
--- a/lib/plox/graph_dataset.ex
+++ /dev/null
@@ -1,77 +0,0 @@
-defmodule Plox.GraphDataset do
-  @moduledoc """
-  TODO: this is a public module that graph component implementers will interact
-  with, so it should be documented
-  """
-
-  alias Plox.ColorScale
-  alias Plox.DataPoint
-  alias Plox.GraphScale
-
-  defstruct [:id, :dataset, :dimensions]
-
-  def new(id, dataset, dimensions) do
-    %__MODULE__{id: id, dataset: dataset, dimensions: dimensions}
-  end
-
-  def get_point(dataset, point_id) do
-    Enum.find_value(dataset.dataset.data, fn data_point ->
-      if data_point.id == point_id, do: data_point
-    end)
-  end
-
-  def get_scale!(%__MODULE__{dataset: dataset, dimensions: dimensions}, key) do
-    case Map.fetch(dataset.scales, key) do
-      {:ok, scale} ->
-        GraphScale.new(key, scale, dimensions)
-
-      :error ->
-        raise ArgumentError,
-          message: "No such scale #{inspect(key)} in dataset #{inspect(dataset)}"
-    end
-  end
-
-  def to_graph_points(%__MODULE__{} = dataset, x_key, y_key) do
-    x_scale = get_scale!(dataset, x_key)
-    y_scale = get_scale!(dataset, y_key)
-
-    Enum.map(dataset.dataset.data, fn data_point ->
-      DataPoint.to_graph_point(data_point, x_scale, x_key, y_scale, y_key)
-    end)
-  end
-
-  def to_graph_point(%__MODULE__{} = dataset, x_key, y_key, id) do
-    x_scale = get_scale!(dataset, x_key)
-    y_scale = get_scale!(dataset, y_key)
-
-    Enum.find_value(dataset.dataset.data, fn data_point ->
-      if data_point.id == id do
-        DataPoint.to_graph_point(data_point, x_scale, x_key, y_scale, y_key)
-      end
-    end)
-  end
-
-  def to_graph_xs(%__MODULE__{} = dataset, x_key) do
-    x_scale = get_scale!(dataset, x_key)
-
-    Enum.map(dataset.dataset.data, fn data_point ->
-      DataPoint.to_graph_x(data_point, x_scale, x_key)
-    end)
-  end
-
-  def to_graph_ys(%__MODULE__{} = dataset, y_key) do
-    y_scale = get_scale!(dataset, y_key)
-
-    Enum.map(dataset.dataset.data, fn data_point ->
-      DataPoint.to_graph_y(data_point, y_scale, y_key)
-    end)
-  end
-
-  def to_color(%__MODULE__{} = _dataset, color, _data_point) when is_binary(color), do: color
-
-  def to_color(%__MODULE__{} = dataset, key, data_point) when is_atom(key) do
-    graph_scale = get_scale!(dataset, key)
-
-    ColorScale.convert_to_color(graph_scale.scale, data_point.mapped[key])
-  end
-end
diff --git a/lib/plox/graph_point.ex b/lib/plox/graph_point.ex
deleted file mode 100644
index d5e953e..0000000
--- a/lib/plox/graph_point.ex
+++ /dev/null
@@ -1,12 +0,0 @@
-defmodule Plox.GraphPoint do
-  @moduledoc """
-  TODO: this is a public module that graph component implementers will interact
-  with, so it should be documented
-  """
-
-  defstruct [:x, :y, :data_point]
-
-  def new(x, y, data_point) do
-    %__MODULE__{x: x, y: y, data_point: data_point}
-  end
-end
diff --git a/lib/plox/graph_scalar.ex b/lib/plox/graph_scalar.ex
deleted file mode 100644
index ace4f09..0000000
--- a/lib/plox/graph_scalar.ex
+++ /dev/null
@@ -1,12 +0,0 @@
-defmodule Plox.GraphScalar do
-  @moduledoc """
-  TODO: this is a public module that graph component implementers will interact
-  with, so it should be documented
-  """
-
-  defstruct [:value, :data_point]
-
-  def new(value, data_point) do
-    %__MODULE__{value: value, data_point: data_point}
-  end
-end
diff --git a/lib/plox/graph_scale.ex b/lib/plox/graph_scale.ex
deleted file mode 100644
index 4b8f935..0000000
--- a/lib/plox/graph_scale.ex
+++ /dev/null
@@ -1,38 +0,0 @@
-defmodule Plox.GraphScale do
-  @moduledoc """
-  TODO: this is a public module that graph component implementers will interact
-  with, so it should be documented
-  """
-
-  alias Plox.Scale
-
-  defstruct [:scale, :graph]
-
-  def new(graph, scale) do
-    %__MODULE__{scale: scale, graph: graph}
-  end
-
-  def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
-
-  def to_graph_x(%__MODULE__{scale: scale, graph: graph}, value) do
-    Scale.convert_to_range(
-      scale,
-      value,
-      (graph.margin.left +
-         graph.padding.left)..(graph.width -
-                                 graph.margin.right -
-                                 graph.padding.right)
-    )
-  end
-
-  def to_graph_y(%__MODULE__{scale: scale, graph: graph}, value) do
-    Scale.convert_to_range(
-      scale,
-      value,
-      (graph.height -
-         graph.margin.bottom -
-         graph.padding.bottom)..(graph.margin.top +
-                                   graph.padding.top)
-    )
-  end
-end
diff --git a/lib/plox/linear_axis.ex b/lib/plox/linear_axis.ex
index 66c7721..a173238 100644
--- a/lib/plox/linear_axis.ex
+++ b/lib/plox/linear_axis.ex
@@ -1,7 +1,32 @@
 defmodule Plox.LinearAxis do
   @moduledoc """
-  TODO: this is a public module that graph component implementers will interact
-  with, so it should be documented
+  LinearAxis implements the `Plox.Axis.Protocol` and is used to convert scale values
+  to graphable values in a linear range between a minimum and maximum.
+
+  This module implements the `Access` behaviour, allowing access to graphable
+  values using the `[]` syntax.
+
+  ## Example
+
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> linear_axis = %Plox.LinearAxis{scale: scale, min: 0, max: 100}
+      iex> linear_axis[1]
+      10.0
+      iex> linear_axis[2]
+      20.0
+
+  This is useful when rendering graph elements in a more intuitive way:
+
+      <!-- Draw a red circle with a radius of 10 (at the given coordinates) -->
+      <.circle cx={25.0} cy={50.0} fill="red" r={linear_axis[1]} />
+
+  This module implements the `Plox.Axis.Protocol` and defines the `Plox.Axis.Protocol.to_graph/2`
+  function. This function is called by the `Access` behaviour:
+
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> linear_axis = Plox.LinearAxis.new(scale, min: 0, max: 100)
+      iex> linear_axis[1] == Plox.Axis.Protocol.to_graph(linear_axis, 1)
+      true
   """
 
   use Plox.Axis
@@ -10,6 +35,17 @@ defmodule Plox.LinearAxis do
 
   defstruct [:scale, :min, :max]
 
+  @doc """
+  Creates a new `Plox.LinearAxis` struct.
+
+  Accepts a `Plox.Scale` struct and `min` and `max` values.
+
+  ## Example
+
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> Plox.LinearAxis.new(scale, min: 0, max: 100)
+      %Plox.LinearAxis{scale: scale, min: 0, max: 100}
+  """
   def new(scale, opts \\ []) do
     Keyword.validate!(opts, [:min, :max])
     min = Keyword.fetch!(opts, :min)
@@ -18,9 +54,11 @@ defmodule Plox.LinearAxis do
     %__MODULE__{scale: scale, min: min, max: max}
   end
 
-  def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
-
   defimpl Plox.Axis.Protocol do
+    @doc """
+    Converts the given `value` to a graphable value linearly interpolated
+    between the `min` and `max` of the axis.
+    """
     def to_graph(%{scale: scale, min: min, max: max}, value) do
       Scale.convert_to_range(scale, value, min..max)
     end
diff --git a/lib/plox/number_scale.ex b/lib/plox/number_scale.ex
index c587242..6f20202 100644
--- a/lib/plox/number_scale.ex
+++ b/lib/plox/number_scale.ex
@@ -1,25 +1,52 @@
 defmodule Plox.NumberScale do
   @moduledoc """
-  An arbitrary precision number scale
+  An arbitrary precision number scale.
+
+  Although internally we use `Decimal` for arbitrary precision and accurate
+  math, this scale expects floats as input and produces floats as output,
+  which may lead to floating point imprecision.
 
   This struct implements the `Plox.Scale` protocol.
 
-  Although internally we use `Decimal` for arbitrary precision and accurate
-  math, this scale expects floats as input and produces floats as output, so
-  there's still some room for floating point imprecision.
+  `Plox.Scale.values/2` returns an enumerable of the numerical values in the scale:
+
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> Plox.Scale.values(scale)
+      [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
+
+      iex> scale = Plox.NumberScale.new(10, 0)
+      iex> Plox.Scale.values(scale, %{ticks: 6})
+      [10.0, 8.0, 6.0, 4.0, 2.0, 0.0]
+
+  `Plox.Scale.convert_to_range/3` returns a number in the given range:
+
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> Plox.Scale.convert_to_range(scale, 5, 0..100)
+      50.0
+
+      iex> scale = Plox.NumberScale.new(10, 0)
+      iex> Plox.Scale.convert_to_range(scale, 2, 0..100)
+      80.0
   """
   defstruct [:first, :last, :backwards?]
 
   @type t :: %__MODULE__{}
 
   @doc """
-  Creates a new `Plox.NumberScale` struct
+  Creates a new `Plox.NumberScale` struct.
 
-  Accepts 2 numbers as `first` and `last` as well as the number of `ticks` that
-  should comprise the scale. The in-between values for these ticks are
-  dynamically calculated based on `first`, `last`, and `ticks`.
+  Accepts 2 numbers as `first` and `last` values. Dynamically determines
+  if the scale is backwards (i.e. `first` is greater than `last`).
 
-  `ticks` must be at least `2`.
+  Raises if given equivalent numbers or if either `first` or `last` is not a number.
+
+  ## Example
+
+      iex> Plox.NumberScale.new(0, 10)
+      %Plox.NumberScale{first: Decimal.new("0.0"), last: Decimal.new("10.0"), backwards?: false}
+
+      iex> Plox.NumberScale.new(10, 0)
+      %Plox.NumberScale{first: Decimal.new("10.0"), last: Decimal.new("0.0"), backwards?: true}
   """
   @spec new(first :: number(), last :: number()) :: t()
   def new(first, last) when is_number(first) and is_number(last) and first != last do
@@ -27,21 +54,29 @@ defmodule Plox.NumberScale do
     last = Decimal.from_float(last / 1.0)
     backwards? = Decimal.compare(first, last) == :gt
 
-    %__MODULE__{
-      first: first,
-      last: last,
-      backwards?: backwards?
-    }
+    %__MODULE__{first: first, last: last, backwards?: backwards?}
   end
 
   def new(_first, _last) do
     raise ArgumentError,
-      message: "Invalid NumberScale: First and last must be numbers and cannot be equivalent."
+      message: "Invalid NumberScale: First and last must be numbers and cannot be equivalent"
   end
 
   defimpl Plox.Scale do
-    def values(scale, opts \\ %{}) do
+    @doc """
+    Returns an enumerable of the numerical values in the scale. Optionally accepts a
+    number of `ticks` to specify how many values to return. The in-between values are
+    dynamically calculated based on `first`, `last`, and `ticks`.
+
+    Raises if `ticks` is less than `2` (default is `11`).
+    """
+    def values(scale, opts) do
       ticks = Map.get(opts, :ticks, 11)
+
+      if ticks < 2 do
+        raise ArgumentError, message: "Invalid ticks count `#{ticks}`, must be at least 2"
+      end
+
       step = scale.last |> Decimal.sub(scale.first) |> Decimal.div(ticks - 1)
 
       # we don't compute the last value because it could include rounding errors
@@ -53,8 +88,21 @@ defmodule Plox.NumberScale do
       |> Enum.map(&Decimal.to_float/1)
     end
 
+    @doc """
+    Converts a number from the scale to a number in the given `to_range`. The given
+    `input_value` must be a number inclusively within the `scale` bounds.
+
+    Raises if `input_value` is out of bounds or not a number.
+    """
     def convert_to_range(scale, input_value, to_range) when is_number(input_value) do
       value = Decimal.from_float(input_value / 1.0)
+      lower = if scale.backwards?, do: scale.last, else: scale.first
+      upper = if scale.backwards?, do: scale.first, else: scale.last
+
+      if Decimal.gt?(value, upper) || Decimal.lt?(value, lower) do
+        raise ArgumentError,
+          message: "Input value `#{inspect(input_value)}` is out of bounds for `#{inspect(scale)}`"
+      end
 
       value
       |> Decimal.sub(scale.first)
diff --git a/lib/plox/scale.ex b/lib/plox/scale.ex
index 2cc1ce0..de254de 100644
--- a/lib/plox/scale.ex
+++ b/lib/plox/scale.ex
@@ -19,17 +19,17 @@ defprotocol Plox.Scale do
   @type t :: any()
 
   @doc """
-  Returns an enumerable of the "labeled values" in a scale
+  Returns an enumerable of the "labeled values" in a scale.
 
   Note: the returned values don't necessarily represent all the values in the
   scale, just the values meant to be labeled and rendered on the corresponding
   axis. e.g. the final value might not be equal to the scale's configured max.
   """
   @spec values(scale :: t(), opts :: map()) :: Enumerable.t()
-  def values(scale, opts)
+  def values(scale, opts \\ %{})
 
   @doc """
-  Converts a specific scale value to a number within the requested range
+  Converts a specific scale value to a number within the requested range.
 
   The destination range must be a valid integer range.
   """
diff --git a/lib/plox/x_axis.ex b/lib/plox/x_axis.ex
index 582f347..6173a9a 100644
--- a/lib/plox/x_axis.ex
+++ b/lib/plox/x_axis.ex
@@ -1,7 +1,34 @@
 defmodule Plox.XAxis do
   @moduledoc """
-  TODO: this is a public module that graph component implementers will interact
-  with, so it should be documented
+  XAxis implements the `Plox.Axis.Protocol` and is used to convert scale values
+  to graphable x-coordinates.
+
+  This module implements the `Access` behaviour, allowing access to graphable
+  values using the `[]` syntax.
+
+  ## Example
+
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      iex> x_axis = %Plox.XAxis{scale: scale, dimensions: dimensions}
+      iex> x_axis[1]
+      10.0
+      iex> x_axis[2]
+      20.0
+
+  This is useful when rendering graph elements in a more intuitive way:
+
+      <!-- Draw a red circle where you expect x = 1 (at the given y-coordinate) -->
+      <.circle cx={x_axis[1]} cy={50.0} fill="red" r="3" />
+
+  This module implements the `Plox.Axis.Protocol` and defines the `Plox.Axis.Protocol.to_graph/2`
+  function. This function is called by the `Access` behaviour:
+
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      iex> x_axis = Plox.XAxis.new(scale, dimensions)
+      iex> x_axis[1] == Plox.Axis.Protocol.to_graph(x_axis, 1)
+      true
   """
 
   use Plox.Axis
@@ -10,22 +37,34 @@ defmodule Plox.XAxis do
 
   defstruct [:scale, :dimensions]
 
+  @doc """
+  Creates a new `Plox.XAxis` struct.
+
+  Accepts a `Plox.Scale` struct and `Plox.Dimensions` struct.
+
+  ## Example
+
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> dimensions = Plox.Dimensions.new(100, 100)
+      iex> Plox.XAxis.new(scale, dimensions)
+      %Plox.XAxis{scale: scale, dimensions: dimensions}
+  """
   def new(scale, dimensions) do
     %__MODULE__{scale: scale, dimensions: dimensions}
   end
 
-  def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
-
   defimpl Plox.Axis.Protocol do
+    @doc """
+    Converts the given `value` to a graphable x-coordinate.
+    """
     def to_graph(%{scale: scale, dimensions: dimensions}, value) do
-      Scale.convert_to_range(
-        scale,
-        value,
-        (dimensions.margin.left +
-           dimensions.padding.left)..(dimensions.width -
-                                        dimensions.margin.right -
-                                        dimensions.padding.right)
-      )
+      range =
+        Range.new(
+          dimensions.margin.left + dimensions.padding.left,
+          dimensions.width - dimensions.margin.right - dimensions.padding.right
+        )
+
+      Scale.convert_to_range(scale, value, range)
     end
   end
 end
diff --git a/lib/plox/y_axis.ex b/lib/plox/y_axis.ex
index 150c0b4..0b965a5 100644
--- a/lib/plox/y_axis.ex
+++ b/lib/plox/y_axis.ex
@@ -1,7 +1,35 @@
 defmodule Plox.YAxis do
   @moduledoc """
-  TODO: this is a public module that graph component implementers will interact
-  with, so it should be documented
+  YAxis implements the `Plox.Axis.Protocol` and is used to convert scale values
+  to graphable y-coordinates.
+
+  This module implements the `Access` behaviour, allowing access to graphable
+  values using the `[]` syntax. Note that y-coordinates go from top to bottom,
+  meaning that lower y values correspond to higher y-coordinates and vice versa.
+
+  ## Example
+
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      iex> y_axis = %Plox.YAxis{scale: scale, dimensions: dimensions}
+      iex> y_axis[1]
+      90.0
+      iex> y_axis[8]
+      20.0
+
+  This is useful when rendering graph elements in a more intuitive way:
+
+      <!-- Draw a red circle where you expect y = 1 (at the given x-coordinate) -->
+      <.circle cx={50.0} cy={y_axis[1]} fill="red" r="3" />
+
+  This module implements the `Plox.Axis.Protocol` and defines the `Plox.Axis.Protocol.to_graph/2`
+  function. This function is called by the `Access` behaviour:
+
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      iex> y_axis = Plox.YAxis.new(scale, dimensions)
+      iex> y_axis[1] == Plox.Axis.Protocol.to_graph(y_axis, 1)
+      true
   """
 
   use Plox.Axis
@@ -10,22 +38,35 @@ defmodule Plox.YAxis do
 
   defstruct [:scale, :dimensions]
 
+  @doc """
+  Creates a new `Plox.YAxis` struct.
+
+  Accepts a `Plox.Scale` struct and `Plox.Dimensions` struct.
+
+  ## Example
+
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> dimensions = Plox.Dimensions.new(100, 100)
+      iex> Plox.YAxis.new(scale, dimensions)
+      %Plox.YAxis{scale: scale, dimensions: dimensions}
+  """
   def new(scale, dimensions) do
     %__MODULE__{scale: scale, dimensions: dimensions}
   end
 
-  def values(%__MODULE__{scale: scale}, opts \\ %{}), do: Scale.values(scale, opts)
-
   defimpl Plox.Axis.Protocol do
+    @doc """
+    Converts the given `value` to a graphable y-coordinate.
+    """
     def to_graph(%{scale: scale, dimensions: dimensions}, value) do
-      Scale.convert_to_range(
-        scale,
-        value,
-        (dimensions.height -
-           dimensions.margin.bottom -
-           dimensions.padding.bottom)..(dimensions.margin.top +
-                                          dimensions.padding.top)
-      )
+      range =
+        Range.new(
+          dimensions.height - dimensions.margin.bottom - dimensions.padding.bottom,
+          dimensions.margin.top + dimensions.padding.top,
+          -1
+        )
+
+      Scale.convert_to_range(scale, value, range)
     end
   end
 end
diff --git a/mix.exs b/mix.exs
index 60250a7..ed88ea9 100644
--- a/mix.exs
+++ b/mix.exs
@@ -48,7 +48,7 @@ defmodule Plox.MixProject do
       groups_for_functions: [
         Components: &(&1[:type] == :component)
       ],
-      extras: ["README.md", "LICENSE", "CODE_OF_CONDUCT.md"]
+      extras: ["README.md", "LICENSE", "CODE_OF_CONDUCT.md", "docs/migration_guide.md"]
     ]
   end
 
@@ -58,17 +58,19 @@ defmodule Plox.MixProject do
         Plox.Box,
         Plox.DataPoint,
         Plox.Dataset,
-        Plox.Dimensions,
-        Plox.Graph,
-        Plox.GraphDataset,
-        Plox.GraphPoint,
-        Plox.GraphScalar,
-        Plox.GraphScale
+        Plox.Dimensions
       ],
       Protocols: [
+        Plox.Axis.Protocol,
         Plox.ColorScale,
         Plox.Scale
       ],
+      Axes: [
+        Plox.ColorAxis,
+        Plox.LinearAxis,
+        Plox.XAxis,
+        Plox.YAxis
+      ],
       Scales: [
         Plox.DateScale,
         Plox.DateTimeScale,
diff --git a/test/plox/color_axis_test.exs b/test/plox/color_axis_test.exs
new file mode 100644
index 0000000..81e10a3
--- /dev/null
+++ b/test/plox/color_axis_test.exs
@@ -0,0 +1,32 @@
+defmodule Plox.ColorAxisTest do
+  use ExUnit.Case
+
+  alias Plox.Axis
+  alias Plox.ColorAxis
+
+  doctest ColorAxis
+
+  setup do
+    %{scale: Plox.FixedColorsScale.new(%{red: "#ff0000", green: "#00ff00", blue: "#0000ff"})}
+  end
+
+  test "new/2", %{scale: scale} do
+    assert ColorAxis.new(scale) == %ColorAxis{scale: scale}
+  end
+
+  test "implements to_graph/2", %{scale: scale} do
+    color_axis = ColorAxis.new(scale)
+
+    assert Axis.Protocol.to_graph(color_axis, :red) == "#ff0000"
+    assert Axis.Protocol.to_graph(color_axis, :green) == "#00ff00"
+    assert Axis.Protocol.to_graph(color_axis, :blue) == "#0000ff"
+  end
+
+  test "fetches graphable values using Access syntax", %{scale: scale} do
+    color_axis = ColorAxis.new(scale)
+
+    assert color_axis[:red] == "#ff0000"
+    assert color_axis[:green] == "#00ff00"
+    assert color_axis[:blue] == "#0000ff"
+  end
+end
diff --git a/test/plox/color_scale_test.exs b/test/plox/color_scale_test.exs
deleted file mode 100644
index 0036b30..0000000
--- a/test/plox/color_scale_test.exs
+++ /dev/null
@@ -1,11 +0,0 @@
-defmodule Plox.ColorScaleTest do
-  use ExUnit.Case
-
-  alias Plox.ColorScale
-
-  doctest ColorScale
-
-  test "the truth" do
-    assert 1 + 1 == 2
-  end
-end
diff --git a/test/plox/data_point_test.exs b/test/plox/data_point_test.exs
index 6a4505f..24a850c 100644
--- a/test/plox/data_point_test.exs
+++ b/test/plox/data_point_test.exs
@@ -6,9 +6,8 @@ defmodule Plox.DataPointTest do
   doctest DataPoint
 
   test "new/3" do
-    data_point = DataPoint.new(1, %{foo: 1, bar: 2}, %{x: 1, y: 2})
-    assert data_point.id == 1
+    data_point = DataPoint.new(%{foo: 1, bar: 2}, %{x: 1, y: 2})
     assert data_point.original == %{foo: 1, bar: 2}
-    assert data_point.mapped == %{x: 1, y: 2}
+    assert data_point.graph == %{x: 1, y: 2}
   end
 end
diff --git a/test/plox/dataset_test.exs b/test/plox/dataset_test.exs
index d5947b2..03504d2 100644
--- a/test/plox/dataset_test.exs
+++ b/test/plox/dataset_test.exs
@@ -3,20 +3,95 @@ defmodule Plox.DatasetTest do
 
   alias Plox.DataPoint
   alias Plox.Dataset
+  alias Plox.DatasetAxis
 
-  doctest Dataset
+  describe "DatasetAxis" do
+    test "fetch/2 returns graphable values" do
+      data = [%{foo: 1, bar: 2}, %{foo: 2, bar: 3}]
+      dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      scale = Plox.NumberScale.new(0, 10)
 
-  test "new/2" do
-    scale = Plox.number_scale(0, 10)
-    axes = %{x: {scale, & &1.foo}, y: {scale, & &1.bar}}
-    data = [%{foo: 1, bar: 2}, %{foo: 2, bar: 3}]
-    dataset = Dataset.new(data, axes)
+      x_axis = Plox.XAxis.new(scale, dimensions)
+      y_axis = Plox.YAxis.new(scale, dimensions)
+      axis_fns = %{x: {x_axis, & &1.foo}, y: {y_axis, & &1.bar}}
+      dataset = Dataset.new(data, axis_fns)
 
-    assert dataset.scales == %{x: scale, y: scale}
+      assert {:ok, dataset_axis_x} = Dataset.fetch(dataset, :x)
+      assert {:ok, dataset_axis_y} = Dataset.fetch(dataset, :y)
 
-    assert dataset.data == [
-             %DataPoint{id: 0, original: %{foo: 1, bar: 2}, mapped: %{x: 1, y: 2}},
-             %DataPoint{id: 1, original: %{foo: 2, bar: 3}, mapped: %{x: 2, y: 3}}
-           ]
+      # y coordinates are height - the expected value (100 - 20 = 80, 100 - 30 = 70)
+      assert {:ok, 10.0} = DatasetAxis.fetch(dataset_axis_x, 1)
+      assert {:ok, 20.0} = DatasetAxis.fetch(dataset_axis_x, 2)
+      assert {:ok, 80.0} = DatasetAxis.fetch(dataset_axis_y, 2)
+      assert {:ok, 70.0} = DatasetAxis.fetch(dataset_axis_y, 3)
+    end
+
+    test "fetches graphable values using Access syntax" do
+      data = [%{foo: 1, bar: 2}, %{foo: 2, bar: 3}]
+      dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      scale = Plox.NumberScale.new(0, 10)
+
+      x_axis = Plox.XAxis.new(scale, dimensions)
+      y_axis = Plox.YAxis.new(scale, dimensions)
+      axis_fns = %{x: {x_axis, & &1.foo}, y: {y_axis, & &1.bar}}
+      dataset = Dataset.new(data, axis_fns)
+
+      # y coordinates are height - the expected value (100 - 20 = 80, 100 - 30 = 70)
+      assert 10.0 = dataset[:x][1]
+      assert 20.0 = dataset[:x][2]
+      assert 80.0 = dataset[:y][2]
+      assert 70.0 = dataset[:y][3]
+    end
+  end
+
+  describe "Dataset" do
+    test "new/2" do
+      data = [%{foo: 1, bar: 2}, %{foo: 2, bar: 3}]
+      dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      scale = Plox.NumberScale.new(0, 10)
+
+      x_axis = Plox.XAxis.new(scale, dimensions)
+      y_axis = Plox.YAxis.new(scale, dimensions)
+      axis_fns = %{x: {x_axis, & &1.foo}, y: {y_axis, & &1.bar}}
+      dataset = Dataset.new(data, axis_fns)
+
+      assert dataset.axes == %{x: x_axis, y: y_axis}
+
+      # y coordinates are height - the expected value (100 - 20 = 80, 100 - 30 = 70)
+      assert dataset.data == [
+               %DataPoint{original: %{foo: 1, bar: 2}, graph: %{x: 10.0, y: 80.0}},
+               %DataPoint{original: %{foo: 2, bar: 3}, graph: %{x: 20.0, y: 70.0}}
+             ]
+    end
+
+    test "fetch/2 returns DatasetAxes" do
+      data = [%{foo: 1, bar: 2}, %{foo: 2, bar: 3}]
+      dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      scale = Plox.NumberScale.new(0, 10)
+
+      x_axis = Plox.XAxis.new(scale, dimensions)
+      y_axis = Plox.YAxis.new(scale, dimensions)
+      axis_fns = %{x: {x_axis, & &1.foo}, y: {y_axis, & &1.bar}}
+      dataset = Dataset.new(data, axis_fns)
+
+      assert {:ok, %DatasetAxis{axis: ^x_axis}} = Dataset.fetch(dataset, :x)
+      assert {:ok, %DatasetAxis{axis: ^y_axis}} = Dataset.fetch(dataset, :y)
+      assert Dataset.fetch(dataset, :z) == :error
+    end
+
+    test "fetches DatasetAxes using Access syntax" do
+      data = [%{foo: 1, bar: 2}, %{foo: 2, bar: 3}]
+      dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      scale = Plox.NumberScale.new(0, 10)
+
+      x_axis = Plox.XAxis.new(scale, dimensions)
+      y_axis = Plox.YAxis.new(scale, dimensions)
+      axis_fns = %{x: {x_axis, & &1.foo}, y: {y_axis, & &1.bar}}
+      dataset = Dataset.new(data, axis_fns)
+
+      assert %DatasetAxis{axis: ^x_axis} = dataset[:x]
+      assert %DatasetAxis{axis: ^y_axis} = dataset[:y]
+      assert dataset[:z] == nil
+    end
   end
 end
diff --git a/test/plox/date_scale_test.exs b/test/plox/date_scale_test.exs
index eedc203..708b19b 100644
--- a/test/plox/date_scale_test.exs
+++ b/test/plox/date_scale_test.exs
@@ -2,16 +2,81 @@ defmodule Plox.DateScaleTest do
   use ExUnit.Case
 
   alias Plox.DateScale
+  alias Plox.Scale
 
   doctest DateScale
 
-  test "new/2" do
-    scale = DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-03]))
-    assert scale.range == Date.range(~D[2019-01-01], ~D[2019-01-03])
+  describe "new/2" do
+    test "with a valid Date range" do
+      scale = DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-03]))
+      assert scale.range == Date.range(~D[2019-01-01], ~D[2019-01-03], 1)
+    end
+
+    test "with a valid Date range reduces step to 1" do
+      scale = DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-03], 2))
+      assert scale.range == Date.range(~D[2019-01-01], ~D[2019-01-03], 1)
+    end
+
+    test "with a valid reverse Date range" do
+      scale = DateScale.new(Date.range(~D[2019-01-03], ~D[2019-01-01], -1))
+      assert scale.range == Date.range(~D[2019-01-03], ~D[2019-01-01], -1)
+    end
+
+    test "raises an error with identical dates" do
+      assert_raise ArgumentError, fn ->
+        DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-01]))
+      end
+    end
+
+    test "raises an error with invalid Date range" do
+      assert_raise ArgumentError, fn ->
+        DateScale.new(0..1)
+      end
+    end
   end
 
-  test "new/2 given a range with a step it reduces it to 1" do
-    scale = DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-03], 2))
-    assert scale.range == Date.range(~D[2019-01-01], ~D[2019-01-03])
+  describe "values/2" do
+    test "with default step (1d)" do
+      scale = DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-03]))
+      assert %Date.Range{first: ~D[2019-01-01], last: ~D[2019-01-03], step: 1} = Scale.values(scale)
+    end
+
+    test "with positive custom step in days" do
+      scale = DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-10]))
+      assert Scale.values(scale, %{step: 2}) == Date.range(~D[2019-01-01], ~D[2019-01-10], 2)
+    end
+
+    test "with negative custom step in days" do
+      scale = DateScale.new(Date.range(~D[2019-01-10], ~D[2019-01-01], -1))
+      assert Scale.values(scale, %{step: 2}) == Date.range(~D[2019-01-10], ~D[2019-01-01], -2)
+    end
+
+    test "raises an error with invalid step" do
+      scale = DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-10]))
+
+      assert_raise ArgumentError, fn ->
+        Scale.values(scale, %{step: 0})
+      end
+    end
+  end
+
+  describe "convert_to_range/3" do
+    test "with a valid Date in the range" do
+      scale = DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-09]))
+      assert Scale.convert_to_range(scale, ~D[2019-01-05], 0..100) == 50.0
+    end
+
+    test "with a valid Date in the reverse range" do
+      scale = DateScale.new(Date.range(~D[2019-01-09], ~D[2019-01-01], -1))
+      assert Scale.convert_to_range(scale, ~D[2019-01-07], 0..100) == 25.0
+    end
+
+    test "raises an error with Date outside the range" do
+      scale = DateScale.new(Date.range(~D[2019-01-01], ~D[2019-01-10]))
+
+      assert_raise ArgumentError, fn ->
+        Scale.convert_to_range(scale, ~D[2019-01-12], 0..100)
+      end
+    end
   end
 end
diff --git a/test/plox/date_time_scale_test.exs b/test/plox/date_time_scale_test.exs
index 71d234a..81c33f1 100644
--- a/test/plox/date_time_scale_test.exs
+++ b/test/plox/date_time_scale_test.exs
@@ -2,16 +2,125 @@ defmodule Plox.DateTimeScaleTest do
   use ExUnit.Case
 
   alias Plox.DateTimeScale
+  alias Plox.Scale
 
   doctest DateTimeScale
 
-  test "the truth" do
-    assert 1 + 1 == 2
+  describe "new/2" do
+    test "with valid NaiveDateTimes" do
+      scale = DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-03 00:00:00])
+      assert scale.first == ~N[2019-01-01 00:00:00]
+      assert scale.last == ~N[2019-01-03 00:00:00]
+    end
+
+    test "with valid DateTimes" do
+      scale = DateTimeScale.new(~U[2019-01-01 00:00:00Z], ~U[2019-01-03 00:00:00Z])
+      assert scale.first == ~U[2019-01-01 00:00:00Z]
+      assert scale.last == ~U[2019-01-03 00:00:00Z]
+    end
+
+    test "raises an error with identical DateTimes" do
+      assert_raise ArgumentError, fn ->
+        DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-01 00:00:00])
+      end
+    end
+
+    test "raises an error with identical NaiveDateTimes" do
+      assert_raise ArgumentError, fn ->
+        DateTimeScale.new(~U[2019-01-01 00:00:00Z], ~U[2019-01-01 00:00:00Z])
+      end
+    end
+
+    test "raises an error with mixed structs" do
+      assert_raise ArgumentError, fn ->
+        DateTimeScale.new(~N[2019-01-01 00:00:00], ~U[2019-01-03 00:00:00Z])
+      end
+    end
+
+    test "raises an error with negative ranges" do
+      assert_raise ArgumentError, fn ->
+        DateTimeScale.new(~N[2019-01-03 00:00:00], ~N[2019-01-01 00:00:00])
+      end
+    end
   end
 
-  test "new/2" do
-    scale = DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-03 00:00:00])
-    assert scale.first == ~N[2019-01-01 00:00:00]
-    assert scale.last == ~N[2019-01-03 00:00:00]
+  describe "values/2" do
+    test "with default step (60s)" do
+      scale = DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-01 00:02:00])
+
+      assert Scale.values(scale) == [
+               ~N[2019-01-01 00:00:00],
+               ~N[2019-01-01 00:01:00],
+               ~N[2019-01-01 00:02:00]
+             ]
+    end
+
+    test "with valid step in days" do
+      scale = DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-03 00:00:00])
+
+      assert Scale.values(scale, %{step: {1, :day}}) == [
+               ~N[2019-01-01 00:00:00],
+               ~N[2019-01-02 00:00:00],
+               ~N[2019-01-03 00:00:00]
+             ]
+    end
+
+    test "with valid step in hours" do
+      scale = DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-01 01:00:00])
+
+      assert Scale.values(scale, %{step: {1, :hour}}) == [
+               ~N[2019-01-01 00:00:00],
+               ~N[2019-01-01 01:00:00]
+             ]
+    end
+
+    test "with valid step in minutes" do
+      scale = DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-01 00:02:00])
+
+      assert Scale.values(scale, %{step: {1, :minute}}) == [
+               ~N[2019-01-01 00:00:00],
+               ~N[2019-01-01 00:01:00],
+               ~N[2019-01-01 00:02:00]
+             ]
+    end
+
+    test "with valid step in seconds" do
+      scale = DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-01 00:00:03])
+
+      assert Scale.values(scale, %{step: {1, :second}}) == [
+               ~N[2019-01-01 00:00:00],
+               ~N[2019-01-01 00:00:01],
+               ~N[2019-01-01 00:00:02],
+               ~N[2019-01-01 00:00:03]
+             ]
+    end
+  end
+
+  describe "convert_to_range/3" do
+    test "with valid NaiveDateTime" do
+      scale = DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-03 00:00:00])
+      assert Scale.convert_to_range(scale, ~N[2019-01-02 00:00:00], 0..100) == 50.0
+    end
+
+    test "with valid DateTime" do
+      scale = DateTimeScale.new(~U[2019-01-01 00:00:00Z], ~U[2019-01-03 00:00:00Z])
+      assert Scale.convert_to_range(scale, ~U[2019-01-02 00:00:00Z], 0..100) == 50.0
+    end
+
+    test "raises an error with values outside the scale" do
+      scale = DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-03 00:00:00])
+
+      assert_raise ArgumentError, fn ->
+        Scale.convert_to_range(scale, ~N[2019-01-04 00:00:00], 0..100)
+      end
+    end
+
+    test "raises an error with invalid datetime" do
+      scale = DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-03 00:00:00])
+
+      assert_raise ArgumentError, fn ->
+        Scale.convert_to_range(scale, ~U[2019-01-02 12:00:00Z], 0..100)
+      end
+    end
   end
 end
diff --git a/test/plox/dimensions_test.exs b/test/plox/dimensions_test.exs
index 85d3b40..a5b3930 100644
--- a/test/plox/dimensions_test.exs
+++ b/test/plox/dimensions_test.exs
@@ -7,7 +7,7 @@ defmodule Plox.DimensionsTest do
   doctest Dimensions
 
   test "new/1" do
-    assert Dimensions.new(%{width: 100, height: 100, margin: 0, padding: 0}) == %Dimensions{
+    assert Dimensions.new(100, 100, margin: 0, padding: 0) == %Dimensions{
              width: 100,
              height: 100,
              margin: %Box{top: 0, right: 0, bottom: 0, left: 0},
diff --git a/test/plox/fixed_colors_scale_test.exs b/test/plox/fixed_colors_scale_test.exs
index c16e8c5..ccd8667 100644
--- a/test/plox/fixed_colors_scale_test.exs
+++ b/test/plox/fixed_colors_scale_test.exs
@@ -1,9 +1,41 @@
 defmodule Plox.FixedColorsScaleTest do
   use ExUnit.Case
 
+  alias Plox.ColorScale
+  alias Plox.FixedColorsScale
+
   doctest Plox.FixedColorsScale
 
-  test "the truth" do
-    assert 1 + 1 == 2
+  describe "new/1" do
+    test "creates a new FixedColorsScale" do
+      scale = FixedColorsScale.new(%{red: "#ff0000", green: "#00ff00", blue: "#0000ff"})
+
+      assert %FixedColorsScale{
+               mapping: %{red: "#ff0000", green: "#00ff00", blue: "#0000ff"}
+             } = scale
+    end
+
+    test "raises an error for invalid input" do
+      assert_raise ArgumentError, fn ->
+        FixedColorsScale.new(%{red: "#ff0000"})
+      end
+    end
+  end
+
+  describe "convert_to_color/2" do
+    test "with valid input" do
+      scale = FixedColorsScale.new(%{red: "#ff0000", green: "#00ff00", blue: "#0000ff"})
+      assert ColorScale.convert_to_color(scale, :red) == "#ff0000"
+      assert ColorScale.convert_to_color(scale, :green) == "#00ff00"
+      assert ColorScale.convert_to_color(scale, :blue) == "#0000ff"
+    end
+
+    test "raises an error for invalid values" do
+      scale = FixedColorsScale.new(%{red: "#ff0000", green: "#00ff00", blue: "#0000ff"})
+
+      assert_raise ArgumentError, fn ->
+        ColorScale.convert_to_color(scale, :yellow)
+      end
+    end
   end
 end
diff --git a/test/plox/fixed_values_scale_test.exs b/test/plox/fixed_values_scale_test.exs
index b77871c..7290a89 100644
--- a/test/plox/fixed_values_scale_test.exs
+++ b/test/plox/fixed_values_scale_test.exs
@@ -1,9 +1,50 @@
 defmodule Plox.FixedValuesScaleTest do
   use ExUnit.Case
 
+  alias Plox.FixedValuesScale
+  alias Plox.Scale
+
   doctest Plox.FixedValuesScale
 
-  test "the truth" do
-    assert 1 + 1 == 2
+  describe "new/1" do
+    test "creates a new FixedValuesScale" do
+      scale = FixedValuesScale.new([:a, :b, :c, :d])
+
+      assert %FixedValuesScale{
+               values: [:a, :b, :c, :d],
+               index_map: %{a: 0, b: 1, c: 2, d: 3},
+               max_index: 3
+             } = scale
+    end
+
+    test "raises an error for invalid input" do
+      assert_raise ArgumentError, fn ->
+        FixedValuesScale.new([1])
+      end
+    end
+  end
+
+  describe "values/1" do
+    test "returns the values in the scale" do
+      scale = FixedValuesScale.new([:a, :b, :c])
+      assert Scale.values(scale) == [:a, :b, :c]
+    end
+  end
+
+  describe "convert_to_range/3" do
+    test "with valid input" do
+      scale = FixedValuesScale.new([:a, :b, :c])
+      assert Scale.convert_to_range(scale, :a, 0..100) == 0.0
+      assert Scale.convert_to_range(scale, :b, 0..100) == 50.0
+      assert Scale.convert_to_range(scale, :c, 0..100) == 100.0
+    end
+
+    test "raises an error for invalid values" do
+      scale = FixedValuesScale.new([:a, :b, :c])
+
+      assert_raise ArgumentError, fn ->
+        Scale.convert_to_range(scale, :d, 0..100)
+      end
+    end
   end
 end
diff --git a/test/plox/graph_dataset_test.exs b/test/plox/graph_dataset_test.exs
deleted file mode 100644
index c1f96ab..0000000
--- a/test/plox/graph_dataset_test.exs
+++ /dev/null
@@ -1,9 +0,0 @@
-defmodule Plox.GraphDatasetTest do
-  use ExUnit.Case
-
-  doctest Plox.GraphDataset
-
-  test "the truth" do
-    assert 1 + 1 == 2
-  end
-end
diff --git a/test/plox/graph_point_test.exs b/test/plox/graph_point_test.exs
deleted file mode 100644
index e6ef63a..0000000
--- a/test/plox/graph_point_test.exs
+++ /dev/null
@@ -1,9 +0,0 @@
-defmodule Plox.GraphPointTest do
-  use ExUnit.Case
-
-  doctest Plox.GraphPoint
-
-  test "the truth" do
-    assert 1 + 1 == 2
-  end
-end
diff --git a/test/plox/graph_scalar_test.exs b/test/plox/graph_scalar_test.exs
deleted file mode 100644
index 24877e6..0000000
--- a/test/plox/graph_scalar_test.exs
+++ /dev/null
@@ -1,9 +0,0 @@
-defmodule Plox.GraphScalarTest do
-  use ExUnit.Case
-
-  doctest Plox.GraphScalar
-
-  test "the truth" do
-    assert 1 + 1 == 2
-  end
-end
diff --git a/test/plox/graph_scale_test.exs b/test/plox/graph_scale_test.exs
deleted file mode 100644
index f1a19b5..0000000
--- a/test/plox/graph_scale_test.exs
+++ /dev/null
@@ -1,9 +0,0 @@
-defmodule Plox.GraphScaleTest do
-  use ExUnit.Case
-
-  doctest Plox.GraphScale
-
-  test "the truth" do
-    assert 1 + 1 == 2
-  end
-end
diff --git a/test/plox/graph_test.exs b/test/plox/graph_test.exs
deleted file mode 100644
index 1092785..0000000
--- a/test/plox/graph_test.exs
+++ /dev/null
@@ -1,9 +0,0 @@
-defmodule Plox.GraphTest do
-  use ExUnit.Case
-
-  doctest Plox.Graph
-
-  test "the truth" do
-    assert 1 + 1 == 2
-  end
-end
diff --git a/test/plox/linear_axis_test.exs b/test/plox/linear_axis_test.exs
new file mode 100644
index 0000000..0e77fdc
--- /dev/null
+++ b/test/plox/linear_axis_test.exs
@@ -0,0 +1,34 @@
+defmodule Plox.LinearAxisTest do
+  use ExUnit.Case
+
+  alias Plox.Axis
+  alias Plox.LinearAxis
+
+  doctest LinearAxis
+
+  setup do
+    %{scale: Plox.NumberScale.new(0, 10)}
+  end
+
+  test "new/2", %{scale: scale} do
+    assert LinearAxis.new(scale, min: 0, max: 100) == %LinearAxis{
+             scale: scale,
+             min: 0,
+             max: 100
+           }
+  end
+
+  test "implements to_graph/2", %{scale: scale} do
+    linear_axis = LinearAxis.new(scale, min: 0, max: 100)
+
+    assert Axis.Protocol.to_graph(linear_axis, 1) == 10.0
+    assert Axis.Protocol.to_graph(linear_axis, 2) == 20.0
+  end
+
+  test "fetches graphable values using Access syntax", %{scale: scale} do
+    linear_axis = LinearAxis.new(scale, min: 0, max: 100)
+
+    assert linear_axis[1] == 10.0
+    assert linear_axis[2] == 20.0
+  end
+end
diff --git a/test/plox/number_scale_test.exs b/test/plox/number_scale_test.exs
index ff35095..9b08f72 100644
--- a/test/plox/number_scale_test.exs
+++ b/test/plox/number_scale_test.exs
@@ -1,14 +1,83 @@
 defmodule Plox.NumberScaleTest do
   use ExUnit.Case
 
+  alias Plox.NumberScale
+  alias Plox.Scale
+
   doctest Plox.NumberScale
 
-  test "the truth" do
-    assert 1 + 1 == 2
+  describe "new/2" do
+    test "with valid numbers" do
+      scale = NumberScale.new(0, 10)
+      assert scale.first == Decimal.new("0.0")
+      assert scale.last == Decimal.new("10.0")
+      refute scale.backwards?
+    end
+
+    test "with reversed numbers" do
+      scale = NumberScale.new(10, 0)
+      assert scale.first == Decimal.new("10.0")
+      assert scale.last == Decimal.new("0.0")
+      assert scale.backwards?
+    end
+
+    test "raises an error with identical numbers" do
+      assert_raise ArgumentError, fn ->
+        NumberScale.new(5, 5)
+      end
+    end
+  end
+
+  describe "values/2" do
+    test "with default ticks" do
+      scale = NumberScale.new(0, 10)
+      assert Scale.values(scale) == [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
+    end
+
+    test "with custom ticks" do
+      scale = NumberScale.new(0, 10)
+      assert Scale.values(scale, %{ticks: 5}) == [0.0, 2.5, 5.0, 7.5, 10.0]
+    end
+
+    test "with reversed scale" do
+      scale = NumberScale.new(10, 0)
+      assert Scale.values(scale) == [10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0]
+    end
+
+    test "raises an error with invalid ticks" do
+      scale = NumberScale.new(0, 10)
+
+      assert_raise ArgumentError, fn ->
+        Scale.values(scale, %{ticks: 1})
+      end
+    end
   end
 
-  test "scale" do
-    scale = Plox.NumberScale.new(0, 100)
-    Plox.Scale.convert_to_range(scale, 200, 0..1000)
+  describe "convert_to_range/3" do
+    test "with valid input" do
+      scale = NumberScale.new(0, 10)
+      assert Scale.convert_to_range(scale, 5, 0..100) == 50.0
+    end
+
+    test "with reversed scale" do
+      scale = NumberScale.new(10, 0)
+      assert Scale.convert_to_range(scale, 2, 0..100) == 80.0
+    end
+
+    test "raises an error with out of bounds input" do
+      scale = NumberScale.new(0, 10)
+
+      assert_raise ArgumentError, fn ->
+        Scale.convert_to_range(scale, 11, 0..100)
+      end
+    end
+
+    test "raises an error with invalid input" do
+      scale = NumberScale.new(0, 10)
+
+      assert_raise ArgumentError, fn ->
+        Scale.convert_to_range(scale, "invalid", 0..100)
+      end
+    end
   end
 end
diff --git a/test/plox/scale_test.exs b/test/plox/scale_test.exs
deleted file mode 100644
index 420e508..0000000
--- a/test/plox/scale_test.exs
+++ /dev/null
@@ -1,9 +0,0 @@
-defmodule Plox.ScaleTest do
-  use ExUnit.Case
-
-  doctest Plox.Scale
-
-  test "the truth" do
-    assert 1 + 1 == 2
-  end
-end
diff --git a/test/plox/x_axis_test.exs b/test/plox/x_axis_test.exs
new file mode 100644
index 0000000..5d009dc
--- /dev/null
+++ b/test/plox/x_axis_test.exs
@@ -0,0 +1,36 @@
+defmodule Plox.XAxisTest do
+  use ExUnit.Case
+
+  alias Plox.Axis
+  alias Plox.XAxis
+
+  doctest XAxis
+
+  setup do
+    %{
+      scale: Plox.NumberScale.new(0, 10),
+      dimensions: Plox.Dimensions.new(100, 100, margin: 0)
+    }
+  end
+
+  test "new/2", %{scale: scale, dimensions: dimensions} do
+    assert XAxis.new(scale, dimensions) == %XAxis{
+             scale: scale,
+             dimensions: dimensions
+           }
+  end
+
+  test "implements to_graph/2", %{scale: scale, dimensions: dimensions} do
+    x_axis = XAxis.new(scale, dimensions)
+
+    assert Axis.Protocol.to_graph(x_axis, 1) == 10.0
+    assert Axis.Protocol.to_graph(x_axis, 2) == 20.0
+  end
+
+  test "fetches graphable values using Access syntax", %{scale: scale, dimensions: dimensions} do
+    x_axis = XAxis.new(scale, dimensions)
+
+    assert x_axis[1] == 10.0
+    assert x_axis[2] == 20.0
+  end
+end
diff --git a/test/plox/y_axis_test.exs b/test/plox/y_axis_test.exs
new file mode 100644
index 0000000..ef74460
--- /dev/null
+++ b/test/plox/y_axis_test.exs
@@ -0,0 +1,38 @@
+defmodule Plox.YAxisTest do
+  use ExUnit.Case
+
+  alias Plox.Axis
+  alias Plox.YAxis
+
+  doctest YAxis
+
+  setup do
+    %{
+      scale: Plox.NumberScale.new(0, 10),
+      dimensions: Plox.Dimensions.new(100, 100, margin: 0)
+    }
+  end
+
+  test "new/2", %{scale: scale, dimensions: dimensions} do
+    assert YAxis.new(scale, dimensions) == %YAxis{
+             scale: scale,
+             dimensions: dimensions
+           }
+  end
+
+  test "implements to_graph/2", %{scale: scale, dimensions: dimensions} do
+    y_axis = YAxis.new(scale, dimensions)
+
+    # y coordinates are height - the expected value (100 - 10 = 90, 100 - 20 = 80)
+    assert Axis.Protocol.to_graph(y_axis, 1) == 90.0
+    assert Axis.Protocol.to_graph(y_axis, 2) == 80.0
+  end
+
+  test "fetches graphable values using Access syntax", %{scale: scale, dimensions: dimensions} do
+    y_axis = YAxis.new(scale, dimensions)
+
+    # y coordinates are height - the expected value (100 - 10 = 90, 100 - 20 = 80)
+    assert y_axis[1] == 90.0
+    assert y_axis[2] == 80.0
+  end
+end
diff --git a/test/plox_test.exs b/test/plox_test.exs
index cd25a17..94eebac 100644
--- a/test/plox_test.exs
+++ b/test/plox_test.exs
@@ -1,9 +1,53 @@
 defmodule PloxTest do
   use ExUnit.Case
 
-  doctest Plox
+  describe "points/2" do
+    test "handles constant values" do
+      assert Plox.points(1, 2) == [{1, 2}]
+      assert Plox.points([1, 2], [3, 4]) == [{1, 3}, {2, 4}]
+    end
 
-  test "the truth" do
-    assert 1 + 1 == 2
+    test "handles DatasetAxes" do
+      data = [%{foo: 1, bar: 2}, %{foo: 2, bar: 3}]
+      dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      scale = Plox.NumberScale.new(0, 10)
+
+      x_axis = Plox.XAxis.new(scale, dimensions)
+      y_axis = Plox.YAxis.new(scale, dimensions)
+      axis_fns = %{x: {x_axis, & &1.foo}, y: {y_axis, & &1.bar}}
+      dataset = Plox.Dataset.new(data, axis_fns)
+
+      # y coordinates are height - the expected value (100 - 20 = 80, 100 - 30 = 70)
+      assert Plox.points(dataset[:x], dataset[:y]) == [{10.0, 80.0}, {20.0, 70.0}]
+      assert Plox.points(dataset[:x], 1) == [{10.0, 1.0}, {20.0, 1.0}]
+      assert Plox.points(1, dataset[:y]) == [{1.0, 80.0}, {1.0, 70.0}]
+      assert Plox.points(dataset[:x], [3, 4]) == [{10.0, 3.0}, {20.0, 4.0}]
+      assert Plox.points([1, 2], dataset[:y]) == [{1.0, 80.0}, {2.0, 70.0}]
+    end
+  end
+
+  describe "values/1" do
+    test "handles constant values" do
+      assert Plox.values([1, 2]) == [{1, 2}]
+      assert Plox.values([[1, 2], [3, 4]]) == [{1, 3}, {2, 4}]
+    end
+
+    test "handles DatasetAxes" do
+      data = [%{foo: 1, bar: 2}, %{foo: 2, bar: 3}]
+      dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      scale = Plox.NumberScale.new(0, 10)
+
+      x_axis = Plox.XAxis.new(scale, dimensions)
+      y_axis = Plox.YAxis.new(scale, dimensions)
+      axis_fns = %{x: {x_axis, & &1.foo}, y: {y_axis, & &1.bar}}
+      dataset = Plox.Dataset.new(data, axis_fns)
+
+      # y coordinates are height - the expected value (100 - 20 = 80, 100 - 30 = 70)
+      assert Plox.values([dataset[:x], dataset[:y]]) == [{10.0, 80.0}, {20.0, 70.0}]
+      assert Plox.values([dataset[:x], 1]) == [{10.0, 1.0}, {20.0, 1.0}]
+      assert Plox.values([1, dataset[:y]]) == [{1.0, 80.0}, {1.0, 70.0}]
+      assert Plox.values([dataset[:x], [3, 4]]) == [{10.0, 3.0}, {20.0, 4.0}]
+      assert Plox.values([[1, 2], dataset[:y]]) == [{1.0, 80.0}, {2.0, 70.0}]
+    end
   end
 end

From eb5a79fab472f76b4802537e2ca75947f10f1156 Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Fri, 18 Jul 2025 11:37:24 -0700
Subject: [PATCH 19/23] Bump Erlang and Elixir versions for CI

---
 .github/workflows/ci.yml | 4 ++--
 mix.exs                  | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 276790f..f0d596c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -8,8 +8,8 @@ on:
 
 env:
   MIX_ENV: test
-  OTP_VERSION_SPEC: "26.x"
-  ELIXIR_VERSION_SPEC: "1.16.x"
+  OTP_VERSION_SPEC: "27.x"
+  ELIXIR_VERSION_SPEC: "1.18.x"
 
 jobs:
   compile:
diff --git a/mix.exs b/mix.exs
index ed88ea9..73b2fee 100644
--- a/mix.exs
+++ b/mix.exs
@@ -8,7 +8,7 @@ defmodule Plox.MixProject do
     [
       app: :plox,
       version: @version,
-      elixir: "~> 1.15",
+      elixir: "~> 1.18",
       start_permanent: Mix.env() == :prod,
       deps: deps(),
 

From fa122b318746af21a24882b30eab35a1346489cc Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Fri, 18 Jul 2025 14:50:51 -0700
Subject: [PATCH 20/23] Update docs to present better in HexDocs

---
 docs/migration_guide.md     |   4 +-
 lib/plox.ex                 | 153 ++++++++++++++++++------------------
 lib/plox/box.ex             |  20 ++---
 lib/plox/color_axis.ex      |   4 +-
 lib/plox/data_point.ex      |  37 +++++++++
 lib/plox/dataset.ex         |   6 +-
 lib/plox/date_scale.ex      |  24 +++---
 lib/plox/date_time_scale.ex |   6 +-
 lib/plox/linear_axis.ex     |   4 +-
 lib/plox/x_axis.ex          |   4 +-
 lib/plox/y_axis.ex          |   4 +-
 11 files changed, 144 insertions(+), 122 deletions(-)

diff --git a/docs/migration_guide.md b/docs/migration_guide.md
index 74a17a7..0d9997b 100644
--- a/docs/migration_guide.md
+++ b/docs/migration_guide.md
@@ -1,4 +1,4 @@
-# Plox Migration Guide (0.2.0 to 0.3.0)
+# Plox Migration Guide (0.2.0 to X.X.X)
 
 Plox has gone through a major philosophical rewrite since its initial publication. This
 guide will help users convert their current Plox graphs over to the new approach.
@@ -54,7 +54,7 @@ example_graph =
 </.graph>
 ```
 
-## Example of 0.3.0 usage
+## Example of X.X.X usage
 
 1. Set up data, dimensions, axes, and dataset:
 
diff --git a/lib/plox.ex b/lib/plox.ex
index 6b55a5b..460f176 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -1,7 +1,6 @@
 defmodule Plox do
   @moduledoc """
-  Composable, customizable, and flexible SVG graphing components rendered server-side
-  for Phoenix and LiveView.
+  Server-side rendered SVG graphing components for Phoenix and LiveView.
   """
 
   use Phoenix.Component
@@ -23,8 +22,6 @@ defmodule Plox do
   # FIXME:
   attr :rest, :global
 
-  slot :legend
-  slot :tooltips
   slot :inner_block, required: true
 
   def graph(assigns) do
@@ -404,25 +401,25 @@ defmodule Plox do
 
   ## Example
 
-    iex> Plox.points(1, 2)
-    [{1, 2}]
-
-    iex> Plox.points([1, 2], [3, 4])
-    [{1, 3}, {2, 4}]
-
-    iex> dataset = %Plox.Dataset{
-    ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
-    ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
-    ...>}
-    iex> Plox.points([1, 2], dataset[:x])
-    [{1, 10}, {2, 30}]
-
-    iex> dataset = %Plox.Dataset{
-    ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
-    ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
-    ...>}
-    iex> Plox.points(dataset[:x], dataset[:y])
-    [{10, 20}, {30, 40}]
+      iex> Plox.points(1, 2)
+      [{1, 2}]
+
+      iex> Plox.points([1, 2], [3, 4])
+      [{1, 3}, {2, 4}]
+
+      iex> dataset = %Plox.Dataset{
+      ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
+      ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
+      ...>}
+      iex> Plox.points([1, 2], dataset[:x])
+      [{1, 10}, {2, 30}]
+
+      iex> dataset = %Plox.Dataset{
+      ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
+      ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
+      ...>}
+      iex> Plox.points(dataset[:x], dataset[:y])
+      [{10, 20}, {30, 40}]
   """
   def points(x, y) do
     values([x, y])
@@ -433,25 +430,25 @@ defmodule Plox do
 
   ## Example
 
-    iex> Plox.values([1, 2])
-    [{1, 2}]
-
-    iex> Plox.values([1, 2], [3, 4])
-    [{1, 3}, {2, 4}]
-
-    iex> dataset = %Plox.Dataset{
-    ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
-    ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
-    ...>}
-    iex> Plox.values([[1, 2], dataset[:x]])
-    [{1, 10}, {2, 30}]
-
-    iex> dataset = %Plox.Dataset{
-    ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
-    ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
-    ...>}
-    iex> Plox.values([dataset[:x], dataset[:y]])
-    [{10, 20}, {30, 40}]
+      iex> Plox.values([1, 2])
+      [{1, 2}]
+
+      iex> Plox.values([1, 2], [3, 4])
+      [{1, 3}, {2, 4}]
+
+      iex> dataset = %Plox.Dataset{
+      ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
+      ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
+      ...>}
+      iex> Plox.values([[1, 2], dataset[:x]])
+      [{1, 10}, {2, 30}]
+
+      iex> dataset = %Plox.Dataset{
+      ...>  data: [%{x: 10, y: 20}, %{x: 30, y: 40}],
+      ...>  axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}
+      ...>}
+      iex> Plox.values([dataset[:x], dataset[:y]])
+      [{10, 20}, {30, 40}]
   """
   def values(data) do
     if Enum.any?(data, &Enumerable.impl_for/1) do
@@ -693,48 +690,48 @@ defmodule Plox do
   #   |> Enum.chunk_every(2, 1, :discard)
   # end
 
-  @doc """
-  Legend row.
-  """
-  @doc type: :component
+  # @doc """
+  # Legend row.
+  # """
+  # @doc type: :component
 
-  slot :inner_block, required: true
+  # slot :inner_block, required: true
 
-  def legend(assigns) do
-    ~H"""
-    <div style="display: flex; gap: 0.5rem">
-      {render_slot(@inner_block)}
-    </div>
-    """
-  end
+  # def legend(assigns) do
+  #   ~H"""
+  #   <div style="display: flex; gap: 0.5rem">
+  #     {render_slot(@inner_block)}
+  #   </div>
+  #   """
+  # end
 
-  @doc """
-  Legend item.
-  """
-  @doc type: :component
+  # @doc """
+  # Legend item.
+  # """
+  # @doc type: :component
 
-  attr :color, :string, required: true
-  attr :label, :string, required: true
+  # attr :color, :string, required: true
+  # attr :label, :string, required: true
 
-  def legend_item(assigns) do
-    ~H"""
-    <div style="display: flex; align-items: baseline; column-gap: 0.5rem">
-      <.color_bubble color={@color} />
-      <p style="font-size: 0.75rem; line-height: 1rem; color: #9D9E9F;">{@label}</p>
-    </div>
-    """
-  end
+  # def legend_item(assigns) do
+  #   ~H"""
+  #   <div style="display: flex; align-items: baseline; column-gap: 0.5rem">
+  #     <.color_bubble color={@color} />
+  #     <p style="font-size: 0.75rem; line-height: 1rem; color: #9D9E9F;">{@label}</p>
+  #   </div>
+  #   """
+  # end
 
-  @doc """
-  A colored circle for legends.
-  """
-  @doc type: :component
+  # @doc """
+  # A colored circle for legends.
+  # """
+  # @doc type: :component
 
-  attr :color, :string, required: true
+  # attr :color, :string, required: true
 
-  def color_bubble(assigns) do
-    ~H"""
-    <div style={"background-color: #{@color}; height: 0.5rem; width: 0.5rem; flex: none; border-radius: 9999px;"} />
-    """
-  end
+  # def color_bubble(assigns) do
+  #   ~H"""
+  #   <div style={"background-color: #{@color}; height: 0.5rem; width: 0.5rem; flex: none; border-radius: 9999px;"} />
+  #   """
+  # end
 end
diff --git a/lib/plox/box.ex b/lib/plox/box.ex
index fe61d5a..4d5d6a3 100644
--- a/lib/plox/box.ex
+++ b/lib/plox/box.ex
@@ -13,20 +13,20 @@ defmodule Plox.Box do
 
   ## Examples
 
-    iex> Plox.Box.new(10)
-    %Plox.Box{top: 10, right: 10, bottom: 10, left: 10}
+      iex> Plox.Box.new(10)
+      %Plox.Box{top: 10, right: 10, bottom: 10, left: 10}
 
-    iex> Plox.Box.new({5, 15})
-    %Plox.Box{top: 5, right: 15, bottom: 5, left: 15}
+      iex> Plox.Box.new({5, 15})
+      %Plox.Box{top: 5, right: 15, bottom: 5, left: 15}
 
-    iex> Plox.Box.new({5, 15, 10})
-    %Plox.Box{top: 5, right: 15, bottom: 10, left: 15}
+      iex> Plox.Box.new({5, 15, 10})
+      %Plox.Box{top: 5, right: 15, bottom: 10, left: 15}
 
-    iex> Plox.Box.new({5, 15, 10, 20})
-    %Plox.Box{top: 5, right: 15, bottom: 10, left: 20}
+      iex> Plox.Box.new({5, 15, 10, 20})
+      %Plox.Box{top: 5, right: 15, bottom: 10, left: 20}
 
-    iex> Plox.Box.new("5 15 10 20")
-    %Plox.Box{top: 5, right: 15, bottom: 10, left: 20}
+      iex> Plox.Box.new("5 15 10 20")
+      %Plox.Box{top: 5, right: 15, bottom: 10, left: 20}
   """
   def new(string) when is_binary(string) do
     string
diff --git a/lib/plox/color_axis.ex b/lib/plox/color_axis.ex
index a0b33e6..c92b5df 100644
--- a/lib/plox/color_axis.ex
+++ b/lib/plox/color_axis.ex
@@ -3,9 +3,7 @@ defmodule Plox.ColorAxis do
   ColorAxis converts `Plox.ColorScale` values to graphable colors.
 
   This module implements the `Access` behaviour, allowing access to graphable
-  values using the `[]` syntax.
-
-  ## Example
+  values using the `[]` syntax:
 
       iex> color_scale = Plox.FixedColorsScale.new(%{red: "#ff0000", green: "#00ff00", blue: "#0000ff"})
       iex> color_axis = Plox.ColorAxis.new(color_scale)
diff --git a/lib/plox/data_point.ex b/lib/plox/data_point.ex
index ff0bd7b..7807bec 100644
--- a/lib/plox/data_point.ex
+++ b/lib/plox/data_point.ex
@@ -1,10 +1,47 @@
 defmodule Plox.DataPoint do
   @moduledoc """
   Data structure for containing raw data and its mapped values for graphing.
+
+  Calculated by `Plox.Dataset.new/2` when processing the raw data:
+
+      iex> data = [%{foo: 1, bar: 2}, %{foo: 2, bar: 3}]
+      iex> dimensions = Plox.Dimensions.new(100, 100, margin: 0)
+      iex> scale = Plox.NumberScale.new(0, 10)
+      iex> x_axis = Plox.XAxis.new(scale, dimensions)
+      iex> Plox.Dataset.new(data, %{x: {x_axis, & &1.foo}})
+      %Plox.Dataset{
+        data: [
+          %Plox.DataPoint{original: %{foo: 1, bar: 2}, graph: %{x: 10.0}},
+          %Plox.DataPoint{original: %{foo: 2, bar: 3}, graph: %{x: 20.0}}
+        ],
+        axes: %{
+          x: %Plox.XAxis{
+            scale: Plox.NumberScale.new(0.0, 10.0),
+            dimensions: %Plox.Dimensions{
+              width: 100,
+              height: 100,
+              margin: %Plox.Box{top: 0, right: 0, bottom: 0, left: 0},
+              padding: %Plox.Box{top: 0, right: 0, bottom: 0, left: 0}
+            }
+          }
+        }
+      }
   """
 
   defstruct [:original, :graph]
 
+  @doc """
+  Creates a new `Plox.DataPoint` struct.
+
+  Accepts the original data and a map of graphable values for each axis.
+
+  ## Example
+
+      iex> original = %{foo: 1, bar: 2}
+      iex> graph = %{x: 10.0, y: 20.0}
+      iex> Plox.DataPoint.new(original, graph)
+      %Plox.DataPoint{original: %{foo: 1, bar: 2}, graph: %{x: 10.0, y: 20.0}}
+  """
   def new(original, graph) do
     %__MODULE__{original: original, graph: graph}
   end
diff --git a/lib/plox/dataset.ex b/lib/plox/dataset.ex
index e0e7698..b2f6393 100644
--- a/lib/plox/dataset.ex
+++ b/lib/plox/dataset.ex
@@ -47,9 +47,7 @@ defmodule Plox.Dataset do
   the `Plox.DataPoint`s to graphable values.
 
   This module implements the `Access` behaviour, allowing access to each axis
-  using the `[]` syntax.
-
-  ## Example
+  using the `[]` syntax:
 
       iex> dataset = %Plox.Dataset{data: [], axes: %{x: %Plox.XAxis{}, y: %Plox.YAxis{}}}
       iex> dataset[:x]
@@ -62,8 +60,6 @@ defmodule Plox.Dataset do
   Since `Plox.Axis` also implements the `Access` behaviour, you can access
   the graphable values more ergonomically when rendering elements in a graph:
 
-  ## Example
-
       <!-- Draw red circles for every x value, but only at y = 40 on the graph -->
       <.circle cx={@dataset[:x]} cy={@dataset[:y][40]} fill="red" r="3" />
   """
diff --git a/lib/plox/date_scale.ex b/lib/plox/date_scale.ex
index 72c8928..e1334d3 100644
--- a/lib/plox/date_scale.ex
+++ b/lib/plox/date_scale.ex
@@ -6,23 +6,23 @@ defmodule Plox.DateScale do
 
   `Plox.Scale.values/2` returns a `t:Date.Range.t/0` enumerable:
 
-    iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-01], ~D[2020-01-10], 1))
-    iex> scale |> Plox.Scale.values(%{step: 2}) |> Enum.to_list()
-    [~D[2020-01-01], ~D[2020-01-03], ~D[2020-01-05], ~D[2020-01-07], ~D[2020-01-09]]
+      iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-01], ~D[2020-01-10], 1))
+      iex> scale |> Plox.Scale.values(%{step: 2}) |> Enum.to_list()
+      [~D[2020-01-01], ~D[2020-01-03], ~D[2020-01-05], ~D[2020-01-07], ~D[2020-01-09]]
 
-    iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-10], ~D[2020-01-01], -1))
-    iex> scale |> Plox.Scale.values(%{step: 3}) |> Enum.to_list()
-    [~D[2020-01-10], ~D[2020-01-07], ~D[2020-01-04], ~D[2020-01-01]]
+      iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-10], ~D[2020-01-01], -1))
+      iex> scale |> Plox.Scale.values(%{step: 3}) |> Enum.to_list()
+      [~D[2020-01-10], ~D[2020-01-07], ~D[2020-01-04], ~D[2020-01-01]]
 
   `Plox.Scale.convert_to_range/3` returns a number in the given range:
 
-    iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-01], ~D[2020-01-09], 1))
-    iex> Plox.Scale.convert_to_range(scale, ~D[2020-01-05], 0..100)
-    50.0
+      iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-01], ~D[2020-01-09], 1))
+      iex> Plox.Scale.convert_to_range(scale, ~D[2020-01-05], 0..100)
+      50.0
 
-    iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-09], ~D[2020-01-01], -1))
-    iex> Plox.Scale.convert_to_range(scale, ~D[2020-01-07], 0..100)
-    25.0
+      iex> scale = Plox.DateScale.new(Date.range(~D[2020-01-09], ~D[2020-01-01], -1))
+      iex> Plox.Scale.convert_to_range(scale, ~D[2020-01-07], 0..100)
+      25.0
   """
   defstruct [:range]
 
diff --git a/lib/plox/date_time_scale.ex b/lib/plox/date_time_scale.ex
index 336c5d4..5ca70d4 100644
--- a/lib/plox/date_time_scale.ex
+++ b/lib/plox/date_time_scale.ex
@@ -16,9 +16,9 @@ defmodule Plox.DateTimeScale do
 
   `Plox.Scale.convert_to_range/3` returns a number in the given range:
 
-    iex> scale = Plox.DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-03 00:00:00])
-    iex> Plox.Scale.convert_to_range(scale, ~N[2019-01-02 00:00:00], 0..100)
-    50.0
+      iex> scale = Plox.DateTimeScale.new(~N[2019-01-01 00:00:00], ~N[2019-01-03 00:00:00])
+      iex> Plox.Scale.convert_to_range(scale, ~N[2019-01-02 00:00:00], 0..100)
+      50.0
   """
   require Logger
 
diff --git a/lib/plox/linear_axis.ex b/lib/plox/linear_axis.ex
index a173238..7489de6 100644
--- a/lib/plox/linear_axis.ex
+++ b/lib/plox/linear_axis.ex
@@ -4,9 +4,7 @@ defmodule Plox.LinearAxis do
   to graphable values in a linear range between a minimum and maximum.
 
   This module implements the `Access` behaviour, allowing access to graphable
-  values using the `[]` syntax.
-
-  ## Example
+  values using the `[]` syntax:
 
       iex> scale = Plox.NumberScale.new(0, 10)
       iex> linear_axis = %Plox.LinearAxis{scale: scale, min: 0, max: 100}
diff --git a/lib/plox/x_axis.ex b/lib/plox/x_axis.ex
index 6173a9a..2809201 100644
--- a/lib/plox/x_axis.ex
+++ b/lib/plox/x_axis.ex
@@ -4,9 +4,7 @@ defmodule Plox.XAxis do
   to graphable x-coordinates.
 
   This module implements the `Access` behaviour, allowing access to graphable
-  values using the `[]` syntax.
-
-  ## Example
+  values using the `[]` syntax:
 
       iex> scale = Plox.NumberScale.new(0, 10)
       iex> dimensions = Plox.Dimensions.new(100, 100, margin: 0)
diff --git a/lib/plox/y_axis.ex b/lib/plox/y_axis.ex
index 0b965a5..edc00d2 100644
--- a/lib/plox/y_axis.ex
+++ b/lib/plox/y_axis.ex
@@ -5,9 +5,7 @@ defmodule Plox.YAxis do
 
   This module implements the `Access` behaviour, allowing access to graphable
   values using the `[]` syntax. Note that y-coordinates go from top to bottom,
-  meaning that lower y values correspond to higher y-coordinates and vice versa.
-
-  ## Example
+  meaning that lower y values correspond to higher y-coordinates and vice versa:
 
       iex> scale = Plox.NumberScale.new(0, 10)
       iex> dimensions = Plox.Dimensions.new(100, 100, margin: 0)

From c75dd9f49fd123cdbd52dee8f51614344aa790fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Chris=20Dos=C3=A9?= <chris@xn--dos-dma.com>
Date: Wed, 23 Jul 2025 13:43:20 -0700
Subject: [PATCH 21/23] Run CI against more elixir/OTP versions (#22)

* Run CI against more elixir/OTP versions

* Run CI on all pushes and PRs, not just against main

* Remove fancy new guard so we can support older Elixir
---
 .github/workflows/ci.yml       | 131 ++++++++++-----------------------
 lib/plox/fixed_colors_scale.ex |   2 +-
 mix.exs                        |   2 +-
 3 files changed, 42 insertions(+), 93 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f0d596c..61f190f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,52 +1,46 @@
 name: CI
 
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
+on: [push, pull_request]
 
 env:
   MIX_ENV: test
-  OTP_VERSION_SPEC: "27.x"
-  ELIXIR_VERSION_SPEC: "1.18.x"
-
-jobs:
-  compile:
-    name: Compile
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up Elixir
-        uses: erlef/setup-beam@v1
-        with:
-          otp-version: ${{ env.OTP_VERSION_SPEC }}
-          elixir-version: ${{ env.ELIXIR_VERSION_SPEC }}
-      - name: Install dependencies
-        run: mix deps.get
-      - name: Compile dependencies
-        run: mix deps.compile
-      - name: Compile
-        run: mix compile --warnings-as-errors
 
+jobs:        
   test:
     name: Test
     runs-on: ubuntu-latest
 
+    # Test on the 3 latest Elixir versions with the latest OTP version that each supports
+    strategy:
+      matrix:
+        include:
+          - elixir: 1.16.x
+            otp: 26.x
+
+          - elixir: 1.17.x
+            otp: 27.x
+
+          - elixir: 1.18.x
+            otp: 28.x
+            lint: true
+
     steps:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Set up Elixir
         uses: erlef/setup-beam@v1
         with:
-          otp-version: ${{ env.OTP_VERSION_SPEC }}
-          elixir-version: ${{ env.ELIXIR_VERSION_SPEC }}
+          otp-version: ${{ matrix.otp }}
+          elixir-version: ${{ matrix.elixir }}
+      
       - name: Install dependencies
         run: mix deps.get
-      - name: Compile dependencies
-        run: mix deps.compile
+      
+      # We only check for warnings on latest Elixir version
+      - name: Compile & lint
+        run: mix compile --warnings-as-errors
+        if: ${{ matrix.lint }}
+      
       - name: Run tests
         run: mix test
 
@@ -54,73 +48,28 @@ jobs:
     name: Check Formatted
     runs-on: ubuntu-latest
 
+    # Check formatting on the latest Elixir version only
+    strategy:
+      matrix:
+        include:
+          - elixir: 1.18.x
+            otp: 28.x
+
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+
       - name: Set up Elixir
         uses: erlef/setup-beam@v1
         with:
-          otp-version: ${{ env.OTP_VERSION_SPEC }}
-          elixir-version: ${{ env.ELIXIR_VERSION_SPEC }}
+          otp-version: ${{ matrix.otp }}
+          elixir-version: ${{ matrix.elixir }}
+
       - name: Install dependencies
         run: mix deps.get
-      - name: Compile dependencies
-        run: mix deps.compile
-      - name: Check formatted
-        run: mix format --check-formatted
-
-  # credo:
-  #   name: Credo
-  #   runs-on: ubuntu-latest
-
-  #   steps:
-  #     - name: Checkout
-  #       uses: actions/checkout@v4
-  #     - name: Set up Elixir
-  #       uses: erlef/setup-beam@v1
-  #       with:
-  #         otp-version: ${{ env.OTP_VERSION_SPEC }}
-  #         elixir-version: ${{ env.ELIXIR_VERSION_SPEC }}
-  #     - name: Install dependencies
-  #       run: mix deps.get
-  #     - name: Compile dependencies
-  #       run: mix deps.compile
-  #     - name: Run credo
-  #       run: mix credo --strict
-
-  # dialyzer:
-  #   name: Dialyzer
-  #   runs-on: ubuntu-latest
 
-  #   env:
-  #     MIX_ENV: dev
+      - name: Compile
+        run: mix compile
 
-  #   steps:
-  #     - name: Checkout
-  #       uses: actions/checkout@v4
-  #     - name: Set mix file hash
-  #       id: set_vars
-  #       run: |
-  #         mix_hash="${{ hashFiles(format('{0}{1}', github.workspace, '/mix.lock')) }}"
-  #         echo "::set-output name=mix_hash::$mix_hash"
-  #     - name: Cache PLT files
-  #       id: cache-plt
-  #       uses: actions/cache@v4
-  #       with:
-  #         path: |
-  #           _build/dev/*.plt
-  #           _build/dev/*.plt.hash
-  #         key: plt-cache-${{ steps.set_vars.outputs.mix_hash }}
-  #         restore-keys: |
-  #           plt-cache-
-  #     - name: Set up Elixir
-  #       uses: erlef/setup-beam@v1
-  #       with:
-  #         otp-version: ${{ env.OTP_VERSION_SPEC }}
-  #         elixir-version: ${{ env.ELIXIR_VERSION_SPEC }}
-  #     - name: Install dependencies
-  #       run: mix deps.get
-  #     - name: Compile dependencies
-  #       run: mix deps.compile
-  #     - name: Run dialyzer
-  #       run: mix dialyzer
+      - name: Check formatted
+        run: mix format --check-formatted
diff --git a/lib/plox/fixed_colors_scale.ex b/lib/plox/fixed_colors_scale.ex
index 9108237..953d2f5 100644
--- a/lib/plox/fixed_colors_scale.ex
+++ b/lib/plox/fixed_colors_scale.ex
@@ -26,7 +26,7 @@ defmodule Plox.FixedColorsScale do
         mapping: %{red: "#ff0000", green: "#00ff00", blue: "#0000ff"}
       }
   """
-  def new(mapping) when is_non_struct_map(mapping) and map_size(mapping) >= 2 do
+  def new(mapping) when not is_struct(mapping) and map_size(mapping) >= 2 do
     %__MODULE__{mapping: mapping}
   end
 
diff --git a/mix.exs b/mix.exs
index 73b2fee..890786d 100644
--- a/mix.exs
+++ b/mix.exs
@@ -8,7 +8,7 @@ defmodule Plox.MixProject do
     [
       app: :plox,
       version: @version,
-      elixir: "~> 1.18",
+      elixir: "~> 1.16",
       start_permanent: Mix.env() == :prod,
       deps: deps(),
 

From bc62321b57383bad52ec5096318f48e415a124b0 Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Wed, 23 Jul 2025 14:36:55 -0700
Subject: [PATCH 22/23] Update CI to only push to main

---
 .github/workflows/ci.yml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 61f190f..a408c38 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,6 +1,10 @@
 name: CI
 
-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - main
+  pull_request:
 
 env:
   MIX_ENV: test

From 010a6d563ebb799977f791e0052af165c1581e8b Mon Sep 17 00:00:00 2001
From: Nikki Kyllonen <nikki-kyllonen@comcast.net>
Date: Wed, 14 Jan 2026 16:31:57 -0800
Subject: [PATCH 23/23] Small cleanups + Fix incorrect migration guide example

---
 docs/migration_guide.md | 4 ++--
 examples/demo_live.exs  | 2 --
 lib/plox.ex             | 9 ++++-----
 lib/plox/dataset.ex     | 1 -
 4 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/docs/migration_guide.md b/docs/migration_guide.md
index 0d9997b..92debdb 100644
--- a/docs/migration_guide.md
+++ b/docs/migration_guide.md
@@ -48,9 +48,9 @@ example_graph =
     {value}
   </.y_axis>
 
-  <.polyline dataset={graph[:dataset]} color="#EC7E16" />
+  <.line_plot dataset={graph[:dataset]} color="#EC7E16" />
 
-  <.circles dataset={graph[:dataset]} color="#EC7E16" />
+  <.points_plot dataset={graph[:dataset]} color="#EC7E16" />
 </.graph>
 ```
 
diff --git a/examples/demo_live.exs b/examples/demo_live.exs
index 6fc618e..b33448c 100644
--- a/examples/demo_live.exs
+++ b/examples/demo_live.exs
@@ -86,13 +86,11 @@ defmodule DemoLive do
 
       <.y_axis_grid_lines axis={@y_axis} ticks={5} stroke="#D3D3D3" />
 
-      <%!-- <.polyline points={Enum.zip(@dataset[:x], @dataset[:y])} stroke="orange" stroke-width={2} /> --%>
       <.polyline points={points(@dataset[:x], @dataset[:y])} stroke="orange" stroke-width={2} />
 
       <%!-- constant y = 40 --%>
       <.polyline points={points(@dataset[:x], @dataset[:y][40])} stroke="purple" stroke-width="2" />
 
-      <%!-- <.step_polyline dataset={@dataset} x={:x} y={:y} stroke="pink" stroke-width="2" /> --%>
       <.step_polyline points={points(@dataset[:x], @dataset[:y])} stroke="pink" stroke-width="2" />
 
       <%!-- you can manually add points like how the polyline SVG accepts them, but it'll turn them into a step line --%>
diff --git a/lib/plox.ex b/lib/plox.ex
index 460f176..a2b6f8d 100644
--- a/lib/plox.ex
+++ b/lib/plox.ex
@@ -19,7 +19,6 @@ defmodule Plox do
   @doc type: :component
 
   attr :dimensions, Dimensions, required: true
-  # FIXME:
   attr :rest, :global
 
   slot :inner_block, required: true
@@ -27,7 +26,7 @@ defmodule Plox do
   def graph(assigns) do
     ~H"""
     <div {@rest}>
-      <div style={"position: relative; width: #{@dimensions.width}px; height: #{@dimensions.height}px"}>
+      <div style={"width: #{@dimensions.width}px; height: #{@dimensions.height}px"}>
         <svg
           viewBox={"0 0 #{@dimensions.width} #{@dimensions.height}"}
           xmlns="http://www.w3.org/2000/svg"
@@ -158,7 +157,7 @@ defmodule Plox do
   attr :position, :atom, values: [:left, :right], default: :left
   attr :gap, :integer, default: 16
   attr :rotation, :integer, default: nil
-  attr :"dominant-baseline", :any, default: nil
+  attr :"dominant-baseline", :any, default: "middle"
   attr :"text-anchor", :any, default: nil
   attr :rest, :global, include: @svg_presentation_globals
 
@@ -169,7 +168,7 @@ defmodule Plox do
     <text
       x={@axis.dimensions.margin.left - @gap}
       y={y = @axis[@value]}
-      dominant-baseline={assigns[:"dominant-baseline"] || "middle"}
+      dominant-baseline={assigns[:"dominant-baseline"]}
       text-anchor={assigns[:"text-anchor"] || "end"}
       transform={
         if @rotation,
@@ -187,7 +186,7 @@ defmodule Plox do
     <text
       x={@axis.dimensions.width - @axis.dimensions.margin.right + @gap}
       y={y = @axis[@value]}
-      dominant-baseline={assigns[:"dominant-baseline"] || "middle"}
+      dominant-baseline={assigns[:"dominant-baseline"]}
       text-anchor={assigns[:"text-anchor"] || "start"}
       transform={
         if @rotation,
diff --git a/lib/plox/dataset.ex b/lib/plox/dataset.ex
index b2f6393..6859718 100644
--- a/lib/plox/dataset.ex
+++ b/lib/plox/dataset.ex
@@ -14,7 +14,6 @@ defmodule Plox.DatasetAxis do
     raise "Not implemented"
   end
 
-  # TODO: not currently being used, but maybe we can?
   @impl Access
   def get_and_update(_axis, _key, _function) do
     raise "Not implemented"