reslop 0.2.5 → 0.2.6

package/lib/diff/unit.js

@@ -5,16 +5,14 @@ const { attachInline } = align;
 const files = require('../files.js');
 const { listPath } = files;
 
-const splitEditor = (text) => {
-  const lines = `${text}`.split('\n');
-  if (!lines.length) return [''];
-  return lines;
-};
+const LCS_CELLS = 4000000;
+
+const splitEditor = (text) => text.split('\n');
 
 const splitFile = (text) => {
   if (!text) return [];
-  const lines = `${text}`.split('\n');
-  if (lines.length && lines[lines.length - 1] === '') lines.pop();
+  const lines = text.split('\n');
+  if (lines[lines.length - 1] === '') lines.pop();
   return lines;
 };
 
@@ -28,53 +26,13 @@ const hunkKey = (item) => {
 
 const sameHunk = (left, right) => {
   if (!left || !right) return false;
-  if (left.hunk && right.hunk && left.hunk === right.hunk) {
+  if (left.hunk && left.hunk === right.hunk) {
     return listPath(left) === listPath(right);
   }
-  const key = hunkKey(left);
-  if (!key) return false;
-  return key === hunkKey(right);
-};
-
-const emptyMarks = (last) => {
-  const size = last + 1;
-  const dels = new Array(size);
-  const adds = new Array(size);
-  for (let i = 0; i < size; i++) {
-    dels[i] = [];
-    adds[i] = null;
-  }
-  return { dels, adds };
-};
-
-const clipAt = (n, last) => Math.min(Math.max(1, n), last);
-
-const applyHunk = (marks, item) => {
-  const hunk = item.hunk;
-  if (!hunk || !hunk.lines) return;
-  const last = marks.dels.length - 1;
-  let newLine = hunk.newStart > 0 ? hunk.newStart : 1;
-  for (const line of hunk.lines) {
-    const extra = {
-      text: line.text ?? '',
-      item,
-      blockId: line.blockId,
-      origin: item.origin,
-    };
-    if (line.type === 'del') {
-      marks.dels[clipAt(newLine, last)].push(extra);
-      continue;
-    }
-    if (line.type === 'add') {
-      marks.adds[clipAt(newLine, last)] = extra;
-      newLine += 1;
-      continue;
-    }
-    newLine += 1;
-  }
+  return hunkKey(left) === hunkKey(right);
 };
 
-const tagged = (type, text, extra = {}) => ({
+const tagged = (type, text, extra) => ({
   type,
   text,
   noNl: false,
@@ -83,20 +41,35 @@ const tagged = (type, text, extra = {}) => ({
   item: extra.item ?? null,
 });
 
-const itemsForPath = (items, rel) => {
-  const out = [];
-  for (const item of items) {
-    if (listPath(item) === rel) out.push(item);
+const NO_EXTRA = {};
+
+const clipAt = (n, last) => Math.min(Math.max(1, n), last);
+
+const markHunk = (marks, item) => {
+  if (!item.hunk) return;
+  const last = marks.dels.length - 1;
+  let newLine = item.hunk.newStart > 0 ? item.hunk.newStart : 1;
+  for (const line of item.hunk.lines) {
+    const { type, text, blockId } = line;
+    const mark = { text, item, blockId, origin: item.origin };
+    if (type === 'del') {
+      marks.dels[clipAt(newLine, last)].push(mark);
+      continue;
+    }
+    if (type === 'add') marks.adds[clipAt(newLine, last)] = mark;
+    newLine += 1;
   }
-  return out;
 };
 
+const itemsForPath = (items, rel) =>
+  items.filter((item) => listPath(item) === rel);
+
 const rowsFromAdds = (items) => {
   const rows = [];
   for (const item of items) {
-    const lines = item.hunk && item.hunk.lines ? item.hunk.lines : [];
-    for (const line of lines) {
-      if (line.type === 'add') rows.push(line.text ?? '');
+    if (!item.hunk) continue;
+    for (const line of item.hunk.lines) {
+      if (line.type === 'add') rows.push(line.text);
     }
   }
   return rows;
@@ -105,28 +78,28 @@ const rowsFromAdds = (items) => {
 const unitLines = (text, items) => {
   let rows = splitFile(text);
   if (!rows.length) rows = rowsFromAdds(items);
-  const marks = emptyMarks(rows.length + 1);
-  for (const item of items) applyHunk(marks, item);
+  const size = rows.length + 2;
+  const marks = {
+    dels: Array.from({ length: size }, () => []),
+    adds: new Array(size).fill(null),
+  };
+  for (const item of items) markHunk(marks, item);
   const out = [];
   for (let i = 0; i < rows.length; i++) {
-    const n = i + 1;
-    for (const del of marks.dels[n]) out.push(tagged('del', del.text, del));
-    const add = marks.adds[n];
+    for (const del of marks.dels[i + 1]) out.push(tagged('del', del.text, del));
+    const add = marks.adds[i + 1];
     if (add) out.push(tagged('add', rows[i], add));
-    else out.push(tagged('ctx', rows[i], {}));
+    else out.push(tagged('ctx', rows[i], NO_EXTRA));
   }
   for (const del of marks.dels[rows.length + 1]) {
     out.push(tagged('del', del.text, del));
   }
-  if (!out.length) out.push(tagged('ctx', '', {}));
+  if (!out.length) out.push(tagged('ctx', '', NO_EXTRA));
   return attachInline(out);
 };
 
-const sameBlock = (line, item) => {
-  if (!line || !item) return false;
-  if (line.item !== item) return false;
-  return line.blockId === item.blockId;
-};
+const sameBlock = (line, item) =>
+  line.item === item && line.blockId === item.blockId;
 
 const changedLineRange = (lines, item, belongs) => {
   let start = -1;
@@ -151,12 +124,11 @@ const hunkLineRange = (lines, item) =>
 
 const fileOffset = (lines, at) => {
   let offset = 0;
-  const target = Math.max(0, at);
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     if (line.type === 'del') continue;
-    if (i >= target) return offset;
-    offset += (line.text ?? '').length + 1;
+    if (i >= at) return offset;
+    offset += line.text.length + 1;
   }
   return offset;
 };
@@ -173,37 +145,27 @@ const fileLineIndex = (lines, fileLine) => {
   return last;
 };
 
-const lastEditableIndex = (lines) => {
-  for (let i = lines.length - 1; i >= 0; i--) {
-    if (lines[i].type !== 'del') return i;
-  }
-  return -1;
-};
-
 const attachEditSpans = (lines) => {
+  let lastAt = lines.length - 1;
+  while (lastAt >= 0 && lines[lastAt].type === 'del') lastAt -= 1;
   let offset = 0;
-  const lastAt = lastEditableIndex(lines);
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     if (line.type === 'del') continue;
-    const text = line.text ?? '';
-    const last = i === lastAt;
     line.wrap = true;
     line.editStart = offset;
-    line.editEnd = offset + text.length;
-    line.editLast = last;
-    offset = last ? offset + text.length : offset + text.length + 1;
+    line.editEnd = offset + line.text.length;
+    line.editLast = i === lastAt;
+    offset = line.editEnd + 1;
   }
   return lines;
 };
 
-const LCS_CELLS = 4000000;
-
 const lcsTable = (prev, next) => {
   const n = prev.length;
   const m = next.length;
   const dp = new Array(n + 1);
-  for (let i = 0; i <= n; i++) dp[i] = new Array(m + 1).fill(0);
+  for (let i = 0; i <= n; i++) dp[i] = new Uint32Array(m + 1);
   for (let i = n - 1; i >= 0; i--) {
     for (let j = m - 1; j >= 0; j--) {
       if (prev[i] === next[j]) dp[i][j] = dp[i + 1][j + 1] + 1;
@@ -215,44 +177,35 @@ const lcsTable = (prev, next) => {
 
 const zipOps = (prev, next) => {
   const n = Math.min(prev.length, next.length);
-  const ops = new Array(Math.max(prev.length, next.length));
-  let at = 0;
-  for (let i = 0; i < n; i++) ops[at++] = { kind: 'rep', text: next[i] };
-  for (let i = n; i < prev.length; i++) ops[at++] = { kind: 'del' };
+  const ops = [];
+  for (let i = 0; i < n; i++) ops.push({ kind: 'rep', text: next[i] });
+  for (let i = n; i < prev.length; i++) ops.push({ kind: 'del' });
   for (let i = n; i < next.length; i++) {
-    ops[at++] = { kind: 'ins', text: next[i] };
+    ops.push({ kind: 'ins', text: next[i] });
   }
   return ops;
 };
 
-const walkLcs = (prev, next, dp) => {
-  const ops = new Array(prev.length + next.length - dp[0][0]);
-  let n = 0;
+const lcsOps = (prev, next) => {
+  const dp = lcsTable(prev, next);
+  const ops = [];
   let i = 0;
   let j = 0;
   while (i < prev.length && j < next.length) {
     if (prev[i] === next[j]) {
-      ops[n++] = { kind: 'eq', text: next[j] };
+      ops.push({ kind: 'eq', text: next[j] });
       i += 1;
       j += 1;
-      continue;
-    }
-    if (dp[i + 1][j] >= dp[i][j + 1]) {
-      ops[n++] = { kind: 'del' };
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      ops.push({ kind: 'del' });
       i += 1;
-      continue;
+    } else {
+      ops.push({ kind: 'ins', text: next[j] });
+      j += 1;
     }
-    ops[n++] = { kind: 'ins', text: next[j] };
-    j += 1;
-  }
-  while (i < prev.length) {
-    ops[n++] = { kind: 'del' };
-    i += 1;
-  }
-  while (j < next.length) {
-    ops[n++] = { kind: 'ins', text: next[j] };
-    j += 1;
   }
+  for (; i < prev.length; i++) ops.push({ kind: 'del' });
+  for (; j < next.length; j++) ops.push({ kind: 'ins', text: next[j] });
   return ops;
 };
 
@@ -261,13 +214,10 @@ const collapseRep = (ops) => {
   for (let i = 0; i < ops.length; i++) {
     const op = ops[i];
     const next = ops[i + 1];
-    if (op.kind === 'del' && next && next.kind === 'ins') {
-      out.push({ kind: 'rep', text: next.text });
-      i += 1;
-      continue;
-    }
-    if (op.kind === 'ins' && next && next.kind === 'del') {
-      out.push({ kind: 'rep', text: op.text });
+    const delIns = op.kind === 'del' && next?.kind === 'ins';
+    const insDel = op.kind === 'ins' && next?.kind === 'del';
+    if (delIns || insDel) {
+      out.push({ kind: 'rep', text: delIns ? next.text : op.text });
       i += 1;
       continue;
     }
@@ -279,91 +229,44 @@ const collapseRep = (ops) => {
 const lineOps = (prev, next) => {
   if (prev.length === next.length) return zipOps(prev, next);
   if (prev.length * next.length > LCS_CELLS) return zipOps(prev, next);
-  return collapseRep(walkLcs(prev, next, lcsTable(prev, next)));
+  return collapseRep(lcsOps(prev, next));
 };
 
-const copyRow = (row, text) => ({
-  type: row.type,
-  text,
-  noNl: row.noNl === true,
-  blockId: row.blockId ?? null,
-  origin: row.origin ?? '',
-  item: row.item ?? null,
-});
-
 const pushDels = (out, base, at) => {
   let i = at;
   while (i < base.length && base[i].type === 'del') {
-    out.push(copyRow(base[i], base[i].text ?? ''));
+    out.push(tagged('del', base[i].text, base[i]));
     i += 1;
   }
   return i;
 };
 
-const mergeEditRows = (baseRows, nextTexts) => {
-  const base = baseRows ?? [];
-  const texts = nextTexts && nextTexts.length ? nextTexts : [''];
+const mergeEditRows = (base, nextTexts) => {
+  const texts = nextTexts.length ? nextTexts : [''];
   const prev = [];
-  for (const row of base) {
-    if (row.type === 'del') continue;
-    prev.push(row.text ?? '');
-  }
-  const ops = lineOps(prev, texts);
+  for (const row of base) if (row.type !== 'del') prev.push(row.text);
   const out = [];
   let at = 0;
-  for (const op of ops) {
+  for (const op of lineOps(prev, texts)) {
     at = pushDels(out, base, at);
     if (op.kind === 'ins') {
-      out.push(tagged('ctx', op.text, {}));
+      out.push(tagged('ctx', op.text, NO_EXTRA));
       continue;
     }
     if (at >= base.length) continue;
-    if (op.kind === 'del') {
-      at += 1;
-      continue;
-    }
-    out.push(copyRow(base[at], op.text));
+    if (op.kind !== 'del') out.push(tagged(base[at].type, op.text, base[at]));
     at += 1;
   }
   pushDels(out, base, at);
-  if (!out.length) out.push(tagged('ctx', '', {}));
+  if (!out.length) out.push(tagged('ctx', '', NO_EXTRA));
   return attachEditSpans(attachInline(out));
 };
 
-const fileLines = (text) => {
-  const rows = splitFile(text);
-  if (!rows.length) rows.push('');
-  const { length } = rows;
-  const out = new Array(length);
-  let offset = 0;
-  for (let i = 0; i < length; i++) {
-    const row = rows[i];
-    const start = offset;
-    const end = start + row.length;
-    const last = i === length - 1;
-    out[i] = {
-      type: 'ctx',
-      text: row,
-      noNl: false,
-      wrap: true,
-      editStart: start,
-      editEnd: end,
-      editLast: last,
-      blockId: null,
-      origin: '',
-      item: null,
-    };
-    offset = last ? end : end + 1;
-  }
-  return out;
-};
-
 module.exports = {
   splitFile,
   splitEditor,
   itemsForPath,
   unitLines,
-  sameBlock,
   sameHunk,
   hunkKey,
   blockLineRange,
@@ -371,7 +274,5 @@ module.exports = {
   blockLineIndex,
   fileOffset,
   fileLineIndex,
-  attachEditSpans,
   mergeEditRows,
-  fileLines,
 };

package/lib/editor.js

@@ -6,6 +6,7 @@ const wrap = require('./wrap.js');
 const { wrapMove } = wrap;
 
 const UNDO_CAP = 100;
+const WORD_RE = /[\p{L}\p{N}_]/u;
 
 const graphemeIndex = (text, cursor) => {
   const parts = graphemes(text);
@@ -24,10 +25,10 @@ const offsetAt = (parts, count) => {
   return pos;
 };
 
-const WORD_RE = /[\p{L}\p{N}_]/u;
-
 const isWordChar = (ch) => WORD_RE.test(ch);
 
+const isSeparator = (ch) => !isWordChar(ch);
+
 const skipWhile = (parts, at, dir, pred) => {
   if (dir > 0) {
     while (at < parts.length && pred(parts[at])) at += 1;
@@ -38,20 +39,10 @@ const skipWhile = (parts, at, dir, pred) => {
 };
 
 const wordIndex = (parts, at, dir) => {
-  const word = (ch) => isWordChar(ch);
-  const sep = (ch) => !isWordChar(ch);
-  if (dir > 0) {
-    if (at < parts.length && word(parts[at])) {
-      return skipWhile(parts, at, 1, word);
-    }
-    at = skipWhile(parts, at, 1, sep);
-    return skipWhile(parts, at, 1, word);
-  }
-  if (at > 0 && word(parts[at - 1])) {
-    return skipWhile(parts, at, -1, word);
-  }
-  at = skipWhile(parts, at, -1, sep);
-  return skipWhile(parts, at, -1, word);
+  const ahead = dir > 0 ? parts[at] : parts[at - 1];
+  const inWord = ahead !== undefined && isWordChar(ahead);
+  const start = inWord ? at : skipWhile(parts, at, dir, isSeparator);
+  return skipWhile(parts, start, dir, isWordChar);
 };
 
 class Editor {
@@ -72,17 +63,22 @@ class Editor {
   restore(snap) {
     this.text = snap.text;
     this.cursor = snap.cursor;
-    this.anchor = snap.anchor ?? null;
+    this.anchor = snap.anchor;
   }
 
   hasSelect() {
     return this.anchor !== null && this.anchor !== this.cursor;
   }
 
-  selectedText() {
-    if (!this.hasSelect()) return '';
+  span() {
+    if (!this.hasSelect()) return { lo: this.cursor, hi: this.cursor };
     const lo = Math.min(this.anchor, this.cursor);
     const hi = Math.max(this.anchor, this.cursor);
+    return { lo, hi };
+  }
+
+  selectedText() {
+    const { lo, hi } = this.span();
     return this.text.slice(lo, hi);
   }
 
@@ -95,26 +91,21 @@ class Editor {
   }
 
   collapse(delta) {
-    const lo = Math.min(this.anchor, this.cursor);
-    const hi = Math.max(this.anchor, this.cursor);
+    const { lo, hi } = this.span();
     this.anchor = null;
     this.cursor = delta < 0 ? lo : hi;
   }
 
   removeSpan() {
     if (!this.hasSelect()) return false;
-    const lo = Math.min(this.anchor, this.cursor);
-    const hi = Math.max(this.anchor, this.cursor);
-    const next = this.text.slice(0, lo) + this.text.slice(hi);
-    this.edit(next, lo);
+    const { lo, hi } = this.span();
+    this.edit(this.text.slice(0, lo) + this.text.slice(hi), lo);
     return true;
   }
 
   edit(nextText, nextCursor) {
     this.undo.push(this.snapshot());
-    if (this.undo.length > UNDO_CAP) {
-      this.undo = this.undo.slice(this.undo.length - UNDO_CAP);
-    }
+    if (this.undo.length > UNDO_CAP) this.undo.shift();
     this.redo = [];
     this.text = nextText;
     this.cursor = nextCursor;
@@ -123,12 +114,9 @@ class Editor {
 
   insert(chunk) {
     this.wantCol = null;
-    const selected = this.hasSelect();
-    const lo = selected ? Math.min(this.anchor, this.cursor) : this.cursor;
-    const hi = selected ? Math.max(this.anchor, this.cursor) : this.cursor;
-    const before = this.text.slice(0, lo);
-    const after = this.text.slice(hi);
-    this.edit(before + chunk + after, lo + chunk.length);
+    const { lo, hi } = this.span();
+    const next = this.text.slice(0, lo) + chunk + this.text.slice(hi);
+    this.edit(next, lo + chunk.length);
   }
 
   replace(text) {
@@ -137,29 +125,29 @@ class Editor {
   }
 
   place(offset) {
-    const next = Math.max(0, Math.min(offset, this.text.length));
     this.wantCol = null;
     this.anchor = null;
-    this.cursor = next;
+    this.cursor = Math.max(0, Math.min(offset, this.text.length));
   }
 
   backspace() {
     this.wantCol = null;
     if (this.removeSpan()) return;
-    const { parts, i } = graphemeIndex(this.text, this.cursor);
+    const { parts, i, pos } = graphemeIndex(this.text, this.cursor);
     if (i === 0) return;
-    const drop = parts[i - 1];
-    const nextParts = [...parts.slice(0, i - 1), ...parts.slice(i)];
-    this.edit(nextParts.join(''), this.cursor - drop.length);
+    const size = parts[i - 1].length;
+    const next = this.text.slice(0, pos - size) + this.text.slice(pos);
+    this.edit(next, this.cursor - size);
   }
 
   delete() {
     this.wantCol = null;
     if (this.removeSpan()) return;
-    const { parts, i } = graphemeIndex(this.text, this.cursor);
+    const { parts, i, pos } = graphemeIndex(this.text, this.cursor);
     if (i >= parts.length) return;
-    const nextParts = [...parts.slice(0, i), ...parts.slice(i + 1)];
-    this.edit(nextParts.join(''), this.cursor);
+    const next =
+      this.text.slice(0, pos) + this.text.slice(pos + parts[i].length);
+    this.edit(next, this.cursor);
   }
 
   move(delta, extend) {
@@ -183,15 +171,14 @@ class Editor {
 
   linePos() {
     const before = this.text.slice(0, this.cursor);
-    const at = before.lastIndexOf('\n');
     const line = before.split('\n').length - 1;
-    const col = at < 0 ? before.length : before.length - at - 1;
+    const col = before.length - before.lastIndexOf('\n') - 1;
     return { line, col };
   }
 
   visibleLineCol() {
     const { col, line } = this.linePos();
-    const row = this.text.split('\n')[line] ?? '';
+    const row = this.text.split('\n')[line];
     return visibleWidth(row.slice(0, col));
   }
 
@@ -203,60 +190,56 @@ class Editor {
   }
 
   moveLine(delta, width, extend) {
-    if (!extend) this.clearSelect();
-    else this.beginSelect();
+    if (extend) this.beginSelect();
+    else this.clearSelect();
     if (width !== undefined) {
-      const col = this.wantCol;
-      const moved = wrapMove(this.text, this.cursor, width, delta, col);
+      const moved = wrapMove(
+        this.text,
+        this.cursor,
+        width,
+        delta,
+        this.wantCol,
+      );
       this.wantCol = moved.col;
       this.cursor = moved.cursor;
       return;
     }
     const rows = this.text.split('\n');
     const { line, col } = this.linePos();
-    let next = line + delta;
-    if (next < 0) next = 0;
-    if (next >= rows.length) next = rows.length - 1;
+    const next = Math.min(Math.max(line + delta, 0), rows.length - 1);
     if (next === line) return;
-    const row = rows[next];
-    const c = Math.min(col, row.length);
     let cursor = 0;
     for (let i = 0; i < next; i++) cursor += rows[i].length + 1;
-    this.cursor = cursor + c;
+    this.cursor = cursor + Math.min(col, rows[next].length);
   }
 
   home(extend) {
     this.wantCol = null;
-    if (!extend) this.clearSelect();
-    else this.beginSelect();
-    const { col } = this.linePos();
-    this.cursor -= col;
+    if (extend) this.beginSelect();
+    else this.clearSelect();
+    this.cursor -= this.linePos().col;
   }
 
   end(extend) {
     this.wantCol = null;
-    if (!extend) this.clearSelect();
-    else this.beginSelect();
+    if (extend) this.beginSelect();
+    else this.clearSelect();
     const { line, col } = this.linePos();
-    const rows = this.text.split('\n');
-    const row = rows[line] ?? '';
-    this.cursor += row.length - col;
+    this.cursor += this.text.split('\n')[line].length - col;
   }
 
   undoEdit() {
     if (!this.undo.length) return;
     this.wantCol = null;
-    const prev = this.undo.pop();
     this.redo.push(this.snapshot());
-    this.restore(prev);
+    this.restore(this.undo.pop());
   }
 
   redoEdit() {
     if (!this.redo.length) return;
     this.wantCol = null;
-    const next = this.redo.pop();
     this.undo.push(this.snapshot());
-    this.restore(next);
+    this.restore(this.redo.pop());
   }
 }