@buoy-gg/shared-ui 7.0.40 → 7.0.42

package/lib/module/dataViewer/lineDiff.js

@@ -1,564 +1 @@
-"use strict";
-
-/**
- * Line-by-line diff computation for React Native
- *
- * Provides utilities for computing line-by-line diffs between objects,
- * with support for word-level highlighting and various comparison methods.
- */
-
-export let DiffType = /*#__PURE__*/function (DiffType) {
-  DiffType["DEFAULT"] = "unchanged";
-  DiffType["ADDED"] = "added";
-  DiffType["REMOVED"] = "removed";
-  DiffType["MODIFIED"] = "modified";
-  return DiffType;
-}({});
-
-/**
- * Marks one side of a diff as "this value did not exist".
- *
- * Deliberately distinct from `null`, `[]`, `{}` and `""` — those are real
- * stored values and diff normally. An absent side contributes zero lines, so a
- * key that was just created reads as purely added rather than as an edit of the
- * literal text `null`.
- *
- * `Symbol.for` so the identity holds even if a bundler ends up with two copies
- * of this module.
- */
-export const ABSENT_VALUE = Symbol.for("buoy.diff.absent");
-
-/** True when a diff side represents a value that did not exist. */
-export function isAbsent(value) {
-  return value === ABSENT_VALUE;
-}
-/**
- * Compute diff based on method - for word-level diff within lines
- */
-function computeDiffByMethod(oldStr, newStr, method) {
-  let oldParts;
-  let newParts;
-  switch (method) {
-    case "chars":
-      // Split into individual characters
-      oldParts = oldStr.split("");
-      newParts = newStr.split("");
-      break;
-    case "words":
-      // Split by word boundaries, keeping whitespace
-      oldParts = oldStr.match(/\S+|\s+/g) || [];
-      newParts = newStr.match(/\S+|\s+/g) || [];
-      break;
-    case "trimmedLines":
-      {
-        // For trimmedLines, compare without leading/trailing whitespace
-        const oldTrimmed = oldStr.trim();
-        const newTrimmed = newStr.trim();
-        // But still do word-level diff on the trimmed content
-        oldParts = oldTrimmed.match(/\S+|\s+/g) || [];
-        newParts = newTrimmed.match(/\S+|\s+/g) || [];
-        break;
-      }
-    case "lines":
-    default:
-      // For lines mode, don't do word diff - just show the whole line
-      return {
-        left: [{
-          value: oldStr,
-          type: DiffType.REMOVED
-        }],
-        right: [{
-          value: newStr,
-          type: DiffType.ADDED
-        }]
-      };
-  }
-
-  // Simple LCS-like algorithm for better diff
-  const left = [];
-  const right = [];
-  let i = 0,
-    j = 0;
-
-  // Find matching parts
-  while (i < oldParts.length && j < newParts.length) {
-    if (oldParts[i] === newParts[j]) {
-      // Parts match
-      left.push({
-        value: oldParts[i],
-        type: DiffType.DEFAULT
-      });
-      right.push({
-        value: newParts[j],
-        type: DiffType.DEFAULT
-      });
-      i++;
-      j++;
-    } else {
-      // Look ahead for matches
-      let foundMatch = false;
-
-      // Check if we can find newParts[j] in upcoming oldParts
-      for (let k = i + 1; k < Math.min(i + 5, oldParts.length); k++) {
-        if (oldParts[k] === newParts[j]) {
-          // Mark everything from i to k-1 as removed
-          for (let m = i; m < k; m++) {
-            left.push({
-              value: oldParts[m],
-              type: DiffType.REMOVED
-            });
-          }
-          i = k;
-          foundMatch = true;
-          break;
-        }
-      }
-      if (!foundMatch) {
-        // Check if we can find oldParts[i] in upcoming newParts
-        for (let k = j + 1; k < Math.min(j + 5, newParts.length); k++) {
-          if (newParts[k] === oldParts[i]) {
-            // Mark everything from j to k-1 as added
-            for (let m = j; m < k; m++) {
-              right.push({
-                value: newParts[m],
-                type: DiffType.ADDED
-              });
-            }
-            j = k;
-            foundMatch = true;
-            break;
-          }
-        }
-      }
-      if (!foundMatch) {
-        // No match found nearby, mark as changed
-        left.push({
-          value: oldParts[i],
-          type: DiffType.REMOVED
-        });
-        right.push({
-          value: newParts[j],
-          type: DiffType.ADDED
-        });
-        i++;
-        j++;
-      }
-    }
-  }
-
-  // Handle remaining parts
-  while (i < oldParts.length) {
-    left.push({
-      value: oldParts[i],
-      type: DiffType.REMOVED
-    });
-    i++;
-  }
-  while (j < newParts.length) {
-    right.push({
-      value: newParts[j],
-      type: DiffType.ADDED
-    });
-    j++;
-  }
-  return {
-    left,
-    right
-  };
-}
-
-/**
- * Convert object to formatted JSON lines
- */
-function objectToLines(obj) {
-  // A value that never existed has no text at all — not the word "null".
-  if (isAbsent(obj)) {
-    return [];
-  }
-  if (obj === null || obj === undefined) {
-    return [String(obj)];
-  }
-  try {
-    // Pretty print JSON with 2 space indentation
-    const jsonStr = JSON.stringify(obj, null, 2);
-    // Split into lines and filter out empty lines that appear between array elements
-    const lines = jsonStr.split("\n");
-
-    // Remove empty lines but keep structure
-    const filteredLines = [];
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-
-      // Keep the line if it's not empty or if it's meaningful whitespace
-      if (trimmed !== "") {
-        filteredLines.push(line);
-      } else if (i === 0 || i === lines.length - 1) {
-        // Keep first and last empty lines if they exist (though they shouldn't)
-        filteredLines.push(line);
-      }
-      // Skip other empty lines
-    }
-    return filteredLines;
-  } catch {
-    return [String(obj)];
-  }
-}
-
-/**
- * Apply showDiffOnly filter with context lines
- */
-function filterDiffWithContext(diffs, contextLines) {
-  if (contextLines < 0) return diffs;
-  const result = [];
-  const changedIndices = [];
-
-  // Find all changed lines
-  diffs.forEach((diff, idx) => {
-    if (diff.type !== DiffType.DEFAULT) {
-      changedIndices.push(idx);
-    }
-  });
-
-  // If no changes, return empty
-  if (changedIndices.length === 0) {
-    return [];
-  }
-
-  // Build ranges to include
-  const ranges = [];
-  let currentStart = Math.max(0, changedIndices[0] - contextLines);
-  let currentEnd = Math.min(diffs.length - 1, changedIndices[0] + contextLines);
-  for (let i = 1; i < changedIndices.length; i++) {
-    const idx = changedIndices[i];
-    const rangeStart = Math.max(0, idx - contextLines);
-    const rangeEnd = Math.min(diffs.length - 1, idx + contextLines);
-
-    // If ranges overlap or are adjacent, merge them
-    if (rangeStart <= currentEnd + 1) {
-      currentEnd = Math.max(currentEnd, rangeEnd);
-    } else {
-      // Save current range and start a new one
-      ranges.push([currentStart, currentEnd]);
-      currentStart = rangeStart;
-      currentEnd = rangeEnd;
-    }
-  }
-
-  // Don't forget the last range
-  ranges.push([currentStart, currentEnd]);
-
-  // Build result from ranges
-  ranges.forEach(([start, end]) => {
-    for (let i = start; i <= end; i++) {
-      result.push(diffs[i]);
-    }
-  });
-  return result;
-}
-
-/**
- * Normalize a line into the key used for matching.
- *
- * Display always uses the raw JSON; only matching sees this. `trimmedLines`
- * drops indentation, and `ignoreTrailingComma` drops the trailing comma so
- * pushing one item onto an array doesn't report the previous last item as
- * modified.
- */
-function normalizeCompareKey(line, compareMethod, ignoreTrailingComma) {
-  const base = compareMethod === "trimmedLines" ? line.trim() : line;
-  return ignoreTrailingComma ? base.replace(/,\s*$/, "") : base;
-}
-
-/**
- * The original heuristic: lines that start alike are an edit of one line rather
- * than an unrelated removal plus addition. Only ever applied inside a hunk the
- * line matcher already proved unmatched, so it can no longer pair lines that
- * merely shifted position.
- */
-function looksLikeModification(oldLine, newLine) {
-  const oldTrimmed = oldLine.trim();
-  const newTrimmed = newLine.trim();
-  return !!oldTrimmed && !!newTrimmed && (oldTrimmed.startsWith(newTrimmed.substring(0, 3)) || newTrimmed.startsWith(oldTrimmed.substring(0, 3)));
-}
-/**
- * Myers is O(ND) in the number of edits, so near-identical values (the common
- * case — one array push) are close to free and only wildly different values get
- * expensive. Past these bounds we fall back to the pairwise walk.
- */
-const MYERS_MAX_TOTAL_LINES = 8000;
-const MYERS_MAX_EDIT_DISTANCE = 1024;
-
-/**
- * Myers' O(ND) diff ("An O(ND) Difference Algorithm and Its Variations", 1986)
- * over line keys — the same algorithm git and `diff` use.
- *
- * Returns null when the input is too large or too dissimilar to be worth it,
- * which tells the caller to use the fallback walk.
- */
-function myersLineOps(a, b) {
-  const n = a.length;
-  const m = b.length;
-  if (n + m > MYERS_MAX_TOTAL_LINES) return null;
-  if (n === 0 && m === 0) return [];
-  const max = n + m;
-  // +1 of padding on each side so the k-1 / k+1 probes at the frontier stay in
-  // bounds without clamping (clamping would corrupt the index arithmetic).
-  const offset = max + 1;
-  const v = new Int32Array(2 * max + 3);
-  const maxD = Math.min(max, MYERS_MAX_EDIT_DISTANCE);
-
-  // Frontier snapshot per depth. Only k in [-(d+1), d+1] is ever read back, so
-  // each snapshot is O(d) and the whole trace is O(D^2) — not O(D * max).
-  const trace = [];
-  for (let d = 0; d <= maxD; d++) {
-    trace.push(v.slice(offset - (d + 1), offset + d + 2));
-    for (let k = -d; k <= d; k += 2) {
-      let x;
-      if (k === -d || k !== d && v[k - 1 + offset] < v[k + 1 + offset]) {
-        x = v[k + 1 + offset];
-      } else {
-        x = v[k - 1 + offset] + 1;
-      }
-      let y = x - k;
-
-      // Follow the diagonal as far as the lines keep matching.
-      while (x < n && y < m && a[x] === b[y]) {
-        x++;
-        y++;
-      }
-      v[k + offset] = x;
-      if (x >= n && y >= m) {
-        return backtrackOps(trace, n, m);
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Walk the recorded frontiers backwards to recover the edit script.
- */
-function backtrackOps(trace, n, m) {
-  const ops = [];
-  let x = n;
-  let y = m;
-  for (let d = trace.length - 1; d >= 0; d--) {
-    const snapshot = trace[d];
-    // Snapshot d covers k in [-(d+1), d+1], so k=0 sits at index d+1.
-    const base = d + 1;
-    const k = x - y;
-    let prevK;
-    if (k === -d || k !== d && snapshot[k - 1 + base] < snapshot[k + 1 + base]) {
-      prevK = k + 1;
-    } else {
-      prevK = k - 1;
-    }
-    const prevX = snapshot[prevK + base];
-    const prevY = prevX - prevK;
-    while (x > prevX && y > prevY) {
-      ops.push({
-        kind: "eq",
-        i: x - 1,
-        j: y - 1
-      });
-      x--;
-      y--;
-    }
-    if (d > 0) {
-      if (x === prevX) {
-        ops.push({
-          kind: "ins",
-          j: y - 1
-        });
-      } else {
-        ops.push({
-          kind: "del",
-          i: x - 1
-        });
-      }
-    }
-    x = prevX;
-    y = prevY;
-  }
-  ops.reverse();
-  return ops;
-}
-
-/**
- * Emit one hunk of unmatched lines. Removals and additions are paired off in
- * order and become MODIFIED rows when they look like an edit of the same line;
- * everything left over stays a one-sided removal or addition.
- */
-function emitHunk(result, dels, inss, oldLines, newLines, compareMethod, disableWordDiff) {
-  const pairs = Math.min(dels.length, inss.length);
-  for (let k = 0; k < pairs; k++) {
-    const i = dels[k];
-    const j = inss[k];
-    if (!looksLikeModification(oldLines[i], newLines[j])) {
-      result.push({
-        leftLineNumber: i + 1,
-        type: DiffType.REMOVED,
-        leftContent: oldLines[i],
-        leftRaw: oldLines[i]
-      });
-      result.push({
-        rightLineNumber: j + 1,
-        type: DiffType.ADDED,
-        rightContent: newLines[j],
-        rightRaw: newLines[j]
-      });
-      continue;
-    }
-    if (!disableWordDiff && compareMethod !== "lines") {
-      const wordDiff = computeDiffByMethod(oldLines[i], newLines[j], compareMethod);
-      result.push({
-        leftLineNumber: i + 1,
-        rightLineNumber: j + 1,
-        type: DiffType.MODIFIED,
-        leftContent: wordDiff.left,
-        rightContent: wordDiff.right,
-        leftRaw: oldLines[i],
-        rightRaw: newLines[j]
-      });
-    } else {
-      result.push({
-        leftLineNumber: i + 1,
-        rightLineNumber: j + 1,
-        type: DiffType.MODIFIED,
-        leftContent: oldLines[i],
-        rightContent: newLines[j],
-        leftRaw: oldLines[i],
-        rightRaw: newLines[j]
-      });
-    }
-  }
-  for (let k = pairs; k < dels.length; k++) {
-    const i = dels[k];
-    result.push({
-      leftLineNumber: i + 1,
-      type: DiffType.REMOVED,
-      leftContent: oldLines[i],
-      leftRaw: oldLines[i]
-    });
-  }
-  for (let k = pairs; k < inss.length; k++) {
-    const j = inss[k];
-    result.push({
-      rightLineNumber: j + 1,
-      type: DiffType.ADDED,
-      rightContent: newLines[j],
-      rightRaw: newLines[j]
-    });
-  }
-}
-
-/**
- * Turn the edit script into rows, grouping each run of unmatched lines into a
- * hunk so modification pairing stays local to a real change.
- */
-function buildRowsFromOps(ops, oldLines, newLines, compareMethod, disableWordDiff) {
-  const result = [];
-  let idx = 0;
-  while (idx < ops.length) {
-    const op = ops[idx];
-    if (op.kind === "eq") {
-      result.push({
-        leftLineNumber: op.i + 1,
-        rightLineNumber: op.j + 1,
-        type: DiffType.DEFAULT,
-        leftContent: oldLines[op.i],
-        rightContent: newLines[op.j],
-        leftRaw: oldLines[op.i],
-        rightRaw: newLines[op.j]
-      });
-      idx++;
-      continue;
-    }
-    const dels = [];
-    const inss = [];
-    while (idx < ops.length && ops[idx].kind !== "eq") {
-      const hunkOp = ops[idx];
-      if (hunkOp.kind === "del") dels.push(hunkOp.i);else if (hunkOp.kind === "ins") inss.push(hunkOp.j);
-      idx++;
-    }
-    emitHunk(result, dels, inss, oldLines, newLines, compareMethod, disableWordDiff);
-  }
-  return result;
-}
-
-/**
- * Fallback pairwise walk, used only when the input is past the Myers bounds.
- * Advances both sides in lockstep, so a shifted line reads as changed — the
- * reason it isn't the primary path.
- */
-function pairwiseLineWalk(oldLines, newLines, oldKeys, newKeys, compareMethod, disableWordDiff) {
-  const result = [];
-  let i = 0;
-  let j = 0;
-  while (i < oldLines.length || j < newLines.length) {
-    if (i >= oldLines.length) {
-      result.push({
-        rightLineNumber: j + 1,
-        type: DiffType.ADDED,
-        rightContent: newLines[j],
-        rightRaw: newLines[j]
-      });
-      j++;
-    } else if (j >= newLines.length) {
-      result.push({
-        leftLineNumber: i + 1,
-        type: DiffType.REMOVED,
-        leftContent: oldLines[i],
-        leftRaw: oldLines[i]
-      });
-      i++;
-    } else if (oldKeys[i] === newKeys[j]) {
-      result.push({
-        leftLineNumber: i + 1,
-        rightLineNumber: j + 1,
-        type: DiffType.DEFAULT,
-        leftContent: oldLines[i],
-        rightContent: newLines[j],
-        leftRaw: oldLines[i],
-        rightRaw: newLines[j]
-      });
-      i++;
-      j++;
-    } else {
-      emitHunk(result, [i], [j], oldLines, newLines, compareMethod, disableWordDiff);
-      i++;
-      j++;
-    }
-  }
-  return result;
-}
-
-/**
- * Compute line-by-line diff between two objects
- *
- * Lines are matched with Myers' O(ND) algorithm over normalized keys, so an
- * insert or append shows up as the one line that actually arrived instead of
- * every line after it shifting into a change.
- */
-export function computeLineDiff(oldValue, newValue, options = {}) {
-  const {
-    compareMethod = "words",
-    disableWordDiff = false,
-    showDiffOnly = false,
-    contextLines = 3,
-    ignoreTrailingComma = true
-  } = options;
-  const oldLines = objectToLines(oldValue);
-  const newLines = objectToLines(newValue);
-  const oldKeys = oldLines.map(line => normalizeCompareKey(line, compareMethod, ignoreTrailingComma));
-  const newKeys = newLines.map(line => normalizeCompareKey(line, compareMethod, ignoreTrailingComma));
-  const ops = myersLineOps(oldKeys, newKeys);
-  const result = ops ? buildRowsFromOps(ops, oldLines, newLines, compareMethod, disableWordDiff) : pairwiseLineWalk(oldLines, newLines, oldKeys, newKeys, compareMethod, disableWordDiff);
-
-  // Apply showDiffOnly filter if enabled
-  if (showDiffOnly) {
-    return filterDiffWithContext(result, contextLines);
-  }
-  return result;
-}
+"use strict";export let DiffType=(function(n){n["DEFAULT"]="unchanged";n["ADDED"]="added";n["REMOVED"]="removed";n["MODIFIED"]="modified";return n})({});export const ABSENT_VALUE=Symbol.for("buoy.diff.absent");export function isAbsent(n){return n===ABSENT_VALUE}function y(n,u,f){let t;let l;switch(f){case"chars":t=n.split("");l=u.split("");break;case"words":t=n.match(/\S+|\s+/g)||[];l=u.match(/\S+|\s+/g)||[];break;case"trimmedLines":{const i=n.trim();const h=u.trim();t=i.match(/\S+|\s+/g)||[];l=h.match(/\S+|\s+/g)||[];break}case"lines":default:return{left:[{value:n,type:DiffType.REMOVED}],right:[{value:u,type:DiffType.ADDED}]}}const o=[];const s=[];let r=0,e=0;while(r<t.length&&e<l.length){if(t[r]===l[e]){o.push({value:t[r],type:DiffType.DEFAULT});s.push({value:l[e],type:DiffType.DEFAULT});r++;e++}else{let i=false;for(let h=r+1;h<Math.min(r+5,t.length);h++){if(t[h]===l[e]){for(let c=r;c<h;c++){o.push({value:t[c],type:DiffType.REMOVED})}r=h;i=true;break}}if(!i){for(let h=e+1;h<Math.min(e+5,l.length);h++){if(l[h]===t[r]){for(let c=e;c<h;c++){s.push({value:l[c],type:DiffType.ADDED})}e=h;i=true;break}}}if(!i){o.push({value:t[r],type:DiffType.REMOVED});s.push({value:l[e],type:DiffType.ADDED});r++;e++}}}while(r<t.length){o.push({value:t[r],type:DiffType.REMOVED});r++}while(e<l.length){s.push({value:l[e],type:DiffType.ADDED});e++}return{left:o,right:s}}function g(n){if(isAbsent(n)){return[]}if(n===null||n===void 0){return[String(n)]}try{const u=JSON.stringify(n,null,2);const f=u.split("\n");const t=[];for(let l=0;l<f.length;l++){const o=f[l];const s=o.trim();if(s!==""){t.push(o)}else if(l===0||l===f.length-1){t.push(o)}}return t}catch{return[String(n)]}}function M(n,u){if(u<0)return n;const f=[];const t=[];n.forEach((r,e)=>{if(r.type!==DiffType.DEFAULT){t.push(e)}});if(t.length===0){return[]}const l=[];let o=Math.max(0,t[0]-u);let s=Math.min(n.length-1,t[0]+u);for(let r=1;r<t.length;r++){const e=t[r];const i=Math.max(0,e-u);const h=Math.min(n.length-1,e+u);if(i<=s+1){s=Math.max(s,h)}else{l.push([o,s]);o=i;s=h}}l.push([o,s]);l.forEach(([r,e])=>{for(let i=r;i<=e;i++){f.push(n[i])}});return f}function D(n,u,f){const t=u==="trimmedLines"?n.trim():n;return f?t.replace(/,\s*$/,""):t}function k(n,u){const f=n.trim();const t=u.trim();return!!f&&!!t&&(f.startsWith(t.substring(0,3))||t.startsWith(f.substring(0,3)))}const b=8e3;const d=1024;function R(n,u){const f=n.length;const t=u.length;if(f+t>b)return null;if(f===0&&t===0)return[];const l=f+t;const o=l+1;const s=new Int32Array(2*l+3);const r=Math.min(l,d);const e=[];for(let i=0;i<=r;i++){e.push(s.slice(o-(i+1),o+i+2));for(let h=-i;h<=i;h+=2){let c;if(h===-i||h!==i&&s[h-1+o]<s[h+1+o]){c=s[h+1+o]}else{c=s[h-1+o]+1}let a=c-h;while(c<f&&a<t&&n[c]===u[a]){c++;a++}s[h+o]=c;if(c>=f&&a>=t){return A(e,f,t)}}}return null}function A(n,u,f){const t=[];let l=u;let o=f;for(let s=n.length-1;s>=0;s--){const r=n[s];const e=s+1;const i=l-o;let h;if(i===-s||i!==s&&r[i-1+e]<r[i+1+e]){h=i+1}else{h=i-1}const c=r[h+e];const a=c-h;while(l>c&&o>a){t.push({kind:"eq",i:l-1,j:o-1});l--;o--}if(s>0){if(l===c){t.push({kind:"ins",j:o-1})}else{t.push({kind:"del",i:l-1})}}l=c;o=a}t.reverse();return t}function E(n,u,f,t,l,o,s){const r=Math.min(u.length,f.length);for(let e=0;e<r;e++){const i=u[e];const h=f[e];if(!k(t[i],l[h])){n.push({leftLineNumber:i+1,type:DiffType.REMOVED,leftContent:t[i],leftRaw:t[i]});n.push({rightLineNumber:h+1,type:DiffType.ADDED,rightContent:l[h],rightRaw:l[h]});continue}if(!s&&o!=="lines"){const c=y(t[i],l[h],o);n.push({leftLineNumber:i+1,rightLineNumber:h+1,type:DiffType.MODIFIED,leftContent:c.left,rightContent:c.right,leftRaw:t[i],rightRaw:l[h]})}else{n.push({leftLineNumber:i+1,rightLineNumber:h+1,type:DiffType.MODIFIED,leftContent:t[i],rightContent:l[h],leftRaw:t[i],rightRaw:l[h]})}}for(let e=r;e<u.length;e++){const i=u[e];n.push({leftLineNumber:i+1,type:DiffType.REMOVED,leftContent:t[i],leftRaw:t[i]})}for(let e=r;e<f.length;e++){const i=f[e];n.push({rightLineNumber:i+1,type:DiffType.ADDED,rightContent:l[i],rightRaw:l[i]})}}function C(n,u,f,t,l){const o=[];let s=0;while(s<n.length){const r=n[s];if(r.kind==="eq"){o.push({leftLineNumber:r.i+1,rightLineNumber:r.j+1,type:DiffType.DEFAULT,leftContent:u[r.i],rightContent:f[r.j],leftRaw:u[r.i],rightRaw:f[r.j]});s++;continue}const e=[];const i=[];while(s<n.length&&n[s].kind!=="eq"){const h=n[s];if(h.kind==="del")e.push(h.i);else if(h.kind==="ins")i.push(h.j);s++}E(o,e,i,u,f,t,l)}return o}function N(n,u,f,t,l,o){const s=[];let r=0;let e=0;while(r<n.length||e<u.length){if(r>=n.length){s.push({rightLineNumber:e+1,type:DiffType.ADDED,rightContent:u[e],rightRaw:u[e]});e++}else if(e>=u.length){s.push({leftLineNumber:r+1,type:DiffType.REMOVED,leftContent:n[r],leftRaw:n[r]});r++}else if(f[r]===t[e]){s.push({leftLineNumber:r+1,rightLineNumber:e+1,type:DiffType.DEFAULT,leftContent:n[r],rightContent:u[e],leftRaw:n[r],rightRaw:u[e]});r++;e++}else{E(s,[r],[e],n,u,l,o);r++;e++}}return s}export function computeLineDiff(n,u,f={}){const{compareMethod:t="words",disableWordDiff:l=false,showDiffOnly:o=false,contextLines:s=3,ignoreTrailingComma:r=true}=f;const e=g(n);const i=g(u);const h=e.map(p=>D(p,t,r));const c=i.map(p=>D(p,t,r));const a=R(h,c);const m=a?C(a,e,i,t,l):N(e,i,h,c,t,l);if(o){return M(m,s)}return m}

package/lib/module/dataViewer/nestedPath.js

@@ -1,109 +1 @@
-"use strict";
-
-/**
- * Immutable path writes over arbitrary JSON-ish data — the write kernel the
- * live explorer edits through.
- *
- * Hoisted verbatim from @buoy-gg/react-query (utils/updateNestedDataByPath +
- * utils/deleteNestedDataByPath), where the RQ Data Editor has run on them in
- * production; react-query re-exports from here. Handles objects, arrays, and
- * Map/Set (a Set edit round-trips through an array).
- */
-
-/**
- * Returns a copy of `oldData` with the node at `updatePath` replaced by
- * `value`. An empty path replaces the whole document.
- */
-export const updateNestedDataByPath = (oldData, updatePath, value) => {
-  if (updatePath.length === 0) {
-    return value;
-  }
-  if (oldData instanceof Map) {
-    const newData = new Map(oldData);
-    if (updatePath.length === 1) {
-      newData.set(updatePath[0], value);
-      return newData;
-    }
-    const [head, ...tail] = updatePath;
-    const currentValue = newData.get(head);
-    newData.set(head, updateNestedDataByPath(currentValue ?? null, tail, value));
-    return newData;
-  }
-  if (oldData instanceof Set) {
-    const setAsArray = updateNestedDataByPath(Array.from(oldData), updatePath, value);
-    return new Set(Array.isArray(setAsArray) ? setAsArray : []);
-  }
-  if (Array.isArray(oldData)) {
-    const newData = [...oldData];
-    if (updatePath.length === 1) {
-      // @ts-expect-error NAS
-      newData[updatePath[0]] = value;
-      return newData;
-    }
-    const [head, ...tail] = updatePath;
-    // @ts-expect-error NAS
-    newData[head] = updateNestedDataByPath(newData[head], tail, value);
-    return newData;
-  }
-  if (oldData instanceof Object) {
-    const newData = {
-      ...oldData
-    };
-    if (updatePath.length === 1) {
-      // @ts-expect-error NAS
-      newData[updatePath[0]] = value;
-      return newData;
-    }
-    const [head, ...tail] = updatePath;
-    // @ts-expect-error NAS
-    newData[head] = updateNestedDataByPath(newData[head], tail, value);
-    return newData;
-  }
-  return oldData;
-};
-
-/**
- * Returns a copy of `oldData` without the node at `deletePath`.
- */
-export const deleteNestedDataByPath = (oldData, deletePath) => {
-  if (oldData instanceof Map) {
-    const newData = new Map(oldData);
-    if (deletePath.length === 1) {
-      newData.delete(deletePath[0]);
-      return newData;
-    }
-    const [head, ...tail] = deletePath;
-    newData.set(head, deleteNestedDataByPath(newData.get(head), tail));
-    return newData;
-  }
-  if (oldData instanceof Set) {
-    const setAsArray = deleteNestedDataByPath(Array.from(oldData), deletePath);
-    return new Set(setAsArray);
-  }
-  if (Array.isArray(oldData)) {
-    const newData = [...oldData];
-    if (deletePath.length === 1) {
-      return newData.filter((_, idx) => idx.toString() !== deletePath[0]);
-    }
-    const [head, ...tail] = deletePath;
-
-    // @ts-expect-error NAS
-    newData[head] = deleteNestedDataByPath(newData[head], tail);
-    return newData;
-  }
-  if (oldData instanceof Object) {
-    const newData = {
-      ...oldData
-    };
-    if (deletePath.length === 1) {
-      // @ts-expect-error NAS
-      delete newData[deletePath[0]];
-      return newData;
-    }
-    const [head, ...tail] = deletePath;
-    // @ts-expect-error NAS
-    newData[head] = deleteNestedDataByPath(newData[head], tail);
-    return newData;
-  }
-  return oldData;
-};
+"use strict";export const updateNestedDataByPath=(t,s,r)=>{if(s.length===0){return r}if(t instanceof Map){const n=new Map(t);if(s.length===1){n.set(s[0],r);return n}const[e,...i]=s;const c=n.get(e);n.set(e,updateNestedDataByPath(c??null,i,r));return n}if(t instanceof Set){const n=updateNestedDataByPath(Array.from(t),s,r);return new Set(Array.isArray(n)?n:[])}if(Array.isArray(t)){const n=[...t];if(s.length===1){n[s[0]]=r;return n}const[e,...i]=s;n[e]=updateNestedDataByPath(n[e],i,r);return n}if(t instanceof Object){const n={...t};if(s.length===1){n[s[0]]=r;return n}const[e,...i]=s;n[e]=updateNestedDataByPath(n[e],i,r);return n}return t};export const deleteNestedDataByPath=(t,s)=>{if(t instanceof Map){const r=new Map(t);if(s.length===1){r.delete(s[0]);return r}const[n,...e]=s;r.set(n,deleteNestedDataByPath(r.get(n),e));return r}if(t instanceof Set){const r=deleteNestedDataByPath(Array.from(t),s);return new Set(r)}if(Array.isArray(t)){const r=[...t];if(s.length===1){return r.filter((i,c)=>c.toString()!==s[0])}const[n,...e]=s;r[n]=deleteNestedDataByPath(r[n],e);return r}if(t instanceof Object){const r={...t};if(s.length===1){delete r[s[0]];return r}const[n,...e]=s;r[n]=deleteNestedDataByPath(r[n],e);return r}return t};