difit 2.2.0 → 2.2.2

package/dist/server/git-diff.test.js

@@ -114,8 +114,10 @@ describe('GitDiffParser', () => {
                 'Binary files /dev/null and b/image.jpg differ',
             ];
             const summary = {
+                file: 'image.jpg',
                 insertions: 0,
                 deletions: 0,
+                binary: true,
             };
             // Access private method for testing
             const result = parser.parseFileBlock(diffLines.join('\n'), summary);
@@ -138,8 +140,10 @@ describe('GitDiffParser', () => {
                 'Binary files a/old-image.png and /dev/null differ',
             ];
             const summary = {
+                file: 'old-image.png',
                 insertions: 0,
                 deletions: 0,
+                binary: true,
             };
             const result = parser.parseFileBlock(diffLines.join('\n'), summary);
             expect(result).toEqual({
@@ -160,8 +164,10 @@ describe('GitDiffParser', () => {
                 'Binary files a/photo.jpg and b/photo.jpg differ',
             ];
             const summary = {
+                file: 'photo.jpg',
                 insertions: 0,
                 deletions: 0,
+                binary: true,
             };
             const result = parser.parseFileBlock(diffLines.join('\n'), summary);
             expect(result).toEqual({
@@ -181,8 +187,11 @@ describe('GitDiffParser', () => {
                 'rename to new-name.gif',
             ];
             const summary = {
+                file: 'new-name.gif',
+                from: 'old-name.gif',
                 insertions: 0,
                 deletions: 0,
+                binary: true,
             };
             const result = parser.parseFileBlock(diffLines.join('\n'), summary);
             expect(result).toEqual({
@@ -206,8 +215,10 @@ describe('GitDiffParser', () => {
                 ' // end',
             ];
             const summary = {
+                file: 'script.js',
                 insertions: 1,
                 deletions: 0,
+                binary: false,
             };
             const result = parser.parseFileBlock(diffLines.join('\n'), summary);
             expect(result).toEqual({
@@ -234,8 +245,10 @@ describe('GitDiffParser', () => {
                 ' // end',
             ];
             const summary = {
+                file: 'script.js',
                 insertions: 0,
                 deletions: 1,
+                binary: false,
             };
             const result = parser.parseFileBlock(diffLines.join('\n'), summary);
             expect(result).toEqual({
@@ -258,8 +271,10 @@ describe('GitDiffParser', () => {
                 '+line 2',
             ];
             const summary = {
+                file: 'new-file.txt',
                 insertions: 2,
                 deletions: 0,
+                binary: false,
             };
             const result = parser.parseFileBlock(diffLines.join('\n'), summary);
             expect(result.status).toBe('added');
@@ -275,13 +290,312 @@ describe('GitDiffParser', () => {
                 '-line 2',
             ];
             const summary = {
+                file: 'deleted-file.txt',
                 insertions: 0,
                 deletions: 2,
+                binary: false,
             };
             const result = parser.parseFileBlock(diffLines.join('\n'), summary);
             expect(result.status).toBe('deleted');
         });
     });
+    describe('parseFileBlock with quoted paths', () => {
+        it('parses file paths with spaces correctly', () => {
+            const diffLines = [
+                'diff --git "a/test with spaces/file name.txt" "b/test with spaces/file name.txt"',
+                'new file mode 100644',
+                'index 0000000..257cc56',
+                '--- /dev/null',
+                '+++ "b/test with spaces/file name.txt"',
+                '@@ -0,0 +1 @@',
+                '+foo',
+            ];
+            const result = parser.parseFileBlock(diffLines.join('\n'), null);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('test with spaces/file name.txt');
+            expect(result.status).toBe('added');
+            expect(result.additions).toBe(1);
+            expect(result.deletions).toBe(0);
+        });
+        it('parses summary-provided filenames with escaped spaces', () => {
+            const diffLines = [
+                'diff --git "a/templates/test file.py" "b/templates/test file.py"',
+                'index abc123..def456 100644',
+                '--- "a/templates/test file.py"',
+                '+++ "b/templates/test file.py"',
+                '@@ -1 +1 @@',
+                '-old',
+                '+new',
+            ];
+            const summary = {
+                file: 'templates/test\\040file.py',
+                insertions: 1,
+                deletions: 1,
+                binary: false,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result?.path).toBe('templates/test file.py');
+            expect(result?.oldPath).toBeUndefined();
+        });
+        it('parses file paths with Jinja template brackets correctly', () => {
+            const diffLines = [
+                'diff --git "a/templates/test_000_{{ package_name }}/__.py" "b/templates/test_000_{{ package_name }}/__.py"',
+                'new file mode 100644',
+                'index 0000000..257cc56',
+                '--- /dev/null',
+                '+++ "b/templates/test_000_{{ package_name }}/__.py"',
+                '@@ -0,0 +1 @@',
+                '+test',
+            ];
+            const result = parser.parseFileBlock(diffLines.join('\n'), null);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('templates/test_000_{{ package_name }}/__.py');
+            expect(result.status).toBe('added');
+        });
+        it('parses file paths with escaped characters correctly', () => {
+            const diffLines = [
+                'diff --git "a/file\\twith\\ttabs.txt" "b/file\\twith\\ttabs.txt"',
+                'new file mode 100644',
+                'index 0000000..257cc56',
+                '--- /dev/null',
+                '+++ "b/file\\twith\\ttabs.txt"',
+                '@@ -0,0 +1 @@',
+                '+content',
+            ];
+            const result = parser.parseFileBlock(diffLines.join('\n'), null);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('file\twith\ttabs.txt');
+            expect(result.status).toBe('added');
+        });
+        it('parses renamed files with spaces correctly', () => {
+            const diffLines = [
+                'diff --git "a/old folder/old name.txt" "b/new folder/new name.txt"',
+                'similarity index 100%',
+                'rename from old folder/old name.txt',
+                'rename to new folder/new name.txt',
+            ];
+            const result = parser.parseFileBlock(diffLines.join('\n'), null);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('new folder/new name.txt');
+            expect(result.oldPath).toBe('old folder/old name.txt');
+            expect(result.status).toBe('renamed');
+        });
+        it('still handles unquoted paths correctly', () => {
+            const diffLines = [
+                'diff --git a/src/file.js b/src/file.js',
+                'index 1234567..8901234 100644',
+                '--- a/src/file.js',
+                '+++ b/src/file.js',
+                '@@ -1,3 +1,3 @@',
+                ' line1',
+                '-old',
+                '+new',
+                ' line3',
+            ];
+            const result = parser.parseFileBlock(diffLines.join('\n'), null);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('src/file.js');
+            expect(result.status).toBe('modified');
+            expect(result.additions).toBe(1);
+            expect(result.deletions).toBe(1);
+        });
+        it('handles unquoted paths with spaces when core.quotePath=false', () => {
+            const diffLines = [
+                'diff --git a/path with spaces/file.txt b/path with spaces/file.txt',
+                'index 1234567..8901234 100644',
+                '--- a/path with spaces/file.txt',
+                '+++ b/path with spaces/file.txt',
+                '@@ -1 +1 @@',
+                '-old content',
+                '+new content',
+            ];
+            const result = parser.parseFileBlock(diffLines.join('\n'), null);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('path with spaces/file.txt');
+            expect(result.status).toBe('modified');
+            expect(result.additions).toBe(1);
+            expect(result.deletions).toBe(1);
+        });
+        it('decodes unquoted octal escapes in diff headers', () => {
+            const diffLines = [
+                'diff --git a/some\\040folder/file\\040name.ts b/some\\040folder/file\\040name.ts',
+                'index 3333333..4444444 100644',
+                '--- a/some\\040folder/file\\040name.ts',
+                '+++ b/some\\040folder/file\\040name.ts',
+                '@@ -1 +1 @@',
+                '-old',
+                '+new',
+            ];
+            const result = parser.parseFileBlock(diffLines.join('\n'), null);
+            expect(result?.path).toBe('some folder/file name.ts');
+            expect(result?.oldPath).toBeUndefined();
+        });
+        it('handles unquoted paths containing "b/" in filename', () => {
+            const diffLines = [
+                'diff --git a/dir b/sub/file b/dir b/sub/file',
+                'index 1234567..8901234 100644',
+                '--- a/dir b/sub/file',
+                '+++ b/dir b/sub/file',
+                '@@ -1 +1 @@',
+                '-old',
+                '+new',
+            ];
+            const result = parser.parseFileBlock(diffLines.join('\n'), null);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('dir b/sub/file');
+            expect(result.oldPath).toBeUndefined();
+            expect(result.status).toBe('modified');
+        });
+        it('handles renamed files with "b/" in the path', () => {
+            const diffLines = [
+                'diff --git a/old b/path/file b/new b/path/file',
+                'similarity index 100%',
+                'rename from old b/path/file',
+                'rename to new b/path/file',
+            ];
+            const result = parser.parseFileBlock(diffLines.join('\n'), null);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('new b/path/file');
+            expect(result.oldPath).toBe('old b/path/file');
+            expect(result.status).toBe('renamed');
+        });
+        it('handles alternative git diff prefixes for working tree comparisons', () => {
+            const diffLines = [
+                'diff --git c/a/test.txt w/a/test.txt',
+                'index 1234567..8901234 100644',
+                '--- c/a/test.txt',
+                '+++ w/a/test.txt\t',
+                '@@ -1 +1 @@',
+                '-old',
+                '+new',
+            ];
+            const summary = {
+                file: 'a/test.txt',
+                insertions: 1,
+                deletions: 1,
+                binary: false,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('a/test.txt');
+            expect(result.oldPath).toBeUndefined();
+            expect(result.status).toBe('modified');
+        });
+        it('handles rename metadata with alternative git prefixes', () => {
+            const diffLines = [
+                'diff --git c/old/name.txt w/new/name.txt',
+                'similarity index 100%',
+                'rename from c/old/name.txt\t',
+                'rename to w/new/name.txt\t',
+            ];
+            const summary = {
+                file: 'new/name.txt',
+                from: 'old/name.txt',
+                insertions: 0,
+                deletions: 0,
+                binary: false,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('new/name.txt');
+            expect(result.oldPath).toBe('old/name.txt');
+            expect(result.status).toBe('renamed');
+        });
+        it('ignores trailing metadata separators in diff path lines', () => {
+            const diffLines = [
+                'diff --git c/foo bar.txt w/foo bar.txt',
+                'index 1234567..8901234 100644',
+                '--- c/foo bar.txt\t',
+                '+++ w/foo bar.txt\t',
+                '@@ -1 +1 @@',
+                '-old',
+                '+new',
+            ];
+            const summary = {
+                file: 'foo bar.txt',
+                insertions: 1,
+                deletions: 1,
+                binary: false,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('foo bar.txt');
+            expect(result.status).toBe('modified');
+        });
+        it('prefers header paths over summary paths when they differ', () => {
+            const diffLines = [
+                'diff --git a/a/test.txt b/a/test.txt',
+                'new file mode 100644',
+                'index 0000000..257cc56',
+                '--- /dev/null',
+                '+++ b/a/test.txt',
+                '@@ -0,0 +1 @@',
+                '+content',
+            ];
+            const summary = {
+                file: 'a/test.txt',
+                insertions: 1,
+                deletions: 0,
+                binary: false,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result).toBeDefined();
+            expect(result?.path).toBe('a/test.txt');
+            expect(result?.status).toBe('added');
+        });
+        it('does not treat added files as renamed even if summary includes from path', () => {
+            const diffLines = [
+                'diff --git a/test.js b/test.js',
+                'new file mode 100644',
+                'index 0000000..257cc56',
+                '--- /dev/null',
+                '+++ b/test.js',
+                '@@ -0,0 +1 @@',
+                '+console.log("test");',
+            ];
+            const summary = {
+                file: 'test.js',
+                from: 'c/test.js',
+                insertions: 1,
+                deletions: 0,
+                binary: false,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result).toBeDefined();
+            expect(result?.status).toBe('added');
+            expect(result?.oldPath).toBeUndefined();
+        });
+        it('parses file paths with octal escape sequences correctly', () => {
+            const diffLines = [
+                'diff --git "a/file\\303\\244.txt" "b/file\\303\\244.txt"',
+                'new file mode 100644',
+                'index 0000000..257cc56',
+                '--- /dev/null',
+                '+++ "b/file\\303\\244.txt"',
+                '@@ -0,0 +1 @@',
+                '+content',
+            ];
+            const result = parser.parseFileBlock(diffLines.join('\n'), null);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('fileä.txt');
+            expect(result.status).toBe('added');
+        });
+        it('parses file paths with mixed escape sequences correctly', () => {
+            const diffLines = [
+                'diff --git "a/dir\\303\\251/file\\twith\\nmixed.txt" "b/dir\\303\\251/file\\twith\\nmixed.txt"',
+                'new file mode 100644',
+                'index 0000000..257cc56',
+                '--- /dev/null',
+                '+++ "b/dir\\303\\251/file\\twith\\nmixed.txt"',
+                '@@ -0,0 +1 @@',
+                '+test',
+            ];
+            const result = parser.parseFileBlock(diffLines.join('\n'), null);
+            expect(result).toBeDefined();
+            expect(result.path).toBe('diré/file\twith\nmixed.txt');
+            expect(result.status).toBe('added');
+        });
+    });
     describe('File status detection improvements', () => {
         it('prioritizes new file mode over other indicators', () => {
             const diffLines = [
@@ -292,8 +606,10 @@ describe('GitDiffParser', () => {
                 '+++ b/test.txt',
             ];
             const summary = {
+                file: 'test.txt',
                 insertions: 5,
                 deletions: 0,
+                binary: false,
             };
             const result = parser.parseFileBlock(diffLines.join('\n'), summary);
             expect(result.status).toBe('added');
@@ -307,8 +623,10 @@ describe('GitDiffParser', () => {
                 '+++ b/test.txt', // This might confuse simple parsers
             ];
             const summary = {
+                file: 'test.txt',
                 insertions: 0,
                 deletions: 5,
+                binary: false,
             };
             const result = parser.parseFileBlock(diffLines.join('\n'), summary);
             expect(result.status).toBe('deleted');

package/dist/server/schemas/commentSchema.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const LineNumberSchema: z.ZodUnion<readonly [z.ZodNumber, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+export declare const CommentSchema: z.ZodObject<{
+    id: z.ZodString;
+    file: z.ZodString;
+    line: z.ZodUnion<readonly [z.ZodNumber, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+    body: z.ZodString;
+    timestamp: z.ZodString;
+    codeContent: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const CommentsPayloadSchema: z.ZodObject<{
+    comments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        file: z.ZodString;
+        line: z.ZodUnion<readonly [z.ZodNumber, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+        body: z.ZodString;
+        timestamp: z.ZodString;
+        codeContent: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ValidatedComment = z.infer<typeof CommentSchema>;
+export type ValidatedCommentsPayload = z.infer<typeof CommentsPayloadSchema>;

package/dist/server/schemas/commentSchema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+// Schema for line number: either a single number or a tuple of two numbers
+export const LineNumberSchema = z.union([z.number(), z.tuple([z.number(), z.number()])]);
+// Schema for a single comment
+export const CommentSchema = z.object({
+    id: z.string(),
+    file: z.string(),
+    line: LineNumberSchema,
+    body: z.string(),
+    timestamp: z.string(),
+    codeContent: z.string().optional(),
+});
+// Schema for the comments payload sent from client
+export const CommentsPayloadSchema = z.object({
+    comments: z.array(CommentSchema).optional(),
+});

package/dist/server/schemas/commentSchema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/schemas/commentSchema.test.js

@@ -0,0 +1,229 @@
+import { describe, it, expect } from 'vitest';
+import { CommentSchema, CommentsPayloadSchema, LineNumberSchema } from './commentSchema';
+describe('Comment Schema Validation', () => {
+    describe('LineNumberSchema', () => {
+        it('should accept single number', () => {
+            const result = LineNumberSchema.safeParse(42);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(42);
+            }
+        });
+        it('should accept tuple of two numbers', () => {
+            const result = LineNumberSchema.safeParse([10, 20]);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual([10, 20]);
+            }
+        });
+        it('should reject string', () => {
+            const result = LineNumberSchema.safeParse('42');
+            expect(result.success).toBe(false);
+        });
+        it('should reject array with more than 2 numbers', () => {
+            const result = LineNumberSchema.safeParse([1, 2, 3]);
+            expect(result.success).toBe(false);
+        });
+        it('should reject array with less than 2 numbers', () => {
+            const result = LineNumberSchema.safeParse([1]);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('CommentSchema', () => {
+        it('should accept valid comment with single line number', () => {
+            const comment = {
+                id: '123',
+                file: 'src/app.ts',
+                line: 42,
+                body: 'Test comment',
+                timestamp: '2024-01-01T00:00:00Z',
+            };
+            const result = CommentSchema.safeParse(comment);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(comment);
+            }
+        });
+        it('should accept valid comment with line range', () => {
+            const comment = {
+                id: '456',
+                file: 'src/utils.ts',
+                line: [10, 20],
+                body: 'Range comment',
+                timestamp: '2024-01-01T00:00:00Z',
+            };
+            const result = CommentSchema.safeParse(comment);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(comment);
+            }
+        });
+        it('should accept comment with optional codeContent', () => {
+            const comment = {
+                id: '789',
+                file: 'src/index.ts',
+                line: 1,
+                body: 'Comment with code',
+                timestamp: '2024-01-01T00:00:00Z',
+                codeContent: 'const x = 42;',
+            };
+            const result = CommentSchema.safeParse(comment);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.codeContent).toBe('const x = 42;');
+            }
+        });
+        it('should reject comment without required fields', () => {
+            const invalidComment = {
+                id: '123',
+                // missing file
+                line: 42,
+                body: 'Test',
+                timestamp: '2024-01-01T00:00:00Z',
+            };
+            const result = CommentSchema.safeParse(invalidComment);
+            expect(result.success).toBe(false);
+            if (!result.success) {
+                expect(result.error.issues[0]?.path).toContain('file');
+            }
+        });
+        it('should reject comment with wrong type for file', () => {
+            const invalidComment = {
+                id: '123',
+                file: 123, // should be string
+                line: 42,
+                body: 'Test',
+                timestamp: '2024-01-01T00:00:00Z',
+            };
+            const result = CommentSchema.safeParse(invalidComment);
+            expect(result.success).toBe(false);
+        });
+        it('should reject comment with invalid line format', () => {
+            const invalidComment = {
+                id: '123',
+                file: 'test.ts',
+                line: 'invalid', // should be number or [number, number]
+                body: 'Test',
+                timestamp: '2024-01-01T00:00:00Z',
+            };
+            const result = CommentSchema.safeParse(invalidComment);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('CommentsPayloadSchema', () => {
+        it('should accept valid payload with comments array', () => {
+            const payload = {
+                comments: [
+                    {
+                        id: '1',
+                        file: 'file1.ts',
+                        line: 10,
+                        body: 'Comment 1',
+                        timestamp: '2024-01-01T00:00:00Z',
+                    },
+                    {
+                        id: '2',
+                        file: 'file2.ts',
+                        line: [20, 30],
+                        body: 'Comment 2',
+                        timestamp: '2024-01-01T00:01:00Z',
+                    },
+                ],
+            };
+            const result = CommentsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.comments).toHaveLength(2);
+            }
+        });
+        it('should accept empty comments array', () => {
+            const payload = { comments: [] };
+            const result = CommentsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.comments).toEqual([]);
+            }
+        });
+        it('should accept payload without comments property', () => {
+            const payload = {};
+            const result = CommentsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.comments).toBeUndefined();
+            }
+        });
+        it('should reject payload with invalid comment in array', () => {
+            const payload = {
+                comments: [
+                    {
+                        id: '1',
+                        file: 'file1.ts',
+                        line: 10,
+                        body: 'Valid comment',
+                        timestamp: '2024-01-01T00:00:00Z',
+                    },
+                    {
+                        id: '2',
+                        // missing file property
+                        line: 20,
+                        body: 'Invalid comment',
+                        timestamp: '2024-01-01T00:01:00Z',
+                    },
+                ],
+            };
+            const result = CommentsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        it('should reject payload with comments as non-array', () => {
+            const payload = {
+                comments: 'not an array',
+            };
+            const result = CommentsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        it('should handle real-world DiffComment format from client', () => {
+            // This simulates the actual DiffComment format sent from client
+            const diffCommentPayload = {
+                comments: [
+                    {
+                        id: 'abc123',
+                        filePath: 'src/components/Button.tsx', // Note: 'filePath' instead of 'file'
+                        position: {
+                            line: 42,
+                            side: 'new',
+                        },
+                        body: 'Fix this button',
+                        createdAt: '2024-01-01T00:00:00Z',
+                    },
+                ],
+            };
+            const result = CommentsPayloadSchema.safeParse(diffCommentPayload);
+            expect(result.success).toBe(false); // Should fail because of incorrect property names
+            if (!result.success) {
+                // Check that it fails because 'file' is missing
+                const fileIssue = result.error.issues.find((issue) => issue.path.includes('file'));
+                expect(fileIssue).toBeDefined();
+            }
+        });
+        it('should accept properly transformed comments from client', () => {
+            // This is what the client should send after transformation
+            const transformedPayload = {
+                comments: [
+                    {
+                        id: 'abc123',
+                        file: 'src/components/Button.tsx', // Correct property name
+                        line: 42, // Extracted from position.line
+                        body: 'Fix this button',
+                        timestamp: '2024-01-01T00:00:00Z', // Renamed from createdAt
+                    },
+                ],
+            };
+            const result = CommentsPayloadSchema.safeParse(transformedPayload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.comments).toHaveLength(1);
+                expect(result.data.comments[0].file).toBe('src/components/Button.tsx');
+            }
+        });
+    });
+});