import { VisQuill, Attach, Animate, EasingFunctions, Svg, Reactive, Circles, Rectangles } from "@visquill/visquill-gdk";
import { categories, points } from "./data";
import "./styles.css";

// Part 7: animated bar heights.
export function run(div: HTMLDivElement) {
  const rvg = VisQuill.create(div, "lens-");
  const canvas = rvg.canvas;
  canvas.handles.defaultZIndex = 1;

  const dots = canvas.layer();
  for (const p of points) {
    dots.visuals.point(`dot ${categories[p.category]}`, p);
  }

  const handle = canvas.handles.disk("handle", { x: 280, y: 170 });

  const cover = canvas.layer();
  cover.visuals.box("shade", [-2000, -2000], [3000, 3000]);
  cover.mask.box("white", [-2000, -2000], [3000, 3000]);

  const lens = canvas.layer();
  Attach.pointToPoint(lens.anchor, handle);
  const radius = lens.values.real(70);
  const ring = lens.visuals.circle("ring");
  Attach.circleRadiusToValue(ring, radius);

  const hole = cover.mask.circle("black");
  Reactive.do([handle, radius], () => {
    Circles.circleAt(handle, radius, hole);
  }, true);

  const counts = categories.map(() => lens.values.real(0));
  Reactive.do([handle, radius], () => {
    const tally = categories.map(() => 0);
    for (const p of points) {
      const distance = Math.hypot(p.x - handle.x, p.y - handle.y);
      if (distance < radius.value) tally[p.category] += 1;
    }
    tally.forEach((n, i) => (counts[i].value = n));
  }, true);

  // The baseline of the bars: a polyline with one segment per category,
  // placed along the top of the ring, slightly outside.
  const baseline = lens.visuals.polyline("baseline", categories.length + 1);
  Attach.polylineToCircle(baseline, ring, Math.PI / 2, { angle: -Math.PI / 2, distance: 4 });

  // The heights follow their target values with a short animation.
  const heights = categories.map(() => lens.values.real(0));
  Reactive.do(counts, () => {
    const total = Math.max(1, counts.reduce((sum, count) => sum + count.value, 0));
    counts.forEach((count, i) => Animate.real.follow(heights[i], (count.value / total) * 60));
  }, true);

  // Each bar is placed on its segment of the baseline, with a gap of 2 px at both ends.
  categories.forEach((category, i) => {
    const bar = lens.visuals.rectangle(`bar ${category}`);
    Reactive.do([baseline, heights[i]], () => {
      Rectangles.alongPaddedSegment(baseline.at(i), baseline.at(i + 1), heights[i], true, 0, 2, 2, bar);
    }, true);
  });

  const sizes = [70, 100, 50];
  let next = 0;
  Svg.get(ring).addEventListener("click", () => {
    next = (next + 1) % sizes.length;
    Animate.real.eased(radius, sizes[next], 600, { easing: EasingFunctions.easeOutCubic });
  });
}
// The data the lens explores: 240 points in four categories. Each category
// is distributed around its own center, so the mix differs across the canvas.
// The random numbers are seeded, so the points are the same on every load.

export const categories = ["red", "green", "blue", "orange"];

// A second property, used in part 9: each point also has a shape.
export const shapes = ["circle", "square", "triangle", "diamond"];

export interface DataPoint {
  x: number;
  y: number;
  category: number; // index into categories
  shape: number;    // index into shapes
}

const centers = [
  { x: 170, y: 120 },
  { x: 390, y: 110 },
  { x: 210, y: 250 },
  { x: 400, y: 240 },
];

export const points: DataPoint[] = [];

const random = seededRandom(7);
centers.forEach((center, category) => {
  for (let i = 0; i < 60; i++) {
    // Normally distributed around the center (Box–Muller), kept on the canvas.
    const length = 65 * Math.sqrt(-2 * Math.log(1 - random()));
    const angle = 2 * Math.PI * random();
    points.push({
      x: clamp(center.x + length * Math.cos(angle), 12, 548),
      y: clamp(center.y + length * Math.sin(angle), 12, 328),
      category,
      shape: 0,
    });
  }
});

// Each shape is most frequent near one corner.
const corners = [
  { x: 0, y: 0 },
  { x: 560, y: 0 },
  { x: 0, y: 340 },
  { x: 560, y: 340 },
];
const randomShape = seededRandom(11);
for (const p of points) {
  const weights = corners.map((c) => Math.exp(-((p.x - c.x) ** 2 + (p.y - c.y) ** 2) / 90000));
  let pick = randomShape() * weights.reduce((sum, w) => sum + w, 0);
  p.shape = weights.findIndex((w) => (pick -= w) < 0);
  if (p.shape < 0) p.shape = weights.length - 1;
}

function clamp(value: number, min: number, max: number): number {
  return Math.min(max, Math.max(min, value));
}

// A small seeded generator (mulberry32): the same seed gives the same numbers.
function seededRandom(seed: number): () => number {
  return () => {
    seed = (seed + 0x6d2b79f5) | 0;
    let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}
/* Each class is the prefix "lens-" plus the name used in demo.ts. */

/* Data points: one class for all dots, one per category. */
.lens-dot { r: 4px; }
.lens-red    { fill: #c0503f; }
.lens-green  { fill: #3f7a5b; }
.lens-blue   { fill: #3d6fa8; }
.lens-orange { fill: #d8913a; }

/* The handle is transparent and about as large as the lens. */
.lens-handle {
  r: 45px;
  fill: transparent;
  cursor: grab;
}
.lens-handle:active { cursor: grabbing; }

.lens-ring {
  fill: none;
  stroke: #1c1a17;
  stroke-width: 2px;
  pointer-events: stroke;
  cursor: pointer;
}

/* The cover darkens the canvas outside the lens. */
.lens-shade { fill: rgb(28 26 23 / 0.55); }

.lens-readout {
  fill: #1c1a17;
  font: 500 14px "JetBrains Mono", ui-monospace, monospace;
  dominant-baseline: hanging;
}

.lens-baseline { fill: none; stroke: none; }

.lens-bar { stroke: #faf6ef; stroke-width: 1.5px; }

.lens-value {
  fill: #faf6ef;
  font: 600 12px "JetBrains Mono", ui-monospace, monospace;
  text-anchor: middle;
  dominant-baseline: middle;
}

/* Part 9: bars of the shape chart; the label shows the shape. */
.lens-shape { fill: #e7decb; }

Build a data lens · Part 7 of 9

Animate the bars

The bar heights change gradually instead of jumping to the new value.

01

Following the target

Instead of assigning the height, Animate.real.follow(height, target) moves it towards the target value over a short time. If the target changes during the animation, the animation continues towards the new target. The rest of the code is unchanged.