@tensor_1/react 2.31.0 → 2.32.0

package/dist/select-model.d.ts

@@ -0,0 +1,80 @@
+import { ReactNode } from 'react';
+
+/**
+ * Select model (HAR-1572) — pure, DOM-free logic behind the UIx `Select` listbox:
+ * flattening options and groups, keyboard movement (APG select-only combobox), typeahead,
+ * filtering and the multi-select value helpers. Unit-tested in select-model.test.mjs.
+ */
+
+interface SelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    /** A second, muted line under the label. */
+    description?: string;
+    /** Shown before the label, in the list and on the trigger. */
+    icon?: ReactNode;
+    /** Extra words that match a search or typeahead (never shown). */
+    keywords?: readonly string[];
+}
+interface SelectGroup {
+    label: string;
+    options: readonly SelectOption[];
+    /** Disables every option in the group. */
+    disabled?: boolean;
+}
+type SelectItem = SelectOption | SelectGroup;
+declare const isSelectGroup: (item: SelectItem) => item is SelectGroup;
+/** @internal One option in list order, with what navigation needs. */
+interface SelectEntry {
+    option: SelectOption;
+    /** Position among all entries (the `aria-activedescendant` target index). */
+    index: number;
+    /** Index into `sections`. */
+    section: number;
+    disabled: boolean;
+    /** In the form value only (an `<option hidden>` placeholder); never listed or focused. */
+    hidden: boolean;
+}
+/** @internal A run of entries: one group, or the ungrouped options between groups. */
+interface SelectSection {
+    label?: string;
+    disabled: boolean;
+    entries: SelectEntry[];
+}
+/** @internal */
+interface SelectModel {
+    sections: SelectSection[];
+    /** Every visible entry, in order (hidden placeholder options are left out). */
+    entries: SelectEntry[];
+    /** Every option including hidden ones, for the form proxy and value lookups. */
+    all: SelectEntry[];
+}
+/** @internal Flatten options and groups into sections and a navigable entry list. */
+declare function buildSelectModel(items: readonly SelectItem[]): SelectModel;
+declare const firstEnabled: (entries: readonly SelectEntry[]) => number;
+declare const lastEnabled: (entries: readonly SelectEntry[]) => number;
+/**
+ * Move the active option by `delta` (±1 for arrows, ±10 for PageUp/PageDown), skipping
+ * disabled options and stopping at the ends (the APG list does not wrap). With no active
+ * option, moving down lands on the first enabled option and moving up on the last.
+ */
+declare function moveActive(entries: readonly SelectEntry[], from: number, delta: number): number;
+/**
+ * Typeahead (APG): the typed buffer matches the start of a label. Repeating one character
+ * ("s", "s") cycles through the options that start with it; a longer string ("re") keeps the
+ * current option while it still matches. Disabled options are skipped. Returns -1 for no match.
+ */
+declare function typeahead(entries: readonly SelectEntry[], buffer: string, from: number): number;
+/** Does the option match a search query (label, value-free keywords and description)? */
+declare function selectOptionMatches(option: SelectOption, query: string): boolean;
+/** Keep only the options (and the groups holding them) that match `query`. */
+declare function filterSelectItems(items: readonly SelectItem[], query: string): SelectItem[];
+/** Count the options in a list of options and groups. */
+declare const countSelectOptions: (items: readonly SelectItem[]) => number;
+/** @internal A form value (string, number, array or nothing) as a list of strings. */
+declare function toValueList(value: unknown): string[];
+/** @internal Toggle `value` in a multi-select value, keeping list order stable. */
+declare function toggleValue(values: readonly string[], value: string): string[];
+
+export { type SelectEntry, type SelectGroup, type SelectItem, type SelectModel, type SelectOption, type SelectSection, buildSelectModel, countSelectOptions, filterSelectItems, firstEnabled, isSelectGroup, lastEnabled, moveActive, selectOptionMatches, toValueList, toggleValue, typeahead };

package/dist/select-model.js

@@ -0,0 +1,109 @@
+import { foldForSearch } from "./search-suggest-model.js";
+const isSelectGroup = (item) => Array.isArray(item.options);
+function buildSelectModel(items) {
+  const sections = [];
+  const entries = [];
+  const all = [];
+  let loose = null;
+  const add = (section, sectionIndex, option, groupDisabled) => {
+    const hidden = !!option.hidden;
+    const entry = {
+      option,
+      index: hidden ? -1 : entries.length,
+      section: sectionIndex,
+      disabled: groupDisabled || !!option.disabled,
+      hidden
+    };
+    all.push(entry);
+    if (hidden) return;
+    entries.push(entry);
+    section.entries.push(entry);
+  };
+  for (const item of items) {
+    if (isSelectGroup(item)) {
+      loose = null;
+      const section = { label: item.label, disabled: !!item.disabled, entries: [] };
+      sections.push(section);
+      for (const option of item.options) add(section, sections.length - 1, option, !!item.disabled);
+    } else {
+      if (!loose) {
+        loose = { disabled: false, entries: [] };
+        sections.push(loose);
+      }
+      add(loose, sections.length - 1, item, false);
+    }
+  }
+  return { sections: sections.filter((s) => s.entries.length > 0 || s.label != null), entries, all };
+}
+function scan(entries, from, step) {
+  for (let i = from; i >= 0 && i < entries.length; i += step) if (!entries[i].disabled) return i;
+  return -1;
+}
+const firstEnabled = (entries) => scan(entries, 0, 1);
+const lastEnabled = (entries) => scan(entries, entries.length - 1, -1);
+function moveActive(entries, from, delta) {
+  if (!entries.length) return -1;
+  if (from < 0) return delta > 0 ? firstEnabled(entries) : lastEnabled(entries);
+  const step = delta > 0 ? 1 : -1;
+  const target = Math.max(0, Math.min(entries.length - 1, from + delta));
+  const found = scan(entries, target, step);
+  if (found >= 0 && found !== from) return found;
+  const back = scan(entries, target, step === 1 ? -1 : 1);
+  return back >= 0 ? step === 1 ? Math.max(back, from) : Math.min(back, from) : from;
+}
+const fold = (text) => foldForSearch(text).text;
+function typeahead(entries, buffer, from) {
+  const query = fold(buffer);
+  if (!query || !entries.length) return -1;
+  const chars = [...query];
+  const repeated = chars.length > 1 && chars.every((c) => c === chars[0]);
+  const needle = repeated ? chars[0] : query;
+  const start = repeated || chars.length === 1 ? from + 1 : Math.max(0, from);
+  const n = entries.length;
+  for (let k = 0; k < n; k += 1) {
+    const i = ((start + k) % n + n) % n;
+    const entry = entries[i];
+    if (!entry.disabled && fold(entry.option.label).trimStart().startsWith(needle)) return i;
+  }
+  return -1;
+}
+function selectOptionMatches(option, query) {
+  const needle = fold(query).trim();
+  if (!needle) return true;
+  return [option.label, ...option.keywords ?? []].some((part) => fold(part).includes(needle));
+}
+function filterSelectItems(items, query) {
+  if (!fold(query).trim()) return [...items];
+  const out = [];
+  for (const item of items) {
+    if (isSelectGroup(item)) {
+      const options = item.options.filter((o) => selectOptionMatches(o, query));
+      if (options.length) out.push({ ...item, options });
+    } else if (selectOptionMatches(item, query)) {
+      out.push(item);
+    }
+  }
+  return out;
+}
+const countSelectOptions = (items) => items.reduce((n, item) => n + (isSelectGroup(item) ? item.options.length : 1), 0);
+function toValueList(value) {
+  if (value == null) return [];
+  if (Array.isArray(value)) return value.map((v) => String(v));
+  return [String(value)];
+}
+function toggleValue(values, value) {
+  return values.includes(value) ? values.filter((v) => v !== value) : [...values, value];
+}
+export {
+  buildSelectModel,
+  countSelectOptions,
+  filterSelectItems,
+  firstEnabled,
+  isSelectGroup,
+  lastEnabled,
+  moveActive,
+  selectOptionMatches,
+  toValueList,
+  toggleValue,
+  typeahead
+};

package/dist/table-engine.d.ts

@@ -71,8 +71,15 @@ interface VirtualWindow {
  * [start, end) plus `overscan` rows on each side; padTop/padBottom are spacer
  * heights (px) so the scrollbar stays correct. Below `threshold` rows, callers
  * should skip virtualization (render all) — see shouldVirtualize.
+ *
+ * `scrollTop` is clamped to what a list of `count` rows can scroll to. A scroll position left
+ * over from a longer list (5,000 rows filtered down to 150 while scrolled far down) then gives
+ * the last rows and a spacer no taller than the list, in the same pass — not an empty window
+ * under a spacer taller than everything, which the browser only corrects scroll by scroll
+ * (HAR-1616).
  */
 declare function virtualWindow(scrollTop: number, viewportH: number, rowH: number, count: number, overscan?: number): VirtualWindow;
+/** `count > threshold`: a list of exactly `threshold` rows is still rendered whole. */
 declare function shouldVirtualize(count: number, threshold?: number): boolean;
 /** Clamp a dragged column width to a sane minimum (and optional maximum). */
 declare function clampWidth(width: number, min?: number, max?: number): number;

package/dist/table-engine.js

@@ -190,7 +190,8 @@ function parseView(qs) {
 }
 function virtualWindow(scrollTop, viewportH, rowH, count, overscan = 6) {
   if (rowH <= 0 || count <= 0) return { start: 0, end: count, padTop: 0, padBottom: 0, total: 0 };
-  const first = Math.max(0, Math.floor(scrollTop / rowH) - overscan);
+  const top = Math.max(0, Math.min(scrollTop, count * rowH - viewportH));
+  const first = Math.max(0, Math.floor(top / rowH) - overscan);
   const visible = Math.ceil(viewportH / rowH) + overscan * 2;
   const end = Math.min(count, first + visible);
   return { start: first, end, padTop: first * rowH, padBottom: (count - end) * rowH, total: count * rowH };

package/dist/text-diff-model.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Two-way text diff for `TextDiff` (HAR-1368). Pure. Myers' O(ND) diff on lines or words,
+ * after trimming the common prefix and suffix. Past `maxEdits` the changed middle is shown as
+ * one replacement instead of searching further, so a rewrite never stalls the page.
+ */
+type TextDiffGranularity = 'line' | 'word';
+interface TextDiffOp {
+    type: 'equal' | 'insert' | 'delete';
+    /** Lines (granularity `line`) or word, space and punctuation tokens (`word`). */
+    tokens: string[];
+}
+interface TextDiffOptions {
+    granularity?: TextDiffGranularity;
+    /** More tokens than this on either side gives `status: 'too-large'`. Default 20 000. */
+    maxTokens?: number;
+    /** Edit budget for the search; beyond it the middle becomes one replacement. Default 2 000. */
+    maxEdits?: number;
+}
+interface TextDiffResult {
+    status: 'ok' | 'too-large';
+    granularity: TextDiffGranularity;
+    ops: TextDiffOp[];
+    /** Lines, or words (not spaces or punctuation), added and removed. */
+    added: number;
+    removed: number;
+}
+/** Splits text into lines (without their `\r\n` / `\n`) or into word, space and punctuation tokens. */
+declare function tokenizeText(text: string, granularity: TextDiffGranularity): string[];
+/** Myers diff of two token lists. Tokens compare by string equality. */
+declare function diffTokens(a: readonly string[], b: readonly string[], maxEdits?: number): TextDiffOp[];
+/** Diffs two texts by line or by word, with added/removed counts. */
+declare function diffText(before: string, after: string, { granularity, maxTokens, maxEdits }?: TextDiffOptions): TextDiffResult;
+/** A run of text inside one line; `changed` marks the words that differ from the other side. */
+interface TextDiffSegment {
+    text: string;
+    changed: boolean;
+}
+interface TextDiffLine {
+    /** 1-based line number on its side. */
+    number: number;
+    /** Word-level marks when the line was paired with a similar counterpart; otherwise one changed segment. */
+    segments: TextDiffSegment[];
+}
+type TextDiffRow = {
+    kind: 'equal';
+    before: TextDiffLine;
+    after: TextDiffLine;
+} | {
+    kind: 'change';
+    before: TextDiffLine;
+    after: TextDiffLine;
+} | {
+    kind: 'delete';
+    before: TextDiffLine;
+} | {
+    kind: 'insert';
+    after: TextDiffLine;
+} | {
+    kind: 'fold';
+    count: number;
+    rows: TextDiffRow[];
+};
+/**
+ * Rows for a line diff: unchanged lines, removed/added lines, and changed lines paired side by
+ * side with word marks. With `context`, unchanged runs longer than needed fold into one row.
+ */
+declare function textDiffRows(result: TextDiffResult, { context }?: {
+    context?: number;
+}): TextDiffRow[];
+
+export { type TextDiffGranularity, type TextDiffLine, type TextDiffOp, type TextDiffOptions, type TextDiffResult, type TextDiffRow, type TextDiffSegment, diffText, diffTokens, textDiffRows, tokenizeText };

package/dist/text-diff-model.js

@@ -0,0 +1,261 @@
+const WORD_TOKENS = /\s+|[\p{L}\p{M}\p{N}_]+|[^\s\p{L}\p{M}\p{N}_]/gu;
+function tokenizeText(text, granularity) {
+  if (granularity === "line") return text === "" ? [] : text.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+  return text.match(WORD_TOKENS) ?? [];
+}
+function myers(a, b, maxEdits) {
+  const n = a.length;
+  const m = b.length;
+  const limit = Math.min(n + m, maxEdits);
+  const offset = limit + 1;
+  const v = new Int32Array(2 * limit + 3);
+  const trace = [];
+  let found = -1;
+  for (let d = 0; d <= limit && found < 0; d += 1) {
+    for (let k = -d; k <= d; k += 2) {
+      let x2 = k === -d || k !== d && v[offset + k - 1] < v[offset + k + 1] ? v[offset + k + 1] : v[offset + k - 1] + 1;
+      let y2 = x2 - k;
+      while (x2 < n && y2 < m && a[x2] === b[y2]) {
+        x2 += 1;
+        y2 += 1;
+      }
+      v[offset + k] = x2;
+      if (x2 >= n && y2 >= m) {
+        found = d;
+        break;
+      }
+    }
+    trace.push(v.slice(offset - d, offset + d + 1));
+  }
+  if (found < 0) return null;
+  const steps = [];
+  let x = n;
+  let y = m;
+  for (let d = found; d > 0; d -= 1) {
+    const prev = trace[d - 1];
+    const at = (k2) => prev[k2 + d - 1];
+    const k = x - y;
+    const prevK = k === -d || k !== d && at(k - 1) < at(k + 1) ? k + 1 : k - 1;
+    const prevX = at(prevK);
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) {
+      steps.push("equal");
+      x -= 1;
+      y -= 1;
+    }
+    if (x === prevX) {
+      steps.push("insert");
+      y -= 1;
+    } else {
+      steps.push("delete");
+      x -= 1;
+    }
+  }
+  while (x > 0 && y > 0) {
+    steps.push("equal");
+    x -= 1;
+    y -= 1;
+  }
+  return steps.reverse();
+}
+function push(ops, type, token) {
+  const last = ops[ops.length - 1];
+  if (last?.type === type) last.tokens.push(token);
+  else ops.push({ type, tokens: [token] });
+}
+function normalize(ops) {
+  const out = [];
+  let del = [];
+  let ins = [];
+  const flush = () => {
+    if (del.length) out.push({ type: "delete", tokens: del });
+    if (ins.length) out.push({ type: "insert", tokens: ins });
+    del = [];
+    ins = [];
+  };
+  for (const op of ops) {
+    if (op.type === "delete") del = del.concat(op.tokens);
+    else if (op.type === "insert") ins = ins.concat(op.tokens);
+    else {
+      flush();
+      const last = out[out.length - 1];
+      if (last?.type === "equal") last.tokens.push(...op.tokens);
+      else out.push({ type: "equal", tokens: [...op.tokens] });
+    }
+  }
+  flush();
+  return out;
+}
+function absorbSpaces(ops) {
+  const out = ops.map((op) => ({ ...op, tokens: [...op.tokens] }));
+  for (let i = 1; i < out.length - 1; i += 1) {
+    const op = out[i];
+    if (op.type === "equal" && out[i - 1].type !== "equal" && out[i + 1].type !== "equal" && op.tokens.every((t) => /^\s+$/.test(t))) {
+      out.splice(i, 1, { type: "delete", tokens: op.tokens }, { type: "insert", tokens: [...op.tokens] });
+    }
+  }
+  return normalize(out);
+}
+function diffTokens(a, b, maxEdits = 2e3) {
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start += 1;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA -= 1;
+    endB -= 1;
+  }
+  const ids = /* @__PURE__ */ new Map();
+  const id = (t) => {
+    let v = ids.get(t);
+    if (v === void 0) {
+      v = ids.size;
+      ids.set(t, v);
+    }
+    return v;
+  };
+  const midA = a.slice(start, endA);
+  const midB = b.slice(start, endB);
+  const steps = myers(midA.map(id), midB.map(id), maxEdits);
+  const ops = [];
+  for (const t of a.slice(0, start)) push(ops, "equal", t);
+  if (steps) {
+    let i = 0;
+    let j = 0;
+    for (const step of steps) {
+      if (step === "equal") {
+        push(ops, "equal", midA[i]);
+        i += 1;
+        j += 1;
+      } else if (step === "delete") {
+        push(ops, "delete", midA[i]);
+        i += 1;
+      } else {
+        push(ops, "insert", midB[j]);
+        j += 1;
+      }
+    }
+  } else {
+    for (const t of midA) push(ops, "delete", t);
+    for (const t of midB) push(ops, "insert", t);
+  }
+  for (const t of a.slice(endA)) push(ops, "equal", t);
+  return normalize(ops);
+}
+const counts = (tokens, granularity) => granularity === "line" ? tokens.length : tokens.filter((t) => /[\p{L}\p{N}]/u.test(t)).length;
+function diffText(before, after, { granularity = "line", maxTokens = 2e4, maxEdits = 2e3 } = {}) {
+  const a = tokenizeText(before, granularity);
+  const b = tokenizeText(after, granularity);
+  if (a.length > maxTokens || b.length > maxTokens) return { status: "too-large", granularity, ops: [], added: 0, removed: 0 };
+  let ops = diffTokens(a, b, maxEdits);
+  if (granularity === "word") ops = absorbSpaces(ops);
+  let added = 0;
+  let removed = 0;
+  for (const op of ops) {
+    if (op.type === "insert") added += counts(op.tokens, granularity);
+    if (op.type === "delete") removed += counts(op.tokens, granularity);
+  }
+  return { status: "ok", granularity, ops, added, removed };
+}
+const SIMILAR = 0.4;
+function compareLines(before, after) {
+  const longest = Math.max(before.length, after.length);
+  if (longest === 0) return { similarity: 1, left: [{ text: "", changed: false }], right: [{ text: "", changed: false }] };
+  if (before.length + after.length > 4e3) return { similarity: 0, left: [{ text: before, changed: true }], right: [{ text: after, changed: true }] };
+  const { ops } = diffText(before, after, { granularity: "word", maxEdits: 400 });
+  const left = [];
+  const right = [];
+  let same = 0;
+  for (const op of ops) {
+    const text = op.tokens.join("");
+    if (op.type === "equal") {
+      same += text.replace(/\s/g, "").length;
+      left.push({ text, changed: false });
+      right.push({ text, changed: false });
+    } else (op.type === "delete" ? left : right).push({ text, changed: true });
+  }
+  const visible = Math.max(before.replace(/\s/g, "").length, after.replace(/\s/g, "").length) || 1;
+  return { similarity: same / visible, left, right };
+}
+function alignBlock(deleted, inserted) {
+  const n = deleted.length;
+  const m = inserted.length;
+  const out = [];
+  if (n * m > 2500) {
+    deleted.forEach((_, i2) => out.push([i2, null, null]));
+    inserted.forEach((_, j2) => out.push([null, j2, null]));
+    return out;
+  }
+  const cmp = deleted.map((d) => inserted.map((i2) => compareLines(d, i2)));
+  const score = Array.from({ length: n + 1 }, () => new Float64Array(m + 1));
+  for (let i2 = n - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = m - 1; j2 >= 0; j2 -= 1) {
+      const sim = cmp[i2][j2].similarity;
+      score[i2][j2] = Math.max(score[i2 + 1][j2], score[i2][j2 + 1], sim >= SIMILAR ? sim + score[i2 + 1][j2 + 1] : 0);
+    }
+  }
+  let i = 0;
+  let j = 0;
+  while (i < n || j < m) {
+    if (i < n && j < m && cmp[i][j].similarity >= SIMILAR && score[i][j] === cmp[i][j].similarity + score[i + 1][j + 1]) {
+      out.push([i, j, cmp[i][j]]);
+      i += 1;
+      j += 1;
+    } else if (i < n && (j >= m || score[i][j] === score[i + 1][j])) {
+      out.push([i, null, null]);
+      i += 1;
+    } else {
+      out.push([null, j, null]);
+      j += 1;
+    }
+  }
+  return out;
+}
+function textDiffRows(result, { context } = {}) {
+  const rows = [];
+  let left = 1;
+  let right = 1;
+  const ops = result.ops;
+  for (let i = 0; i < ops.length; i += 1) {
+    const op = ops[i];
+    if (op.type === "equal") {
+      for (const text of op.tokens) rows.push({ kind: "equal", before: { number: left++, segments: [{ text, changed: false }] }, after: { number: right++, segments: [{ text, changed: false }] } });
+      continue;
+    }
+    const deleted = op.type === "delete" ? op.tokens : [];
+    const inserted = op.type === "insert" ? op.tokens : ops[i + 1]?.type === "insert" ? ops[i + 1].tokens : [];
+    if (op.type === "delete" && ops[i + 1]?.type === "insert") i += 1;
+    for (const [d, n, pair] of alignBlock(deleted, inserted)) {
+      if (pair && d !== null && n !== null) rows.push({ kind: "change", before: { number: left++, segments: pair.left }, after: { number: right++, segments: pair.right } });
+      else if (d !== null) rows.push({ kind: "delete", before: { number: left++, segments: [{ text: deleted[d], changed: true }] } });
+      else if (n !== null) rows.push({ kind: "insert", after: { number: right++, segments: [{ text: inserted[n], changed: true }] } });
+    }
+  }
+  if (context === void 0 || context < 0) return rows;
+  const out = [];
+  for (let i = 0; i < rows.length; ) {
+    if (rows[i].kind !== "equal") {
+      out.push(rows[i]);
+      i += 1;
+      continue;
+    }
+    let j = i;
+    while (j < rows.length && rows[j].kind === "equal") j += 1;
+    const keepHead = i === 0 ? 0 : context;
+    const keepTail = j === rows.length ? 0 : context;
+    const hidden = j - i - keepHead - keepTail;
+    if (hidden > 1) {
+      out.push(...rows.slice(i, i + keepHead));
+      out.push({ kind: "fold", count: hidden, rows: rows.slice(i + keepHead, j - keepTail) });
+      out.push(...rows.slice(j - keepTail, j));
+    } else out.push(...rows.slice(i, j));
+    i = j;
+  }
+  return out;
+}
+export {
+  diffText,
+  diffTokens,
+  textDiffRows,
+  tokenizeText
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensor_1/react",
-  "version": "2.31.0",
+  "version": "2.32.0",
   "description": "Thin React wrappers over the UIx v2 CSS component library.",
   "license": "UNLICENSED",
   "type": "module",

package/dist/ChartCore-DzWe10bN.d.cts

@@ -1,59 +0,0 @@
-import * as react from 'react';
-import { CSSProperties, ReactNode, HTMLAttributes } from 'react';
-import { EChartsOption, ECharts } from 'echarts';
-
-declare function uixChartPalette(): string[];
-interface ChartTableRow {
-    [key: string]: string | number;
-}
-/**
- * Every word the chart renders itself (TENSOR RX-125, UIX-04 / UIX-05). The
- * loading text used to live in CSS `content:`, where nothing could translate it.
- */
-interface ChartLabels {
-    /** Shown (and announced inside the busy region) while `loading`. */
-    loading: ReactNode;
-    /** Accessible name when neither `ariaLabel` nor `title` is given. */
-    chart: string;
-    /** Appended to the chart's name for its data-table alternative. */
-    dataTableSuffix: string;
-}
-declare const DEFAULT_CHART_LABELS: ChartLabels;
-interface ChartProps {
-    option: EChartsOption;
-    title?: string;
-    subtitle?: string;
-    height?: string | number;
-    className?: string;
-    style?: CSSProperties;
-    ariaLabel?: string;
-    tableData?: ChartTableRow[];
-    tableHeaders?: string[];
-    onReady?: (chart: ECharts) => void;
-    header?: ReactNode;
-    headerAction?: ReactNode;
-    footer?: ReactNode;
-    loading?: boolean;
-    empty?: ReactNode;
-    /** Translatable words; English defaults in {@link DEFAULT_CHART_LABELS}. */
-    labels?: Partial<ChartLabels>;
-}
-interface ChartMetricProps extends HTMLAttributes<HTMLDivElement> {
-    value: ReactNode;
-    label?: ReactNode;
-    delta?: ReactNode;
-    deltaTone?: 'neutral' | 'positive' | 'negative' | 'warning';
-}
-declare function ChartMetric({ value, label, delta, deltaTone, className, ...props }: ChartMetricProps): react.JSX.Element;
-interface ChartLegendProps extends HTMLAttributes<HTMLUListElement> {
-    children?: ReactNode;
-}
-declare function ChartLegend({ children, className, ...props }: ChartLegendProps): react.JSX.Element;
-interface ChartLegendItemProps extends HTMLAttributes<HTMLLIElement> {
-    label: ReactNode;
-    color?: string;
-    swatch?: 'block' | 'line' | 'dash';
-}
-declare function ChartLegendItem({ label, color, swatch, className, style, ...props }: ChartLegendItemProps): react.JSX.Element;
-
-export { type ChartProps as C, DEFAULT_CHART_LABELS as D, type ChartLabels as a, ChartLegend as b, ChartLegendItem as c, type ChartLegendItemProps as d, type ChartLegendProps as e, ChartMetric as f, type ChartMetricProps as g, type ChartTableRow as h, uixChartPalette as u };