@tensor_1/react 2.31.0 → 2.33.0

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.33.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 };