@howells/hairline 0.0.0-stage → 0.1.0

package/lib/types/charts/basics/rung-geometry.d.ts

@@ -0,0 +1,6 @@
+/** Thickness of one rung: the family's mark, a solid 2px bar on whole pixels. */
+export declare const RUNG = 2;
+/** Whole-pixel pitch for `count` rungs in `room` px, between 4 and `max`. */
+export declare const rungPitch: (room: number, count: number, max?: number) => number;
+/** Top edge of rung `k` (0 = lowest) above a whole-pixel `floor`. */
+export declare const rungY: (floor: number, k: number, pitch: number) => number;

package/lib/types/charts/basics/rung-histogram.d.ts

@@ -0,0 +1,22 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { HistBin } from "./rung-histogram.data.js";
+interface RungHistogramProps extends NoteProps {
+    data?: HistBin[];
+    format?: (v: number) => string;
+    /** Formats bin edges on the axis, e.g. 210 → "3:30". */
+    formatX?: (v: number) => string;
+    height?: number;
+    /** Label every nth bin edge (doubled when bins are under 34px wide). */
+    labelEvery?: number;
+    /** The marker's position; defaults to the median. Pass null to hide it. */
+    marker?: number | null;
+    markerLabel?: string;
+    /** Records per rung. */
+    unit?: number;
+}
+/**
+ * F14 Finish times. Binned counts drawn as stacks of 2px rungs at one pitch, one
+ * per record, every fifth darker; the tallest bin in ink with its count, and an evenly dotted guide where half the records are in.
+ */
+export declare const RungHistogram: (props: RungHistogramProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/basics/rung-histogram.data.d.ts

@@ -0,0 +1,34 @@
+/** One bin: [x0, x1) and how many records fell in it. */
+export interface HistBin {
+    count: number;
+    x0: number;
+    x1: number;
+}
+/**
+ * London Marathon 2016 (24 April 2016): mass-event finishers in five-minute
+ * bins of finish time, 2:30 to 7:00, as a count of runners. Edges are finish
+ * time in minutes, so 180 is 3:00 (the file does not say gun or chip time).
+ *
+ * Source: AndrewMillerOnline/marathon-results (MIT licence), a public GitHub
+ * dataset of marathon results gathered from the race's own results site, file
+ * London/results-2014-2018.csv. No login or token needed.
+ *   https://github.com/AndrewMillerOnline/marathon-results
+ *   https://raw.githubusercontent.com/AndrewMillerOnline/marathon-results/main/London/results-2014-2018.csv
+ * Fetched 2026-10-15.
+ *
+ * Transform: keep rows with year = 2016 (38,983 rows). Drop the 44 elite-field
+ * rows (event=ELIT in details_url) and 79 rows with no valid half and finish
+ * time pair (the finish is blank or not after halfway), leaving 38,860 mass
+ * finishers. Rows for 2015 to 2018 are one field short (no club value), so the
+ * finish time sits in the column headed time_half and the half-way time in the
+ * one headed division; the time_full column is empty on every such row. Each
+ * finish time is floored to whole minutes and counted in [x0, x1) five-minute
+ * bins from 150 to 420 minutes. 72 finishers under 2:30 and 442 at 7:00
+ * or later fall outside the window and are not drawn, so the 54 bins hold
+ * 38,346. Runners tied on place stay as separate records (each has its own id).
+ * Cross-check: https://www.race-insight.com/en/results/london-marathon-2016
+ * (fetched 2026-10-15) lists 38,983 participants, the same as the file's 38,983 rows.
+ */
+export declare const rungHistogramDemo: HistBin[];
+/** Where the cumulative count crosses half, interpolated inside its bin. */
+export declare const binMedian: (bins: readonly HistBin[]) => number;

package/lib/types/charts/basics/rung-waterfall.d.ts

@@ -0,0 +1,19 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { WaterfallDatum } from "./rung-waterfall.data.js";
+interface RungWaterfallProps extends NoteProps {
+    data?: WaterfallDatum[];
+    /** Units per rung. */
+    unit?: number;
+    height?: number;
+    format?: (v: number) => string;
+    /** Index drawn in the hero colour. */
+    highlight?: number;
+}
+/**
+ * F9 Waterfall. Gross to net as floating blocks of 2px rungs at one pitch:
+ * totals stand on the floor, steps float at the running level, deductions are
+ * broken (beaded) rungs. Solid hairline connectors carry the level across;
+ * the closing total is in ink.
+ */
+export declare const RungWaterfall: (props: RungWaterfallProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/basics/rung-waterfall.data.d.ts

@@ -0,0 +1,31 @@
+/** A step adds or removes `value`; a total draws the running level from the floor (its `value` is optional). */
+export interface WaterfallDatum {
+    label: string;
+    total?: boolean;
+    value?: number;
+}
+/**
+ * F9 Where carbon goes. The world's carbon dioxide in an average year of
+ * 2015 to 2024, in billions of tonnes of CO2: what fossil fuels and land use
+ * emit (40.9), what the ocean and plants take back up, and what is left in
+ * the air (20.4), about half.
+ *
+ * Source: Global Carbon Project, Global Carbon Budget 2025 (Friedlingstein et
+ * al., 2025, Earth System Science Data), Global_Carbon_Budget_2025v1.0.xlsx,
+ * sheet "Global Carbon Budget". Freely available; cite the Global Carbon
+ * Budget 2025 (ICOS licence CC BY 4.0).
+ *   https://globalcarbonbudget.org/datahub/the-latest-gcb-data-2025/
+ *   https://doi.org/10.18160/GCP-2025
+ * Fetched 2026-10-16.
+ *
+ * Transform: mean of the ten years 2015 to 2024 for each column, in GtC.
+ * Fossil is "fossil emissions excluding carbonation" less "cement
+ * carbonation sink" (10.012 - 0.210 = 9.802), as the budget's headline
+ * fossil figure is net of carbonation; land use is "land-use change
+ * emissions" (1.372); ocean and plants are "ocean sink" (3.221) and "land
+ * sink" (2.363). Each is multiplied by 3.664 to give GtCO2, as the sheet
+ * directs, and rounded to 0.1 so the totals add up as shown: 35.9, 5.0,
+ * 11.8 and 8.7. The closing total is the level reached, 20.4, as is measured
+ * "atmospheric growth" (20.42); the budget imbalance (0.06) is left out. Scripts: reference/scripts/F9-gcb/sheet.py and budget.py.
+ */
+export declare const rungWaterfallDemo: WaterfallDatum[];

package/lib/types/charts/basics/rungs.d.ts

@@ -0,0 +1,28 @@
+interface RungsProps {
+    /** Class for every `every`th rung, so a stack counts off ("" for none). */
+    accent?: string;
+    /** Accent rhythm in rungs; 5 by default. */
+    every?: number;
+    className: string;
+    /** Pattern fill (`url(#id)`) for the rungs themselves, e.g. a dotted rung. */
+    fill?: string;
+    floor: number;
+    /** Rungs already stacked below this run (stacks and waterfalls). */
+    from?: number;
+    id: string;
+    left: number;
+    n: number;
+    /** Entry-stagger slot of the lowest rung. */
+    order?: number;
+    pitch: number;
+    /** Whole px an accent rung reaches past the run on each side; 0 by default. */
+    reach?: number;
+    width: number;
+}
+/**
+ * A run of `n` countable rungs standing on `floor`, one per unit: solid 2px
+ * bars at one whole-pixel pitch. Every fifth (or `every`th) rung can step
+ * darker, and reach a little wider, like the long marks on a rule.
+ */
+export declare const Rungs: (props: RungsProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/basics/series-key.d.ts

@@ -0,0 +1,19 @@
+/** One key entry: a swatch (pattern fill or solid tone) and its name. */
+export interface KeyItem {
+    /** Pattern fill (`paint(id)`) for a textured swatch. */
+    fill?: string;
+    name: string;
+    /** Fill class for a solid swatch, e.g. "fill-hero". */
+    tone?: string;
+}
+interface SeriesKeyProps {
+    /** Which edge `x` is: the row's left edge (default) or its right edge. */
+    align?: "end" | "start";
+    items: readonly KeyItem[];
+    x: number;
+    /** Baseline of the names; swatches centre on their x-height. */
+    y: number;
+}
+/** A one-row key: 12px swatches, each named in the note voice. */
+export declare const SeriesKey: (props: SeriesKeyProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/basics/stacked-rungs.d.ts

@@ -0,0 +1,20 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { StackDatum } from "./stacked-rungs.data.js";
+interface StackedRungsProps extends NoteProps {
+    data?: StackDatum[];
+    /** Series names, bottom (darkest) first. At most three. */
+    series?: string[];
+    /** Units per rung. */
+    unit?: number;
+    height?: number;
+    format?: (v: number) => string;
+    /** Index of the category whose bottom segment is drawn in the hero colour. */
+    highlight?: number;
+}
+/**
+ * F7 Stacked counts. Each category is one stack of 2px rungs split into up to
+ * three engravings (dark rungs, light rungs, beaded rungs) with a one-rung gap
+ * between segments. The leader's bottom segment is in ink. Segment counts sit beside the stack, the total on top.
+ */
+export declare const StackedRungs: (props: StackedRungsProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/basics/stacked-rungs.data.d.ts

@@ -0,0 +1,26 @@
+/** One category split into up to three parts, bottom part first. */
+export interface StackDatum {
+    label: string;
+    parts: number[];
+}
+/**
+ * F7 Medals by Games. Great Britain's gold, silver and bronze medals at the
+ * last four Summer Olympics. Totals: London 65, Rio 67, Tokyo 64, Paris 65.
+ *
+ * Source: the medal counts in the infobox of the Wikipedia article for each
+ * Games (text available under CC BY-SA 4.0), which cite the IOC and BBC Sport
+ * medal tables.
+ *   https://en.wikipedia.org/wiki/Great_Britain_at_the_2012_Summer_Olympics
+ *   https://en.wikipedia.org/wiki/Great_Britain_at_the_2016_Summer_Olympics
+ *   https://en.wikipedia.org/wiki/Great_Britain_at_the_2020_Summer_Olympics
+ *   https://en.wikipedia.org/wiki/Great_Britain_at_the_2024_Summer_Olympics
+ * Fetched 2026-10-15 (wikitext via action=raw).
+ *
+ * Transform: the gold, silver and bronze fields of each infobox, unchanged.
+ * London 2012 is the count after the later reallocation of a men's high jump
+ * medal (29 gold, 18 silver, 18 bronze; the original count was 17 silver and
+ * 19 bronze, as the article text says). Scripts: reference/scripts/F7/gen.py.
+ */
+export declare const stackedRungsDemo: StackDatum[];
+/** Series names for the demo, bottom (darkest) first. */
+export declare const stackedRungsSeries: string[];

package/lib/types/charts/basics/stream-ribbon.d.ts

@@ -0,0 +1,19 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { StreamData } from "./stream-ribbon.data.js";
+interface StreamRibbonProps extends NoteProps {
+    data?: StreamData;
+    format?: (v: number) => string;
+    height?: number;
+    /** Each date stands for a whole year (dated 1 January): ticks, tooltips and the description say years, not periods. */
+    yearly?: boolean;
+}
+/**
+ * F16 Streamgraph. Composition over continuous time as a wiggle-centred
+ * stream: band width = each series, the river's width = the total. Every
+ * band is engraved on paper inside a 1px rule; today's leader is crosshatched
+ * in ink under a 2px ink top edge. Sized
+ * for a half cell, the river fills the height; the latest total sits at its
+ * mouth.
+ */
+export declare const StreamRibbon: (props: StreamRibbonProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/basics/stream-ribbon.data.d.ts

@@ -0,0 +1,29 @@
+export interface StreamSeries {
+    name: string;
+    values: number[];
+}
+/** Series are listed bottom to top; every series has one value per date. */
+export interface StreamData {
+    dates: Date[];
+    series: StreamSeries[];
+}
+/**
+ * F16 Runs by source. Where the runs came from in the Indian Premier League,
+ * each year from 2008 to 2026: running between the wickets, fours, sixes and
+ * extras, in the first two innings of every match (1243 matches). Sixes
+ * grew from 3,738 runs in 2008 to 8,556 in 2026.
+ *
+ * Source: Cricsheet, Indian Premier League ball-by-ball data, CSV format
+ * (ipl_csv2.zip; Open Data Commons Attribution License v1.0, credit Cricsheet).
+ *   https://cricsheet.org/downloads/
+ *   https://cricsheet.org/downloads/ipl_csv2.zip
+ * Fetched 2026-10-15.
+ *
+ * Transform: for every match file (all_matches.csv, which repeats every match, is skipped), every delivery in innings 1 and 2 (super overs left out),
+ * group by the year of start_date. A delivery with runs_off_bat of 4 or 6 that
+ * is not flagged non_boundary counts its runs to Fours or Sixes; every other
+ * run off the bat counts to Running; the extras column (wides, no-balls, byes,
+ * leg byes, penalties) counts to Extras. Each year is dated 1 January in the
+ * chart, a placeholder for the season. Scripts: reference/scripts/F16/gen.py.
+ */
+export declare const streamRibbonDemo: StreamData;

package/lib/types/charts/basics/tick-box.d.ts

@@ -0,0 +1,19 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { BoxDatum } from "./tick-box.data.js";
+interface TickBoxProps extends NoteProps {
+    data?: BoxDatum[];
+    /** "low" (default) puts the lowest median in ink; "high" the highest. */
+    darkest?: "high" | "low";
+    format?: (v: number) => string;
+    height?: number;
+    /** Axis ticks; defaults to five even steps. */
+    ticks?: number[];
+}
+/**
+ * F15 Box plot. The box is the middle half, diagonal hatch on paper inside a
+ * 1px rule; a 2px rung marks the median, whiskers and caps are
+ * hairlines, outliers are hollow. The lowest median (or highest, with
+ * `darkest`) is crosshatched in ink, its median an ink rung in a paper gutter.
+ */
+export declare const TickBox: (props: TickBoxProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/basics/tick-box.data.d.ts

@@ -0,0 +1,30 @@
+/** A five-number summary plus the points beyond the whiskers. */
+export interface BoxDatum {
+    label: string;
+    max: number;
+    median: number;
+    min: number;
+    outliers?: number[];
+    q1: number;
+    q3: number;
+}
+/**
+ * F15 Sunshine by season. Hours of bright sunshine in each month recorded at
+ * Oxford (Radcliffe Observatory), grouped by season: spring is March to May,
+ * summer June to August, autumn September to November, winter December to
+ * February. 1173 monthly readings, from 1929 to 2026-09.
+ *
+ * Source: Met Office historic station data, Oxford, monthly (Open Government
+ * Licence v3.0). Sunshine comes from a Campbell Stokes recorder, and from an
+ * automatic Kipp & Zonen sensor in later years, as the file's header explains.
+ *   https://www.metoffice.gov.uk/research/climate/maps-and-data/historic-station-data
+ *   https://www.metoffice.gov.uk/pub/data/weather/uk/climate/stationdata/oxforddata.txt
+ * Fetched 2026-10-15.
+ *
+ * Transform: take the "sun" column, drop months marked missing (---), strip the
+ * estimate (*) and sensor (#) marks, and group the months by season. For each
+ * season: quartiles by linear interpolation, the whiskers at the lowest and
+ * highest reading within 1.5 times the interquartile range of the box, and the
+ * readings beyond them listed as outliers. Scripts: reference/scripts/F11/gen.py.
+ */
+export declare const tickBoxDemo: BoxDatum[];

package/lib/types/charts/basics/tick-donut.d.ts

@@ -0,0 +1,24 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { ShareDatum } from "./tick-donut.data.js";
+interface TickDonutProps extends NoteProps {
+    data?: ShareDatum[];
+    height?: number;
+    format?: (v: number) => string;
+    /** Big centre number and the caption under it. Defaults to the total over "total". */
+    center?: {
+        caption: string;
+        value: string;
+    };
+    /** Index of the source to draw in the hero colour. */
+    highlight?: number;
+    /** What the total counts, captioned under it, e.g. "a year". */
+    unit?: string;
+}
+/**
+ * F4 Share ring. A dial of 100 radial 2px rungs, one per percent, read
+ * clockwise from twelve o'clock, every tenth a little longer, inside an
+ * evenly dotted ring. The largest source is in ink, the rest one grey each;
+ * the total sits in the middle, every source named outside the rim.
+ */
+export declare const TickDonut: (props: TickDonutProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/basics/tick-donut.data.d.ts

@@ -0,0 +1,25 @@
+/** One part of a whole. */
+export interface ShareDatum {
+    label: string;
+    value: number;
+}
+/**
+ * F4 Where the bill goes. What the energy price cap allows for in a typical
+ * annual dual fuel bill paid by Direct Debit, 1 October to 31 December 2025:
+ * pounds a year, £1,755 in all.
+ *
+ * Source: Ofgem, "Energy price cap (default tariff) update from 1 October 2025",
+ * letter of 27 August 2025, Annex 1 "Direct Debit Price Cap Cost Breakdown"
+ * (a UK regulator's published letter), cap period 15a, typical domestic consumption
+ * at medium level.
+ *   https://www.ofgem.gov.uk/sites/default/files/2025-08/summary-of-changes-to-energy-price-cap-1-october-to-31-december-2025.pdf
+ * Fetched 2026-10-15.
+ *
+ * Transform: wholesale (including contracts for difference) 720, networks
+ * 396, operating, debt and industry costs 270, policy 215 and VAT 84 are the
+ * October to December column as printed. "Other" adds the earnings before
+ * interest and tax allowance (42), headroom (18) and levelisation
+ * allowance (10): 70. The six parts add to 1755, the printed total.
+ * Scripts: reference/scripts/F4/gen.py.
+ */
+export declare const tickDonutDemo: ShareDatum[];

package/lib/types/charts/basics/tick-gauge.d.ts

@@ -0,0 +1,22 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { TickGaugeDatum } from "./tick-gauge.data.js";
+interface TickGaugeProps extends NoteProps {
+    /** Line under the big number; receives the ticks still to come. Defaults to the amount to come. */
+    caption?: (remaining: number) => string;
+    data?: TickGaugeDatum;
+    /** Formats the raw value and target for the tooltip. */
+    format?: (v: number) => string;
+    height?: number;
+    /** Total sweep of the dial in degrees, centred on 12 o'clock. */
+    sweep?: number;
+    /** How many ticks make the full dial. */
+    ticks?: number;
+}
+/**
+ * F11 Progress dial. Progress toward a target as a dial of 2px rungs, one per
+ * percent: earned rungs in one mid grey, the rung at the current value in
+ * ink, the rest pale, inside an evenly dotted arc.
+ * The big number says it plainly.
+ */
+export declare const TickGauge: (props: TickGaugeProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/basics/tick-gauge.data.d.ts

@@ -0,0 +1,24 @@
+/** Progress toward a target, in any unit. */
+export interface TickGaugeDatum {
+    target: number;
+    value: number;
+}
+/**
+ * F11 Rain so far. Rain recorded at Oxford (Radcliffe Observatory) from January
+ * to September 2026, in millimetres (242.6), against the average annual total
+ * for 1991 to 2020 (681.4). Months from January 2026 are provisional and
+ * many readings are marked as estimates in the file.
+ *
+ * Source: Met Office historic station data, Oxford, monthly (Open Government
+ * Licence v3.0). Station at 51.761 N, 1.262 W, 63 m.
+ *   https://www.metoffice.gov.uk/research/climate/maps-and-data/historic-station-data
+ *   https://www.metoffice.gov.uk/pub/data/weather/uk/climate/stationdata/oxforddata.txt
+ * Fetched 2026-10-15.
+ *
+ * Transform: value = the sum of the "rain" column for the 9 months of 2026 in
+ * the file (January to month 9). target = the mean over 1991 to 2020 of each
+ * year's sum of the 12 monthly "rain" values (all 360 months present), computed
+ * here rather than quoted from a Met Office average. Asterisks marking estimates
+ * are ignored. Scripts: reference/scripts/F11/gen.py.
+ */
+export declare const tickGaugeDemo: TickGaugeDatum;

package/lib/types/charts/basics/tick-rows.d.ts

@@ -0,0 +1,18 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { CountDatum } from "./tick-rows.data.js";
+interface TickRowsProps extends NoteProps {
+    data?: CountDatum[];
+    /** Units per tick. */
+    unit?: number;
+    height?: number;
+    format?: (v: number) => string;
+    /** Index of the row drawn in the hero colour. */
+    highlight?: number;
+}
+/**
+ * F5 Count rows. Each row is a queue of countable 2px rungs at one pitch, one
+ * per unit, bundled in fives with one empty slot between bundles, like a
+ * tally, on a faint track with the count at the end. The leading row is ink.
+ */
+export declare const TickRows: (props: TickRowsProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/basics/tick-rows.data.d.ts

@@ -0,0 +1,23 @@
+/** A labelled count. */
+export interface CountDatum {
+    label: string;
+    value: number;
+}
+/**
+ * F5 Birds counted. Total birds of each species counted in the UK's gardens in
+ * the 2026 Big Garden Birdwatch, the six most seen: the house
+ * sparrow (1,275,378) heads the list, ahead of the blue tit (1,114,620).
+ *
+ * Source: RSPB, Big Garden Birdwatch results page and its data file
+ * bgbw_results_2022_2026_en.json (version 2026-03-12), UK leaderboard for 2026.
+ *   https://www.rspb.org.uk/whats-happening/big-garden-birdwatch/results
+ *   https://base-prod.rspb-prod.magnolia-platform.com/dam/jcr:a3238936-23e0-4b99-a88a-6838d0f0c9b2/bgbw_results_2022_2026_en.json
+ * Fetched 2026-10-15. The RSPB states no reuse licence on the page; the counts
+ * are published facts and are credited here.
+ *
+ * Transform: the first six species of years[2026].countries["UK"].species, in
+ * the order given (already by count, largest first), with the first letter of
+ * each name capitalised and the rest lower case. Counts are as published.
+ * Scripts: reference/scripts/F5/gen.py.
+ */
+export declare const tickRowsDemo: CountDatum[];

package/lib/types/charts/basics/util-a.d.ts

@@ -0,0 +1,10 @@
+import type { FontMetrics } from "../../schema/metrics.js";
+/** Saturday or Sunday, in UTC. */
+export declare const isWeekend: (d: Date) => boolean;
+export declare const fmtMonthDay: (d: Date) => string;
+/** UTC midnight `n` days after `start` (ISO date string). */
+export declare const dayAfter: (start: string, n: number) => Date;
+/** Room a right-hand value scale needs past the last datum, in px. */
+export declare const VALUE_AXIS_ROOM = 48;
+/** The baseline of a daily chart: above the axis labels and any wrapped note. */
+export declare const dailyFloor: (height: number, note: string | undefined, width: number, metrics?: FontMetrics) => number;

package/lib/types/charts/basics/util-b.d.ts

@@ -0,0 +1,13 @@
+import type { FontMetrics } from "../../schema/metrics.js";
+/** Point on a circle, angle in radians measured clockwise from 12 o'clock. */
+export declare const polar: (cx: number, cy: number, r: number, a: number) => {
+    x: number;
+    y: number;
+};
+/** Index of the largest value (first one wins ties). */
+export declare const maxIndex: (values: readonly number[]) => number;
+/**
+ * Ink width of a string in the 11px sans roles, for centring a composition:
+ * digits are tabular (0.65em), the rest is `sansWidth` less its safety margin.
+ */
+export declare const inkWidth: (text: string, metrics?: FontMetrics) => number;

package/lib/types/charts/big/circular-graph.d.ts

@@ -0,0 +1,20 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { RingData } from "./circular-graph.data.js";
+interface CircularGraphProps extends NoteProps {
+    data?: RingData;
+    format?: (v: number) => string;
+    height?: number;
+    /** Node id(s) labelled at rest; defaults to the two largest of each group. */
+    highlight?: string | string[];
+    /** Word after the neighbour count in the tooltip, e.g. "borders shown". */
+    linkUnit?: string;
+    /** Unit after a node's size in the tooltip. */
+    sizeUnit?: string;
+}
+/**
+ * B1 Land borders (big). Countries sit on a ring grouped by continent, dot area =
+ * land neighbours; links curve inside the ring like chords. Hover a node to light up its
+ * neighbours; click anywhere to replay the entry.
+ */
+export declare const CircularGraph: (props: CircularGraphProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/big/circular-graph.data.d.ts

@@ -0,0 +1,46 @@
+/**
+ * B1 Land borders: the countries with five or more land neighbours, round a
+ * ring by continent, linked by the length of border they share.
+ * Source: CIA, The World Factbook, country profiles, Geography, "Land
+ * boundaries: border countries" (public domain). The CIA took the Factbook
+ * offline in February 2026; the profiles were fetched on 2026-10-15 from the
+ * factbook.json mirror, https://github.com/factbook/factbook.json (one JSON
+ * file per country, a verbatim copy of the profile text), 252 files.
+ * Transform: each "Name 1,234 km" entry in a profile's border list is one
+ * reported length; entries for the same neighbour are summed (China-Russia is
+ * 4,133 + 46 km). Territories and dependencies are left out (French Guiana,
+ * Gaza Strip, West Bank, Gibraltar, Hong Kong, Macau, Western Sahara, Saint
+ * Martin, Sint Maarten, the Guantanamo Bay base, Akrotiri and Dhekelia,
+ * Greenland); so is the European Union's profile. Where both countries report
+ * the border and differ (Israel-Jordan 327 and 307, Germany-Poland 447 and
+ * 467, Mexico-United States 3,155 and 3,111) the larger is kept; one pair is
+ * reported by one side only (Denmark's profile lists Canada, 1.3 km, a pair
+ * outside the countries shown). 156
+ * countries have a land border; the 57 with five or more neighbours are
+ * shown, with 105 borders among them. A node's size is its number of land
+ * neighbours counting the countries not shown. Continent is assigned by hand
+ * (Russia in Europe; Turkey, Azerbaijan and Kazakhstan in Asia; the Middle
+ * East, Central, South and East Asia together as Asia).
+ * Names are the Factbook's short forms; the Central African Republic's is
+ * missing there and is written out, and "Cote d'Ivoire" takes its accent.
+ */
+export interface RingNode {
+    /** Group the node belongs to; groups sit together on the ring. */
+    group: string;
+    /** Unique id, also the label, e.g. "Germany". */
+    id: string;
+    /** Size measure (land neighbours); drives the dot area. */
+    size: number;
+}
+export interface RingLink {
+    source: string;
+    target: string;
+    /** Length of the border the two countries share, in km. */
+    weight: number;
+}
+export interface RingData {
+    links: RingLink[];
+    nodes: RingNode[];
+}
+/** The 57 countries with five or more land neighbours; a link is the length of border they share. */
+export declare const circularGraphDemo: RingData;