angular-my-report 0.1.0 → 0.1.1

package/src/lib/engine/chartLayout.ts

@@ -1,265 +0,0 @@
-import type { ChartSpec } from '../model/types';
-import { chartData, compactNumber, niceScale, sliceColor } from './chart';
-import { formatValue, type Row } from './expressions';
-
-/** SVG drawing primitives (coordinates in element pixels). */
-export type Prim =
-  | { t: 'path'; d: string; fill: string; stroke?: string; sw?: number; opacity?: number; title?: string }
-  | { t: 'line'; x1: number; y1: number; x2: number; y2: number; stroke: string; sw: number }
-  | { t: 'poly'; points: string; stroke: string; sw: number }
-  | { t: 'circle'; cx: number; cy: number; r: number; fill: string; stroke: string; sw: number; title?: string }
-  | { t: 'text'; x: number; y: number; text: string; anchor: 'start' | 'middle' | 'end'; size: number; weight: number; fill: string };
-
-const GRID = '#e4e4e0';
-const AXIS = '#9a9a96';
-const MUTED = '#5f5e5a';
-const SURFACE_GAP = '#ffffff';
-
-/** Rect with a rounded data end (the end away from the baseline). */
-function bar(x: number, y: number, w: number, h: number, end: 'top' | 'bottom' | 'right' | 'left'): string {
-  const r = Math.max(0, Math.min(3, w / 2, h / 2));
-  const R = (n: number) => +n.toFixed(2);
-  switch (end) {
-    case 'top':
-      return `M${R(x)},${R(y + h)}V${R(y + r)}Q${R(x)},${R(y)} ${R(x + r)},${R(y)}H${R(x + w - r)}Q${R(x + w)},${R(y)} ${R(x + w)},${R(y + r)}V${R(y + h)}Z`;
-    case 'bottom':
-      return `M${R(x)},${R(y)}V${R(y + h - r)}Q${R(x)},${R(y + h)} ${R(x + r)},${R(y + h)}H${R(x + w - r)}Q${R(x + w)},${R(y + h)} ${R(x + w)},${R(y + h - r)}V${R(y)}Z`;
-    case 'right':
-      return `M${R(x)},${R(y)}H${R(x + w - r)}Q${R(x + w)},${R(y)} ${R(x + w)},${R(y + r)}V${R(y + h - r)}Q${R(x + w)},${R(y + h)} ${R(x + w - r)},${R(y + h)}H${R(x)}Z`;
-    case 'left':
-      return `M${R(x + w)},${R(y)}H${R(x + r)}Q${R(x)},${R(y)} ${R(x)},${R(y + r)}V${R(y + h - r)}Q${R(x)},${R(y + h)} ${R(x + r)},${R(y + h)}H${R(x + w)}Z`;
-  }
-}
-
-/** Lays out a chart into SVG primitives for a w×h box. */
-export function layoutChart(spec: ChartSpec, rows: Row[], w: number, h: number, fontSize: number, textColor: string): Prim[] {
-  const P: Prim[] = [];
-  const fs = Math.max(6, fontSize);
-  const cw = fs * 0.58; // average glyph width estimate
-  const text = (x: number, y: number, s: string, anchor: 'start' | 'middle' | 'end', size = fs, weight = 400, fill = MUTED) =>
-    s && P.push({ t: 'text', x, y, text: s, anchor, size, weight, fill });
-  const fit = (s: string, maxW: number) => {
-    if (s.length * cw <= maxW) return s;
-    const n = Math.floor(maxW / cw) - 1;
-    return n < 1 ? '' : s.slice(0, n) + '…';
-  };
-  const fmt = (v: number) => formatValue(v, spec.valueFormat);
-
-  let top = 4;
-  let bottom = h - 4;
-  const left = 4;
-  const right = w - 4;
-  if (spec.title) {
-    text(w / 2, top + fs + 1, fit(spec.title, w - 8), 'middle', fs + 2, 700, textColor);
-    top += fs + 9;
-  }
-
-  const data = chartData(spec, rows);
-  const pie = spec.type === 'pie' || spec.type === 'doughnut';
-  if (!data.categories.length || bottom - top < 20) {
-    text(w / 2, (top + bottom) / 2, 'No data', 'middle');
-    return P;
-  }
-
-  // Legend (bottom): always for ≥2 series; pie slices are categories, so pies always get one.
-  const legend = pie
-    ? data.categories.map((c, i) => ({ name: c, color: sliceColor(c, i) }))
-    : data.series.length > 1
-      ? data.series.map((s) => ({ name: s.name, color: s.color }))
-      : [];
-  if (spec.showLegend && legend.length) {
-    const lineH = fs + 6;
-    const items = legend.map((l) => ({ ...l, label: fit(l.name, (right - left) / 2), width: 0 }));
-    items.forEach((it) => (it.width = 14 + it.label.length * cw + 12));
-    const lines: (typeof items)[] = [[]];
-    let x = 0;
-    for (const it of items) {
-      if (x + it.width > right - left && lines[lines.length - 1].length) {
-        lines.push([]);
-        x = 0;
-      }
-      lines[lines.length - 1].push(it);
-      x += it.width;
-    }
-    const shown = lines.slice(0, 3);
-    bottom -= shown.length * lineH + 2;
-    shown.forEach((line, li) => {
-      const total = line.reduce((s, it) => s + it.width, 0) - 12;
-      let lx = (w - total) / 2;
-      const ly = bottom + 4 + li * lineH;
-      for (const it of line) {
-        P.push({ t: 'path', d: bar(lx, ly + (lineH - 10) / 2 - 1, 10, 10, 'top'), fill: it.color });
-        text(lx + 14, ly + lineH / 2 + fs * 0.35 - 1, it.label, 'start', fs, 400, textColor);
-        lx += it.width;
-      }
-    });
-  }
-
-  if (pie) {
-    layoutPie(P, data, spec, left, top, right, bottom, fs, fmt);
-    return P;
-  }
-
-  const values = data.series.flatMap((s) => s.values);
-  const scale = niceScale(Math.min(...values), Math.max(...values));
-  const ticks: number[] = [];
-  for (let t = scale.min; t <= scale.max + scale.step / 2; t += scale.step) ticks.push(+t.toFixed(10));
-  const n = data.categories.length;
-  const sCount = data.series.length;
-  const title = (cat: string, s: { name: string }, v: number) => `${cat}${sCount > 1 || spec.valueFields.length ? ' · ' + s.name : ''}: ${fmt(v)}`;
-
-  if (spec.type === 'hbar') {
-    const labelW = Math.min((right - left) * 0.35, Math.max(...data.categories.map((c) => c.length)) * cw + 8);
-    const valueW = spec.showValues && sCount === 1 ? Math.max(...values.map((v) => fmt(v).length)) * cw + 6 : 6;
-    const x0 = left + labelW;
-    const x1 = right - valueW;
-    const y0 = top + 2;
-    const y1 = bottom - fs - 6;
-    if (x1 - x0 < 20 || y1 - y0 < 10) return P;
-    const xOf = (v: number) => x0 + ((v - scale.min) / (scale.max - scale.min)) * (x1 - x0);
-    for (const t of ticks) {
-      if (spec.showGrid) P.push({ t: 'line', x1: xOf(t), y1: y0, x2: xOf(t), y2: y1, stroke: GRID, sw: 1 });
-      text(xOf(t), y1 + fs + 3, compactNumber(t), 'middle');
-    }
-    P.push({ t: 'line', x1: xOf(0), y1: y0, x2: xOf(0), y2: y1, stroke: AXIS, sw: 1 });
-    const band = (y1 - y0) / n;
-    const every = Math.max(1, Math.ceil((fs + 2) / band));
-    const groupH = band * 0.72;
-    const barH = Math.max(1, (groupH - (sCount - 1) * 2) / sCount);
-    data.categories.forEach((cat, i) => {
-      if (i % every === 0) text(x0 - 5, y0 + i * band + band / 2 + fs * 0.35, fit(cat, labelW - 8), 'end', fs, 400, textColor);
-      data.series.forEach((s, j) => {
-        const v = s.values[i];
-        const y = y0 + i * band + (band - groupH) / 2 + j * (barH + 2);
-        const a = xOf(0);
-        const b = xOf(v);
-        const x = Math.min(a, b);
-        const bw = Math.abs(b - a);
-        if (bw > 0) P.push({ t: 'path', d: bar(x, y, bw, barH, v >= 0 ? 'right' : 'left'), fill: s.color, title: title(cat, s, v) });
-        if (spec.showValues && sCount === 1 && barH >= fs * 0.8) text(Math.max(a, b) + 4, y + barH / 2 + fs * 0.35, fmt(v), 'start', fs, 400, textColor);
-      });
-    });
-    return P;
-  }
-
-  // Vertical charts: bar, line, area.
-  const yLabelW = Math.max(...ticks.map((t) => compactNumber(t).length)) * cw + 6;
-  const x0 = left + yLabelW;
-  const x1 = right;
-  const y0 = top + (spec.showValues ? fs + 2 : 4);
-  const y1 = bottom - fs - 6;
-  if (x1 - x0 < 20 || y1 - y0 < 10) return P;
-  const yOf = (v: number) => y1 - ((v - scale.min) / (scale.max - scale.min)) * (y1 - y0);
-  for (const t of ticks) {
-    if (spec.showGrid) P.push({ t: 'line', x1: x0, y1: yOf(t), x2: x1, y2: yOf(t), stroke: GRID, sw: 1 });
-    text(x0 - 5, yOf(t) + fs * 0.35, compactNumber(t), 'end');
-  }
-  const band = (x1 - x0) / n;
-  const maxLabel = Math.max(...data.categories.map((c) => Math.min(c.length, 14))) * cw + 6;
-  // Label every bar when ~4 characters fit (truncated); otherwise thin the labels out.
-  const every = band >= cw * 4 + 4 ? 1 : Math.max(1, Math.ceil(maxLabel / band));
-  data.categories.forEach((cat, i) => {
-    if (i % every !== 0) return;
-    const cx = x0 + i * band + band / 2;
-    // Centred labels must not run past the plot edges.
-    const room = Math.min(band * every - 4, 2 * (cx - left), 2 * (right - cx));
-    text(cx, y1 + fs + 3, fit(cat, room), 'middle', fs, 400, textColor);
-  });
-
-  if (spec.type === 'bar') {
-    const groupW = band * 0.72;
-    const barW = Math.max(1, (groupW - (sCount - 1) * 2) / sCount);
-    data.categories.forEach((cat, i) => {
-      data.series.forEach((s, j) => {
-        const v = s.values[i];
-        const x = x0 + i * band + (band - groupW) / 2 + j * (barW + 2);
-        const a = yOf(0);
-        const b = yOf(v);
-        const y = Math.min(a, b);
-        const bh = Math.abs(a - b);
-        if (bh > 0) P.push({ t: 'path', d: bar(x, y, barW, bh, v >= 0 ? 'top' : 'bottom'), fill: s.color, title: title(cat, s, v) });
-        const label = fmt(v);
-        if (spec.showValues && sCount === 1 && label.length * cw <= band + 4) text(x + barW / 2, Math.min(a, b) - 4, label, 'middle', fs, 400, textColor);
-      });
-    });
-  } else {
-    const xAt = (i: number) => x0 + i * band + band / 2;
-    data.series.forEach((s) => {
-      const pts = s.values.map((v, i) => [xAt(i), yOf(v)] as const);
-      if (spec.type === 'area') {
-        const d = `M${pts[0][0]},${yOf(0)}` + pts.map(([x, y]) => `L${x},${y}`).join('') + `L${pts[pts.length - 1][0]},${yOf(0)}Z`;
-        P.push({ t: 'path', d, fill: s.color, opacity: 0.16 });
-      }
-      P.push({ t: 'poly', points: pts.map(([x, y]) => `${+x.toFixed(2)},${+y.toFixed(2)}`).join(' '), stroke: s.color, sw: 2 });
-      const markers = n <= 40;
-      pts.forEach(([x, y], i) => {
-        // Small markers carry the hover tooltip; a 2px surface ring separates them from the line.
-        P.push({ t: 'circle', cx: x, cy: y, r: markers ? 3.5 : 0.01, fill: s.color, stroke: SURFACE_GAP, sw: markers ? 1.5 : 0, title: title(data.categories[i], s, s.values[i]) });
-      });
-      if (spec.showValues && sCount === 1 && n <= 15) pts.forEach(([x, y], i) => text(x, y - 7, fmt(s.values[i]), 'middle', fs, 400, textColor));
-    });
-  }
-  P.push({ t: 'line', x1: x0, y1: yOf(0), x2: x1, y2: yOf(0), stroke: AXIS, sw: 1 });
-  return P;
-}
-
-function layoutPie(
-  P: Prim[],
-  data: ReturnType<typeof chartData>,
-  spec: ChartSpec,
-  left: number,
-  top: number,
-  right: number,
-  bottom: number,
-  fs: number,
-  fmt: (v: number) => string,
-) {
-  const vals = data.series[0].values.map((v) => Math.max(0, v));
-  const total = vals.reduce((a, b) => a + b, 0);
-  const cx = (left + right) / 2;
-  const cy = (top + bottom) / 2;
-  const r = Math.max(4, Math.min(right - left, bottom - top) / 2 - 2);
-  const ir = spec.type === 'doughnut' ? r * 0.58 : 0;
-  if (total <= 0) {
-    P.push({ t: 'text', x: cx, y: cy, text: 'No data', anchor: 'middle', size: fs, weight: 400, fill: MUTED });
-    return;
-  }
-  const pt = (a: number, rad: number) => `${+(cx + rad * Math.cos(a)).toFixed(2)},${+(cy + rad * Math.sin(a)).toFixed(2)}`;
-  let a0 = -Math.PI / 2;
-  vals.forEach((v, i) => {
-    if (v <= 0) return;
-    const cat = data.categories[i];
-    const sweep = (v / total) * Math.PI * 2;
-    const a1 = a0 + sweep;
-    const pct = (v / total) * 100;
-    const title = `${cat}: ${fmt(v)} (${pct.toFixed(1)}%)`;
-    let d: string;
-    if (sweep >= Math.PI * 2 - 1e-6) {
-      // Full circle: two half arcs.
-      d = `M${pt(0, r)}A${r},${r} 0 1 1 ${pt(Math.PI, r)}A${r},${r} 0 1 1 ${pt(0, r)}Z`;
-      if (ir) d += `M${pt(0, ir)}A${ir},${ir} 0 1 0 ${pt(Math.PI, ir)}A${ir},${ir} 0 1 0 ${pt(0, ir)}Z`;
-    } else {
-      const large = sweep > Math.PI ? 1 : 0;
-      d = ir
-        ? `M${pt(a0, r)}A${r},${r} 0 ${large} 1 ${pt(a1, r)}L${pt(a1, ir)}A${ir},${ir} 0 ${large} 0 ${pt(a0, ir)}Z`
-        : `M${cx},${cy}L${pt(a0, r)}A${r},${r} 0 ${large} 1 ${pt(a1, r)}Z`;
-    }
-    // 2px surface-colored stroke separates neighbouring slices.
-    P.push({ t: 'path', d, fill: sliceColor(cat, i), stroke: SURFACE_GAP, sw: 2, title });
-    if (spec.showValues && sweep > 0.35) {
-      const mid = (a0 + a1) / 2;
-      const lr = ir ? (r + ir) / 2 : r * 0.62;
-      P.push({
-        t: 'text',
-        x: cx + lr * Math.cos(mid),
-        y: cy + lr * Math.sin(mid) + fs * 0.35,
-        text: `${Math.round(pct)}%`,
-        anchor: 'middle',
-        size: fs,
-        weight: 700,
-        fill: '#ffffff',
-      });
-    }
-    a0 = a1;
-  });
-}

package/src/lib/engine/crosstab.ts

@@ -1,96 +0,0 @@
-import type { ReportElement, TableColumn } from '../model/types';
-import { aggregate, formatValue, getPath, type Row } from './expressions';
-import type { TableRenderData } from './table';
-
-export interface Pivot {
-  rowKeys: string[];
-  colKeys: string[];
-  /** cells[r][c] = aggregate, null when no rows fall in the cell. */
-  cells: (number | null)[][];
-  rowTotals: (number | null)[];
-  colTotals: (number | null)[];
-  grandTotal: number | null;
-}
-
-const num = (v: unknown): number | null => (v == null || Number.isNaN(Number(v)) ? null : Number(v));
-const byName = (a: string, b: string) => a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' });
-// Braces would be read as expressions when the cell text is rendered.
-const literal = (s: string) => s.replace(/[{}]/g, '');
-
-export function pivot(el: ReportElement, rows: Row[]): Pivot {
-  const x = el.crosstab!;
-  const key = (r: Row, f: string) => (f ? String(getPath(r, f) ?? '(blank)') : 'All');
-  const rowKeys = [...new Set(rows.map((r) => key(r, x.rowField)))].sort(byName);
-  const colKeys = [...new Set(rows.map((r) => key(r, x.columnField)))].sort(byName);
-  const bucket = new Map<string, Row[]>();
-  for (const r of rows) {
-    const k = key(r, x.rowField) + '\u0000' + key(r, x.columnField);
-    let b = bucket.get(k);
-    if (!b) bucket.set(k, (b = []));
-    b.push(r);
-  }
-  const agg = (set: Row[]) => (set.length ? num(aggregate(x.aggregate, x.valueField, set)) : null);
-  const cells = rowKeys.map((rk) => colKeys.map((ck) => agg(bucket.get(rk + '\u0000' + ck) ?? [])));
-  // Totals aggregate the underlying rows (so avg/min/max stay correct, not sums of averages).
-  const rowTotals = rowKeys.map((rk) => agg(rows.filter((r) => key(r, x.rowField) === rk)));
-  const colTotals = colKeys.map((ck) => agg(rows.filter((r) => key(r, x.columnField) === ck)));
-  return { rowKeys, colKeys, cells, rowTotals, colTotals, grandTotal: agg(rows) };
-}
-
-/**
- * Turns a cross table into an ordinary table element + data rows (cells pre-formatted), so the
- * renderer can paginate it with the table code: header repeats, rows flow, totals form the footer.
- */
-export function crosstabAsTable(el: ReportElement, rows: Row[]): { table: ReportElement; data: Row[]; render: TableRenderData } {
-  const x = el.crosstab!;
-  const p = pivot(el, rows);
-  const fmt = (v: number | null) => (v == null ? '' : formatValue(v, x.valueFormat));
-  const totalLabel = x.aggregate === 'count' ? 'Count' : x.aggregate === 'avg' ? 'Average' : 'Total';
-
-  const col = (id: string, header: string, footer: string, width: number, align: TableColumn['align']): TableColumn => ({
-    id,
-    header: literal(header),
-    text: `{${id}}`,
-    footer: literal(footer),
-    width,
-    align,
-    format: { kind: 'none', decimals: 0, currency: '' },
-  });
-  const columns: TableColumn[] = [
-    col('c0', x.cornerText || `${x.rowField || ''} / ${x.columnField || ''}`, totalLabel, 1.6, 'left'),
-    ...p.colKeys.map((k, i) => col(`c${i + 1}`, k, fmt(p.colTotals[i]), 1, 'right')),
-  ];
-  if (x.showRowTotals) columns.push(col(`c${p.colKeys.length + 1}`, totalLabel, fmt(p.grandTotal), 1, 'right'));
-
-  const data: Row[] = p.rowKeys.map((rk, r) => {
-    const o: Row = { c0: literal(rk) };
-    p.colKeys.forEach((_, c) => (o[`c${c + 1}`] = fmt(p.cells[r][c])));
-    if (x.showRowTotals) o[`c${p.colKeys.length + 1}`] = fmt(p.rowTotals[r]);
-    return o;
-  });
-
-  const table: ReportElement = {
-    ...el,
-    kind: 'table',
-    table: {
-      columns,
-      showHeader: true,
-      repeatHeader: x.repeatHeader,
-      showFooter: x.showColumnTotals,
-      headerHeight: x.headerHeight,
-      rowHeight: x.rowHeight,
-      headerBackground: x.headerBackground,
-      headerColor: x.headerColor,
-      stripeBackground: x.stripeBackground,
-      gridColor: x.gridColor,
-    },
-  };
-  const render: TableRenderData = {
-    header: columns.map((c) => c.header),
-    headerHeight: x.headerHeight,
-    rows: data.map((d, i) => ({ cells: columns.map((c) => String(d[c.id] ?? '')), height: x.rowHeight, index: i })),
-    footer: x.showColumnTotals ? columns.map((c) => c.footer) : null,
-    footerHeight: x.rowHeight,
-  };
-  return { table, data, render };
-}

package/src/lib/engine/dataSources.ts

@@ -1,204 +0,0 @@
-import type { DataSourceDef } from '../model/types';
-import { emptyDataSource } from '../model/defaults';
-import { getPath, type Row } from './expressions';
-
-export type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'object';
-export interface FieldInfo {
-  name: string;
-  type: FieldType;
-}
-export interface LoadResult {
-  rows: Row[];
-  fields: FieldInfo[];
-  requestUrl: string;
-  /** Non-fatal note, e.g. the array path was not found and auto-detect was used. */
-  warning?: string;
-  /** The whole JSON document (first page for OData), readable in formulas as root.x. */
-  root?: unknown;
-}
-
-export function parseHeaders(text: string): Record<string, string> {
-  const h: Record<string, string> = {};
-  for (const line of text.split(/\r?\n/)) {
-    const i = line.indexOf(':');
-    if (i > 0) h[line.slice(0, i).trim()] = line.slice(i + 1).trim();
-  }
-  return h;
-}
-
-export const hasSource = (ds: DataSourceDef) => !!(ds.url.trim() || (ds.type === 'json' && ds.inline.trim()));
-
-export function buildODataUrl(ds: DataSourceDef): string {
-  let base = ds.url.trim().replace(/\/+$/, '');
-  if (ds.entitySet.trim()) base += '/' + ds.entitySet.trim();
-  const q: string[] = [];
-  const add = (k: string, v: string) => v.trim() && q.push(`${k}=${encodeURIComponent(v.trim())}`);
-  add('$select', ds.select);
-  add('$filter', ds.filter);
-  add('$orderby', ds.orderby);
-  add('$expand', ds.expand);
-  if (ds.top) q.push(`$top=${ds.top}`);
-  return q.length ? base + (base.includes('?') ? '&' : '?') + q.join('&') : base;
-}
-
-async function fetchJson(url: string, headers: Record<string, string>, signal?: AbortSignal): Promise<any> {
-  const res = await fetch(url, { headers: { Accept: 'application/json', ...headers }, signal });
-  if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText} — ${url}`);
-  const text = await res.text();
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error(`Response is not valid JSON — ${url}`);
-  }
-}
-
-function extractArray(data: unknown, path: string, onWarn: (w: string) => void = () => {}): Row[] {
-  let cur: any = path.trim() ? getPath(data, path.trim()) : data;
-  // A path that doesn't exist in this response (e.g. left over from another URL) falls back to auto-detect.
-  if (cur === undefined && path.trim()) {
-    onWarn(`Array path "${path.trim()}" not found in the response; auto-detected the data instead. Clear the Array path field.`);
-    cur = data;
-    path = '';
-  }
-  if (Array.isArray(cur)) return cur;
-  if (cur && typeof cur === 'object') {
-    for (const key of ['value', 'items', 'data', 'results', 'rows', 'records']) {
-      if (Array.isArray(cur[key])) return cur[key];
-    }
-    const firstArray = Object.values(cur).find(Array.isArray);
-    if (firstArray) return firstArray as Row[];
-    return [cur];
-  }
-  throw new Error(path ? `No array found at "${path}"` : 'Data is not an array or object');
-}
-
-export async function loadData(ds: DataSourceDef, signal?: AbortSignal): Promise<LoadResult> {
-  const headers = parseHeaders(ds.headers);
-  let rows: Row[];
-  let requestUrl = '';
-  let warning: string | undefined;
-  let root: unknown;
-
-  if (ds.type === 'json') {
-    let data: unknown;
-    if (ds.inline.trim()) {
-      try {
-        data = JSON.parse(ds.inline);
-      } catch (e) {
-        throw new Error('Pasted JSON is invalid: ' + (e as Error).message);
-      }
-    } else {
-      requestUrl = ds.url.trim();
-      data = await fetchJson(requestUrl, headers, signal);
-    }
-    root = data;
-    rows = extractArray(data, ds.dataPath, (w) => (warning = w));
-  } else {
-    requestUrl = buildODataUrl(ds);
-    rows = [];
-    let next: string | undefined = requestUrl;
-    const max = ds.maxRows || 5000;
-    while (next && rows.length < max) {
-      const json: any = await fetchJson(next, headers, signal);
-      root ??= json;
-      const page: Row[] = json.value ?? json.d?.results ?? (Array.isArray(json.d) ? json.d : json.d ? [json.d] : []);
-      rows.push(...page);
-      const link: string | undefined = json['@odata.nextLink'] ?? json['odata.nextLink'] ?? json.d?.__next;
-      next = link && !ds.top ? new URL(link, next).toString() : undefined;
-    }
-    rows = rows.slice(0, max);
-  }
-  return { rows, fields: inferFields(rows), requestUrl, warning, root };
-}
-
-function typeOf(v: unknown): FieldType | null {
-  if (v == null) return null;
-  if (typeof v === 'number') return 'number';
-  if (typeof v === 'boolean') return 'boolean';
-  if (typeof v === 'string') {
-    if (/^\d{4}-\d{2}-\d{2}([T ][\d:.]+)?(Z|[+-]\d{2}:?\d{2})?$/.test(v) || /^\/Date\(-?\d+/.test(v)) return 'date';
-    return 'string';
-  }
-  return 'object';
-}
-
-/** Infers field names (flattening nested objects into dot paths) from a sample of rows. */
-export function inferFields(rows: Row[]): FieldInfo[] {
-  const types = new Map<string, FieldType | null>();
-  const visit = (obj: Record<string, unknown>, prefix: string, depth: number) => {
-    for (const [k, v] of Object.entries(obj)) {
-      if (k.startsWith('@') || k.startsWith('__')) continue;
-      const name = prefix + k;
-      if (v && typeof v === 'object' && !Array.isArray(v) && depth < 2) {
-        visit(v as Record<string, unknown>, name + '.', depth + 1);
-        continue;
-      }
-      if (Array.isArray(v)) continue;
-      const t = typeOf(v);
-      if (!types.has(name) || (types.get(name) === null && t)) types.set(name, t);
-    }
-  };
-  for (const r of rows.slice(0, 50)) if (r && typeof r === 'object') visit(r, '', 0);
-  return [...types].map(([name, type]) => ({ name, type: type ?? 'string' }));
-}
-
-/** Lists entity sets from an OData service ($metadata XML, falling back to the JSON service document). */
-export async function loadODataEntitySets(serviceUrl: string, headersText: string): Promise<string[]> {
-  const base = serviceUrl.trim().replace(/\/+$/, '');
-  const headers = parseHeaders(headersText);
-  try {
-    const res = await fetch(base + '/$metadata', { headers: { Accept: 'application/xml', ...headers } });
-    if (res.ok) {
-      const xml = new DOMParser().parseFromString(await res.text(), 'application/xml');
-      const sets = [...xml.getElementsByTagNameNS('*', 'EntitySet')].map((n) => n.getAttribute('Name') ?? '').filter(Boolean);
-      if (sets.length) return sets;
-    }
-  } catch {
-    /* fall through */
-  }
-  const doc = await fetchJson(base, headers);
-  const list: any[] = doc.value ?? doc.d?.EntitySets ?? [];
-  return list.map((x) => (typeof x === 'string' ? x : x.name ?? x.url)).filter(Boolean);
-}
-
-export interface DetectedSource {
-  dataSource: DataSourceDef;
-  /** Human-readable summary of what was detected. */
-  note: string;
-}
-
-/**
- * Builds a data source from a pasted URL: fetches it once and decides between plain JSON and OData
- * (OData responses carry @odata.context / odata.metadata / a "d" wrapper). An OData service root
- * is resolved to its first entity set. Previous settings (array path, query options) are reset.
- */
-export async function detectDataSource(rawUrl: string, headers = ''): Promise<DetectedSource> {
-  let url = rawUrl.trim();
-  if (!url) throw new Error('Enter a URL');
-  url = url.replace(/\/\$metadata\/?$/i, ''); // a $metadata link means the service root
-  const base = { ...emptyDataSource(), headers };
-  const json: any = await fetchJson(url, parseHeaders(headers));
-
-  const isOData = json && typeof json === 'object' && !Array.isArray(json) && ('@odata.context' in json || 'odata.metadata' in json || 'd' in json);
-  if (!isOData) {
-    const rows = extractArray(json, '');
-    return { dataSource: { ...base, type: 'json', url }, note: `JSON · ${rows.length} rows` };
-  }
-
-  // Service document: lists entity sets instead of data rows.
-  const ctx: string = json['@odata.context'] ?? json['odata.metadata'] ?? '';
-  const v4Sets = /\$metadata$/.test(ctx) && Array.isArray(json.value) ? json.value.filter((x: any) => !x.kind || x.kind === 'EntitySet') : null;
-  const v2Sets: string[] | null = Array.isArray(json.d?.EntitySets) ? json.d.EntitySets : null;
-  const sets: string[] = v4Sets ? v4Sets.map((x: any) => x.url ?? x.name) : v2Sets ?? [];
-  if (sets.length) {
-    return {
-      dataSource: { ...base, type: 'odata', url: url.replace(/\/+$/, ''), entitySet: sets[0], top: 100 },
-      note: `OData service · using entity set "${sets[0]}" (${sets.length} available, first 100 rows) — pick another under Entity set`,
-    };
-  }
-  const rows = json.value ?? json.d?.results ?? json.d;
-  return {
-    dataSource: { ...base, type: 'odata', url },
-    note: `OData · ${Array.isArray(rows) ? rows.length : 1} rows${json['@odata.nextLink'] ? ' (more pages will be fetched)' : ''}`,
-  };
-}