enarratio-astro 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to enarratio-astro are recorded here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project uses
+[Semantic Versioning](https://semver.org/). Before 1.0.0, a minor version may change the options;
+every such change is listed here.
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-24
+
+### Added
+
+- `<Chart>`: bar, line, stacked area, scatter and heatmap charts drawn on the server by Enarratio
+  0.3.1, from rows or from CSV, semicolon- or tab-separated text, with a required description, a
+  data table, and light and dark themes. The chart CSS is written once per page.
+- Charts in Markdown: `chart` code blocks, with `satteriCharts()` for Sätteri and `remarkCharts`
+  for remark.
+- `<Enhance />` and the `interactive` option: Enarratio's enhancement script, only on pages that
+  ask for it.
+- `styles`: `"theme"` (default), `"base"` for sites whose tokens define the colors, or `"none"`.
+- A note in place of a chart that cannot be drawn, saying why.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dustin Edwards
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,151 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# enarratio-astro
+
+**Accessible charts for [Astro](https://astro.build): a `<Chart>` component and charts in Markdown,
+drawn on the server by [Enarratio](https://github.com/DrDustinEdwards/enarratio).**
+
+A chart arrives in the page as HTML and SVG: complete before any script runs, readable by screen
+readers and search engines, with a data table, and in light and dark. It draws bar (stacked, side
+by side, vertical or horizontal; counting rows when no value column is given), line, stacked area,
+scatter (with an optional regression line and 95% band) and heatmap charts. A chart can be made
+interactive (hover and focus details, keyboard navigation, click-to-filter) with Enarratio's small
+enhancement script, which is added only to pages that ask for it.
+
+Supports Astro 6 or later. Status: 0.x, so options may change before 1.0; every change is in the
+[changelog](https://github.com/DrDustinEdwards/astro/blob/main/packages/enarratio-astro/CHANGELOG.md). For EmDash sites,
+[enarratio-emdash](https://github.com/DrDustinEdwards/astro/tree/main/packages/enarratio-emdash#readme) adds the same charts as a block
+in the editor.
+
+## Install
+
+```sh
+npm install enarratio-astro
+```
+
+## In a page
+
+```astro
+---
+import Chart from "enarratio-astro/Chart.astro";
+
+const downloads = [
+  { year: 2024, package: "Core", downloads: 4100 },
+  { year: 2025, package: "Core", downloads: 5300 },
+  { year: 2026, package: "Core", downloads: 6100 },
+  { year: 2024, package: "Plugin", downloads: 1200 },
+  { year: 2025, package: "Plugin", downloads: 1900 },
+  { year: 2026, package: "Plugin", downloads: 2800 },
+];
+---
+<Chart
+  type="line"
+  data={downloads}
+  x="year"
+  y="downloads"
+  series="package"
+  title="Downloads per year"
+  alt="Downloads per year, 2024 to 2026: the core grows from 4,100 to 6,100, the plugin from 1,200 to 2,800."
+  interactive
+/>
+```
+
+`data` is rows as objects (from code, JSON or a content collection; dates become ISO dates) or
+text: CSV, semicolon-separated, or pasted from a spreadsheet (tab-separated), first row naming the
+columns. The chart CSS is written once per page, however many charts it has.
+
+## In Markdown
+
+A code block whose language is `chart` becomes a chart: options, a line of three dashes, then the
+data.
+
+~~~md
+```chart
+type: bar
+x: team
+y: tickets
+series: status
+layout: grouped
+alt: Support has the most open tickets; Platform has closed the most.
+---
+team,status,tickets
+Support,Open,14
+Support,Closed,22
+Platform,Open,5
+Platform,Closed,31
+```
+~~~
+
+Register the plugin for Astro's Markdown processor. Astro 7's default, Sätteri:
+
+```js
+// astro.config.mjs
+import { satteri } from "@astrojs/markdown-satteri";
+import { satteriCharts } from "enarratio-astro/markdown";
+
+export default defineConfig({
+  markdown: { processor: satteri({ mdastPlugins: [satteriCharts()] }) },
+});
+```
+
+With remark (Astro 6, or Astro 7's unified processor):
+
+```js
+import { remarkCharts } from "enarratio-astro/markdown";
+
+export default defineConfig({ markdown: { remarkPlugins: [remarkCharts] } });
+```
+
+A Markdown chart with `interactive: true` is marked for the enhancement script; include it once in
+the page's layout with `<Enhance />` from `enarratio-astro/Enhance.astro`. It finds every
+interactive chart on the page and works with view transitions.
+
+## Options
+
+The component's props and a Markdown block's keys are the same:
+
+| Option | Used by | Notes |
+|---|---|---|
+| `type` | all | `bar` (default), `line`, `area` (stacked), `scatter` or `heatmap`. |
+| `data` | all | The data (component only; in Markdown it follows the dashes). Up to 5000 rows and 50 columns. |
+| `alt` | all | **Required.** What the chart shows and finds, in a sentence. It names the chart for screen readers. |
+| `title`, `caption` | all | Optional. The caption is for source, method or caveats. |
+| `x` | all | The column along the x axis. Column names match without regard to case. ISO dates make a time axis in line and area charts. |
+| `y` | all | The value column. Bar charts count rows when it is missing. For a heatmap, the row column. |
+| `series` | bar, line, area, scatter | Splits rows into series, told apart by color and by legend, labels or symbols. |
+| `value` | heatmap | The cell value column. |
+| `xLabel`, `yLabel` | all | Axis labels. |
+| `layout` | bar | `stacked` (default) or `grouped`. |
+| `orientation` | bar | `vertical` (default) or `horizontal`. |
+| `scale` | line, scatter | `linear` (default) or `log`. |
+| `regression` | scatter | A least-squares line with its 95% band. |
+| `dataTable` | all | `details` (default; behind a "Data table" toggle) or `visually-hidden` (screen readers only). |
+| `id` | all | The figure's id. |
+| `interactive` | all | Adds the enhancement script. Off by default, so pages stay script-free. |
+
+A chart that cannot be drawn (a column that is not in the data, text in a number column, a missing
+`alt`) is replaced by a short note saying why, and the reason is logged, so one mistake never
+breaks the page. All text is escaped.
+
+## Styles
+
+The component takes `styles`, `theme` and `stylesheetOptions`; the Markdown plugins take the same
+as options (`satteriCharts({ styles: "base" })`).
+
+- `styles: "theme"` (default): an Enarratio theme (`theme`, default Enarratio's own), in light and
+  dark. Charts follow the page's `color-scheme`; for a site that switches with an attribute, pass
+  `stylesheetOptions={{ colorScheme: { dark: '[data-theme="dark"]' } }}`.
+- `styles: "base"`: layout rules without colors or fonts, for a site whose own design tokens define
+  the `--enarratio-*` properties. [Capsomer](https://github.com/DrDustinEdwards/capsomer)'s tokens do.
+- `styles: "none"`: nothing; the site includes Enarratio's stylesheet itself.
+
+Enarratio's [README](https://github.com/DrDustinEdwards/enarratio#themes) covers themes and the
+custom properties.
+
+## Rendering cost
+
+Bar, line and area charts are drawn by `enarratio/lite`, which builds the SVG as a string with no
+DOM, the cheapest render on Cloudflare Workers. Scatter plots and heatmaps load `enarratio/plot`
+(Observable Plot and linkedom) only when a page has one.
+
+## License
+
+[MIT](LICENSE). Copyright (c) 2026 Dustin Edwards.

package/dist/chart.d.ts

@@ -0,0 +1,59 @@
+/** The chart types a {@link ChartSpec} can draw. */
+export declare const CHART_TYPES: readonly ["bar", "line", "area", "scatter", "heatmap"];
+export type ChartType = (typeof CHART_TYPES)[number];
+/**
+ * One chart, as an author writes it: in a component's props, a Markdown `chart` block, or an
+ * EmDash Chart block. Every field is checked when the chart is drawn, so a spec can come from
+ * content as easily as from code.
+ */
+export interface ChartSpec {
+    /** Bar (default), line, area (stacked), scatter or heatmap. */
+    readonly type?: string | undefined;
+    /**
+     * The data: CSV, semicolon- or tab-separated text whose first row names the columns, or rows
+     * as objects (from JSON or a content collection) whose values are numbers, text, dates or empty.
+     */
+    readonly data: string | readonly Readonly<Record<string, unknown>>[];
+    /** Required: what the chart shows and finds, in a sentence. Names the chart for screen readers. */
+    readonly alt?: string | undefined;
+    readonly title?: string | undefined;
+    /** Source, method or caveats, below the chart. */
+    readonly caption?: string | undefined;
+    /** The column along the x axis. Column names match without regard to case. */
+    readonly x?: string | undefined;
+    /** The value column. Bar charts count rows without one; for a heatmap, the row column. */
+    readonly y?: string | undefined;
+    /** A column that splits rows into series. */
+    readonly series?: string | undefined;
+    /** Heatmap: the cell value column. */
+    readonly value?: string | undefined;
+    readonly xLabel?: string | undefined;
+    readonly yLabel?: string | undefined;
+    /** Bar: series stacked (default) or side by side ("grouped"). */
+    readonly layout?: string | undefined;
+    /** Bar: "vertical" (default) or "horizontal". */
+    readonly orientation?: string | undefined;
+    /** Line and scatter: "linear" (default) or "log" y axis. */
+    readonly scale?: string | undefined;
+    /** Scatter: a least-squares line with its 95% band. */
+    readonly regression?: boolean | undefined;
+    /** "details" (default): the data table behind a toggle; "visually-hidden": for screen readers only. */
+    readonly dataTable?: string | undefined;
+    /** The figure's id, reported as `chartId` in the enhancement layer's events. */
+    readonly id?: string | undefined;
+}
+/** A drawn chart's HTML, or why it could not be drawn, in words an author can act on. */
+export type ChartResult = {
+    readonly ok: true;
+    readonly html: string;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/**
+ * Draws a chart. Bar, line and area charts come from `enarratio/lite`, which builds the SVG as a
+ * string with no DOM, the cheapest render on a Worker; scatter plots and heatmaps load
+ * `enarratio/plot` (Observable Plot and linkedom) only when a page has one. Never throws: a chart
+ * that cannot be drawn returns the reason instead, so one mistake cannot break a page.
+ */
+export declare function renderChart(spec: ChartSpec): Promise<ChartResult>;

package/dist/chart.js

@@ -0,0 +1,116 @@
+import { areaChart, barChart, lineChart } from "enarratio/lite";
+import { column, parseTable, tableFromRows } from "./data.js";
+/** The chart types a {@link ChartSpec} can draw. */
+export const CHART_TYPES = ["bar", "line", "area", "scatter", "heatmap"];
+function text(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+/** Copies the rows with one column's numbers turned into text, for fields Enarratio reads as names. */
+function asNames(table, name) {
+    return table.rows.map((row) => {
+        const copy = Object.assign(Object.create(null), row);
+        const v = copy[name];
+        if (typeof v === "number")
+            copy[name] = String(v);
+        return copy;
+    });
+}
+/** Checks that a column holds only numbers and empty cells. */
+function numeric(table, name) {
+    const bad = table.rows.find((row) => typeof row[name] === "string");
+    if (bad)
+        throw new Error(`The column "${name}" should hold numbers, but has "${bad[name]}".`);
+}
+/** The options every chart type shares: text, the data table and the id. */
+function figure(spec) {
+    const alt = text(spec.alt);
+    if (!alt)
+        throw new Error("Add a description (alt): one sentence on what the chart shows.");
+    const title = text(spec.title);
+    const caption = text(spec.caption);
+    const xLabel = text(spec.xLabel);
+    const yLabel = text(spec.yLabel);
+    const id = text(spec.id)?.replace(/[^A-Za-z0-9_-]/g, "");
+    return {
+        alt,
+        ...(title ? { title } : {}),
+        ...(caption ? { caption } : {}),
+        ...(xLabel ? { xLabel } : {}),
+        ...(yLabel ? { yLabel } : {}),
+        ...(id ? { id } : {}),
+        dataTable: spec.dataTable === "visually-hidden" ? "visually-hidden" : "details",
+    };
+}
+async function draw(spec) {
+    const type = (text(spec.type) ?? "bar").toLowerCase();
+    if (!CHART_TYPES.includes(type)) {
+        throw new Error(`There is no chart type "${spec.type}". Use one of: ${CHART_TYPES.join(", ")}.`);
+    }
+    const common = figure(spec);
+    const table = typeof spec.data === "string" ? parseTable(spec.data) : tableFromRows(spec.data);
+    const x = column(table, spec.x, "x axis");
+    const seriesName = text(spec.series) ? column(table, spec.series, "series") : undefined;
+    const data = seriesName ? asNames(table, seriesName) : [...table.rows];
+    const series = seriesName ? { series: seriesName } : {};
+    const log = spec.scale === "log" ? { yType: "log" } : {};
+    switch (type) {
+        case "bar": {
+            const y = text(spec.y) ? column(table, spec.y, "values") : undefined;
+            if (y)
+                numeric(table, y);
+            return barChart({
+                ...common,
+                data,
+                x,
+                ...(y ? { y } : {}),
+                ...series,
+                layout: spec.layout === "grouped" ? "grouped" : "stacked",
+                orientation: spec.orientation === "horizontal" ? "horizontal" : "vertical",
+            });
+        }
+        case "line":
+        case "area": {
+            const y = column(table, spec.y, "values");
+            numeric(table, y);
+            const options = { ...common, data, x, y, ...series };
+            return type === "line" ? lineChart({ ...options, ...log }) : areaChart(options);
+        }
+        case "scatter": {
+            const y = column(table, spec.y, "values");
+            numeric(table, x);
+            numeric(table, y);
+            const { scatterPlot } = await import("enarratio/plot");
+            return scatterPlot({
+                ...common,
+                data,
+                x,
+                y,
+                ...series,
+                ...log,
+                regression: spec.regression === true,
+            });
+        }
+        case "heatmap": {
+            const y = column(table, spec.y, "rows");
+            const value = column(table, spec.value, "cell values");
+            numeric(table, value);
+            const { heatmap } = await import("enarratio/plot");
+            return heatmap({ ...common, data, x, y, value });
+        }
+    }
+}
+/**
+ * Draws a chart. Bar, line and area charts come from `enarratio/lite`, which builds the SVG as a
+ * string with no DOM, the cheapest render on a Worker; scatter plots and heatmaps load
+ * `enarratio/plot` (Observable Plot and linkedom) only when a page has one. Never throws: a chart
+ * that cannot be drawn returns the reason instead, so one mistake cannot break a page.
+ */
+export async function renderChart(spec) {
+    try {
+        return { ok: true, html: await draw(spec) };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/data.d.ts

@@ -0,0 +1,22 @@
+/** A cell after parsing: a number, text, or `null` for an empty cell. */
+export type Cell = number | string | null;
+/** A table parsed from the block's data field. */
+export interface Table {
+    readonly columns: readonly string[];
+    readonly rows: ReadonlyArray<Readonly<Record<string, Cell>>>;
+}
+/** Limits that keep one chart's render bounded, whatever an editor pastes. */
+export declare const MAX_ROWS = 5000;
+export declare const MAX_COLUMNS = 50;
+/**
+ * Parses the data an editor pasted or typed: CSV, semicolon-separated or tab-separated text
+ * whose first row names the columns. Throws an Error whose message an editor can act on.
+ */
+export declare function parseTable(text: string): Table;
+/**
+ * The column an editor named, matched without regard to case or surrounding space. Throws when
+ * there is none, listing the columns there are.
+ */
+export declare function column(table: Table, name: string | undefined, role: string): string;
+/** Reads rows given as objects (from JSON or a content collection) into a table. */
+export declare function tableFromRows(input: readonly Readonly<Record<string, unknown>>[]): Table;

package/dist/data.js

@@ -0,0 +1,161 @@
+/** Limits that keep one chart's render bounded, whatever an editor pastes. */
+export const MAX_ROWS = 5000;
+export const MAX_COLUMNS = 50;
+const NUMBER = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
+const GROUPED_NUMBER = /^[+-]?\d{1,3}(?:,\d{3})+(?:\.\d+)?$/;
+/** Reads a cell: numbers (including "1,234") become numbers, an empty cell `null`, the rest text. */
+function cell(raw) {
+    const text = raw.trim();
+    if (text === "")
+        return null;
+    if (NUMBER.test(text))
+        return Number(text);
+    if (GROUPED_NUMBER.test(text))
+        return Number(text.replaceAll(",", ""));
+    return text;
+}
+/**
+ * The delimiter of pasted data: a tab when the header row has one (a spreadsheet paste),
+ * otherwise whichever of comma and semicolon appears more often outside quotes in that row.
+ */
+function delimiter(text) {
+    const header = text.slice(0, text.search(/\r?\n|$/));
+    if (header.includes("\t"))
+        return "\t";
+    const unquoted = header.replace(/"[^"]*"/g, "");
+    const count = (c) => unquoted.split(c).length - 1;
+    return count(";") > count(",") ? ";" : ",";
+}
+/** Splits delimited text into records, following RFC 4180 quoting ("" is a literal quote). */
+function records(text, sep) {
+    const out = [];
+    let record = [];
+    let field = "";
+    let quoted = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quoted) {
+            if (c === '"' && text[i + 1] === '"') {
+                field += '"';
+                i++;
+            }
+            else if (c === '"') {
+                quoted = false;
+            }
+            else {
+                field += c;
+            }
+        }
+        else if (c === '"' && field.trim() === "") {
+            quoted = true;
+            field = "";
+        }
+        else if (c === sep) {
+            record.push(field);
+            field = "";
+        }
+        else if (c === "\n" || c === "\r") {
+            if (c === "\r" && text[i + 1] === "\n")
+                i++;
+            record.push(field);
+            out.push(record);
+            record = [];
+            field = "";
+        }
+        else {
+            field += c;
+        }
+    }
+    if (quoted)
+        throw new Error("The data has a quote that is never closed.");
+    record.push(field);
+    out.push(record);
+    return out.filter((r) => r.some((f) => f.trim() !== ""));
+}
+/**
+ * Parses the data an editor pasted or typed: CSV, semicolon-separated or tab-separated text
+ * whose first row names the columns. Throws an Error whose message an editor can act on.
+ */
+export function parseTable(text) {
+    const all = records(text, delimiter(text));
+    const [header, ...body] = all;
+    if (!header || body.length === 0) {
+        throw new Error("Add data: a first row naming the columns, then at least one row of values.");
+    }
+    const columns = header.map((name) => name.trim());
+    if (columns.length > MAX_COLUMNS)
+        throw new Error(`The data has more than ${MAX_COLUMNS} columns.`);
+    if (body.length > MAX_ROWS)
+        throw new Error(`The data has more than ${MAX_ROWS} rows.`);
+    const seen = new Set();
+    for (const name of columns) {
+        if (name === "")
+            throw new Error("Every column in the first row needs a name.");
+        const key = name.toLowerCase();
+        if (seen.has(key))
+            throw new Error(`Two columns are named "${name}".`);
+        seen.add(key);
+    }
+    const rows = body.map((record, n) => {
+        if (record.slice(columns.length).some((f) => f.trim() !== "")) {
+            throw new Error(`Row ${n + 2} has more values than there are columns.`);
+        }
+        // No prototype, so a column named "__proto__" is an ordinary field.
+        const row = Object.create(null);
+        columns.forEach((name, i) => {
+            row[name] = cell(record[i] ?? "");
+        });
+        return row;
+    });
+    return { columns, rows };
+}
+/**
+ * The column an editor named, matched without regard to case or surrounding space. Throws when
+ * there is none, listing the columns there are.
+ */
+export function column(table, name, role) {
+    const wanted = name?.trim().toLowerCase() ?? "";
+    if (wanted === "")
+        throw new Error(`Name the ${role} column.`);
+    const found = table.columns.find((c) => c.toLowerCase() === wanted);
+    if (!found) {
+        throw new Error(`There is no column "${name?.trim()}" for the ${role}. The columns are: ${table.columns.join(", ")}.`);
+    }
+    return found;
+}
+/** Reads one value from a row given as an object: dates as ISO text, true and false as text. */
+function value(raw) {
+    if (raw === null || raw === undefined || raw === "")
+        return null;
+    if (typeof raw === "number")
+        return Number.isFinite(raw) ? raw : null;
+    if (typeof raw === "string")
+        return raw;
+    if (raw instanceof Date)
+        return raw.toISOString();
+    if (typeof raw === "boolean")
+        return String(raw);
+    throw new Error(`A value in the data is ${Array.isArray(raw) ? "a list" : "an object"}; use numbers or text.`);
+}
+/** Reads rows given as objects (from JSON or a content collection) into a table. */
+export function tableFromRows(input) {
+    if (input.length === 0)
+        throw new Error("Add data: at least one row.");
+    if (input.length > MAX_ROWS)
+        throw new Error(`The data has more than ${MAX_ROWS} rows.`);
+    const columns = [];
+    for (const row of input) {
+        for (const key of Object.keys(row))
+            if (!columns.includes(key))
+                columns.push(key);
+    }
+    if (columns.length > MAX_COLUMNS)
+        throw new Error(`The data has more than ${MAX_COLUMNS} columns.`);
+    const rows = input.map((source) => {
+        const row = Object.create(null);
+        for (const name of columns)
+            row[name] = value(source[name]);
+        return row;
+    });
+    return { columns, rows };
+}

package/dist/figure.d.ts

@@ -0,0 +1,6 @@
+import type { ChartResult } from "./chart.js";
+/**
+ * The markup that goes on the page for a drawn chart, or for one that could not be drawn: the
+ * chart in a wrapper (marked when it is interactive), or a note saying why.
+ */
+export declare function chartMarkup(result: ChartResult, interactive: boolean): string;

package/dist/figure.js

@@ -0,0 +1,12 @@
+import { escapeHtml } from "enarratio";
+/**
+ * The markup that goes on the page for a drawn chart, or for one that could not be drawn: the
+ * chart in a wrapper (marked when it is interactive), or a note saying why.
+ */
+export function chartMarkup(result, interactive) {
+    if (!result.ok) {
+        return `<p class="enarratio-chart-error" role="note">This chart could not be drawn. ${escapeHtml(result.error)}</p>`;
+    }
+    const mark = interactive ? " data-enarratio-interactive-chart" : "";
+    return `<div class="enarratio-chart"${mark}>${result.html}</div>`;
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Enarratio charts for Astro: a `<Chart>` component (`enarratio-astro/Chart.astro`), charts in
+ * Markdown (`enarratio-astro/markdown`), and the functions under both, drawn on the server by
+ * Enarratio as accessible HTML and SVG.
+ *
+ * @packageDocumentation
+ */
+export { CHART_TYPES, type ChartResult, type ChartSpec, type ChartType, renderChart, } from "./chart.js";
+export { type Cell, parseTable, type Table, tableFromRows } from "./data.js";
+export { chartMarkup } from "./figure.js";
+export { chartStyles, type StyleOptions, type Styles } from "./styles.js";

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * Enarratio charts for Astro: a `<Chart>` component (`enarratio-astro/Chart.astro`), charts in
+ * Markdown (`enarratio-astro/markdown`), and the functions under both, drawn on the server by
+ * Enarratio as accessible HTML and SVG.
+ *
+ * @packageDocumentation
+ */
+export { CHART_TYPES, renderChart, } from "./chart.js";
+export { parseTable, tableFromRows } from "./data.js";
+export { chartMarkup } from "./figure.js";
+export { chartStyles } from "./styles.js";

package/dist/markdown.d.ts

@@ -0,0 +1,67 @@
+import { type ChartSpec } from "./chart.js";
+import { type StyleOptions } from "./styles.js";
+/** Options for the Markdown plugins: how charts are styled. */
+export type MarkdownChartOptions = StyleOptions;
+/**
+ * Reads a `chart` code block: `key: value` lines, a line of three dashes, then the data.
+ *
+ * ```chart
+ * type: line
+ * x: month
+ * y: visitors
+ * alt: Monthly visitors rise from 820 to 1,190.
+ * ---
+ * month,visitors
+ * 2026-01-01,820
+ * ```
+ */
+export declare function parseChartBlock(source: string): ChartSpec & {
+    readonly interactive: boolean;
+};
+/** The parts of a Markdown code node the plugins read. */
+interface CodeNode {
+    readonly type: "code";
+    readonly lang?: string | null | undefined;
+    readonly value: string;
+}
+/** The parts of the Sätteri visitor context the plugin uses. */
+interface SatteriContext {
+    replaceNode(node: Readonly<CodeNode>, content: {
+        type: "html";
+        value: string;
+    }): void;
+}
+/**
+ * Charts in Markdown for Astro's default Markdown processor, Sätteri (Astro 7 and later): every
+ * code block whose language is `chart` becomes a chart, drawn when the site builds or renders.
+ *
+ * @example
+ * // astro.config.mjs
+ * import { satteri } from "@astrojs/markdown-satteri";
+ * import { satteriCharts } from "enarratio-astro/markdown";
+ * export default defineConfig({ markdown: { processor: satteri({ mdastPlugins: [satteriCharts()] }) } });
+ */
+export declare function satteriCharts(options?: MarkdownChartOptions): {
+    name: string;
+    before(): void;
+    code(node: Readonly<CodeNode>, ctx: SatteriContext): Promise<void>;
+};
+interface MdastParent {
+    children: Array<{
+        type: string;
+        lang?: string | null | undefined;
+        value?: string | undefined;
+        children?: unknown[] | undefined;
+    }>;
+}
+/**
+ * Charts in Markdown for the unified (remark) processor, Astro 6's default and an option in
+ * Astro 7: every code block whose language is `chart` becomes a chart.
+ *
+ * @example
+ * // astro.config.mjs, Astro 6
+ * import { remarkCharts } from "enarratio-astro/markdown";
+ * export default defineConfig({ markdown: { remarkPlugins: [remarkCharts] } });
+ */
+export declare function remarkCharts(options?: MarkdownChartOptions): (tree: MdastParent) => Promise<void>;
+export {};