@lapismd/design-core 0.1.0

package/src/shared/diff/core/merge/actions.ts

@@ -0,0 +1,142 @@
+import type { MergeAction, MergeModel } from "./types.js";
+import {
+  cloneBlockWithBaseLines,
+  createBlock,
+  linesFromBlock,
+  recomputeModel,
+} from "./blocks.js";
+import { diffSequences } from "./diff.js";
+import { splitLines } from "./lines.js";
+import { assembleOneWayMerge } from "./one-way.js";
+import { assembleThreeWayMerge } from "./three-way.js";
+
+type BlockRange = {
+  blockIndex: number;
+  start: number;
+  end: number;
+};
+
+function blockRangeForIndex(
+  ranges: readonly BlockRange[],
+  index: number,
+): BlockRange | undefined {
+  const containing = ranges.find(
+    (range) => range.start <= index && index < range.end,
+  );
+  if (containing) {
+    return containing;
+  }
+  const atBoundary = ranges.find((range) => range.start === index);
+  if (atBoundary) {
+    return atBoundary;
+  }
+  for (let rangeIndex = ranges.length - 1; rangeIndex >= 0; rangeIndex -= 1) {
+    const range = ranges[rangeIndex];
+    if (range.end <= index) {
+      return range;
+    }
+  }
+  return ranges[0];
+}
+
+function replaceCenterContent(model: MergeModel, content: string): MergeModel {
+  const currentLines = splitLines(model.base);
+  const nextLines = splitLines(content);
+  if (model.blocks.length === 0) {
+    const blocks = [
+      createBlock(
+        0,
+        "unchanged",
+        true,
+        { left: [], base: nextLines, right: [] },
+        { left: null, base: 0, right: null },
+        model.options,
+      ),
+    ];
+    return recomputeModel({ ...model, base: content }, blocks);
+  }
+  const ranges: BlockRange[] = [];
+  let lineIndex = 0;
+  for (let blockIndex = 0; blockIndex < model.blocks.length; blockIndex += 1) {
+    const block = model.blocks[blockIndex];
+    const start = lineIndex;
+    lineIndex += linesFromBlock(block, "base").length;
+    ranges.push({ blockIndex, start, end: lineIndex });
+  }
+  const linesByBlock = model.blocks.map((): string[] => []);
+  let currentIndex = 0;
+  for (const op of diffSequences(currentLines, nextLines, model.options)) {
+    if (op.kind === "same") {
+      const range = blockRangeForIndex(ranges, currentIndex);
+      if (range) {
+        linesByBlock[range.blockIndex].push(op.right);
+      }
+      currentIndex += 1;
+    } else if (op.kind === "left") {
+      currentIndex += 1;
+    } else {
+      const range = blockRangeForIndex(ranges, currentIndex);
+      if (range) {
+        linesByBlock[range.blockIndex].push(op.value);
+      }
+    }
+  }
+  const blocks = model.blocks.map((block, index) =>
+    cloneBlockWithBaseLines(
+      block,
+      linesByBlock[index] ?? [],
+      block.resolved,
+      model.options,
+    ),
+  );
+  return recomputeModel({ ...model, base: content }, blocks);
+}
+
+export function applyMergeAction(
+  model: MergeModel,
+  action: MergeAction,
+): MergeModel {
+  if (action.type === "edit-center") {
+    return model.mode === "three-way"
+      ? replaceCenterContent(model, action.content)
+      : assembleOneWayMerge(model.left, action.content, model.options);
+  }
+  const targetSide =
+    action.type === "accept-left"
+      ? "left"
+      : action.type === "accept-right"
+        ? "right"
+        : action.type === "accept-side" || action.type === "accept-all"
+          ? action.side
+          : null;
+  const applyToAll =
+    action.type === "accept-all" ||
+    (targetSide !== null && !("blockId" in action));
+  const blocks = model.blocks.map((block) => {
+    const isTarget =
+      applyToAll || ("blockId" in action && action.blockId === block.id);
+    if (!isTarget) {
+      return block;
+    }
+    if (targetSide) {
+      return cloneBlockWithBaseLines(
+        block,
+        linesFromBlock(block, targetSide),
+        true,
+        model.options,
+      );
+    }
+    if (action.type === "delete-merged-content") {
+      return cloneBlockWithBaseLines(block, [], true, model.options);
+    }
+    if (action.type === "mark-resolved") {
+      return { ...block, resolved: action.resolved ?? true };
+    }
+    return block;
+  });
+  return recomputeModel(model, blocks);
+}
+
+export function serializeMergeCenter(model: MergeModel): string {
+  return model.base;
+}

package/src/shared/diff/core/merge/blocks.ts

@@ -0,0 +1,120 @@
+import type {
+  MergeBlock,
+  MergeBlockKind,
+  MergeLine,
+  MergeModel,
+  MergeOptions,
+  MergeSide,
+} from "./types.js";
+import { diffInlineParts } from "./inline-diff.js";
+import { hasTrailingNewline, joinLines } from "./lines.js";
+
+export function createLines(
+  blockId: string,
+  side: MergeSide,
+  lines: readonly string[],
+  lineStart: number | null,
+  compareLines: readonly string[],
+  options: Required<MergeOptions>,
+): MergeLine[] {
+  return lines.map((text, index) => ({
+    id: `${blockId}:${side}:${index}`,
+    text,
+    lineNumber: lineStart === null ? null : lineStart + index + 1,
+    parts: diffInlineParts(
+      text,
+      compareLines[index] ?? "",
+      options.lineDiffAlgorithm,
+    ),
+  }));
+}
+
+export function createBlock(
+  index: number,
+  kind: MergeBlockKind,
+  resolved: boolean,
+  linesBySide: Partial<Record<MergeSide, string[]>>,
+  lineStarts: Partial<Record<MergeSide, number | null>>,
+  options: Required<MergeOptions>,
+): MergeBlock {
+  const id = `block-${index}`;
+  const baseCompare = linesBySide.base ?? [];
+  const sides: Partial<Record<MergeSide, MergeLine[]>> = {};
+  for (const side of ["left", "base", "right"] as const) {
+    const sideLines = linesBySide[side];
+    if (!sideLines) {
+      continue;
+    }
+    const compareLines = side === "base" ? sideLines : baseCompare;
+    sides[side] = createLines(
+      id,
+      side,
+      sideLines,
+      lineStarts[side] ?? null,
+      compareLines,
+      options,
+    );
+  }
+  return { id, kind, resolved, sides, originalBaseLines: [...baseCompare] };
+}
+
+export function linesFromBlock(block: MergeBlock, side: MergeSide): string[] {
+  return (block.sides[side] ?? []).map((line) => line.text);
+}
+
+export function recomputeModel(
+  model: MergeModel,
+  blocks: MergeBlock[],
+): MergeModel {
+  const baseLines = blocks.flatMap((block) => linesFromBlock(block, "base"));
+  const conflictCount = blocks.filter(
+    (block) => block.kind === "conflict",
+  ).length;
+  const unresolvedConflictCount = blocks.filter(
+    (block) => block.kind === "conflict" && !block.resolved,
+  ).length;
+  return {
+    ...model,
+    base: joinLines(baseLines, hasTrailingNewline(model.base)),
+    blocks,
+    conflictCount,
+    unresolvedConflictCount,
+  };
+}
+
+export function cloneBlockWithBaseLines(
+  block: MergeBlock,
+  lines: string[],
+  resolved: boolean,
+  options: Required<MergeOptions>,
+): MergeBlock {
+  const lineStart = block.sides.base?.[0]?.lineNumber
+    ? block.sides.base[0].lineNumber - 1
+    : null;
+  const nextBlock = createBlock(
+    Number(block.id.replace("block-", "")) || 0,
+    block.kind,
+    resolved,
+    {
+      left: linesFromBlock(block, "left"),
+      base: lines,
+      right: linesFromBlock(block, "right"),
+    },
+    {
+      left: block.sides.left?.[0]?.lineNumber
+        ? block.sides.left[0].lineNumber - 1
+        : null,
+      base: lineStart,
+      right: block.sides.right?.[0]?.lineNumber
+        ? block.sides.right[0].lineNumber - 1
+        : null,
+    },
+    options,
+  );
+  return {
+    ...nextBlock,
+    originalBaseLines: [
+      ...(block.originalBaseLines ?? linesFromBlock(block, "base")),
+    ],
+  };
+}

package/src/shared/diff/core/merge/diff.ts

@@ -0,0 +1,67 @@
+import type { MergeOptions } from "./types.js";
+import { normalizeComparableLine } from "./options.js";
+
+export type DiffOp =
+  | { kind: "same"; left: string; right: string }
+  | { kind: "left"; value: string }
+  | { kind: "right"; value: string };
+
+export function diffSequences(
+  left: readonly string[],
+  right: readonly string[],
+  options: Required<MergeOptions>,
+): DiffOp[] {
+  const leftComparable = left.map((line) =>
+    normalizeComparableLine(line, options),
+  );
+  const rightComparable = right.map((line) =>
+    normalizeComparableLine(line, options),
+  );
+  const rows = left.length + 1;
+  const columns = right.length + 1;
+  const table = Array.from({ length: rows }, () =>
+    new Array<number>(columns).fill(0),
+  );
+  for (let leftIndex = left.length - 1; leftIndex >= 0; leftIndex -= 1) {
+    for (let rightIndex = right.length - 1; rightIndex >= 0; rightIndex -= 1) {
+      table[leftIndex]![rightIndex] =
+        leftComparable[leftIndex] === rightComparable[rightIndex]
+          ? table[leftIndex + 1]![rightIndex + 1]! + 1
+          : Math.max(
+              table[leftIndex + 1]![rightIndex]!,
+              table[leftIndex]![rightIndex + 1]!,
+            );
+    }
+  }
+  const ops: DiffOp[] = [];
+  let leftIndex = 0;
+  let rightIndex = 0;
+  while (leftIndex < left.length && rightIndex < right.length) {
+    if (leftComparable[leftIndex] === rightComparable[rightIndex]) {
+      ops.push({
+        kind: "same",
+        left: left[leftIndex] ?? "",
+        right: right[rightIndex] ?? "",
+      });
+      leftIndex += 1;
+      rightIndex += 1;
+    } else if (
+      table[leftIndex + 1]![rightIndex]! >= table[leftIndex]![rightIndex + 1]!
+    ) {
+      ops.push({ kind: "left", value: left[leftIndex] ?? "" });
+      leftIndex += 1;
+    } else {
+      ops.push({ kind: "right", value: right[rightIndex] ?? "" });
+      rightIndex += 1;
+    }
+  }
+  while (leftIndex < left.length) {
+    ops.push({ kind: "left", value: left[leftIndex] ?? "" });
+    leftIndex += 1;
+  }
+  while (rightIndex < right.length) {
+    ops.push({ kind: "right", value: right[rightIndex] ?? "" });
+    rightIndex += 1;
+  }
+  return ops;
+}

package/src/shared/diff/core/merge/index.ts

@@ -0,0 +1,32 @@
+export type {
+  LineDiffAlgorithm,
+  MergeAction,
+  MergeBlock,
+  MergeBlockKind,
+  MergeLine,
+  MergeLinePart,
+  MergeMode,
+  MergeModel,
+  MergeOptions,
+  MergeSide,
+} from "./types.js";
+export { applyMergeAction, serializeMergeCenter } from "./actions.js";
+export { assembleOneWayMerge } from "./one-way.js";
+export { assembleThreeWayMerge } from "./three-way.js";
+export { diffSequences, type DiffOp } from "./diff.js";
+export { splitLines } from "./lines.js";
+export { DEFAULT_OPTIONS } from "./options.js";
+export {
+  createMergeRenderModel,
+  deleteMergedRenderComponentFromCenter,
+  mergeRenderComponentIntoCenter,
+  navigationIndexForLine,
+  pendingMergeNavigationTargets,
+  type MergeNavigationTarget,
+  type MergeRenderModel,
+  type RenderAction,
+  type RenderActionKind,
+  type RenderComponent,
+  type RenderConnection,
+  type RenderVisualKind,
+} from "./render-model.js";

package/src/shared/diff/core/merge/inline-diff.ts

@@ -0,0 +1,35 @@
+import type { LineDiffAlgorithm, MergeLinePart } from "./types.js";
+import { diffSequences } from "./diff.js";
+import { DEFAULT_OPTIONS } from "./options.js";
+
+function tokenizeInline(text: string, algorithm: LineDiffAlgorithm): string[] {
+  if (algorithm === "characters") {
+    return [...text];
+  }
+  if (algorithm === "words") {
+    return text.match(/\S+|\s+/g) ?? [];
+  }
+  return text.match(/\w+|\s+|[^\w\s]+/g) ?? [];
+}
+
+export function diffInlineParts(
+  text: string,
+  against: string,
+  algorithm: LineDiffAlgorithm,
+): MergeLinePart[] {
+  if (text === against) {
+    return text ? [{ text, changed: false }] : [];
+  }
+  const tokens = tokenizeInline(text, algorithm);
+  const againstTokens = tokenizeInline(against, algorithm);
+  const ops = diffSequences(tokens, againstTokens, DEFAULT_OPTIONS);
+  const parts: MergeLinePart[] = [];
+  for (const op of ops) {
+    if (op.kind === "same") {
+      parts.push({ text: op.left, changed: false });
+    } else if (op.kind === "left") {
+      parts.push({ text: op.value, changed: true });
+    }
+  }
+  return parts.length > 0 ? parts : [{ text, changed: true }];
+}

package/src/shared/diff/core/merge/lines.ts

@@ -0,0 +1,44 @@
+import type { MergeOptions } from "./types.js";
+import { normalizeComparableLine } from "./options.js";
+
+export function splitLines(text: string): string[] {
+  if (text.length === 0) {
+    return [];
+  }
+  const lines = text.split("\n");
+  if (lines.at(-1) === "") {
+    lines.pop();
+  }
+  return lines;
+}
+
+export function joinLines(
+  lines: readonly string[],
+  trailingNewline: boolean,
+): string {
+  const body = lines.join("\n");
+  return trailingNewline && lines.length > 0 ? `${body}\n` : body;
+}
+
+export function hasTrailingNewline(text: string): boolean {
+  return text.endsWith("\n");
+}
+
+export function linesEqual(
+  left: readonly string[],
+  right: readonly string[],
+  options: Required<MergeOptions>,
+): boolean {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index += 1) {
+    if (
+      normalizeComparableLine(left[index] ?? "", options) !==
+      normalizeComparableLine(right[index] ?? "", options)
+    ) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/shared/diff/core/merge/one-way.ts

@@ -0,0 +1,101 @@
+import type {
+  MergeBlock,
+  MergeBlockKind,
+  MergeModel,
+  MergeOptions,
+} from "./types.js";
+import { createBlock, recomputeModel } from "./blocks.js";
+import { diffSequences } from "./diff.js";
+import { splitLines } from "./lines.js";
+import { normalizeOptions } from "./options.js";
+
+export function assembleOneWayMerge(
+  left: string,
+  right: string,
+  options?: MergeOptions,
+): MergeModel {
+  const normalizedOptions = normalizeOptions(options);
+  const leftLines = splitLines(left);
+  const rightLines = splitLines(right);
+  const ops = diffSequences(leftLines, rightLines, normalizedOptions);
+  const blocks: MergeBlock[] = [];
+  let leftLine = 0;
+  let rightLine = 0;
+  let pendingLeft: string[] = [];
+  let pendingRight: string[] = [];
+  let pendingLeftStart = 0;
+  let pendingRightStart = 0;
+
+  function flushPending(): void {
+    if (pendingLeft.length === 0 && pendingRight.length === 0) {
+      return;
+    }
+    const kind: MergeBlockKind =
+      pendingLeft.length > 0 && pendingRight.length > 0
+        ? "modified"
+        : pendingLeft.length > 0
+          ? "removed"
+          : "added";
+    blocks.push(
+      createBlock(
+        blocks.length,
+        kind,
+        true,
+        { left: pendingLeft, right: pendingRight, base: pendingRight },
+        {
+          left: pendingLeftStart,
+          right: pendingRightStart,
+          base: pendingRightStart,
+        },
+        normalizedOptions,
+      ),
+    );
+    pendingLeft = [];
+    pendingRight = [];
+  }
+
+  for (const op of ops) {
+    if (op.kind === "same") {
+      flushPending();
+      blocks.push(
+        createBlock(
+          blocks.length,
+          "unchanged",
+          true,
+          { left: [op.left], right: [op.right], base: [op.right] },
+          { left: leftLine, right: rightLine, base: rightLine },
+          normalizedOptions,
+        ),
+      );
+      leftLine += 1;
+      rightLine += 1;
+      continue;
+    }
+    if (pendingLeft.length === 0 && pendingRight.length === 0) {
+      pendingLeftStart = leftLine;
+      pendingRightStart = rightLine;
+    }
+    if (op.kind === "left") {
+      pendingLeft.push(op.value);
+      leftLine += 1;
+    } else {
+      pendingRight.push(op.value);
+      rightLine += 1;
+    }
+  }
+  flushPending();
+  return recomputeModel(
+    {
+      mode: "one-way",
+      left,
+      base: right,
+      right,
+      sourceBase: right,
+      blocks,
+      options: normalizedOptions,
+      conflictCount: 0,
+      unresolvedConflictCount: 0,
+    },
+    blocks,
+  );
+}

package/src/shared/diff/core/merge/options.ts

@@ -0,0 +1,25 @@
+import type { MergeOptions } from "./types.js";
+
+export const DEFAULT_OPTIONS: Required<MergeOptions> = {
+  ignoreWhitespace: false,
+  ignoreCase: false,
+  lineDiffAlgorithm: "words_with_space",
+  workingCopyCenter: false,
+};
+
+export function normalizeOptions(
+  options?: MergeOptions,
+): Required<MergeOptions> {
+  return { ...DEFAULT_OPTIONS, ...options };
+}
+
+export function normalizeComparableLine(
+  line: string,
+  options: Required<MergeOptions>,
+): string {
+  let normalized = options.ignoreWhitespace ? line.replace(/\s+/g, "") : line;
+  if (options.ignoreCase) {
+    normalized = normalized.toLocaleLowerCase();
+  }
+  return normalized;
+}