diffity 0.1.0

package/packages/ui/tests/context-expansion.test.ts

@@ -0,0 +1,279 @@
+import { describe, it, expect } from 'vitest';
+import type { DiffHunk } from '@diffity/parser';
+import {
+  computeGaps,
+  createContextLines,
+  getExpandRange,
+  type ExpandableGap,
+} from '../src/lib/context-expansion';
+
+function makeHunk(oldStart: number, oldCount: number, newStart: number, newCount: number): DiffHunk {
+  return {
+    oldStart,
+    oldCount,
+    newStart,
+    newCount,
+    lines: [],
+  };
+}
+
+describe('computeGaps', () => {
+  it('returns empty for no hunks', () => {
+    expect(computeGaps([], null)).toEqual([]);
+  });
+
+  it('creates a top gap when first hunk does not start at line 1', () => {
+    const hunks = [makeHunk(10, 5, 10, 5)];
+    const gaps = computeGaps(hunks, null);
+
+    expect(gaps).toHaveLength(1);
+    expect(gaps[0]).toMatchObject({
+      id: 'top',
+      position: 'top',
+      oldStart: 1,
+      oldEnd: 9,
+      totalLines: 9,
+    });
+  });
+
+  it('does not create a top gap when first hunk starts at line 1', () => {
+    const hunks = [makeHunk(1, 5, 1, 5)];
+    const gaps = computeGaps(hunks, null);
+
+    expect(gaps).toHaveLength(0);
+  });
+
+  it('creates a between gap for non-adjacent hunks', () => {
+    const hunks = [makeHunk(1, 10, 1, 10), makeHunk(50, 5, 50, 5)];
+    const gaps = computeGaps(hunks, null);
+
+    expect(gaps).toHaveLength(1);
+    expect(gaps[0]).toMatchObject({
+      id: 'between-0',
+      position: 'between',
+      oldStart: 11,
+      oldEnd: 49,
+      totalLines: 39,
+    });
+  });
+
+  it('does not create a between gap for adjacent hunks', () => {
+    const hunks = [makeHunk(1, 10, 1, 10), makeHunk(11, 5, 11, 5)];
+    const gaps = computeGaps(hunks, null);
+
+    expect(gaps).toHaveLength(0);
+  });
+
+  it('creates a bottom gap when file has lines after last hunk', () => {
+    const hunks = [makeHunk(1, 10, 1, 10)];
+    const gaps = computeGaps(hunks, 50);
+
+    expect(gaps).toHaveLength(1);
+    expect(gaps[0]).toMatchObject({
+      id: 'bottom',
+      position: 'bottom',
+      oldStart: 11,
+      oldEnd: 50,
+      totalLines: 40,
+    });
+  });
+
+  it('does not create a bottom gap when fileLineCount is null', () => {
+    const hunks = [makeHunk(1, 10, 1, 10)];
+    const gaps = computeGaps(hunks, null);
+
+    expect(gaps).toHaveLength(0);
+  });
+
+  it('creates top, between, and bottom gaps together', () => {
+    const hunks = [makeHunk(20, 5, 20, 5), makeHunk(50, 5, 50, 5)];
+    const gaps = computeGaps(hunks, 100);
+
+    expect(gaps).toHaveLength(3);
+    expect(gaps[0].position).toBe('top');
+    expect(gaps[1].position).toBe('between');
+    expect(gaps[2].position).toBe('bottom');
+  });
+
+  it('creates multiple between gaps for multiple non-adjacent hunks', () => {
+    const hunks = [
+      makeHunk(1, 5, 1, 5),
+      makeHunk(20, 5, 20, 5),
+      makeHunk(50, 5, 50, 5),
+    ];
+    const gaps = computeGaps(hunks, null);
+
+    expect(gaps).toHaveLength(2);
+    expect(gaps[0].id).toBe('between-0');
+    expect(gaps[0].oldStart).toBe(6);
+    expect(gaps[0].oldEnd).toBe(19);
+    expect(gaps[1].id).toBe('between-1');
+    expect(gaps[1].oldStart).toBe(25);
+    expect(gaps[1].oldEnd).toBe(49);
+  });
+});
+
+describe('createContextLines', () => {
+  const fileLines = Array.from({ length: 100 }, (_, i) => `line ${i + 1}`);
+
+  it('creates context lines for a given range', () => {
+    const lines = createContextLines(fileLines, 5, 8, 0);
+
+    expect(lines).toHaveLength(4);
+    expect(lines[0]).toMatchObject({ type: 'context', content: 'line 5', oldLineNumber: 5, newLineNumber: 5 });
+    expect(lines[3]).toMatchObject({ type: 'context', content: 'line 8', oldLineNumber: 8, newLineNumber: 8 });
+  });
+
+  it('applies new line number offset', () => {
+    const lines = createContextLines(fileLines, 5, 7, 3);
+
+    expect(lines[0]).toMatchObject({ oldLineNumber: 5, newLineNumber: 8 });
+    expect(lines[2]).toMatchObject({ oldLineNumber: 7, newLineNumber: 10 });
+  });
+
+  it('handles single line range', () => {
+    const lines = createContextLines(fileLines, 10, 10, 0);
+
+    expect(lines).toHaveLength(1);
+    expect(lines[0].content).toBe('line 10');
+  });
+
+  it('returns empty string for out-of-bounds lines', () => {
+    const lines = createContextLines(['a', 'b'], 3, 3, 0);
+
+    expect(lines).toHaveLength(1);
+    expect(lines[0].content).toBe('');
+  });
+});
+
+describe('getExpandRange', () => {
+  const gap: ExpandableGap = {
+    id: 'between-0',
+    position: 'between',
+    oldStart: 20,
+    oldEnd: 100,
+    newStart: 20,
+    newEnd: 100,
+    totalLines: 81,
+  };
+
+  const noExpansion = { fromTop: 0, fromBottom: 0 };
+
+  describe('direction: all', () => {
+    it('returns the full remaining range', () => {
+      const range = getExpandRange(gap, 'all', noExpansion);
+
+      expect(range).toEqual({ oldStart: 20, oldEnd: 100 });
+    });
+
+    it('returns the remaining range after partial expansion', () => {
+      const range = getExpandRange(gap, 'all', { fromTop: 10, fromBottom: 5 });
+
+      expect(range).toEqual({ oldStart: 30, oldEnd: 95 });
+    });
+  });
+
+  describe('direction: down (expand from top of gap)', () => {
+    it('returns a chunk from the start of the gap', () => {
+      const range = getExpandRange(gap, 'down', noExpansion);
+
+      expect(range).toEqual({ oldStart: 20, oldEnd: 39 });
+    });
+
+    it('continues from where previous expansion left off', () => {
+      const range = getExpandRange(gap, 'down', { fromTop: 20, fromBottom: 0 });
+
+      expect(range).toEqual({ oldStart: 40, oldEnd: 59 });
+    });
+
+    it('clamps to remaining end', () => {
+      const range = getExpandRange(gap, 'down', { fromTop: 70, fromBottom: 0 });
+
+      expect(range).toEqual({ oldStart: 90, oldEnd: 100 });
+    });
+  });
+
+  describe('direction: up (expand from bottom of gap)', () => {
+    it('returns a chunk from the end of the gap', () => {
+      const range = getExpandRange(gap, 'up', noExpansion);
+
+      expect(range).toEqual({ oldStart: 81, oldEnd: 100 });
+    });
+
+    it('continues from where previous expansion left off', () => {
+      const range = getExpandRange(gap, 'up', { fromTop: 0, fromBottom: 20 });
+
+      expect(range).toEqual({ oldStart: 61, oldEnd: 80 });
+    });
+
+    it('clamps to remaining start', () => {
+      const range = getExpandRange(gap, 'up', { fromTop: 0, fromBottom: 70 });
+
+      expect(range).toEqual({ oldStart: 20, oldEnd: 30 });
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns null when fully expanded', () => {
+      const range = getExpandRange(gap, 'down', { fromTop: 81, fromBottom: 0 });
+
+      expect(range).toBeNull();
+    });
+
+    it('returns null when top and bottom overlap', () => {
+      const range = getExpandRange(gap, 'up', { fromTop: 50, fromBottom: 40 });
+
+      expect(range).toBeNull();
+    });
+
+    it('expands all when remaining fits in one chunk', () => {
+      const smallGap: ExpandableGap = { ...gap, oldStart: 20, oldEnd: 30, totalLines: 11 };
+
+      const rangeDown = getExpandRange(smallGap, 'down', noExpansion);
+      expect(rangeDown).toEqual({ oldStart: 20, oldEnd: 30 });
+
+      const rangeUp = getExpandRange(smallGap, 'up', noExpansion);
+      expect(rangeUp).toEqual({ oldStart: 20, oldEnd: 30 });
+    });
+
+    it('handles top gap expanding upward', () => {
+      const topGap: ExpandableGap = {
+        id: 'top',
+        position: 'top',
+        oldStart: 1,
+        oldEnd: 50,
+        newStart: 1,
+        newEnd: 50,
+        totalLines: 50,
+      };
+
+      const range = getExpandRange(topGap, 'up', noExpansion);
+
+      expect(range).toEqual({ oldStart: 31, oldEnd: 50 });
+    });
+
+    it('handles bottom gap expanding downward', () => {
+      const bottomGap: ExpandableGap = {
+        id: 'bottom',
+        position: 'bottom',
+        oldStart: 80,
+        oldEnd: 120,
+        newStart: 80,
+        newEnd: 120,
+        totalLines: 41,
+      };
+
+      const range = getExpandRange(bottomGap, 'down', noExpansion);
+
+      expect(range).toEqual({ oldStart: 80, oldEnd: 99 });
+    });
+
+    it('handles simultaneous expansion from both directions', () => {
+      const rangeDown = getExpandRange(gap, 'down', { fromTop: 20, fromBottom: 20 });
+      expect(rangeDown).toEqual({ oldStart: 40, oldEnd: 59 });
+
+      const rangeUp = getExpandRange(gap, 'up', { fromTop: 20, fromBottom: 20 });
+      expect(rangeUp).toEqual({ oldStart: 61, oldEnd: 80 });
+    });
+  });
+});

package/packages/ui/tests/diff-utils.test.ts

@@ -0,0 +1,409 @@
+import { describe, it, expect } from 'vitest';
+import type { DiffFile, DiffHunk, DiffLine } from '@diffity/parser';
+import { getAutoCollapsedPaths, getChangeGroups, buildChangeGroupPatch } from '../src/lib/diff-utils';
+
+function makeFile(path: string, status: DiffFile['status'] = 'modified'): DiffFile {
+  return {
+    oldPath: status === 'added' ? '' : path,
+    newPath: status === 'deleted' ? '' : path,
+    status,
+    additions: 1,
+    deletions: 0,
+    hunks: [],
+  };
+}
+
+describe('getAutoCollapsedPaths', () => {
+  it('collapses deleted files', () => {
+    const files = [makeFile('src/old.ts', 'deleted'), makeFile('src/new.ts')];
+    const collapsed = getAutoCollapsedPaths(files);
+
+    expect(collapsed.has('src/old.ts')).toBe(true);
+    expect(collapsed.has('src/new.ts')).toBe(false);
+  });
+
+  describe('lock files', () => {
+    const lockFiles = [
+      'package-lock.json',
+      'pnpm-lock.yaml',
+      'pnpm-lock.yml',
+      'bun.lock',
+      'bun.lockb',
+      'yarn.lock',
+      'Cargo.lock',
+      'Gemfile.lock',
+      'composer.lock',
+      'poetry.lock',
+      'Pipfile.lock',
+      'go.sum',
+      'pubspec.lock',
+      'Podfile.lock',
+    ];
+
+    for (const name of lockFiles) {
+      it(`collapses ${name}`, () => {
+        const files = [makeFile(name)];
+        const collapsed = getAutoCollapsedPaths(files);
+
+        expect(collapsed.has(name)).toBe(true);
+      });
+    }
+
+    it('collapses lock files in subdirectories', () => {
+      const files = [makeFile('packages/app/package-lock.json')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.has('packages/app/package-lock.json')).toBe(true);
+    });
+  });
+
+  describe('minified files', () => {
+    it('collapses .min.js files', () => {
+      const files = [makeFile('dist/app.min.js')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.has('dist/app.min.js')).toBe(true);
+    });
+
+    it('collapses .min.css files', () => {
+      const files = [makeFile('styles/main.min.css')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.has('styles/main.min.css')).toBe(true);
+    });
+
+    it('does not collapse regular .js files', () => {
+      const files = [makeFile('src/app.js')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.size).toBe(0);
+    });
+  });
+
+  describe('generated files', () => {
+    it('collapses .d.ts files', () => {
+      const files = [makeFile('types/index.d.ts')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.has('types/index.d.ts')).toBe(true);
+    });
+
+    it('collapses .map files', () => {
+      const files = [makeFile('dist/app.js.map')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.has('dist/app.js.map')).toBe(true);
+    });
+
+    it('collapses .snap files', () => {
+      const files = [makeFile('tests/__snapshots__/app.test.snap')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.has('tests/__snapshots__/app.test.snap')).toBe(true);
+    });
+
+    it('collapses files in dist/', () => {
+      const files = [makeFile('dist/index.js')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.has('dist/index.js')).toBe(true);
+    });
+
+    it('collapses files in build/', () => {
+      const files = [makeFile('build/output.js')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.has('build/output.js')).toBe(true);
+    });
+
+    it('collapses .generated.ts files', () => {
+      const files = [makeFile('src/api.generated.ts')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.has('src/api.generated.ts')).toBe(true);
+    });
+
+    it('collapses protobuf generated files', () => {
+      const files = [makeFile('proto/message.pb.go')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.has('proto/message.pb.go')).toBe(true);
+    });
+
+    it('collapses .lock extension files', () => {
+      const files = [makeFile('some-tool.lock')];
+      const collapsed = getAutoCollapsedPaths(files);
+
+      expect(collapsed.has('some-tool.lock')).toBe(true);
+    });
+  });
+
+  it('does not collapse regular source files', () => {
+    const files = [
+      makeFile('src/app.tsx'),
+      makeFile('lib/utils.ts'),
+      makeFile('README.md'),
+      makeFile('package.json'),
+    ];
+    const collapsed = getAutoCollapsedPaths(files);
+
+    expect(collapsed.size).toBe(0);
+  });
+
+  it('handles mix of collapsible and non-collapsible files', () => {
+    const files = [
+      makeFile('src/app.tsx'),
+      makeFile('package-lock.json'),
+      makeFile('dist/bundle.min.js'),
+      makeFile('src/old.ts', 'deleted'),
+      makeFile('lib/utils.ts'),
+    ];
+    const collapsed = getAutoCollapsedPaths(files);
+
+    expect(collapsed.size).toBe(3);
+    expect(collapsed.has('src/app.tsx')).toBe(false);
+    expect(collapsed.has('package-lock.json')).toBe(true);
+    expect(collapsed.has('dist/bundle.min.js')).toBe(true);
+    expect(collapsed.has('src/old.ts')).toBe(true);
+    expect(collapsed.has('lib/utils.ts')).toBe(false);
+  });
+});
+
+function makeLine(type: DiffLine['type'], content: string, oldNum: number | null, newNum: number | null): DiffLine {
+  return { type, content, oldLineNumber: oldNum, newLineNumber: newNum };
+}
+
+function makeHunk(lines: DiffLine[], oldStart = 1, newStart = 1): DiffHunk {
+  let oldCount = 0;
+  let newCount = 0;
+  for (const line of lines) {
+    if (line.type === 'context' || line.type === 'delete') {
+      oldCount++;
+    }
+    if (line.type === 'context' || line.type === 'add') {
+      newCount++;
+    }
+  }
+  return {
+    header: `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`,
+    oldStart,
+    oldCount,
+    newStart,
+    newCount,
+    lines,
+  };
+}
+
+function makeDiffFile(hunks: DiffHunk[], status: DiffFile['status'] = 'modified'): DiffFile {
+  return {
+    oldPath: 'src/file.ts',
+    newPath: 'src/file.ts',
+    status,
+    additions: 0,
+    deletions: 0,
+    hunks,
+    isBinary: false,
+  };
+}
+
+describe('getChangeGroups', () => {
+  it('returns empty array for all context lines', () => {
+    const lines = [
+      makeLine('context', 'a', 1, 1),
+      makeLine('context', 'b', 2, 2),
+    ];
+
+    expect(getChangeGroups(lines)).toEqual([]);
+  });
+
+  it('identifies a single change group', () => {
+    const lines = [
+      makeLine('context', 'a', 1, 1),
+      makeLine('delete', 'b', 2, null),
+      makeLine('add', 'c', null, 2),
+      makeLine('context', 'd', 3, 3),
+    ];
+    const groups = getChangeGroups(lines);
+
+    expect(groups).toEqual([{ startIndex: 1, endIndex: 2 }]);
+  });
+
+  it('identifies multiple change groups', () => {
+    const lines = [
+      makeLine('context', 'a', 1, 1),
+      makeLine('delete', 'b', 2, null),
+      makeLine('context', 'c', 3, 2),
+      makeLine('add', 'd', null, 3),
+      makeLine('add', 'e', null, 4),
+      makeLine('context', 'f', 4, 5),
+    ];
+    const groups = getChangeGroups(lines);
+
+    expect(groups).toEqual([
+      { startIndex: 1, endIndex: 1 },
+      { startIndex: 3, endIndex: 4 },
+    ]);
+  });
+
+  it('handles change group at start of hunk', () => {
+    const lines = [
+      makeLine('add', 'new', null, 1),
+      makeLine('context', 'a', 1, 2),
+    ];
+    const groups = getChangeGroups(lines);
+
+    expect(groups).toEqual([{ startIndex: 0, endIndex: 0 }]);
+  });
+
+  it('handles change group at end of hunk', () => {
+    const lines = [
+      makeLine('context', 'a', 1, 1),
+      makeLine('delete', 'old', 2, null),
+    ];
+    const groups = getChangeGroups(lines);
+
+    expect(groups).toEqual([{ startIndex: 1, endIndex: 1 }]);
+  });
+
+  it('handles all changed lines as one group', () => {
+    const lines = [
+      makeLine('delete', 'a', 1, null),
+      makeLine('delete', 'b', 2, null),
+      makeLine('add', 'c', null, 1),
+    ];
+    const groups = getChangeGroups(lines);
+
+    expect(groups).toEqual([{ startIndex: 0, endIndex: 2 }]);
+  });
+});
+
+describe('buildChangeGroupPatch', () => {
+  it('builds a patch for a single change group with context', () => {
+    const lines = [
+      makeLine('context', 'before', 1, 1),
+      makeLine('delete', 'old', 2, null),
+      makeLine('add', 'new', null, 2),
+      makeLine('context', 'after', 3, 3),
+    ];
+    const hunk = makeHunk(lines);
+    const file = makeDiffFile([hunk]);
+    const patch = buildChangeGroupPatch(file, hunk, 1, 2);
+
+    expect(patch).toContain('--- a/src/file.ts');
+    expect(patch).toContain('+++ b/src/file.ts');
+    expect(patch).toContain('@@ -1,3 +1,3 @@');
+    expect(patch).toContain(' before');
+    expect(patch).toContain('-old');
+    expect(patch).toContain('+new');
+    expect(patch).toContain(' after');
+  });
+
+  it('builds a patch for a change group without preceding context', () => {
+    const lines = [
+      makeLine('add', 'new line', null, 1),
+      makeLine('context', 'existing', 1, 2),
+    ];
+    const hunk = makeHunk(lines, 1, 1);
+    const file = makeDiffFile([hunk]);
+    const patch = buildChangeGroupPatch(file, hunk, 0, 0);
+
+    expect(patch).toContain('+new line');
+    expect(patch).toContain(' existing');
+    const patchLines = patch.split('\n');
+    const diffLines = patchLines.filter(l => !l.startsWith('---') && !l.startsWith('+++') && !l.startsWith('@@'));
+    expect(diffLines.some(l => l.startsWith('-'))).toBe(false);
+  });
+
+  it('includes up to 3 context lines before and after', () => {
+    const lines = [
+      makeLine('context', 'c1', 1, 1),
+      makeLine('context', 'c2', 2, 2),
+      makeLine('context', 'c3', 3, 3),
+      makeLine('context', 'c4', 4, 4),
+      makeLine('delete', 'old', 5, null),
+      makeLine('context', 'c5', 6, 5),
+      makeLine('context', 'c6', 7, 6),
+      makeLine('context', 'c7', 8, 7),
+      makeLine('context', 'c8', 9, 8),
+    ];
+    const hunk = makeHunk(lines);
+    const file = makeDiffFile([hunk]);
+    const patch = buildChangeGroupPatch(file, hunk, 4, 4);
+
+    expect(patch).toContain(' c2');
+    expect(patch).toContain(' c3');
+    expect(patch).toContain(' c4');
+    expect(patch).toContain('-old');
+    expect(patch).toContain(' c5');
+    expect(patch).toContain(' c6');
+    expect(patch).toContain(' c7');
+    expect(patch).not.toContain(' c1');
+    expect(patch).not.toContain(' c8');
+  });
+
+  it('selects only one change group from a hunk with multiple', () => {
+    const lines = [
+      makeLine('context', 'a', 1, 1),
+      makeLine('delete', 'first-del', 2, null),
+      makeLine('add', 'first-add', null, 2),
+      makeLine('context', 'b', 3, 3),
+      makeLine('delete', 'second-del', 4, null),
+      makeLine('context', 'c', 5, 4),
+    ];
+    const hunk = makeHunk(lines);
+    const file = makeDiffFile([hunk]);
+
+    const patch = buildChangeGroupPatch(file, hunk, 4, 4);
+
+    expect(patch).toContain('-second-del');
+    expect(patch).toContain(' b');
+    expect(patch).toContain(' c');
+    expect(patch).not.toContain('first');
+  });
+
+  it('builds a correct patch for delete-only changes', () => {
+    const lines = [
+      makeLine('context', 'keep-before', 1, 1),
+      makeLine('delete', 'removed-a', 2, null),
+      makeLine('delete', 'removed-b', 3, null),
+      makeLine('context', 'keep-after', 4, 2),
+    ];
+    const hunk = makeHunk(lines);
+    const file = makeDiffFile([hunk]);
+    const patch = buildChangeGroupPatch(file, hunk, 1, 2);
+
+    expect(patch).toContain('@@ -1,4 +1,2 @@');
+    expect(patch).toContain(' keep-before');
+    expect(patch).toContain('-removed-a');
+    expect(patch).toContain('-removed-b');
+    expect(patch).toContain(' keep-after');
+    const patchLines = patch.split('\n');
+    const diffLines = patchLines.filter(l => !l.startsWith('---') && !l.startsWith('+++') && !l.startsWith('@@'));
+    expect(diffLines.some(l => l.startsWith('+'))).toBe(false);
+  });
+
+  it('builds a correct patch for delete-only with no surrounding context', () => {
+    const lines = [
+      makeLine('delete', 'only-line', 1, null),
+    ];
+    const hunk = makeHunk(lines, 1, 1);
+    const file = makeDiffFile([hunk]);
+    const patch = buildChangeGroupPatch(file, hunk, 0, 0);
+
+    expect(patch).toContain('@@ -1,1 +1,0 @@');
+    expect(patch).toContain('-only-line');
+  });
+
+  it('handles added file paths', () => {
+    const lines = [
+      makeLine('add', 'new content', null, 1),
+    ];
+    const hunk = makeHunk(lines, 0, 1);
+    const file = makeDiffFile([hunk], 'added');
+    file.oldPath = '/dev/null';
+    const patch = buildChangeGroupPatch(file, hunk, 0, 0);
+
+    expect(patch).toContain('--- /dev/null');
+    expect(patch).toContain('+++ b/src/file.ts');
+  });
+});

package/packages/ui/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true,
+    "jsx": "react-jsx",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"]
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "references": [
+    { "path": "../parser" }
+  ]
+}