@esportsplus/ui 0.56.4 → 0.57.0

package/src/components/editor/diffs/diff3.ts

@@ -0,0 +1,280 @@
+import { changes, diffSequences, type Change } from './engine';
+
+
+// A conflict block in merged text. Offsets span from the start of its '<<<<<<<' line to past the end of its
+// '>>>>>>>' line; 'line' is its first line, 0-based. The sections keep their own line breaks.
+type ConflictMarker = {
+    base: string | null;
+    current: string;
+    from: number;
+    incoming: string;
+    line: number;
+    to: number;
+};
+
+type MergeChoice = 'both' | 'current' | 'incoming';
+
+// A run of the merge. 'equal' is unchanged on both sides, 'current' and 'incoming' changed on that side only, 'same'
+// changed alike on both, and 'conflict' changed differently. Without a base every difference is a conflict.
+type MergeRegion = {
+    base: readonly string[] | null;
+    current: readonly string[];
+    incoming: readonly string[];
+    kind: 'conflict' | 'current' | 'equal' | 'incoming' | 'same';
+};
+
+type MergeResult = {
+    conflicts: number;
+    regions: MergeRegion[];
+    // Merged text with conflict markers around whatever could not be merged.
+    text: string;
+};
+
+// Where the sections of a block being read start and end, -1 until seen.
+type Open = {
+    at: number;
+    base: number;
+    baseStart: number;
+    current: number;
+    line: number;
+    separator: number;
+    separatorEnd: number;
+};
+
+
+const EOL = /\r\n|\r|\n/;
+
+const LINE = /\r\n|\r|\n|$/g;
+
+const MARKER_BASE = '|||||||';
+
+const MARKER_CURRENT = '<<<<<<<';
+
+const MARKER_INCOMING = '>>>>>>>';
+
+const MARKER_SEPARATOR = '=======';
+
+const TRAILING_EOL = /(?:\r\n|\r|\n)$/;
+
+
+function delta(list: readonly Change[], first: number, last: number) {
+    let out = 0;
+
+    for (let i = first; i < last; i++) {
+        out += (list[i].modified.to - list[i].modified.from) - (list[i].original.to - list[i].original.from);
+    }
+
+    return out;
+}
+
+function equal(a: readonly string[], b: readonly string[]) {
+    if (a.length !== b.length) {
+        return false;
+    }
+
+    for (let i = 0, n = a.length; i < n; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+function is(line: string, marker: string) {
+    return line.startsWith(marker) && (line.length === marker.length || line[marker.length] === ' ');
+}
+
+function threeWay(origin: readonly string[], ours: readonly string[], theirs: readonly string[]) {
+    let left = changes(diffSequences(origin, ours)),
+        right = changes(diffSequences(origin, theirs)),
+        out: MergeRegion[] = [],
+        at = 0,
+        i = 0,
+        j = 0,
+        shiftLeft = 0,
+        shiftRight = 0;
+
+    while (i < left.length || j < right.length) {
+        let first = j >= right.length || (i < left.length && left[i].original.from <= right[j].original.from),
+            start = first ? left[i].original.from : right[j].original.from,
+            end = start,
+            li = i,
+            rj = j;
+
+        // A chunk grows while a change on either side overlaps or touches it.
+        for (let grown = true; grown;) {
+            grown = false;
+
+            while (i < left.length && left[i].original.from <= end) {
+                end = Math.max(end, left[i++].original.to);
+                grown = true;
+            }
+
+            while (j < right.length && right[j].original.from <= end) {
+                end = Math.max(end, right[j++].original.to);
+                grown = true;
+            }
+        }
+
+        if (start > at) {
+            let lines = origin.slice(at, start);
+
+            out.push({ base: lines, current: lines, incoming: lines, kind: 'equal' });
+        }
+
+        let mine = ours.slice(start + shiftLeft, end + shiftLeft + delta(left, li, i)),
+            yours = theirs.slice(start + shiftRight, end + shiftRight + delta(right, rj, j)),
+            kind: MergeRegion['kind'] = 'conflict';
+
+        if (li === i) {
+            kind = 'incoming';
+        }
+        else if (rj === j) {
+            kind = 'current';
+        }
+        else if (equal(mine, yours)) {
+            kind = 'same';
+        }
+
+        out.push({ base: origin.slice(start, end), current: mine, incoming: yours, kind });
+        shiftLeft += delta(left, li, i);
+        shiftRight += delta(right, rj, j);
+        at = end;
+    }
+
+    if (at < origin.length) {
+        let lines = origin.slice(at);
+
+        out.push({ base: lines, current: lines, incoming: lines, kind: 'equal' });
+    }
+
+    return out;
+}
+
+function twoWay(ours: readonly string[], theirs: readonly string[]) {
+    let list = changes(diffSequences(ours, theirs)),
+        out: MergeRegion[] = [],
+        at = 0;
+
+    for (let i = 0, n = list.length; i < n; i++) {
+        let change = list[i];
+
+        if (change.original.from > at) {
+            let lines = ours.slice(at, change.original.from);
+
+            out.push({ base: null, current: lines, incoming: lines, kind: 'equal' });
+        }
+
+        out.push({
+            base: null,
+            current: ours.slice(change.original.from, change.original.to),
+            incoming: theirs.slice(change.modified.from, change.modified.to),
+            kind: 'conflict'
+        });
+        at = change.original.to;
+    }
+
+    if (at < ours.length) {
+        let lines = ours.slice(at);
+
+        out.push({ base: null, current: lines, incoming: lines, kind: 'equal' });
+    }
+
+    return out;
+}
+
+
+// Three-way merge by lines: a change on one side only is taken, and changes on both sides that overlap or touch
+// conflict unless they are identical. Without a base every difference between the sides conflicts.
+const diff3 = (base: string | null, current: string, incoming: string): MergeResult => {
+    let ours = current.split(EOL),
+        theirs = incoming.split(EOL),
+        regions = base === null ? twoWay(ours, theirs) : threeWay(base.split(EOL), ours, theirs),
+        conflicts = 0,
+        lines: string[] = [];
+
+    for (let i = 0, n = regions.length; i < n; i++) {
+        let region = regions[i];
+
+        if (region.kind !== 'conflict') {
+            lines.push(...(region.kind === 'incoming' ? region.incoming : region.current));
+            continue;
+        }
+
+        conflicts++;
+        lines.push(`${MARKER_CURRENT} current`, ...region.current);
+
+        if (region.base) {
+            lines.push(`${MARKER_BASE} base`, ...region.base);
+        }
+
+        lines.push(MARKER_SEPARATOR, ...region.incoming, `${MARKER_INCOMING} incoming`);
+    }
+
+    return { conflicts, regions, text: lines.join(EOL.exec(current)?.[0] ?? '\n') };
+};
+
+// Every complete conflict block in 'text', in order. A block opened again before it closes starts over.
+const conflictMarkers = (text: string): ConflictMarker[] => {
+    let index = 0,
+        open: Open | null = null,
+        out: ConflictMarker[] = [];
+
+    LINE.lastIndex = 0;
+
+    for (let at = 0; ; index++) {
+        let match = LINE.exec(text)!,
+            next = match.index + match[0].length,
+            line = text.slice(at, match.index);
+
+        if (is(line, MARKER_CURRENT)) {
+            open = { at, base: -1, baseStart: -1, current: next, line: index, separator: -1, separatorEnd: -1 };
+        }
+        else if (open && open.separator < 0) {
+            if (open.base < 0 && is(line, MARKER_BASE)) {
+                open.base = at;
+                open.baseStart = next;
+            }
+            else if (line === MARKER_SEPARATOR) {
+                open.separator = at;
+                open.separatorEnd = next;
+            }
+        }
+        else if (open && is(line, MARKER_INCOMING)) {
+            out.push({
+                base: open.base < 0 ? null : text.slice(open.baseStart, open.separator),
+                current: text.slice(open.current, open.base < 0 ? open.separator : open.base),
+                from: open.at,
+                incoming: text.slice(open.separatorEnd, at),
+                line: open.line,
+                to: next
+            });
+            open = null;
+        }
+
+        if (!match[0]) {
+            break;
+        }
+
+        at = next;
+    }
+
+    return out;
+};
+
+// The text that replaces a conflict block for a choice. A block on the last line, without a line break of its own,
+// drops the trailing one its sections carry.
+const resolveMarker = (text: string, marker: ConflictMarker, choice: MergeChoice) => {
+    let out = choice === 'current' ? marker.current : choice === 'incoming' ? marker.incoming : marker.current + marker.incoming;
+
+    if (marker.to === text.length && !TRAILING_EOL.test(text)) {
+        out = out.replace(TRAILING_EOL, '');
+    }
+
+    return out;
+};
+
+
+export { conflictMarkers, diff3, resolveMarker };
+export type { ConflictMarker, MergeChoice, MergeRegion, MergeResult };

package/src/components/editor/diffs/engine.ts

@@ -0,0 +1,192 @@
+// Myers O(ND) diff over sequences, after the forked engine in t3code's @t3tools/diffs.
+
+
+// A run that differs between the two sides, as half-open index ranges: an empty 'original' range is a pure insertion
+// at 'original.from', an empty 'modified' range a pure deletion at 'modified.from'.
+type Change = {
+    modified: Range;
+    original: Range;
+};
+
+type Op = {
+    // Index into the original side for 'equal' and 'delete'.
+    a: number;
+    // Index into the modified side for 'equal' and 'insert'.
+    b: number;
+    type: 'delete' | 'equal' | 'insert';
+};
+
+type Range = { from: number; to: number };
+
+
+const EOL = /\r\n|\r|\n/;
+
+
+function middle<T>(a: readonly T[], b: readonly T[], start: number, endA: number, endB: number, eq: (x: T, y: T) => boolean) {
+    let n = endA - start,
+        m = endB - start,
+        out: Op[] = [];
+
+    if (n === 0 || m === 0) {
+        for (let i = 0; i < n; i++) {
+            out.push({ a: start + i, b: start, type: 'delete' });
+        }
+
+        for (let j = 0; j < m; j++) {
+            out.push({ a: start, b: start + j, type: 'insert' });
+        }
+
+        return out;
+    }
+
+    let max = n + m,
+        offset = max,
+        trace: Int32Array[] = [],
+        v = new Int32Array(2 * max + 1);
+
+    // Each step only keeps the diagonals it can reach, so the trace grows with D squared rather than D times N + M.
+    outer: for (let d = 0; d <= max; d++) {
+        trace.push(v.slice(offset - d, offset + d + 1));
+
+        for (let k = -d; k <= d; k += 2) {
+            let index = offset + k,
+                x = k === -d || (k !== d && v[index - 1] < v[index + 1]) ? v[index + 1] : v[index - 1] + 1,
+                y = x - k;
+
+            while (x < n && y < m && eq(a[start + x], b[start + y])) {
+                x++;
+                y++;
+            }
+
+            v[index] = x;
+
+            if (x >= n && y >= m) {
+                break outer;
+            }
+        }
+    }
+
+    let x = n,
+        y = m;
+
+    for (let d = trace.length - 1; d > 0; d--) {
+        let row = trace[d],
+            k = x - y,
+            previous = k === -d || (k !== d && row[d + k - 1] < row[d + k + 1]) ? k + 1 : k - 1,
+            px = row[d + previous],
+            py = px - previous;
+
+        while (x > px && y > py) {
+            x--;
+            y--;
+            out.push({ a: start + x, b: start + y, type: 'equal' });
+        }
+
+        if (x === px) {
+            y--;
+            out.push({ a: start + x, b: start + y, type: 'insert' });
+        }
+        else {
+            x--;
+            out.push({ a: start + x, b: start + y, type: 'delete' });
+        }
+    }
+
+    while (x > 0 && y > 0) {
+        x--;
+        y--;
+        out.push({ a: start + x, b: start + y, type: 'equal' });
+    }
+
+    while (y > 0) {
+        y--;
+        out.push({ a: start + x, b: start + y, type: 'insert' });
+    }
+
+    while (x > 0) {
+        x--;
+        out.push({ a: start + x, b: start + y, type: 'delete' });
+    }
+
+    return out.reverse();
+}
+
+
+// One op per aligned element, in order. The common prefix and suffix are trimmed first, which dominates real diffs.
+const diffSequences = <T>(a: readonly T[], b: readonly T[], eq: (x: T, y: T) => boolean = (x, y) => x === y): Op[] => {
+    let n = a.length,
+        m = b.length,
+        start = 0;
+
+    while (start < n && start < m && eq(a[start], b[start])) {
+        start++;
+    }
+
+    let endA = n,
+        endB = m;
+
+    while (endA > start && endB > start && eq(a[endA - 1], b[endB - 1])) {
+        endA--;
+        endB--;
+    }
+
+    let out: Op[] = [];
+
+    for (let i = 0; i < start; i++) {
+        out.push({ a: i, b: i, type: 'equal' });
+    }
+
+    let inner = middle(a, b, start, endA, endB, eq);
+
+    for (let i = 0, k = inner.length; i < k; i++) {
+        out.push(inner[i]);
+    }
+
+    for (let i = endA, j = endB; i < n; i++, j++) {
+        out.push({ a: i, b: j, type: 'equal' });
+    }
+
+    return out;
+};
+
+// The runs that differ, merging adjacent deletes and inserts into one change each.
+const changes = (ops: readonly Op[]): Change[] => {
+    let out: Change[] = [],
+        current: Change | null = null;
+
+    for (let i = 0, n = ops.length; i < n; i++) {
+        let op = ops[i];
+
+        if (op.type === 'equal') {
+            current = null;
+            continue;
+        }
+
+        if (!current) {
+            current = { modified: { from: op.b, to: op.b }, original: { from: op.a, to: op.a } };
+            out.push(current);
+        }
+
+        if (op.type === 'delete') {
+            current.original.to = op.a + 1;
+        }
+        else {
+            current.modified.to = op.b + 1;
+        }
+    }
+
+    return out;
+};
+
+// Changed line ranges between two texts, line endings ignored.
+const diffLines = (original: string, modified: string): Change[] => {
+    if (original === modified) {
+        return [];
+    }
+
+    return changes(diffSequences(original.split(EOL), modified.split(EOL)));
+};
+
+
+export { changes, diffLines, diffSequences };
+export type { Change, Op, Range };

package/src/components/editor/diffs/hunks.ts

@@ -0,0 +1,196 @@
+import { diffSequences, type Range } from './engine';
+
+
+// Two texts aligned line by line, with every changed run and the totals for a header.
+type Diff = {
+    additions: number;
+    changes: DiffChange[];
+    deletions: number;
+    modified: readonly string[];
+    original: readonly string[];
+    rows: Row[];
+};
+
+// One contiguous changed run, as 'onaccept' and 'onrevert' receive it. 'original' and 'modified' are 0-based,
+// half-open line ranges, the texts are those lines joined with '\n', and 'rows' indexes 'Diff.rows'.
+type DiffChange = {
+    index: number;
+    modified: Range;
+    modifiedText: string;
+    original: Range;
+    originalText: string;
+    rows: Range;
+};
+
+// Changes grouped with their surrounding context, git style; 'changes' indexes 'Diff.changes'.
+type Hunk = {
+    changes: Range;
+    modified: Range;
+    original: Range;
+    rows: Range;
+};
+
+type Layout = {
+    // Unchanged rows outside every hunk, hidden behind an "N hidden lines" row, leading and trailing ones included.
+    gaps: Range[];
+    hunks: Hunk[];
+};
+
+// One aligned row; 'original' and 'modified' are 0-based line indexes, null on the side the row is absent from.
+type Row = {
+    modified: number | null;
+    original: number | null;
+    type: RowType;
+};
+
+type RowType = 'delete' | 'equal' | 'insert';
+
+
+const EOL = /\r\n|\r|\n/;
+
+
+function eol(text: string) {
+    return EOL.exec(text)?.[0] ?? '\n';
+}
+
+function splice(text: string, range: Range, replacement: string, empty: boolean) {
+    let lines = text.split(EOL);
+
+    lines.splice(range.from, range.to - range.from, ...(empty ? [] : replacement.split('\n')));
+
+    return lines.join(eol(text));
+}
+
+
+// Takes one change into the original text: its original lines become the modified ones.
+const acceptChange = (original: string, change: DiffChange) => {
+    return splice(original, change.original, change.modifiedText, change.modified.from === change.modified.to);
+};
+
+// Every row of both texts in order, with each changed run; 'ignoreWhitespace' compares lines without their leading
+// and trailing whitespace.
+const diffTexts = (original: string, modified: string, { ignoreWhitespace = false }: { ignoreWhitespace?: boolean } = {}): Diff => {
+    let a = original.split(EOL),
+        b = modified.split(EOL),
+        ops = ignoreWhitespace
+            ? diffSequences(a.map((line) => line.trim()), b.map((line) => line.trim()))
+            : diffSequences(a, b),
+        additions = 0,
+        changes: DiffChange[] = [],
+        current: DiffChange | null = null,
+        deletions = 0,
+        rows: Row[] = new Array(ops.length);
+
+    for (let i = 0, n = ops.length; i < n; i++) {
+        let op = ops[i];
+
+        if (op.type === 'equal') {
+            current = null;
+            rows[i] = { modified: op.b, original: op.a, type: 'equal' };
+            continue;
+        }
+
+        if (!current) {
+            current = {
+                index: changes.length,
+                modified: { from: op.b, to: op.b },
+                modifiedText: '',
+                original: { from: op.a, to: op.a },
+                originalText: '',
+                rows: { from: i, to: i }
+            };
+            changes.push(current);
+        }
+
+        current.rows.to = i + 1;
+
+        if (op.type === 'delete') {
+            current.original.to = op.a + 1;
+            deletions++;
+            rows[i] = { modified: null, original: op.a, type: 'delete' };
+        }
+        else {
+            current.modified.to = op.b + 1;
+            additions++;
+            rows[i] = { modified: op.b, original: null, type: 'insert' };
+        }
+    }
+
+    for (let i = 0, n = changes.length; i < n; i++) {
+        let change = changes[i];
+
+        change.modifiedText = b.slice(change.modified.from, change.modified.to).join('\n');
+        change.originalText = a.slice(change.original.from, change.original.to).join('\n');
+    }
+
+    return { additions, changes, deletions, modified: b, original: a, rows };
+};
+
+// Groups changes into hunks with 'context' unchanged rows around each, merging hunks whose context would touch; the
+// rest are gaps. Identical texts are one gap.
+const hunks = (diff: Diff, context = 3): Layout => {
+    let { changes, rows } = diff,
+        gaps: Range[] = [],
+        out: Hunk[] = [],
+        total = rows.length;
+
+    context = Math.max(0, context);
+
+    for (let i = 0, n = changes.length; i < n; i++) {
+        let change = changes[i],
+            from = Math.max(0, change.rows.from - context),
+            last = out[out.length - 1];
+
+        if (last && from <= last.rows.to) {
+            last.changes.to = i + 1;
+            last.rows.to = Math.min(total, change.rows.to + context);
+            continue;
+        }
+
+        out.push({
+            changes: { from: i, to: i + 1 },
+            modified: { from: 0, to: 0 },
+            original: { from: 0, to: 0 },
+            rows: { from, to: Math.min(total, change.rows.to + context) }
+        });
+    }
+
+    let at = 0;
+
+    for (let i = 0, n = out.length; i < n; i++) {
+        let hunk = out[i],
+            first = rows[hunk.rows.from],
+            last = rows[hunk.rows.to - 1];
+
+        if (hunk.rows.from > at) {
+            gaps.push({ from: at, to: hunk.rows.from });
+        }
+
+        at = hunk.rows.to;
+
+        // A row absent from one side still sits between two lines of it; count from the change's own ranges there.
+        hunk.original = {
+            from: first.original ?? changes[hunk.changes.from].original.from,
+            to: last.original === null ? changes[hunk.changes.to - 1].original.to : last.original + 1
+        };
+        hunk.modified = {
+            from: first.modified ?? changes[hunk.changes.from].modified.from,
+            to: last.modified === null ? changes[hunk.changes.to - 1].modified.to : last.modified + 1
+        };
+    }
+
+    if (at < total) {
+        gaps.push({ from: at, to: total });
+    }
+
+    return { gaps, hunks: out };
+};
+
+// Takes one change back out of the modified text: its modified lines become the original ones.
+const revertChange = (modified: string, change: DiffChange) => {
+    return splice(modified, change.modified, change.originalText, change.original.from === change.original.to);
+};
+
+
+export { acceptChange, diffTexts, hunks, revertChange };
+export type { Diff, DiffChange, Hunk, Layout, Row, RowType };

package/src/components/editor/diffs/index.ts

@@ -0,0 +1,20 @@
+import merge from './merge';
+import view from './view';
+import '~/css-utilities/scrollbar/scss/index.scss';
+import './scss/index.scss';
+
+
+const diffs: typeof view & { merge: typeof merge } = Object.assign(view, { merge });
+
+
+export default diffs;
+export { conflictMarkers, diff3, resolveMarker } from './diff3';
+export { changes, diffLines, diffSequences } from './engine';
+export { acceptChange, diffTexts, hunks, revertChange } from './hunks';
+export { words } from './words';
+export type { ConflictMarker, MergeChoice, MergeRegion, MergeResult } from './diff3';
+export type { Change, Op, Range } from './engine';
+export type { Diff, DiffChange, Hunk, Layout, Row, RowType } from './hunks';
+export type { MergeAttributes } from './merge';
+export type { DiffsAttributes, DiffsController, DiffsState, Mode } from './view';
+export type { Words } from './words';