ompchamber 2.0.2 → 3.1.0

package/src/shared/lib/code/editor/find.test.ts

@@ -0,0 +1,203 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The find widget's arithmetic: what a query matches, where the caret lands
+ * after a replacement, and how `$1` is expanded. These are the rules the widget
+ * count, the on-screen highlights and the written buffer all read, so each is
+ * asserted against the engine's own `String.replace` behaviour where one
+ * exists.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  buildFindRegex,
+  expandReplacement,
+  findMatches,
+  lineIndexAt,
+  lineStartOffset,
+  matchIndexAtOrAfter,
+  MAX_FIND_MATCHES,
+  replaceAllMatches,
+  replaceMatch,
+  stepMatchIndex,
+  type FindOptions,
+} from '@/shared/lib/code/editor/find';
+
+const PLAIN: FindOptions = { matchCase: false, wholeWord: false, isRegex: false };
+
+describe('findMatches', () => {
+  test('finds literal occurrences in document order, ignoring case by default', () => {
+    const text = 'Alpha beta ALPHA alpha';
+    expect(findMatches(text, 'alpha', PLAIN).matches).toEqual([
+      { start: 0, end: 5 },
+      { start: 11, end: 16 },
+      { start: 17, end: 22 },
+    ]);
+  });
+
+  test('matchCase narrows to the exact spelling', () => {
+    expect(findMatches('Alpha alpha', 'alpha', { ...PLAIN, matchCase: true }).matches).toEqual([
+      { start: 6, end: 11 },
+    ]);
+  });
+
+  test('wholeWord rejects a match inside a longer word', () => {
+    const text = 'cat category cat';
+    expect(findMatches(text, 'cat', { ...PLAIN, wholeWord: true }).matches).toEqual([
+      { start: 0, end: 3 },
+      { start: 13, end: 16 },
+    ]);
+  });
+
+  test('wholeWord keeps an alternation’s own precedence', () => {
+    // `\bfoo|bar\b` would match `bar` inside `barbaz`; the group prevents it.
+    expect(findMatches('barbaz bar', 'foo|bar', { ...PLAIN, wholeWord: true, isRegex: true }).matches).toEqual([
+      { start: 7, end: 10 },
+    ]);
+  });
+
+  test('regex mode compiles the query as written', () => {
+    expect(findMatches('a1 b2 c3', '[a-z]\\d', { ...PLAIN, isRegex: true }).matches).toEqual([
+      { start: 0, end: 2 },
+      { start: 3, end: 5 },
+      { start: 6, end: 8 },
+    ]);
+  });
+
+  test('an uncompilable regex is reported as invalid, not as no matches', () => {
+    const result = findMatches('abc', '(', { ...PLAIN, isRegex: true });
+    expect(result).toEqual({ matches: [], truncated: false, invalid: true });
+  });
+
+  test('an empty query matches nothing and is not an error', () => {
+    expect(findMatches('abc', '', PLAIN)).toEqual({ matches: [], truncated: false, invalid: false });
+  });
+
+  test('skips zero-width matches instead of looping forever', () => {
+    const result = findMatches('abc', 'x*', { ...PLAIN, isRegex: true });
+    expect(result.matches).toEqual([]);
+    expect(result.invalid).toBe(false);
+  });
+
+  test('caps the collected matches and says so', () => {
+    const text = 'a'.repeat(MAX_FIND_MATCHES + 10);
+    const result = findMatches(text, 'a', PLAIN);
+    expect(result.matches).toHaveLength(MAX_FIND_MATCHES);
+    expect(result.truncated).toBe(true);
+  });
+});
+
+describe('buildFindRegex', () => {
+  test('escapes a literal query so regex metacharacters are literal', () => {
+    const regex = buildFindRegex('a.c', PLAIN);
+    expect(regex?.test('a.c')).toBe(true);
+    expect(regex?.test('abc')).toBe(false);
+  });
+
+  test('returns null for an empty query and for a bad pattern', () => {
+    expect(buildFindRegex('', PLAIN)).toBeNull();
+    expect(buildFindRegex('[', { ...PLAIN, isRegex: true })).toBeNull();
+  });
+});
+
+describe('replaceMatch', () => {
+  test('literal replacement inserts the field verbatim, dollar signs included', () => {
+    const text = 'const a = 1;';
+    const result = replaceMatch(text, { start: 6, end: 7 }, 'a', '$&x', PLAIN);
+    expect(result?.text).toBe('const $&x = 1;');
+    expect(result?.caret).toBe(6 + 3);
+  });
+
+  test('regex replacement expands capture groups like String.replace', () => {
+    const text = 'key = value';
+    const result = replaceMatch(text, { start: 6, end: 11 }, '(\\w+)', '[$1]', { ...PLAIN, isRegex: true });
+    expect(result?.text).toBe('key = [value]');
+    expect(result?.caret).toBe(13);
+  });
+
+  test('refuses a match that is no longer at its offset', () => {
+    expect(replaceMatch('abc', { start: 5, end: 7 }, 'a', 'z', PLAIN)).toBeNull();
+  });
+});
+
+describe('replaceAllMatches', () => {
+  test('literal replace-all rewrites every occurrence', () => {
+    expect(replaceAllMatches('a a a', 'a', 'b', PLAIN)).toBe('b b b');
+  });
+
+  test('regex replace-all agrees with the engine', () => {
+    const text = 'foo1 bar2';
+    const options: FindOptions = { ...PLAIN, isRegex: true };
+    expect(replaceAllMatches(text, '([a-z]+)(\\d)', '$2-$1', options)).toBe(text.replace(/([a-z]+)(\d)/g, '$2-$1'));
+  });
+
+  test('whole-word replace-all leaves substrings alone', () => {
+    expect(replaceAllMatches('cat category', 'cat', 'dog', { ...PLAIN, wholeWord: true })).toBe('dog category');
+  });
+
+  test('returns null for an unusable query', () => {
+    expect(replaceAllMatches('abc', '(', 'x', { ...PLAIN, isRegex: true })).toBeNull();
+    expect(replaceAllMatches('abc', '', 'x', PLAIN)).toBeNull();
+  });
+});
+
+describe('expandReplacement', () => {
+  /** Indexed by group number, `[0]` unused — the shape `groupsOf` produces. */
+  const groups = { full: 'ab12', numbered: [undefined, 'a', 'b'] as const, named: { tail: '12' } };
+
+  test('expands $&, $1 and $<name>', () => {
+    expect(expandReplacement('$&|$1|$2|$<tail>', groups)).toBe('ab12|a|b|12');
+  });
+
+  test('$$ is a literal dollar and an unknown group is empty', () => {
+    expect(expandReplacement('$$$9', groups)).toBe('$');
+  });
+
+  test('a missing two-digit group falls back to the one-digit group plus the digit', () => {
+    // The engine's own reading of `$12` with two groups: `$1` then a literal `2`.
+    expect('x'.replace(/(x)/, '$12')).toBe('x2');
+    expect(expandReplacement('$12', groups)).toBe('a2');
+  });
+
+  test('a template without a dollar is returned as-is', () => {
+    expect(expandReplacement('plain', groups)).toBe('plain');
+  });
+});
+
+describe('caret anchoring', () => {
+  test('lineIndexAt and lineStartOffset are inverses for every line start', () => {
+    const text = 'one\ntwo\n\nfour';
+    // Line starts in `text`: 0, 4, 8 (the empty line) and 9.
+    for (const offset of [0, 4, 8, 9]) {
+      const line = lineIndexAt(text, offset);
+      expect(lineStartOffset(text, line)).toBe(offset);
+    }
+    expect(lineIndexAt(text, 13)).toBe(3);
+  });
+
+  test('lineIndexAt clamps an offset past the end to the last line', () => {
+    expect(lineIndexAt('one\ntwo', 999)).toBe(1);
+  });
+
+  test('a caret inside a match selects that match, and past the last wraps to the first', () => {
+    const matches = [
+      { start: 0, end: 3 },
+      { start: 10, end: 13 },
+    ];
+    expect(matchIndexAtOrAfter(matches, 1)).toBe(0);
+    expect(matchIndexAtOrAfter(matches, 3)).toBe(1);
+    expect(matchIndexAtOrAfter(matches, 13)).toBe(0);
+    expect(matchIndexAtOrAfter([], 0)).toBe(-1);
+  });
+
+  test('stepping wraps at both ends', () => {
+    expect(stepMatchIndex(2, 3, 1)).toBe(0);
+    expect(stepMatchIndex(0, 3, -1)).toBe(2);
+    expect(stepMatchIndex(-1, 3, -1)).toBe(2);
+    expect(stepMatchIndex(0, 0, 1)).toBe(-1);
+  });
+});

package/src/shared/lib/code/editor/find.ts

@@ -0,0 +1,224 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { lineIndexAt, lineStartOffset, type TextRange } from '@/shared/lib/code/editor/lines';
+
+export { lineIndexAt, lineStartOffset };
+
+/**
+ * Find and replace over one document buffer — the pure half of the editor's
+ * find widget.
+ *
+ * Everything here is offset arithmetic on a string: what the query compiles
+ * to, which ranges match, where the caret lands after a replacement, and how
+ * `$1` is expanded. The widget, the hook that owns its state and the editor
+ * surface that paints the matches all read these results, so none of them
+ * re-implements a rule and the count in the widget cannot disagree with the
+ * ranges on screen.
+ */
+
+export interface FindOptions {
+  matchCase: boolean;
+  wholeWord: boolean;
+  isRegex: boolean;
+}
+
+/** Half-open `[start, end)` offset range in the document. */
+export type FindMatch = TextRange;
+
+export interface FindResult {
+  matches: FindMatch[];
+  /** The document holds more matches than the cap; the list stops at it. */
+  truncated: boolean;
+  /** A regex query that does not compile — a different answer from "no matches". */
+  invalid: boolean;
+}
+
+/**
+ * Ceiling on collected matches. A one-character query over a large file matches
+ * tens of thousands of times and every match costs a Range in the highlight
+ * registry, so past this the list stops and the widget reports `N+`.
+ */
+export const MAX_FIND_MATCHES = 5_000;
+
+export const DEFAULT_FIND_OPTIONS: FindOptions = {
+  matchCase: false,
+  wholeWord: false,
+  isRegex: false,
+};
+
+/**
+ * The pattern a query compiles to, or null when the query is empty or does not
+ * compile. A literal query is escaped here rather than at the call site so the
+ * match scan and the replacement splice can never disagree about what the
+ * pattern was.
+ *
+ * Whole-word is a `\b`-anchored non-capturing group rather than a bare wrap so
+ * an alternation (`foo|bar`) keeps its own precedence.
+ */
+export function buildFindRegex(query: string, options: FindOptions): RegExp | null {
+  if (!query) return null;
+  const source = options.isRegex ? query : query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const wrapped = options.wholeWord ? `\\b(?:${source})\\b` : source;
+  try {
+    return new RegExp(wrapped, options.matchCase ? 'g' : 'gi');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Every match of `query` in `text`, in document order.
+ *
+ * Zero-width matches (`^`, `\b`, `a*`) are skipped: they have nothing to
+ * highlight and nothing to replace, and stepping past them is what keeps the
+ * scan terminating.
+ */
+export function findMatches(text: string, query: string, options: FindOptions): FindResult {
+  const regex = buildFindRegex(query, options);
+  if (!query) return { matches: [], truncated: false, invalid: false };
+  if (!regex) return { matches: [], truncated: false, invalid: true };
+
+  const matches: FindMatch[] = [];
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(text)) !== null) {
+    if (match[0].length === 0) {
+      regex.lastIndex += 1;
+      continue;
+    }
+    matches.push({ start: match.index, end: match.index + match[0].length });
+    if (matches.length >= MAX_FIND_MATCHES) return { matches, truncated: true, invalid: false };
+  }
+  return { matches, truncated: false, invalid: false };
+}
+
+/**
+ * The match to call "current" for a caret/anchor at `offset`: the first one
+ * that ends after it, so a caret sitting inside a match still counts as being
+ * on that match. Wraps to the first match when the anchor is past the last one,
+ * and reports -1 for an empty list.
+ */
+export function matchIndexAtOrAfter(matches: readonly FindMatch[], offset: number): number {
+  if (matches.length === 0) return -1;
+  for (let index = 0; index < matches.length; index++) {
+    if (matches[index].end > offset) return index;
+  }
+  return 0;
+}
+
+/** Step one match forward (`1`) or back (`-1`), wrapping at either end. */
+export function stepMatchIndex(index: number, count: number, direction: 1 | -1): number {
+  if (count <= 0) return -1;
+  if (index < 0) return direction === 1 ? 0 : count - 1;
+  return (index + direction + count) % count;
+}
+
+/** What a replacement template is expanded against. */
+export interface MatchGroups {
+  /** `$&` — the whole match. */
+  full: string;
+  /** `$1`…`$99`, indexed by their own number: entry `n` is group `n` (`[0]` is unused). */
+  numbered: readonly (string | undefined)[];
+  /** `$<name>` — named capture groups. */
+  named?: Record<string, string | undefined>;
+}
+
+/** The engine's own argument order: `found[1]` is `$1`. */
+function groupsOf(found: RegExpExecArray): MatchGroups {
+  return {
+    full: found[0],
+    numbered: [undefined, ...found.slice(1)],
+    named: found.groups,
+  };
+}
+
+const SUBSTITUTION = /\$(\$|&|\d{1,2}|<[^>]*>)/g;
+
+/**
+ * Expand a replacement template the way `String.prototype.replace` does for a
+ * string replacement: `$$`, `$&`, `$1`–`$99` and `$<name>`. The prefix/suffix
+ * forms (`` $` `` / `$'`) are deliberately left literal — nothing in the UI
+ * offers them, and leaving the two characters alone is the honest reading.
+ *
+ * A two-digit group that does not exist falls back to the one-digit group plus
+ * the second digit, which is the engine's own behaviour for `$12` when the
+ * pattern has one group.
+ */
+export function expandReplacement(template: string, groups: MatchGroups): string {
+  if (!template.includes('$')) return template;
+  return template.replace(SUBSTITUTION, (_token, body: string) => {
+    if (body === '$') return '$';
+    if (body === '&') return groups.full;
+    if (body.startsWith('<')) return groups.named?.[body.slice(1, -1)] ?? '';
+    if (body.length === 2) {
+      const direct = groups.numbered[Number(body)];
+      if (direct !== undefined) return direct;
+      const first = groups.numbered[Number(body[0])];
+      return first === undefined ? '' : first + body[1];
+    }
+    return groups.numbered[Number(body)] ?? '';
+  });
+}
+
+/**
+ * Replace one match. Returns the new buffer and where the caret should land
+ * (just after the inserted text), or null when the match is no longer there —
+ * the regex is re-run at the match's own offset rather than trusting the
+ * offsets handed in, so a stale list cannot splice the wrong range.
+ */
+export function replaceMatch(
+  text: string,
+  match: FindMatch,
+  query: string,
+  replacement: string,
+  options: FindOptions,
+): { text: string; caret: number } | null {
+  const regex = buildFindRegex(query, options);
+  if (!regex) return null;
+  // The pattern is re-run at the match's own offset rather than trusting the
+  // offsets handed in: a list computed against an older buffer cannot splice
+  // the wrong range out of the current one.
+  regex.lastIndex = match.start;
+  const found = regex.exec(text);
+  if (!found || found.index !== match.start) return null;
+  if (!options.isRegex) {
+    // Literal mode inserts the field verbatim: `$&` in the replace box is the
+    // two characters the user typed, not the match.
+    return {
+      text: text.slice(0, match.start) + replacement + text.slice(match.end),
+      caret: match.start + replacement.length,
+    };
+  }
+  const inserted = expandReplacement(replacement, groupsOf(found));
+  return {
+    text: text.slice(0, found.index) + inserted + text.slice(found.index + found[0].length),
+    caret: found.index + inserted.length,
+  };
+}
+
+/** Replace every match. Null when the query is empty or does not compile. */
+export function replaceAllMatches(
+  text: string,
+  query: string,
+  replacement: string,
+  options: FindOptions,
+): string | null {
+  const regex = buildFindRegex(query, options);
+  if (!regex) return null;
+  if (!options.isRegex) return text.replace(regex, () => replacement);
+  return text.replace(regex, (...args: unknown[]) => {
+    // A replacer's arguments are `(match, …groups, offset, string, groups?)`;
+    // rebuilding an exec result from them keeps one expansion rule for both
+    // the single and the bulk path.
+    const last = args[args.length - 1];
+    const hasNamed = typeof last === 'object' && last !== null;
+    const groups = args.slice(1, args.length - (hasNamed ? 3 : 2)) as string[];
+    return expandReplacement(replacement, {
+      full: String(args[0]),
+      numbered: [undefined, ...groups],
+      named: hasNamed ? (last as Record<string, string | undefined>) : undefined,
+    });
+  });
+}

package/src/{client/components/common/code-editor → shared/lib/code/editor}/history.test.ts

@@ -14,7 +14,7 @@ import {
   stepHistory,
   HISTORY_TIME_GAP,
   type HistoryRecord,
-} from '@/client/components/common/code-editor/history';
+} from '@/shared/lib/code/editor/history';
 
 const NOW = 1_700_000_000_000;
 

package/src/shared/lib/code/editor/keymap.test.ts

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The editor keymap's contract.
+ *
+ * These assertions exist because the failure mode is silent: a chord matched on
+ * `event.key` never fires on macOS (Option produces a different character), a
+ * platform whose binding was forgotten makes a documented shortcut dead, and a
+ * label that disagrees with the stroke it describes turns a tooltip into a
+ * lie. Each of those is a test here rather than a bug report.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { EDITOR_KEY_BINDINGS, editorStrokeFor, isFindBarCommand } from '@/shared/lib/code/editor/keymap';
+import { describeBinding, resolveBinding, type KeyboardEventLike, type KeyBinding } from '@/shared/lib/ui/key-binding';
+import type { EditorCommand } from '@/shared/lib/code/editor/keymap';
+
+/** A keyboard event with only the fields the matcher reads. */
+function key(code: string, keyName: string, modifiers: Partial<KeyboardEventLike> = {}): KeyboardEventLike {
+  return { code, key: keyName, metaKey: false, ctrlKey: false, altKey: false, shiftKey: false, ...modifiers };
+}
+
+function commandFor(event: KeyboardEventLike, isMac: boolean): EditorCommand | null {
+  return resolveBinding(EDITOR_KEY_BINDINGS, event, isMac);
+}
+
+describe('editor keymap', () => {
+  test('⌘D adds the next occurrence, ⇧⌘D inserts a cursor below', () => {
+    expect(commandFor(key('KeyD', 'd', { metaKey: true }), true)).toBe('selectNextOccurrence');
+    expect(commandFor(key('KeyD', 'd', { ctrlKey: true }), false)).toBe('selectNextOccurrence');
+    expect(commandFor(key('KeyD', 'd', { metaKey: true, shiftKey: true }), true)).toBe('insertCursorBelow');
+  });
+
+  test('a binding from the other platform never fires', () => {
+    // Ctrl+D on macOS is the emacs forward-delete; ⌘D on Windows belongs to nobody.
+    expect(commandFor(key('KeyD', 'd', { ctrlKey: true }), true)).toBeNull();
+    expect(commandFor(key('KeyD', 'd', { metaKey: true }), false)).toBeNull();
+  });
+
+  test('the line commands use the arrows with the modifiers each platform expects', () => {
+    expect(commandFor(key('ArrowUp', 'ArrowUp', { altKey: true }), true)).toBe('moveLineUp');
+    expect(commandFor(key('ArrowDown', 'ArrowDown', { altKey: true }), true)).toBe('moveLineDown');
+    expect(commandFor(key('ArrowDown', 'ArrowDown', { metaKey: true, altKey: true, shiftKey: true }), true)).toBe('copyLineDown');
+    expect(commandFor(key('KeyK', 'k', { metaKey: true, shiftKey: true }), true)).toBe('deleteLine');
+  });
+
+  test('toggle comment is read from the physical Slash key', () => {
+    expect(commandFor(key('Slash', '/', { metaKey: true }), true)).toBe('toggleComment');
+    expect(commandFor(key('Slash', '/', { ctrlKey: true }), false)).toBe('toggleComment');
+  });
+
+  test('every command carries both platforms and a label', () => {
+    for (const binding of EDITOR_KEY_BINDINGS) {
+      expect(binding.label.length).toBeGreaterThan(0);
+      expect(binding.mac.code.length).toBeGreaterThan(0);
+      expect(binding.other.code.length).toBeGreaterThan(0);
+    }
+  });
+
+  test('no two commands claim the same chord on a platform', () => {
+    for (const isMac of [true, false]) {
+      const seen = new Map<string, EditorCommand>();
+      for (const binding of EDITOR_KEY_BINDINGS) {
+        const stroke = editorStrokeFor(binding.command, isMac, false);
+        if (!stroke) continue;
+        const id = `${stroke.code}|${stroke.meta ? 'm' : ''}${stroke.ctrl ? 'c' : ''}${stroke.alt ? 'a' : ''}${stroke.shift ? 's' : ''}`;
+        const owner = seen.get(id);
+        expect(`${binding.command} vs ${owner}`).toBe(`${binding.command} vs undefined`);
+        seen.set(id, binding.command);
+      }
+    }
+  });
+
+  test('redo has a Windows-only chord without disturbing the others', () => {
+    expect(editorStrokeFor('redo', true, false)).toEqual({ code: 'KeyZ', meta: true, shift: true });
+    expect(editorStrokeFor('redo', false, true)).toEqual({ code: 'KeyY', ctrl: true });
+    expect(editorStrokeFor('redo', false, false)).toEqual({ code: 'KeyZ', ctrl: true, shift: true });
+  });
+
+  test('the find-bar commands are exactly the ones the bar owns', () => {
+    expect(isFindBarCommand('find')).toBe(true);
+    expect(isFindBarCommand('toggleComment')).toBe(false);
+    expect(isFindBarCommand('selectNextOccurrence')).toBe(false);
+  });
+});
+
+describe('binding labels', () => {
+  const binding = (command: EditorCommand): KeyBinding<EditorCommand> => {
+    const found = EDITOR_KEY_BINDINGS.find((entry) => entry.command === command);
+    if (!found) throw new Error(`no binding for ${command}`);
+    return found;
+  };
+
+  test('mac chords render without separators', () => {
+    expect(describeBinding(binding('selectNextOccurrence'), true)).toBe('⌘D');
+    expect(describeBinding(binding('copyLineDown'), true)).toBe('⌥⇧⌘ArrowDown');
+    expect(describeBinding(binding('toggleComment'), true)).toBe('⌘/');
+  });
+
+  test('other platforms render with + separators', () => {
+    expect(describeBinding(binding('selectNextOccurrence'), false)).toBe('Ctrl+D');
+    expect(describeBinding(binding('moveLineUp'), false)).toBe('Alt+ArrowUp');
+    expect(describeBinding(binding('lineStart'), false)).toBe('Home');
+  });
+});