@buoy-gg/shared-ui 7.0.41 → 7.0.42

package/lib/commonjs/dataViewer/lineDiff.js

@@ -1,568 +1 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.DiffType = exports.ABSENT_VALUE = void 0;
-exports.computeLineDiff = computeLineDiff;
-exports.isAbsent = isAbsent;
-/**
- * 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.
- */
-let DiffType = exports.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.
- */
-const ABSENT_VALUE = exports.ABSENT_VALUE = Symbol.for("buoy.diff.absent");
-
-/** True when a diff side represents a value that did not exist. */
-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.
- */
-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";Object.defineProperty(exports,"__esModule",{value:true});exports.DiffType=exports.ABSENT_VALUE=void 0;exports.computeLineDiff=computeLineDiff;exports.isAbsent=isAbsent;let DiffType=exports.DiffType=(function(n){n["DEFAULT"]="unchanged";n["ADDED"]="added";n["REMOVED"]="removed";n["MODIFIED"]="modified";return n})({});const ABSENT_VALUE=exports.ABSENT_VALUE=Symbol.for("buoy.diff.absent");function isAbsent(n){return n===ABSENT_VALUE}function computeDiffByMethod(n,h,f){let t;let s;switch(f){case"chars":t=n.split("");s=h.split("");break;case"words":t=n.match(/\S+|\s+/g)||[];s=h.match(/\S+|\s+/g)||[];break;case"trimmedLines":{const i=n.trim();const l=h.trim();t=i.match(/\S+|\s+/g)||[];s=l.match(/\S+|\s+/g)||[];break}case"lines":default:return{left:[{value:n,type:DiffType.REMOVED}],right:[{value:h,type:DiffType.ADDED}]}}const o=[];const u=[];let r=0,e=0;while(r<t.length&&e<s.length){if(t[r]===s[e]){o.push({value:t[r],type:DiffType.DEFAULT});u.push({value:s[e],type:DiffType.DEFAULT});r++;e++}else{let i=false;for(let l=r+1;l<Math.min(r+5,t.length);l++){if(t[l]===s[e]){for(let c=r;c<l;c++){o.push({value:t[c],type:DiffType.REMOVED})}r=l;i=true;break}}if(!i){for(let l=e+1;l<Math.min(e+5,s.length);l++){if(s[l]===t[r]){for(let c=e;c<l;c++){u.push({value:s[c],type:DiffType.ADDED})}e=l;i=true;break}}}if(!i){o.push({value:t[r],type:DiffType.REMOVED});u.push({value:s[e],type:DiffType.ADDED});r++;e++}}}while(r<t.length){o.push({value:t[r],type:DiffType.REMOVED});r++}while(e<s.length){u.push({value:s[e],type:DiffType.ADDED});e++}return{left:o,right:u}}function objectToLines(n){if(isAbsent(n)){return[]}if(n===null||n===void 0){return[String(n)]}try{const h=JSON.stringify(n,null,2);const f=h.split("\n");const t=[];for(let s=0;s<f.length;s++){const o=f[s];const u=o.trim();if(u!==""){t.push(o)}else if(s===0||s===f.length-1){t.push(o)}}return t}catch{return[String(n)]}}function filterDiffWithContext(n,h){if(h<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 s=[];let o=Math.max(0,t[0]-h);let u=Math.min(n.length-1,t[0]+h);for(let r=1;r<t.length;r++){const e=t[r];const i=Math.max(0,e-h);const l=Math.min(n.length-1,e+h);if(i<=u+1){u=Math.max(u,l)}else{s.push([o,u]);o=i;u=l}}s.push([o,u]);s.forEach(([r,e])=>{for(let i=r;i<=e;i++){f.push(n[i])}});return f}function normalizeCompareKey(n,h,f){const t=h==="trimmedLines"?n.trim():n;return f?t.replace(/,\s*$/,""):t}function looksLikeModification(n,h){const f=n.trim();const t=h.trim();return!!f&&!!t&&(f.startsWith(t.substring(0,3))||t.startsWith(f.substring(0,3)))}const MYERS_MAX_TOTAL_LINES=8e3;const MYERS_MAX_EDIT_DISTANCE=1024;function myersLineOps(n,h){const f=n.length;const t=h.length;if(f+t>MYERS_MAX_TOTAL_LINES)return null;if(f===0&&t===0)return[];const s=f+t;const o=s+1;const u=new Int32Array(2*s+3);const r=Math.min(s,MYERS_MAX_EDIT_DISTANCE);const e=[];for(let i=0;i<=r;i++){e.push(u.slice(o-(i+1),o+i+2));for(let l=-i;l<=i;l+=2){let c;if(l===-i||l!==i&&u[l-1+o]<u[l+1+o]){c=u[l+1+o]}else{c=u[l-1+o]+1}let a=c-l;while(c<f&&a<t&&n[c]===h[a]){c++;a++}u[l+o]=c;if(c>=f&&a>=t){return backtrackOps(e,f,t)}}}return null}function backtrackOps(n,h,f){const t=[];let s=h;let o=f;for(let u=n.length-1;u>=0;u--){const r=n[u];const e=u+1;const i=s-o;let l;if(i===-u||i!==u&&r[i-1+e]<r[i+1+e]){l=i+1}else{l=i-1}const c=r[l+e];const a=c-l;while(s>c&&o>a){t.push({kind:"eq",i:s-1,j:o-1});s--;o--}if(u>0){if(s===c){t.push({kind:"ins",j:o-1})}else{t.push({kind:"del",i:s-1})}}s=c;o=a}t.reverse();return t}function emitHunk(n,h,f,t,s,o,u){const r=Math.min(h.length,f.length);for(let e=0;e<r;e++){const i=h[e];const l=f[e];if(!looksLikeModification(t[i],s[l])){n.push({leftLineNumber:i+1,type:DiffType.REMOVED,leftContent:t[i],leftRaw:t[i]});n.push({rightLineNumber:l+1,type:DiffType.ADDED,rightContent:s[l],rightRaw:s[l]});continue}if(!u&&o!=="lines"){const c=computeDiffByMethod(t[i],s[l],o);n.push({leftLineNumber:i+1,rightLineNumber:l+1,type:DiffType.MODIFIED,leftContent:c.left,rightContent:c.right,leftRaw:t[i],rightRaw:s[l]})}else{n.push({leftLineNumber:i+1,rightLineNumber:l+1,type:DiffType.MODIFIED,leftContent:t[i],rightContent:s[l],leftRaw:t[i],rightRaw:s[l]})}}for(let e=r;e<h.length;e++){const i=h[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:s[i],rightRaw:s[i]})}}function buildRowsFromOps(n,h,f,t,s){const o=[];let u=0;while(u<n.length){const r=n[u];if(r.kind==="eq"){o.push({leftLineNumber:r.i+1,rightLineNumber:r.j+1,type:DiffType.DEFAULT,leftContent:h[r.i],rightContent:f[r.j],leftRaw:h[r.i],rightRaw:f[r.j]});u++;continue}const e=[];const i=[];while(u<n.length&&n[u].kind!=="eq"){const l=n[u];if(l.kind==="del")e.push(l.i);else if(l.kind==="ins")i.push(l.j);u++}emitHunk(o,e,i,h,f,t,s)}return o}function pairwiseLineWalk(n,h,f,t,s,o){const u=[];let r=0;let e=0;while(r<n.length||e<h.length){if(r>=n.length){u.push({rightLineNumber:e+1,type:DiffType.ADDED,rightContent:h[e],rightRaw:h[e]});e++}else if(e>=h.length){u.push({leftLineNumber:r+1,type:DiffType.REMOVED,leftContent:n[r],leftRaw:n[r]});r++}else if(f[r]===t[e]){u.push({leftLineNumber:r+1,rightLineNumber:e+1,type:DiffType.DEFAULT,leftContent:n[r],rightContent:h[e],leftRaw:n[r],rightRaw:h[e]});r++;e++}else{emitHunk(u,[r],[e],n,h,s,o);r++;e++}}return u}function computeLineDiff(n,h,f={}){const{compareMethod:t="words",disableWordDiff:s=false,showDiffOnly:o=false,contextLines:u=3,ignoreTrailingComma:r=true}=f;const e=objectToLines(n);const i=objectToLines(h);const l=e.map(p=>normalizeCompareKey(p,t,r));const c=i.map(p=>normalizeCompareKey(p,t,r));const a=myersLineOps(l,c);const m=a?buildRowsFromOps(a,e,i,t,s):pairwiseLineWalk(e,i,l,c,t,s);if(o){return filterDiffWithContext(m,u)}return m}

package/lib/commonjs/dataViewer/nestedPath.js

@@ -1,115 +1 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.updateNestedDataByPath = exports.deleteNestedDataByPath = void 0;
-/**
- * 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.
- */
-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`.
- */
-exports.updateNestedDataByPath = updateNestedDataByPath;
-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;
-};
-exports.deleteNestedDataByPath = deleteNestedDataByPath;
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.updateNestedDataByPath=exports.deleteNestedDataByPath=void 0;const updateNestedDataByPath=(t,e,n)=>{if(e.length===0){return n}if(t instanceof Map){const r=new Map(t);if(e.length===1){r.set(e[0],n);return r}const[s,...i]=e;const c=r.get(s);r.set(s,updateNestedDataByPath(c??null,i,n));return r}if(t instanceof Set){const r=updateNestedDataByPath(Array.from(t),e,n);return new Set(Array.isArray(r)?r:[])}if(Array.isArray(t)){const r=[...t];if(e.length===1){r[e[0]]=n;return r}const[s,...i]=e;r[s]=updateNestedDataByPath(r[s],i,n);return r}if(t instanceof Object){const r={...t};if(e.length===1){r[e[0]]=n;return r}const[s,...i]=e;r[s]=updateNestedDataByPath(r[s],i,n);return r}return t};exports.updateNestedDataByPath=updateNestedDataByPath;const deleteNestedDataByPath=(t,e)=>{if(t instanceof Map){const n=new Map(t);if(e.length===1){n.delete(e[0]);return n}const[r,...s]=e;n.set(r,deleteNestedDataByPath(n.get(r),s));return n}if(t instanceof Set){const n=deleteNestedDataByPath(Array.from(t),e);return new Set(n)}if(Array.isArray(t)){const n=[...t];if(e.length===1){return n.filter((i,c)=>c.toString()!==e[0])}const[r,...s]=e;n[r]=deleteNestedDataByPath(n[r],s);return n}if(t instanceof Object){const n={...t};if(e.length===1){delete n[e[0]];return n}const[r,...s]=e;n[r]=deleteNestedDataByPath(n[r],s);return n}return t};exports.deleteNestedDataByPath=deleteNestedDataByPath;