@svgrid/grid 3.0.1 → 3.0.2

package/src/SvRowGroupPanel.svelte

@@ -12,6 +12,8 @@
       />
 -->
 <script lang="ts">
+  import { GRID_ICON_GLYPHS, type GridIconName, type GridIcons } from './grid-icons'
+
   type Col = { id: string; label: string }
   type Props = {
     /** Columns that can be grouped on. */
@@ -22,8 +24,15 @@
     onChange: (groupBy: string[]) => void
     /** Text shown when nothing is grouped. */
     placeholder?: string
+    /**
+     * Icon overrides, the same map `<SvGrid icons>` takes. This panel draws
+     * `drag-handle`, `remove` and `breadcrumb-separator`. You mount it
+     * yourself, so pass the same object you gave the grid to keep them
+     * consistent.
+     */
+    icons?: GridIcons
   }
-  let { columns, groupBy, onChange, placeholder = 'Drag a column here to group by it' }: Props = $props()
+  let { columns, groupBy, onChange, placeholder = 'Drag a column here to group by it', icons }: Props = $props()
 
   const labelOf = (id: string) => columns.find((c) => c.id === id)?.label ?? id
   const available = $derived(columns.filter((c) => !groupBy.includes(c.id)))
@@ -68,6 +77,13 @@
   }
 </script>
 
+<!-- Same override-or-default resolution SvGrid uses, kept local because this
+     component is mounted by the consumer and never sees the grid's snippet. -->
+{#snippet ic(name: GridIconName)}
+  {@const override = icons?.[name]}
+  {#if override}{@render override()}{:else}{GRID_ICON_GLYPHS[name]}{/if}
+{/snippet}
+
 <div
   class="sv-rowgroup-panel"
   role="group"
@@ -80,7 +96,7 @@
     <span class="sv-rgp-empty">{placeholder}</span>
   {:else}
     {#each groupBy as id, i (id)}
-      {#if i > 0}<span class="sv-rgp-sep" aria-hidden="true">›</span>{/if}
+      {#if i > 0}<span class="sv-rgp-sep" aria-hidden="true">{@render ic('breadcrumb-separator')}</span>{/if}
       <!-- svelte-ignore a11y_no_noninteractive_tabindex, a11y_no_noninteractive_element_interactions -->
       <span
         class="sv-rgp-chip"
@@ -95,9 +111,9 @@
         ondrop={() => reorder(i)}
         onkeydown={(e) => onChipKeydown(e, i)}
       >
-        <span class="sv-rgp-grip" aria-hidden="true">⠿</span>
+        <span class="sv-rgp-grip" aria-hidden="true">{@render ic('drag-handle')}</span>
         {labelOf(id)}
-        <button type="button" class="sv-rgp-x" onclick={() => remove(id)} aria-label={`Stop grouping by ${labelOf(id)}`}>×</button>
+        <button type="button" class="sv-rgp-x" onclick={() => remove(id)} aria-label={`Stop grouping by ${labelOf(id)}`}>{@render ic('remove')}</button>
       </span>
     {/each}
   {/if}

package/src/ai.test.ts

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import {
   setAIProvider, getAIProvider, hasAIProvider,
   mockAIProvider,
-  aiFilter, aiSmartFill, aiSummarize, aiClassify,
+  aiFilter, aiSmartFill, aiSummarize, aiClassify, aiChart,
   type AIProvider, type AIRequest,
 } from './ai'
 
@@ -500,3 +500,62 @@ describe('cancellation', () => {
     expect(receivedSignal).toBe(controller.signal)
   })
 })
+
+describe('aiChart type vocabulary', () => {
+  beforeEach(() => setAIProvider(mockAIProvider))
+  afterEach(() => setAIProvider(null))
+
+  const rows = [
+    { region: 'EMEA', product: 'A', day: '2026-01-01', revenue: 10 },
+    { region: 'APAC', product: 'B', day: '2026-01-02', revenue: 20 },
+  ]
+  const plan = (q: string) => aiChart(fakeApi(rows).api as never, q)
+
+  it('reaches the types the panel can build, not just the original four', async () => {
+    // The prompt offered bar|line|area|pie while the picker had grown to
+    // thirteen, and anything else was coerced to 'bar' - so "chart this" could
+    // never produce nine of the types sitting right next to it.
+    expect((await plan('show the drop-off by stage')).type).toBe('funnel')
+    expect((await plan('treemap of revenue by region')).type).toBe('treemap')
+    expect((await plan('running total contribution by region')).type).toBe('waterfall')
+    expect((await plan('the spread of revenue by region, with outliers')).type).toBe('boxplot')
+    expect((await plan('a heatmap of revenue')).type).toBe('heatmap')
+    expect((await plan('flow from region to product')).type).toBe('sankey')
+  })
+
+  it('still defaults to a bar chart for a plain request', async () => {
+    expect((await plan('revenue by region')).type).toBe('bar')
+    expect((await plan('revenue over time')).type).toBe('line')
+    expect((await plan('share of revenue by region')).type).toBe('pie')
+  })
+
+  it('never returns a plan the panel would draw as an empty frame', async () => {
+    // Two-dimension types need a split; a calendar needs a real date column.
+    // Rather than render nothing and blame the request, they fall back to a
+    // bar, which any dimension and measure can draw.
+    // Asserted unconditionally. An `if (p.type === 'heatmap')` here would pass
+    // by doing nothing the day the mock stops producing one.
+    const heat = await plan('heatmap of revenue')
+    expect(heat.type).toBe('heatmap')
+    expect(heat.series).toBeTruthy()
+    const flow = await plan('flow from region to product')
+    expect(flow.type).toBe('sankey')
+    expect(flow.series).toBeTruthy()
+    const noDates = [{ region: 'EMEA', revenue: 1 }]
+    const cal = await aiChart(fakeApi(noDates).api as never, 'a calendar of revenue')
+    expect(cal.type).toBe('bar')
+  })
+
+  it('drops the dimension for a gauge, which has no category axis', async () => {
+    const g = await plan('revenue on a gauge against target')
+    expect(g.type).toBe('gauge')
+    expect(g.dimension).toBeNull()
+  })
+
+  it('coerces an unknown type rather than passing it through', async () => {
+    const bogus: AIProvider = async () =>
+      JSON.stringify({ type: 'sunburst', dimension: 'region', measure: 'revenue', reduce: 'sum' })
+    setAIProvider(bogus)
+    expect((await plan('anything')).type).toBe('bar')
+  })
+})

package/src/ai.ts

@@ -835,8 +835,20 @@ export async function aiFindAnomalies<
 // 7. Natural-language chart ("chart this")
 // ---------------------------------------------------------------------------
 
-/** Chart shapes the model may choose from when planning a visualisation. */
-export type AIChartType = 'bar' | 'line' | 'area' | 'pie'
+/**
+ * Chart shapes the model may choose from when planning a visualisation.
+ *
+ * These are exactly the types the built-in panel can build from a dimension, a
+ * measure and an optional split - which is all a chart plan carries. Two
+ * families are deliberately absent, because a plan cannot express them:
+ * scatter needs a SECOND measure for its y axis, and candlestick / OHLC need
+ * four under first/max/min/last. Asking for either would produce a plan the
+ * panel renders as an empty frame, which is worse than not offering it.
+ */
+export type AIChartType =
+  | 'bar' | 'line' | 'area' | 'pie'
+  | 'treemap' | 'funnel' | 'waterfall' | 'radar'
+  | 'heatmap' | 'boxplot' | 'gauge' | 'calendar' | 'sankey'
 
 /** A chart the model proposed: its type, and the fields to plot. */
 export type AIChartPlan = {
@@ -881,7 +893,7 @@ export async function aiChart<
     `into a strict-JSON chart plan the grid can render.\n\n` +
     `Columns:\n${schemaToPromptBlock(schema)}\n\n` +
     `Output JSON schema:\n` +
-    `{ "type": "bar"|"line"|"area"|"pie", ` +
+    `{ "type": "bar"|"line"|"area"|"pie"|"treemap"|"funnel"|"waterfall"|"radar"|"heatmap"|"boxplot"|"gauge"|"calendar"|"sankey", ` +
     `"dimension": "<a categorical column to group by>", ` +
     `"series": "<a second categorical column to split into series, or null>", ` +
     `"measure": "<a numeric column to aggregate>", ` +
@@ -893,6 +905,16 @@ export async function aiChart<
     `"rationale": "<one-sentence explanation>" }\n\n` +
     `Rules: pick "dimension" and "series" from text/date columns and "measure" ` +
     `from a numeric column; use only column names from the list above; ` +
+    `default to "bar" unless the request clearly wants another type. ` +
+    `Type hints: share/proportion/breakdown -> pie; nested/hierarchy/"what makes ` +
+    `up" -> treemap; drop-off/conversion/stages/pipeline -> funnel; ` +
+    `running total/contribution/bridge -> waterfall; comparing several measures ` +
+    `per item -> radar; a grid of two dimensions -> heatmap (needs "series"); ` +
+    `spread/distribution/variance/outliers/percentiles -> boxplot; a single ` +
+    `number vs a target -> gauge (leave "dimension" null); a year of daily ` +
+    `activity -> calendar (dimension must be a date column); flow between two ` +
+    `things -> sankey (needs "series": dimension is the source, series the ` +
+    `target). ` +
     `"stacked"/"stack" -> stacked:true; "log"/"logarithmic" -> logScale:true; ` +
     `"over time"/"by date"/a date dimension -> timeAxis:true; ` +
     `money/revenue/price/$ -> valueFormat:"currency"; rate/%/share -> valueFormat:"percent"; ` +
@@ -909,7 +931,11 @@ export async function aiChart<
 
   const valid = new Set(schema.map((c) => c.field))
   const numericFields = new Set(schema.filter((c) => c.type === 'number').map((c) => c.field))
-  const CHART_TYPES: AIChartType[] = ['bar', 'line', 'area', 'pie']
+  const CHART_TYPES: AIChartType[] = [
+    'bar', 'line', 'area', 'pie',
+    'treemap', 'funnel', 'waterfall', 'radar',
+    'heatmap', 'boxplot', 'gauge', 'calendar', 'sankey',
+  ]
   plan.type = CHART_TYPES.includes(plan.type) ? plan.type : 'bar'
   plan.dimension = plan.dimension && valid.has(plan.dimension) ? plan.dimension : null
   plan.series = plan.series && valid.has(plan.series) && plan.series !== plan.dimension ? plan.series : null
@@ -917,6 +943,18 @@ export async function aiChart<
     plan.measure && numericFields.has(plan.measure)
       ? plan.measure
       : (schema.find((c) => c.type === 'number')?.field ?? null)
+  // Shape check. Some types need more than a dimension and a measure, and a
+  // plan that does not satisfy one renders an empty frame - the model asked for
+  // a chart the data cannot make. Fall back to a bar, which any dimension and
+  // measure can draw, rather than showing nothing and blaming the request.
+  const dateFields = new Set(schema.filter((c) => c.type === 'date').map((c) => c.field))
+  const needsSplit = plan.type === 'heatmap' || plan.type === 'sankey'
+  if (needsSplit && !plan.series) plan.type = 'bar'
+  if (plan.type === 'calendar' && !(plan.dimension && dateFields.has(plan.dimension))) plan.type = 'bar'
+  // A gauge is one number: it has no category axis, so a dimension is noise.
+  if (plan.type === 'gauge') plan.dimension = null
+  if (plan.type !== 'gauge' && !plan.dimension) plan.type = 'bar'
+
   plan.reduce = ['sum', 'avg', 'count'].includes(plan.reduce) ? plan.reduce : 'sum'
   plan.stacked = plan.stacked === true
   plan.logScale = plan.logScale === true
@@ -1031,8 +1069,20 @@ function buildMockChart(prompt: string): AIChartPlan {
   const textFields = typed.filter((f) => f.type === 'string' || f.type === 'date').map((f) => f.name)
   const numberFields = typed.filter((f) => f.type === 'number').map((f) => f.name)
 
+  // Mirrors the type hints in the real prompt, so the bundled offline provider
+  // can reach the same charts a model can. Ordered most-specific first: "share
+  // of the pipeline" is a funnel request, not a pie one.
   const type: AIChartType =
-    /\bline\b|\btrend\b|over time/.test(q) ? 'line'
+    /\bfunnel\b|drop.?off|conversion|\bstages?\b|pipeline/.test(q) ? 'funnel'
+    : /\bwaterfall\b|running total|contribution|\bbridge\b/.test(q) ? 'waterfall'
+    : /\btree ?map\b|nested|hierarch/.test(q) ? 'treemap'
+    : /\bradar\b|spider|multi.?measure/.test(q) ? 'radar'
+    : /\bheat ?map\b/.test(q) ? 'heatmap'
+    : /\bbox ?plot\b|spread|distribution|variance|outlier|percentile|quartile/.test(q) ? 'boxplot'
+    : /\bgauge\b|\bdial\b|vs target|against target/.test(q) ? 'gauge'
+    : /\bcalendar\b|daily activity|year of/.test(q) ? 'calendar'
+    : /\bsankey\b|\bflow\b/.test(q) ? 'sankey'
+    : /\bline\b|\btrend\b|over time/.test(q) ? 'line'
     : /\barea\b/.test(q) ? 'area'
     : /\bpie\b|share|proportion|breakdown/.test(q) ? 'pie'
     : 'bar'
@@ -1046,8 +1096,11 @@ function buildMockChart(prompt: string): AIChartPlan {
     return null
   }
   const dimension = pickText(byMatch?.[1]) ?? textFields[0] ?? null
+  // Heatmap and sankey are two-dimension charts: without a split the shape
+  // check downgrades them to a bar, so the mock would answer "heatmap" with a
+  // bar chart and look broken rather than offline.
   const series =
-    /\b(split|stack(?:ed)?|by product|by category|per)\b/.test(q)
+    /\b(split|stack(?:ed)?|by product|by category|per)\b/.test(q) || type === 'heatmap' || type === 'sankey'
       ? (textFields.find((t) => t !== dimension) ?? null)
       : null
   const measure = numberFields.find((n) => q.includes(n.toLowerCase())) ?? numberFields[0] ?? null

package/src/cell-formatting.ts

@@ -74,7 +74,13 @@ type NumericFormatInput = {
  * + currency + options).
  */
 const numberFormatterCache = new Map<string, Intl.NumberFormat>()
-function getNumberFormatter(
+/**
+ * A cached `Intl.NumberFormat` for the locale and options given. Cached because
+ * constructing one is among the most expensive calls in the platform, and both
+ * callers do it per rendered value: once per cell while scrolling a number
+ * column, and once per axis tick, data label and tooltip while drawing a chart.
+ */
+export function getNumberFormatter(
   locales: string | readonly string[] | undefined,
   options: Intl.NumberFormatOptions,
 ): Intl.NumberFormat {

package/src/chart-export.test.ts

@@ -4,7 +4,10 @@ import {
   chartToPngBlob,
   downloadChartSvg,
   downloadChartPng,
+  chartSpecToCsv,
+  chartCsvExportable,
 } from './chart-export'
+import type { ChartSpec } from './chart'
 
 const SVG_NS = 'http://www.w3.org/2000/svg'
 
@@ -368,3 +371,112 @@ describe('downloadChartPng', () => {
     expect(revoke).toHaveBeenCalledWith('blob:png-url')
   })
 })
+
+describe('chartSpecToCsv: series that carry more than one number', () => {
+  it('keeps a plain series byte-identical', () => {
+    const csv = chartSpecToCsv({
+      type: 'bar',
+      categories: ['a', 'b'],
+      series: [{ label: 'rev', values: [1, 2] }, { label: 'cost', values: [3, 4] }],
+    })
+    expect(csv).toBe('Category,rev,cost\na,1,3\nb,2,4')
+  })
+
+  it('writes all four prices for a candlestick, not just the closes', () => {
+    // The screen-reader table was given the four real numbers on purpose. The
+    // export is what people actually take away, and it wrote `values` - the
+    // closes - and silently dropped the rest.
+    const csv = chartSpecToCsv({
+      type: 'candlestick',
+      categories: ['2026-03-02', '2026-03-03'],
+      series: [{
+        label: 'ACME',
+        values: [105, 101],
+        ohlc: [{ o: 100, h: 110, l: 95, c: 105 }, { o: 105, h: 108, l: 99, c: 101 }],
+      }],
+    })
+    const [header, ...rows] = csv.split('\n')
+    expect(header).toBe('Category,ACME Open,ACME High,ACME Low,ACME Close')
+    expect(rows[0]).toBe('2026-03-02,100,110,95,105')
+    expect(rows[1]).toBe('2026-03-03,105,108,99,101')
+  })
+
+  it('writes the whole five-number summary for a box plot', () => {
+    const csv = chartSpecToCsv({
+      type: 'boxplot',
+      categories: ['eu', 'ap'],
+      series: [{
+        label: 'ms',
+        values: [20, 30],
+        boxes: [
+          { min: 10, q1: 15, median: 20, q3: 25, max: 30, outliers: [90, 120] },
+          { min: 20, q1: 25, median: 30, q3: 35, max: 40 },
+        ],
+      }],
+    })
+    const [header, ...rows] = csv.split('\n')
+    expect(header).toBe('Category,ms Min,ms Q1,ms Median,ms Q3,ms Max,ms Outliers')
+    expect(rows[0]).toBe('eu,10,15,20,25,30,90 120')
+    // A box with no outliers leaves the cell empty rather than writing "0".
+    expect(rows[1]).toBe('ap,20,25,30,35,40,')
+  })
+
+  it('resolves error bars to absolute low / high', () => {
+    const csv = chartSpecToCsv({
+      type: 'bar',
+      categories: ['a', 'b', 'c'],
+      series: [{ label: 'mean', values: [10, 20, 30], errors: [2, { lo: 25, hi: 18 }, null] }],
+    })
+    const [header, ...rows] = csv.split('\n')
+    expect(header).toBe('Category,mean,mean Low,mean High')
+    expect(rows[0]).toBe('a,10,8,12')       // symmetric margin
+    expect(rows[1]).toBe('b,20,18,25')      // explicit pair, order normalised
+    expect(rows[2]).toBe('c,30,,')          // null: value only
+  })
+
+  it('exports scatter points instead of nothing', () => {
+    // Scatter has no categories, so this used to return '' and the export
+    // button did nothing at all.
+    const csv = chartSpecToCsv({
+      type: 'scatter',
+      categories: [],
+      series: [
+        { label: 'EMEA', values: [], points: [{ x: 1, y: 2, r: 3, label: 'Ada' }] },
+        { label: 'APAC', values: [], points: [{ x: 4, y: 5 }] },
+      ],
+    })
+    expect(csv.split('\n')).toEqual([
+      'Series,X,Y,Size,Label',
+      'EMEA,1,2,3,Ada',
+      'APAC,4,5,,',
+    ])
+  })
+
+  it('still writes nothing for the specs with no rectangular data', () => {
+    expect(chartSpecToCsv({ type: 'gauge', categories: [], series: [], gaugeValue: 5 })).toBe('')
+    expect(chartSpecToCsv({ type: 'bar', categories: [], series: [] })).toBe('')
+  })
+})
+
+describe('chartCsvExportable', () => {
+  it('agrees with the serializer on every shape', () => {
+    // The panel greys out its CSV item on this predicate rather than on
+    // `chartSpecToCsv(spec) !== ''`, because that would serialise a 100k-point
+    // series on every render just to decide whether a button is enabled. The
+    // cost of a mirror is drift, so assert the two agree.
+    const specs: ChartSpec[] = [
+      { type: 'bar', categories: ['a'], series: [{ label: 's', values: [1] }] },
+      { type: 'bar', categories: [], series: [] },
+      { type: 'bar', categories: ['a'], series: [] },
+      { type: 'bar', categories: [], series: [{ label: 's', values: [] }] },
+      { type: 'gauge', categories: [], series: [], gaugeValue: 5 },
+      { type: 'scatter', categories: [], series: [{ label: 's', values: [], points: [{ x: 1, y: 2 }] }] },
+      { type: 'scatter', categories: [], series: [{ label: 's', values: [], points: [] }] },
+    ]
+    for (const spec of specs) {
+      expect(chartCsvExportable(spec), JSON.stringify(spec.type + ':' + spec.categories.length)).toBe(
+        chartSpecToCsv(spec) !== '',
+      )
+    }
+  })
+})

package/src/chart-export.ts

@@ -176,18 +176,86 @@ const csvCell = (v: unknown): string => {
 
 /**
  * Serialize a chart's data to CSV: one row per category, one column per series
- * (`Category, <series 1>, ...`). Empty for exotic specs (sankey/treemap/gauge/
- * calendar) that don't carry a rectangular categories x series grid.
+ * (`Category, <series 1>, ...`).
+ *
+ * A series that carries more than one number per category widens instead of
+ * losing them. `ohlc` becomes four columns, `boxes` five plus its outliers,
+ * `errors` two. This used to write `values` and nothing else, which quietly
+ * made "Export CSV" on a candlestick chart hand back the closing prices only -
+ * the screen-reader table was given the four real numbers on purpose and the
+ * export, which is what people actually take away, was not.
+ *
+ * Scatter has no categories, so it gets its own long-format table of points
+ * rather than exporting nothing at all.
+ *
+ * Still empty for the specs with no rectangular data to write: sankey, treemap,
+ * gauge and calendar.
  */
 export function chartSpecToCsv(spec: ChartSpec): string {
-  const cats = spec.categories ?? []
   const series = spec.series ?? []
+  // Scatter: one row per point. `categories` is empty for these, so the
+  // category path below would return '' and the export button would do nothing.
+  if (series.some((s) => s.points?.length)) {
+    const header = ['Series', 'X', 'Y', 'Size', 'Label'].map(csvCell).join(',')
+    const rows: string[] = []
+    for (const s of series) {
+      for (const p of s.points ?? []) {
+        rows.push([s.label, p.x, p.y, p.r ?? '', p.label ?? ''].map(csvCell).join(','))
+      }
+    }
+    return rows.length ? [header, ...rows].join('\n') : ''
+  }
+
+  const cats = spec.categories ?? []
   if (!cats.length || !series.length) return ''
-  const header = ['Category', ...series.map((s) => s.label)].map(csvCell).join(',')
-  const rows = cats.map((cat, i) =>
-    [cat, ...series.map((s) => s.values[i] ?? '')].map(csvCell).join(','),
-  )
-  return [header, ...rows].join('\n')
+
+  // One header cell per column a series contributes. A plain series keeps its
+  // bare label, so an existing export is byte-identical.
+  const header: string[] = ['Category']
+  for (const s of series) {
+    if (s.ohlc) header.push(`${s.label} Open`, `${s.label} High`, `${s.label} Low`, `${s.label} Close`)
+    else if (s.boxes) header.push(`${s.label} Min`, `${s.label} Q1`, `${s.label} Median`, `${s.label} Q3`, `${s.label} Max`, `${s.label} Outliers`)
+    else if (s.errors) header.push(s.label, `${s.label} Low`, `${s.label} High`)
+    else header.push(s.label)
+  }
+
+  const rows = cats.map((cat, i) => {
+    const cells: unknown[] = [cat]
+    for (const s of series) {
+      if (s.ohlc) {
+        const k = s.ohlc[i]
+        cells.push(k?.o ?? '', k?.h ?? '', k?.l ?? '', k?.c ?? '')
+      } else if (s.boxes) {
+        const b = s.boxes[i]
+        // Outliers are a list inside one cell; csvCell quotes it.
+        cells.push(b?.min ?? '', b?.q1 ?? '', b?.median ?? '', b?.q3 ?? '', b?.max ?? '', b?.outliers?.join(' ') ?? '')
+      } else if (s.errors) {
+        const v = s.values[i]
+        const e = s.errors[i]
+        const lo = e == null ? '' : typeof e === 'number' ? (v ?? 0) - Math.abs(e) : Math.min(e.lo, e.hi)
+        const hi = e == null ? '' : typeof e === 'number' ? (v ?? 0) + Math.abs(e) : Math.max(e.lo, e.hi)
+        cells.push(v ?? '', lo, hi)
+      } else {
+        cells.push(s.values[i] ?? '')
+      }
+    }
+    return cells.map(csvCell).join(',')
+  })
+  return [header.map(csvCell).join(','), ...rows].join('\n')
+}
+
+/**
+ * Whether {@link chartSpecToCsv} would produce anything, without building it.
+ *
+ * The chart panel disables its CSV menu item on this. It has to be a predicate
+ * rather than `chartSpecToCsv(spec) !== ''` because that runs on every render,
+ * and serialising a 100,000-point series to decide whether to grey out a button
+ * is not a thing to do sixty times a second.
+ */
+export function chartCsvExportable(spec: ChartSpec): boolean {
+  const series = spec.series ?? []
+  if (series.some((s) => s.points?.length)) return true
+  return !!(spec.categories?.length && series.length)
 }
 
 /** Download the chart's data as a `.csv` file. Returns false if there's no