@fusedashlabs/widgets 0.2.0 → 0.3.1

package/dist/components/bias-variance-tradeoff-chart/lib/domain.d.ts

@@ -0,0 +1,8 @@
+import { BiasVarianceSeries } from './types.js';
+/** Client `extent(data, d => x)` with the Visx `[0, 1]` fallback. */
+export declare function biasVarianceXDomain(series: BiasVarianceSeries[]): [number, number];
+/** Client `[0, max(y) * 1.1]` — the plot always sits on a zero baseline. */
+export declare function biasVarianceYDomain(series: BiasVarianceSeries[]): [number, number];
+/** Union of every series' x values, ascending — the crosshair snaps to these. */
+export declare function biasVarianceXValues(series: BiasVarianceSeries[]): number[];
+//# sourceMappingURL=domain.d.ts.map

package/dist/components/bias-variance-tradeoff-chart/lib/domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../../src/components/bias-variance-tradeoff-chart/lib/domain.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,qEAAqE;AACrE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAYlF;AAED,4EAA4E;AAC5E,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CASlF;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,EAAE,GAAG,MAAM,EAAE,CAM1E"}

package/dist/components/bias-variance-tradeoff-chart/lib/domain.js

@@ -0,0 +1,37 @@
+import { FD } from "../../../utils/fusedash-visual.js";
+function biasVarianceXDomain(series) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const s of series) {
+    for (const p of s.points) {
+      if (p.x < min) min = p.x;
+      if (p.x > max) max = p.x;
+    }
+  }
+  if (!Number.isFinite(min) || !Number.isFinite(max)) return [0, 1];
+  if (min === max) return [min, min + 1];
+  return [min, max];
+}
+function biasVarianceYDomain(series) {
+  let max = -Infinity;
+  for (const s of series) {
+    for (const p of s.points) {
+      if (p.y > max) max = p.y;
+    }
+  }
+  if (!Number.isFinite(max) || max <= 0) return [0, 1];
+  return [0, max * FD.biasVarianceDomainPadFactor];
+}
+function biasVarianceXValues(series) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const s of series) {
+    for (const p of s.points) seen.add(p.x);
+  }
+  return [...seen].sort((a, b) => a - b);
+}
+export {
+  biasVarianceXDomain,
+  biasVarianceXValues,
+  biasVarianceYDomain
+};
+//# sourceMappingURL=domain.js.map

package/dist/components/bias-variance-tradeoff-chart/lib/domain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.js","sources":["../../../../src/components/bias-variance-tradeoff-chart/lib/domain.ts"],"sourcesContent":["import { FD } from '../../../utils/fusedash-visual.js';\nimport type { BiasVarianceSeries } from './types.js';\n\n/** Client `extent(data, d => x)` with the Visx `[0, 1]` fallback. */\nexport function biasVarianceXDomain(series: BiasVarianceSeries[]): [number, number] {\n  let min = Infinity;\n  let max = -Infinity;\n  for (const s of series) {\n    for (const p of s.points) {\n      if (p.x < min) min = p.x;\n      if (p.x > max) max = p.x;\n    }\n  }\n  if (!Number.isFinite(min) || !Number.isFinite(max)) return [0, 1];\n  if (min === max) return [min, min + 1];\n  return [min, max];\n}\n\n/** Client `[0, max(y) * 1.1]` — the plot always sits on a zero baseline. */\nexport function biasVarianceYDomain(series: BiasVarianceSeries[]): [number, number] {\n  let max = -Infinity;\n  for (const s of series) {\n    for (const p of s.points) {\n      if (p.y > max) max = p.y;\n    }\n  }\n  if (!Number.isFinite(max) || max <= 0) return [0, 1];\n  return [0, max * FD.biasVarianceDomainPadFactor];\n}\n\n/** Union of every series' x values, ascending — the crosshair snaps to these. */\nexport function biasVarianceXValues(series: BiasVarianceSeries[]): number[] {\n  const seen = new Set<number>();\n  for (const s of series) {\n    for (const p of s.points) seen.add(p.x);\n  }\n  return [...seen].sort((a, b) => a - b);\n}\n"],"names":[],"mappings":";AAIO,SAAS,oBAAoB,QAAgD;AAClF,MAAI,MAAM;AACV,MAAI,MAAM;AACV,aAAW,KAAK,QAAQ;AACtB,eAAW,KAAK,EAAE,QAAQ;AACxB,UAAI,EAAE,IAAI,IAAK,OAAM,EAAE;AACvB,UAAI,EAAE,IAAI,IAAK,OAAM,EAAE;AAAA,IACzB;AAAA,EACF;AACA,MAAI,CAAC,OAAO,SAAS,GAAG,KAAK,CAAC,OAAO,SAAS,GAAG,EAAG,QAAO,CAAC,GAAG,CAAC;AAChE,MAAI,QAAQ,IAAK,QAAO,CAAC,KAAK,MAAM,CAAC;AACrC,SAAO,CAAC,KAAK,GAAG;AAClB;AAGO,SAAS,oBAAoB,QAAgD;AAClF,MAAI,MAAM;AACV,aAAW,KAAK,QAAQ;AACtB,eAAW,KAAK,EAAE,QAAQ;AACxB,UAAI,EAAE,IAAI,IAAK,OAAM,EAAE;AAAA,IACzB;AAAA,EACF;AACA,MAAI,CAAC,OAAO,SAAS,GAAG,KAAK,OAAO,EAAG,QAAO,CAAC,GAAG,CAAC;AACnD,SAAO,CAAC,GAAG,MAAM,GAAG,2BAA2B;AACjD;AAGO,SAAS,oBAAoB,QAAwC;AAC1E,QAAM,2BAAW,IAAA;AACjB,aAAW,KAAK,QAAQ;AACtB,eAAW,KAAK,EAAE,OAAQ,MAAK,IAAI,EAAE,CAAC;AAAA,EACxC;AACA,SAAO,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AACvC;"}

package/dist/components/bias-variance-tradeoff-chart/lib/format.d.ts

@@ -0,0 +1,3 @@
+/** Tooltip / reference-label numbers: trim trailing zeros, keep small floats readable. */
+export declare function formatTradeoffValue(value: number): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/components/bias-variance-tradeoff-chart/lib/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../src/components/bias-variance-tradeoff-chart/lib/format.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIzD"}

package/dist/components/bias-variance-tradeoff-chart/lib/format.js

@@ -0,0 +1,9 @@
+function formatTradeoffValue(value) {
+  if (!Number.isFinite(value)) return "";
+  if (Number.isInteger(value)) return String(value);
+  return String(Number(value.toFixed(3)));
+}
+export {
+  formatTradeoffValue
+};
+//# sourceMappingURL=format.js.map

package/dist/components/bias-variance-tradeoff-chart/lib/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sources":["../../../../src/components/bias-variance-tradeoff-chart/lib/format.ts"],"sourcesContent":["/** Tooltip / reference-label numbers: trim trailing zeros, keep small floats readable. */\nexport function formatTradeoffValue(value: number): string {\n  if (!Number.isFinite(value)) return '';\n  if (Number.isInteger(value)) return String(value);\n  return String(Number(value.toFixed(3)));\n}\n"],"names":[],"mappings":"AACO,SAAS,oBAAoB,OAAuB;AACzD,MAAI,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACpC,MAAI,OAAO,UAAU,KAAK,EAAG,QAAO,OAAO,KAAK;AAChD,SAAO,OAAO,OAAO,MAAM,QAAQ,CAAC,CAAC,CAAC;AACxC;"}

package/dist/components/bias-variance-tradeoff-chart/lib/index.d.ts

@@ -0,0 +1,5 @@
+export { normalizeBiasVarianceData } from './normalize.js';
+export { biasVarianceXDomain, biasVarianceXValues, biasVarianceYDomain, } from './domain.js';
+export { formatTradeoffValue } from './format.js';
+export type { BiasVarianceAxisDetail, BiasVarianceChartData, BiasVarianceChartInput, BiasVarianceDomainLimit, BiasVarianceHoverEntry, BiasVarianceModel, BiasVariancePoint, BiasVarianceSeries, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/bias-variance-tradeoff-chart/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/bias-variance-tradeoff-chart/lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,YAAY,EACV,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,YAAY,CAAC"}

package/dist/components/bias-variance-tradeoff-chart/lib/normalize.d.ts

@@ -0,0 +1,4 @@
+import { BiasVarianceChartInput, BiasVarianceModel } from './types.js';
+/** Normalize FuseDash widget / chat payloads into tradeoff curves. */
+export declare function normalizeBiasVarianceData(input: BiasVarianceChartInput): BiasVarianceModel;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/components/bias-variance-tradeoff-chart/lib/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../src/components/bias-variance-tradeoff-chart/lib/normalize.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,sBAAsB,EAEtB,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AA8HpB,sEAAsE;AACtE,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,sBAAsB,GAC5B,iBAAiB,CAwCnB"}

package/dist/components/bias-variance-tradeoff-chart/lib/normalize.js

@@ -0,0 +1,135 @@
+import { resolveFormattingColor } from "../../../utils/fuse-palette.js";
+import { isFuseWidgetPayload, rowsOf, firstField, resolveUniqueValuesOrder } from "../../../utils/fuse-widget.js";
+import { FD } from "../../../utils/fusedash-visual.js";
+const EMPTY = { series: [], domainsLimits: [] };
+function colorForSeries(formatting, key, index, seriesCount) {
+  const hasKey = formatting == null ? void 0 : formatting.some((entry) => String(entry.key) === key);
+  if (hasKey) return resolveFormattingColor(formatting, key, seriesCount);
+  return FD.biasVarianceSeries[index % FD.biasVarianceSeries.length];
+}
+function toNumber(value) {
+  return Number(value ?? 0);
+}
+function sortPoints(points) {
+  return points.sort((a, b) => a.x - b.x);
+}
+function normalizeDomainLimits(raw) {
+  if (!Array.isArray(raw)) return [];
+  const limits = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const entry = item;
+    if (!Array.isArray(entry.values)) continue;
+    const values = entry.values.map((v) => Number(v)).filter((v) => Number.isFinite(v)).slice(0, 2);
+    if (!values.length) continue;
+    limits.push({
+      values,
+      color: typeof entry.color === "string" ? entry.color : void 0,
+      orientation: entry.orientation === "vertical" ? "vertical" : "horizontal"
+    });
+  }
+  return limits;
+}
+function fromFuseWidget(widget) {
+  const rows = rowsOf(widget);
+  const xKey = firstField(widget.xAxe ?? void 0) ?? "x";
+  const yKey = firstField(widget.yAxe ?? void 0) ?? "y";
+  const seriesKey = firstField(widget.groupBy ?? void 0) ?? "series";
+  const byGroup = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const x = toNumber(row[xKey]);
+    const y = toNumber(row[yKey]);
+    if (!Number.isFinite(x) || !Number.isFinite(y)) continue;
+    const id = String(row[seriesKey] ?? "");
+    const points = byGroup.get(id) ?? [];
+    points.push({ x, y });
+    byGroup.set(id, points);
+  }
+  const ids = resolveUniqueValuesOrder(byGroup.keys(), widget.uniqueValues, seriesKey);
+  const series = ids.filter((id) => byGroup.has(id)).map((id, index) => ({
+    id,
+    name: id,
+    color: colorForSeries(widget.formatting, id, index, ids.length),
+    points: sortPoints(byGroup.get(id) ?? [])
+  })).filter((s) => s.points.length > 0);
+  return {
+    series,
+    domainsLimits: normalizeDomainLimits(
+      widget.domainsLimits
+    ),
+    xField: firstField(widget.xAxe ?? void 0),
+    yField: firstField(widget.yAxe ?? void 0),
+    groupField: firstField(widget.groupBy ?? void 0),
+    axisDetails: widget.axisDetails
+  };
+}
+function fromSeriesList(list) {
+  return list.map((s, index) => ({
+    id: s.id,
+    name: s.name ?? s.id,
+    color: s.color ?? FD.biasVarianceSeries[index % FD.biasVarianceSeries.length],
+    points: sortPoints(
+      (s.points ?? []).map((p) => ({ x: Number(p.x), y: Number(p.y) })).filter((p) => Number.isFinite(p.x) && Number.isFinite(p.y))
+    )
+  })).filter((s) => s.points.length > 0);
+}
+function fromLabelValues(rows) {
+  const points = [];
+  rows.forEach((row, index) => {
+    const parsed = Number(row.label);
+    const x = Number.isFinite(parsed) ? parsed : index;
+    const y = Number(row.value);
+    if (!Number.isFinite(y)) return;
+    points.push({ x, y });
+  });
+  if (!points.length) return [];
+  return [
+    {
+      id: "default",
+      name: "Series",
+      color: FD.biasVarianceSeries[0],
+      points: sortPoints(points)
+    }
+  ];
+}
+function normalizeBiasVarianceData(input) {
+  if (!input) return EMPTY;
+  if (Array.isArray(input)) {
+    if (!input.length) return EMPTY;
+    const first = input[0];
+    if ("points" in first) {
+      return { ...EMPTY, series: fromSeriesList(input) };
+    }
+    if ("label" in first && "value" in first) {
+      return {
+        ...EMPTY,
+        series: fromLabelValues(input)
+      };
+    }
+    return EMPTY;
+  }
+  if (isFuseWidgetPayload(input)) return fromFuseWidget(input);
+  if (typeof input === "object") {
+    const chart = input;
+    const domainsLimits = normalizeDomainLimits(chart.domainsLimits);
+    if (Array.isArray(chart.series)) {
+      return {
+        series: fromSeriesList(chart.series),
+        domainsLimits
+      };
+    }
+    if (Array.isArray(chart.points)) {
+      return {
+        series: fromSeriesList([
+          { id: "default", name: "Series", points: chart.points }
+        ]),
+        domainsLimits
+      };
+    }
+  }
+  return EMPTY;
+}
+export {
+  normalizeBiasVarianceData
+};
+//# sourceMappingURL=normalize.js.map

package/dist/components/bias-variance-tradeoff-chart/lib/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.js","sources":["../../../../src/components/bias-variance-tradeoff-chart/lib/normalize.ts"],"sourcesContent":["import { resolveFormattingColor } from '../../../utils/fuse-palette.js';\nimport {\n  firstField,\n  isFuseWidgetPayload,\n  resolveUniqueValuesOrder,\n  rowsOf,\n  type FuseWidgetLike,\n} from '../../../utils/fuse-widget.js';\nimport { FD } from '../../../utils/fusedash-visual.js';\nimport type {\n  BiasVarianceChartInput,\n  BiasVarianceDomainLimit,\n  BiasVarianceModel,\n  BiasVariancePoint,\n  BiasVarianceSeries,\n} from './types.js';\n\nconst EMPTY: BiasVarianceModel = { series: [], domainsLimits: [] };\n\n/**\n * Client widget palette — the FuseDash BiasVarianceTradeoffChart carries its own\n * `colors` array instead of going through `formatting`, so that stays the\n * default. An explicit `formatting` block on the payload still wins.\n */\nfunction colorForSeries(\n  formatting: FuseWidgetLike['formatting'],\n  key: string,\n  index: number,\n  seriesCount: number,\n): string {\n  const hasKey = formatting?.some((entry) => String(entry.key) === key);\n  if (hasKey) return resolveFormattingColor(formatting, key, seriesCount);\n  return FD.biasVarianceSeries[index % FD.biasVarianceSeries.length];\n}\n\nfunction toNumber(value: unknown): number {\n  return Number(value ?? 0);\n}\n\nfunction sortPoints(points: BiasVariancePoint[]): BiasVariancePoint[] {\n  return points.sort((a, b) => a.x - b.x);\n}\n\n/** `domainsLimits` is optional on the widget and hand-authored — keep only usable entries. */\nfunction normalizeDomainLimits(raw: unknown): BiasVarianceDomainLimit[] {\n  if (!Array.isArray(raw)) return [];\n  const limits: BiasVarianceDomainLimit[] = [];\n  for (const item of raw) {\n    if (!item || typeof item !== 'object') continue;\n    const entry = item as { values?: unknown; color?: unknown; orientation?: unknown };\n    if (!Array.isArray(entry.values)) continue;\n    const values = entry.values\n      .map((v) => Number(v))\n      .filter((v) => Number.isFinite(v))\n      .slice(0, 2);\n    if (!values.length) continue;\n    limits.push({\n      values,\n      color: typeof entry.color === 'string' ? entry.color : undefined,\n      orientation: entry.orientation === 'vertical' ? 'vertical' : 'horizontal',\n    });\n  }\n  return limits;\n}\n\nfunction fromFuseWidget(widget: FuseWidgetLike): BiasVarianceModel {\n  const rows = rowsOf(widget);\n  const xKey = firstField(widget.xAxe ?? undefined) ?? 'x';\n  const yKey = firstField(widget.yAxe ?? undefined) ?? 'y';\n  const seriesKey = firstField(widget.groupBy ?? undefined) ?? 'series';\n\n  const byGroup = new Map<string, BiasVariancePoint[]>();\n  for (const row of rows) {\n    const x = toNumber(row[xKey]);\n    const y = toNumber(row[yKey]);\n    if (!Number.isFinite(x) || !Number.isFinite(y)) continue;\n    const id = String(row[seriesKey] ?? '');\n    const points = byGroup.get(id) ?? [];\n    points.push({ x, y });\n    byGroup.set(id, points);\n  }\n\n  const ids = resolveUniqueValuesOrder(byGroup.keys(), widget.uniqueValues, seriesKey);\n  const series = ids\n    .filter((id) => byGroup.has(id))\n    .map((id, index) => ({\n      id,\n      name: id,\n      color: colorForSeries(widget.formatting, id, index, ids.length),\n      points: sortPoints(byGroup.get(id) ?? []),\n    }))\n    .filter((s) => s.points.length > 0);\n\n  return {\n    series,\n    domainsLimits: normalizeDomainLimits(\n      (widget as { domainsLimits?: unknown }).domainsLimits,\n    ),\n    xField: firstField(widget.xAxe ?? undefined),\n    yField: firstField(widget.yAxe ?? undefined),\n    groupField: firstField(widget.groupBy ?? undefined),\n    axisDetails: widget.axisDetails as BiasVarianceModel['axisDetails'],\n  };\n}\n\nfunction fromSeriesList(list: BiasVarianceSeries[]): BiasVarianceSeries[] {\n  return list\n    .map((s, index) => ({\n      id: s.id,\n      name: s.name ?? s.id,\n      color: s.color ?? FD.biasVarianceSeries[index % FD.biasVarianceSeries.length],\n      points: sortPoints(\n        (s.points ?? [])\n          .map((p) => ({ x: Number(p.x), y: Number(p.y) }))\n          .filter((p) => Number.isFinite(p.x) && Number.isFinite(p.y)),\n      ),\n    }))\n    .filter((s) => s.points.length > 0);\n}\n\n/** `[{ label, value }]` — labels are the complexity steps, index when not numeric. */\nfunction fromLabelValues(rows: Array<{ label?: unknown; value?: unknown }>): BiasVarianceSeries[] {\n  const points: BiasVariancePoint[] = [];\n  rows.forEach((row, index) => {\n    const parsed = Number(row.label);\n    const x = Number.isFinite(parsed) ? parsed : index;\n    const y = Number(row.value);\n    if (!Number.isFinite(y)) return;\n    points.push({ x, y });\n  });\n  if (!points.length) return [];\n  return [\n    {\n      id: 'default',\n      name: 'Series',\n      color: FD.biasVarianceSeries[0],\n      points: sortPoints(points),\n    },\n  ];\n}\n\n/** Normalize FuseDash widget / chat payloads into tradeoff curves. */\nexport function normalizeBiasVarianceData(\n  input: BiasVarianceChartInput,\n): BiasVarianceModel {\n  if (!input) return EMPTY;\n\n  if (Array.isArray(input)) {\n    if (!input.length) return EMPTY;\n    const first = input[0] as unknown as Record<string, unknown>;\n    if ('points' in first) {\n      return { ...EMPTY, series: fromSeriesList(input as BiasVarianceSeries[]) };\n    }\n    if ('label' in first && 'value' in first) {\n      return {\n        ...EMPTY,\n        series: fromLabelValues(input as unknown as Array<{ label: unknown; value: unknown }>),\n      };\n    }\n    return EMPTY;\n  }\n\n  if (isFuseWidgetPayload(input)) return fromFuseWidget(input);\n\n  if (typeof input === 'object') {\n    const chart = input as { series?: unknown; points?: unknown; domainsLimits?: unknown };\n    const domainsLimits = normalizeDomainLimits(chart.domainsLimits);\n    if (Array.isArray(chart.series)) {\n      return {\n        series: fromSeriesList(chart.series as BiasVarianceSeries[]),\n        domainsLimits,\n      };\n    }\n    if (Array.isArray(chart.points)) {\n      return {\n        series: fromSeriesList([\n          { id: 'default', name: 'Series', points: chart.points as BiasVariancePoint[] },\n        ]),\n        domainsLimits,\n      };\n    }\n  }\n\n  return EMPTY;\n}\n"],"names":[],"mappings":"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"}

package/dist/components/bias-variance-tradeoff-chart/lib/types.d.ts

@@ -0,0 +1,47 @@
+/** One point on a tradeoff curve — both axes are continuous. */
+export interface BiasVariancePoint {
+    x: number;
+    y: number;
+}
+export interface BiasVarianceSeries {
+    id: string;
+    name?: string;
+    color?: string;
+    /** Sorted ascending by `x` */
+    points: BiasVariancePoint[];
+}
+/** FuseDash `domainsLimits` entry — a reference line, or a band when it carries two values. */
+export interface BiasVarianceDomainLimit {
+    values: number[];
+    color?: string;
+    orientation: 'vertical' | 'horizontal';
+}
+export interface BiasVarianceAxisDetail {
+    label?: string;
+    measure_unit_symbol?: string;
+}
+/** One row of the crosshair tooltip. */
+export interface BiasVarianceHoverEntry {
+    seriesId: string;
+    seriesName: string;
+    color: string;
+    value: number;
+    /** The curve nearest the cursor — siblings are dimmed while it is hovered. */
+    focused: boolean;
+}
+export interface BiasVarianceModel {
+    series: BiasVarianceSeries[];
+    domainsLimits: BiasVarianceDomainLimit[];
+    xField?: string;
+    yField?: string;
+    groupField?: string;
+    axisDetails?: Record<string, BiasVarianceAxisDetail>;
+}
+/** Chat shape: `{ series: [...] }` or `{ points: [...] }` for a single curve. */
+export interface BiasVarianceChartData {
+    series?: BiasVarianceSeries[];
+    points?: BiasVariancePoint[];
+    domainsLimits?: BiasVarianceDomainLimit[];
+}
+export type BiasVarianceChartInput = BiasVarianceChartData | BiasVarianceSeries[] | Record<string, unknown> | null | undefined;
+//# sourceMappingURL=types.d.ts.map

package/dist/components/bias-variance-tradeoff-chart/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/components/bias-variance-tradeoff-chart/lib/types.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,MAAM,WAAW,iBAAiB;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,MAAM,EAAE,iBAAiB,EAAE,CAAC;CAC7B;AAED,+FAA+F;AAC/F,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,UAAU,GAAG,YAAY,CAAC;CACxC;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,wCAAwC;AACxC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,aAAa,EAAE,uBAAuB,EAAE,CAAC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;CACtD;AAED,iFAAiF;AACjF,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC9B,MAAM,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAC7B,aAAa,CAAC,EAAE,uBAAuB,EAAE,CAAC;CAC3C;AAED,MAAM,MAAM,sBAAsB,GAC9B,qBAAqB,GACrB,kBAAkB,EAAE,GACpB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvB,IAAI,GACJ,SAAS,CAAC"}

package/dist/components/bias-variance-tradeoff-chart/metadata.json.d.ts

@@ -0,0 +1,41 @@
+declare const _default: {
+  "id": "bias-variance-tradeoff-chart",
+  "tag": "ui9000-bias-variance-tradeoff-chart",
+  "title": "Bias-Variance Tradeoff Chart",
+  "description": "Chat-optimized bias-variance tradeoff curves. FuseDash BiasVarianceTradeoffChart Visx → D3.",
+  "chartTypeKeys": ["biasVarianceTradeoffChart"],
+  "source": "client/libs/shared/components/src/Widgets/BiasVarianceTradeoffChart/",
+  "stack": "d3",
+  "lazyImport": "@fusedashlabs/widgets/lazy/bias-variance-tradeoff-chart",
+  "entry": "@fusedashlabs/widgets/bias-variance-tradeoff-chart",
+  "usageConditions": {
+    "host": "mcp-chat",
+    "notFor": "fusedash-editor",
+    "mapsExcluded": true
+  },
+  "allowedActions": ["hover", "resize"],
+  "propsSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "data": {
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "FuseDash WidgetItem-shaped payload (numeric xAxe / yAxe, groupBy series, optional domainsLimits)"
+          },
+          {
+            "type": "object",
+            "description": "Chat shape: { series: [{ id, name, color, points: [{ x, y }] }], domainsLimits }"
+          }
+        ]
+      },
+      "show-grid": { "type": "boolean" },
+      "show-legend": { "type": "boolean" },
+      "show-tooltip": { "type": "boolean" }
+    }
+  }
+}
+;
+
+export default _default;

package/dist/components/bias-variance-tradeoff-chart/metadata.json.js

@@ -0,0 +1,42 @@
+const id = "bias-variance-tradeoff-chart";
+const tag = "ui9000-bias-variance-tradeoff-chart";
+const title = "Bias-Variance Tradeoff Chart";
+const description = "Chat-optimized bias-variance tradeoff curves. FuseDash BiasVarianceTradeoffChart Visx → D3.";
+const chartTypeKeys = ["biasVarianceTradeoffChart"];
+const source = "client/libs/shared/components/src/Widgets/BiasVarianceTradeoffChart/";
+const stack = "d3";
+const lazyImport = "@fusedashlabs/widgets/lazy/bias-variance-tradeoff-chart";
+const entry = "@fusedashlabs/widgets/bias-variance-tradeoff-chart";
+const usageConditions = { "host": "mcp-chat", "notFor": "fusedash-editor", "mapsExcluded": true };
+const allowedActions = ["hover", "resize"];
+const propsSchema = { "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "properties": { "data": { "oneOf": [{ "type": "object", "description": "FuseDash WidgetItem-shaped payload (numeric xAxe / yAxe, groupBy series, optional domainsLimits)" }, { "type": "object", "description": "Chat shape: { series: [{ id, name, color, points: [{ x, y }] }], domainsLimits }" }] }, "show-grid": { "type": "boolean" }, "show-legend": { "type": "boolean" }, "show-tooltip": { "type": "boolean" } } };
+const biasVarianceTradeoffMeta = {
+  id,
+  tag,
+  title,
+  description,
+  chartTypeKeys,
+  source,
+  stack,
+  lazyImport,
+  entry,
+  usageConditions,
+  allowedActions,
+  propsSchema
+};
+export {
+  allowedActions,
+  chartTypeKeys,
+  biasVarianceTradeoffMeta as default,
+  description,
+  entry,
+  id,
+  lazyImport,
+  propsSchema,
+  source,
+  stack,
+  tag,
+  title,
+  usageConditions
+};
+//# sourceMappingURL=metadata.json.js.map

package/dist/components/bias-variance-tradeoff-chart/metadata.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/components/bias-variance-tradeoff-chart/render/draw.d.ts

@@ -0,0 +1,31 @@
+import { WidgetTheme } from '../../../types/index.js';
+import { BiasVarianceHoverEntry, BiasVarianceModel } from '../lib/index.js';
+export interface RenderBiasVarianceChartOptions {
+    model: BiasVarianceModel;
+    width: number;
+    height: number;
+    /** FuseDash BiasVarianceTradeoffChart margins when omitted by the host */
+    margin?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    theme: WidgetTheme;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    onHover?: (payload: {
+        x: number;
+        entries: BiasVarianceHoverEntry[];
+        event: MouseEvent;
+    }) => void;
+    onLeave?: () => void;
+}
+/**
+ * FuseDash BiasVarianceTradeoffChart — D3 rewrite.
+ *
+ * Coordinate system matches the client Visx build: both scales carry the margin
+ * in their range, so there is no inner plot translate.
+ */
+export declare function renderBiasVarianceChart(container: HTMLElement, options: RenderBiasVarianceChartOptions): void;
+//# sourceMappingURL=draw.d.ts.map

package/dist/components/bias-variance-tradeoff-chart/render/draw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draw.d.ts","sourceRoot":"","sources":["../../../../src/components/bias-variance-tradeoff-chart/render/draw.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,EAML,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EAGvB,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,8BAA8B;IAC7C,KAAK,EAAE,iBAAiB,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE;QAClB,CAAC,EAAE,MAAM,CAAC;QACV,OAAO,EAAE,sBAAsB,EAAE,CAAC;QAClC,KAAK,EAAE,UAAU,CAAC;KACnB,KAAK,IAAI,CAAC;IACX,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAiKD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,WAAW,EACtB,OAAO,EAAE,8BAA8B,GACtC,IAAI,CA+ON"}

package/dist/components/bias-variance-tradeoff-chart/render/draw.js

@@ -0,0 +1,203 @@
+import { scaleLinear } from "d3-scale";
+import { select, pointer } from "d3-selection";
+import { line, curveMonotoneX } from "d3-shape";
+import { FD, seriesColor } from "../../../utils/fusedash-visual.js";
+import { biasVarianceXDomain, biasVarianceYDomain, biasVarianceXValues } from "../lib/domain.js";
+import { formatTradeoffValue } from "../lib/format.js";
+function resolveColor(series, index, theme) {
+  if (series.color) return series.color;
+  if (index === 0 && theme.primary) return theme.primary;
+  if (index === 1 && theme.secondary) return theme.secondary;
+  return seriesColor(index);
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function appendLimitLabel(parent, opts) {
+  const { x, y, text, align } = opts;
+  const width = text.length * 6 + 8;
+  const height = 16;
+  const left = align === "center" ? x - width / 2 : x + 8;
+  parent.append("rect").attr("x", left).attr("y", y).attr("width", width).attr("height", height).attr("rx", 6).attr("ry", 6).attr("fill", FD.domainLimitLabelFill);
+  parent.append("text").attr("x", left + width / 2).attr("y", y + 11).attr("text-anchor", "middle").attr("fill", FD.domainLimitLabelText).attr("font-size", FD.domainLimitLabelSize).text(text);
+}
+function renderDomainLimits(root, limits, xScale, yScale, bounds) {
+  const arrow = FD.domainLimitArrow;
+  const layer = root.append("g").attr("class", "domain-limits").attr("pointer-events", "none");
+  for (const limit of limits) {
+    const color = limit.color || FD.domainLimitColor;
+    const group = layer.append("g").attr("class", `domain-limit domain-limit--${limit.orientation}`);
+    const hasBand = limit.values.length === 2;
+    if (limit.orientation === "vertical") {
+      const positions2 = limit.values.map(
+        (v) => clamp(xScale(v), bounds.left, bounds.right)
+      );
+      if (hasBand) {
+        group.append("rect").attr("x", Math.min(positions2[0], positions2[1])).attr("y", bounds.top).attr("width", Math.abs(positions2[1] - positions2[0])).attr("height", bounds.bottom - bounds.top).attr("fill", color).attr("fill-opacity", FD.domainLimitFillOpacity);
+      }
+      positions2.forEach((x, i) => {
+        group.append("line").attr("x1", x).attr("x2", x).attr("y1", bounds.top).attr("y2", bounds.bottom).attr("stroke", color).attr("stroke-dasharray", FD.domainLimitDash);
+        group.append("path").attr("d", `M ${x},${bounds.top + arrow} L ${x - 6},${bounds.top} L ${x + 6},${bounds.top} Z`).attr("fill", color);
+        group.append("path").attr(
+          "d",
+          `M ${x},${bounds.bottom - arrow} L ${x - 6},${bounds.bottom} L ${x + 6},${bounds.bottom} Z`
+        ).attr("fill", color);
+        appendLimitLabel(group, {
+          x,
+          y: bounds.top + arrow,
+          text: formatTradeoffValue(limit.values[i]),
+          align: "center"
+        });
+      });
+      continue;
+    }
+    const positions = limit.values.map((v) => clamp(yScale(v), bounds.top, bounds.bottom));
+    if (hasBand) {
+      group.append("rect").attr("x", bounds.left).attr("y", Math.min(positions[0], positions[1])).attr("width", bounds.right - bounds.left).attr("height", Math.abs(positions[1] - positions[0])).attr("fill", color).attr("fill-opacity", FD.domainLimitFillOpacity);
+    }
+    positions.forEach((y, i) => {
+      group.append("line").attr("x1", bounds.left).attr("x2", bounds.right).attr("y1", y).attr("y2", y).attr("stroke", color).attr("stroke-dasharray", FD.domainLimitDash);
+      group.append("path").attr(
+        "d",
+        `M ${bounds.right - arrow},${y} L ${bounds.right},${y - 6} L ${bounds.right},${y + 6} Z`
+      ).attr("fill", color);
+      group.append("path").attr(
+        "d",
+        `M ${bounds.left + arrow},${y} L ${bounds.left},${y - 6} L ${bounds.left},${y + 6} Z`
+      ).attr("fill", color);
+      appendLimitLabel(group, {
+        x: bounds.left,
+        y: y - 17,
+        text: formatTradeoffValue(limit.values[i]),
+        align: "right"
+      });
+    });
+  }
+}
+function renderBiasVarianceChart(container, options) {
+  const {
+    model,
+    width,
+    height,
+    margin = { ...FD.biasVarianceMargin },
+    theme,
+    showGrid = true,
+    showTooltip = true,
+    onHover,
+    onLeave
+  } = options;
+  container.replaceChildren();
+  const { series } = model;
+  if (!series.length || width <= 0 || height <= 0) return;
+  const plotLeft = margin.left;
+  const plotRight = width - margin.right;
+  const plotTop = margin.top;
+  const plotBottom = height - margin.bottom;
+  if (plotRight - plotLeft < 8 || plotBottom - plotTop < 8) return;
+  const xScale = scaleLinear().domain(biasVarianceXDomain(series)).range([plotLeft, plotRight]);
+  const yScale = scaleLinear().domain(biasVarianceYDomain(series)).range([plotBottom, plotTop]).nice();
+  const xTicks = xScale.ticks(FD.biasVarianceXTicks);
+  const yTicks = yScale.ticks(FD.biasVarianceYTicks);
+  const svg = select(container).append("svg").attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`).attr("preserveAspectRatio", "xMidYMid meet").attr("role", "img").attr("aria-label", "Bias-variance tradeoff chart").style("display", "block").style("font-family", theme.fontFamily);
+  const root = svg.append("g").attr("class", "plot");
+  if (showGrid) {
+    const grid = root.append("g").attr("class", "grid").attr("pointer-events", "none");
+    for (const tick of yTicks) {
+      grid.append("line").attr("x1", plotLeft).attr("x2", plotRight).attr("y1", yScale(tick)).attr("y2", yScale(tick)).attr("stroke", FD.biasVarianceGridStroke).attr("stroke-dasharray", FD.biasVarianceGridDash).attr("shape-rendering", "crispEdges");
+    }
+  }
+  const lineGen = line().x((d) => xScale(d.x)).y((d) => yScale(d.y)).curve(curveMonotoneX);
+  const curves = root.append("g").attr("class", "series-layer");
+  series.forEach((s, i) => {
+    curves.append("path").attr("class", `series series-${i}`).datum(s.points).attr("fill", "none").attr("stroke", resolveColor(s, i, theme)).attr("stroke-width", FD.biasVarianceLineWidth).attr("opacity", FD.biasVarianceLineOpacity).attr("pointer-events", "none").attr("d", lineGen);
+  });
+  const allSeriesPaths = () => curves.selectAll("path.series");
+  const focusSeries = (focused) => {
+    allSeriesPaths().attr(
+      "opacity",
+      (_d, i) => i === focused ? 1 : FD.biasVarianceLineOpacityDimmed
+    );
+  };
+  const restoreSeries = () => {
+    allSeriesPaths().attr("opacity", FD.biasVarianceLineOpacity);
+  };
+  const axes = root.append("g").attr("class", "axes").attr("pointer-events", "none");
+  for (const tick of yTicks) {
+    axes.append("text").attr("x", plotLeft - 8).attr("y", yScale(tick) + 4).attr("text-anchor", "end").attr("fill", FD.biasVarianceLabelFill).attr("font-size", FD.axisLabelSize).text(formatTradeoffValue(tick));
+  }
+  for (const tick of xTicks) {
+    axes.append("text").attr("x", xScale(tick)).attr("y", plotBottom + 18).attr("text-anchor", "middle").attr("fill", FD.biasVarianceLabelFill).attr("font-size", FD.axisLabelSize).text(formatTradeoffValue(tick));
+  }
+  axes.append("line").attr("x1", plotLeft).attr("x2", plotLeft).attr("y1", plotTop).attr("y2", plotBottom).attr("stroke", FD.biasVarianceAxisStroke);
+  axes.append("line").attr("x1", plotLeft).attr("x2", plotRight).attr("y1", plotBottom).attr("y2", plotBottom).attr("stroke", FD.biasVarianceAxisStroke);
+  if (model.domainsLimits.length) {
+    renderDomainLimits(root, model.domainsLimits, xScale, yScale, {
+      left: plotLeft,
+      right: plotRight,
+      top: plotTop,
+      bottom: plotBottom
+    });
+  }
+  if (!showTooltip || !onHover) return;
+  const hoverLayer = root.append("g").attr("class", "hover").attr("pointer-events", "none");
+  const guide = hoverLayer.append("line").attr("stroke", FD.biasVarianceAxisStroke).attr("stroke-width", 1).attr("stroke-dasharray", FD.domainLimitDash).attr("opacity", 0);
+  const dots = hoverLayer.append("g").attr("class", "hover-dots");
+  const xValues = biasVarianceXValues(series);
+  const nearestX = (px) => {
+    let best = xValues[0];
+    let bestDist = Infinity;
+    for (const value of xValues) {
+      const dist = Math.abs(xScale(value) - px);
+      if (dist < bestDist) {
+        bestDist = dist;
+        best = value;
+      }
+    }
+    return best;
+  };
+  root.append("rect").attr("class", "hover-target").attr("x", plotLeft).attr("y", plotTop).attr("width", plotRight - plotLeft).attr("height", plotBottom - plotTop).attr("fill", "transparent").on("mousemove", (event) => {
+    const [px, py] = pointer(event, svg.node());
+    const x = nearestX(px);
+    if (x == null) return;
+    const gx = xScale(x);
+    guide.attr("x1", gx).attr("x2", gx).attr("y1", plotTop).attr("y2", plotBottom).attr("opacity", 1);
+    let focused = -1;
+    let focusedDist = Infinity;
+    series.forEach((s, i) => {
+      const point = s.points.find((p) => p.x === x);
+      if (!point) return;
+      const dist = Math.abs(yScale(point.y) - py);
+      if (dist < focusedDist) {
+        focusedDist = dist;
+        focused = i;
+      }
+    });
+    focusSeries(focused);
+    dots.selectAll("*").remove();
+    const entries = [];
+    series.forEach((s, i) => {
+      const point = s.points.find((p) => p.x === x);
+      if (!point) return;
+      const color = resolveColor(s, i, theme);
+      const isFocused = i === focused;
+      entries.push({
+        seriesId: s.id,
+        seriesName: s.name ?? s.id,
+        color,
+        value: point.y,
+        focused: isFocused
+      });
+      dots.append("circle").attr("class", isFocused ? "hover-dot hover-dot--focused" : "hover-dot").attr("cx", gx).attr("cy", yScale(point.y)).attr("r", FD.stepHoverDotRadius).attr("fill", color).attr("stroke", "#fff").attr("stroke-width", 2).attr("opacity", isFocused ? 1 : FD.biasVarianceLineOpacityDimmed);
+    });
+    onHover({ x, entries, event });
+  }).on("mouseleave", () => {
+    guide.attr("opacity", 0);
+    dots.selectAll("*").remove();
+    restoreSeries();
+    onLeave == null ? void 0 : onLeave();
+  });
+}
+export {
+  renderBiasVarianceChart
+};
+//# sourceMappingURL=draw.js.map