@tuicomponents/diff 0.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.cjs +400 -0
- package/dist/index.cjs.map +1 -0
- package/dist/index.d.cts +417 -0
- package/dist/index.d.ts +417 -0
- package/dist/index.js +371 -0
- package/dist/index.js.map +1 -0
- package/package.json +49 -0
package/dist/index.d.cts
ADDED
|
@@ -0,0 +1,417 @@
|
|
|
1
|
+
import * as zod from 'zod';
|
|
2
|
+
import { z } from 'zod';
|
|
3
|
+
import { BaseTuiComponent, ComponentMetadata, RenderContext, RenderResult } from '@tuicomponents/core';
|
|
4
|
+
|
|
5
|
+
/**
|
|
6
|
+
* Type of diff line.
|
|
7
|
+
*/
|
|
8
|
+
declare const lineTypeSchema: z.ZodEnum<["addition", "deletion", "context"]>;
|
|
9
|
+
type LineType = z.infer<typeof lineTypeSchema>;
|
|
10
|
+
/**
|
|
11
|
+
* Schema for a single diff line.
|
|
12
|
+
*/
|
|
13
|
+
declare const diffLineSchema: z.ZodObject<{
|
|
14
|
+
/**
|
|
15
|
+
* Type of the line.
|
|
16
|
+
*/
|
|
17
|
+
type: z.ZodEnum<["addition", "deletion", "context"]>;
|
|
18
|
+
/**
|
|
19
|
+
* Content of the line.
|
|
20
|
+
*/
|
|
21
|
+
content: z.ZodString;
|
|
22
|
+
/**
|
|
23
|
+
* Optional line number in the old file (for deletions and context).
|
|
24
|
+
*/
|
|
25
|
+
oldLineNumber: z.ZodOptional<z.ZodNumber>;
|
|
26
|
+
/**
|
|
27
|
+
* Optional line number in the new file (for additions and context).
|
|
28
|
+
*/
|
|
29
|
+
newLineNumber: z.ZodOptional<z.ZodNumber>;
|
|
30
|
+
}, "strip", z.ZodTypeAny, {
|
|
31
|
+
type: "addition" | "deletion" | "context";
|
|
32
|
+
content: string;
|
|
33
|
+
oldLineNumber?: number | undefined;
|
|
34
|
+
newLineNumber?: number | undefined;
|
|
35
|
+
}, {
|
|
36
|
+
type: "addition" | "deletion" | "context";
|
|
37
|
+
content: string;
|
|
38
|
+
oldLineNumber?: number | undefined;
|
|
39
|
+
newLineNumber?: number | undefined;
|
|
40
|
+
}>;
|
|
41
|
+
type DiffLine = z.infer<typeof diffLineSchema>;
|
|
42
|
+
/**
|
|
43
|
+
* Schema for a hunk (section of changes).
|
|
44
|
+
*/
|
|
45
|
+
declare const hunkSchema: z.ZodObject<{
|
|
46
|
+
/**
|
|
47
|
+
* Hunk header information.
|
|
48
|
+
*/
|
|
49
|
+
header: z.ZodOptional<z.ZodObject<{
|
|
50
|
+
oldStart: z.ZodNumber;
|
|
51
|
+
oldCount: z.ZodNumber;
|
|
52
|
+
newStart: z.ZodNumber;
|
|
53
|
+
newCount: z.ZodNumber;
|
|
54
|
+
}, "strip", z.ZodTypeAny, {
|
|
55
|
+
oldStart: number;
|
|
56
|
+
oldCount: number;
|
|
57
|
+
newStart: number;
|
|
58
|
+
newCount: number;
|
|
59
|
+
}, {
|
|
60
|
+
oldStart: number;
|
|
61
|
+
oldCount: number;
|
|
62
|
+
newStart: number;
|
|
63
|
+
newCount: number;
|
|
64
|
+
}>>;
|
|
65
|
+
/**
|
|
66
|
+
* Lines in the hunk.
|
|
67
|
+
*/
|
|
68
|
+
lines: z.ZodArray<z.ZodObject<{
|
|
69
|
+
/**
|
|
70
|
+
* Type of the line.
|
|
71
|
+
*/
|
|
72
|
+
type: z.ZodEnum<["addition", "deletion", "context"]>;
|
|
73
|
+
/**
|
|
74
|
+
* Content of the line.
|
|
75
|
+
*/
|
|
76
|
+
content: z.ZodString;
|
|
77
|
+
/**
|
|
78
|
+
* Optional line number in the old file (for deletions and context).
|
|
79
|
+
*/
|
|
80
|
+
oldLineNumber: z.ZodOptional<z.ZodNumber>;
|
|
81
|
+
/**
|
|
82
|
+
* Optional line number in the new file (for additions and context).
|
|
83
|
+
*/
|
|
84
|
+
newLineNumber: z.ZodOptional<z.ZodNumber>;
|
|
85
|
+
}, "strip", z.ZodTypeAny, {
|
|
86
|
+
type: "addition" | "deletion" | "context";
|
|
87
|
+
content: string;
|
|
88
|
+
oldLineNumber?: number | undefined;
|
|
89
|
+
newLineNumber?: number | undefined;
|
|
90
|
+
}, {
|
|
91
|
+
type: "addition" | "deletion" | "context";
|
|
92
|
+
content: string;
|
|
93
|
+
oldLineNumber?: number | undefined;
|
|
94
|
+
newLineNumber?: number | undefined;
|
|
95
|
+
}>, "many">;
|
|
96
|
+
}, "strip", z.ZodTypeAny, {
|
|
97
|
+
lines: {
|
|
98
|
+
type: "addition" | "deletion" | "context";
|
|
99
|
+
content: string;
|
|
100
|
+
oldLineNumber?: number | undefined;
|
|
101
|
+
newLineNumber?: number | undefined;
|
|
102
|
+
}[];
|
|
103
|
+
header?: {
|
|
104
|
+
oldStart: number;
|
|
105
|
+
oldCount: number;
|
|
106
|
+
newStart: number;
|
|
107
|
+
newCount: number;
|
|
108
|
+
} | undefined;
|
|
109
|
+
}, {
|
|
110
|
+
lines: {
|
|
111
|
+
type: "addition" | "deletion" | "context";
|
|
112
|
+
content: string;
|
|
113
|
+
oldLineNumber?: number | undefined;
|
|
114
|
+
newLineNumber?: number | undefined;
|
|
115
|
+
}[];
|
|
116
|
+
header?: {
|
|
117
|
+
oldStart: number;
|
|
118
|
+
oldCount: number;
|
|
119
|
+
newStart: number;
|
|
120
|
+
newCount: number;
|
|
121
|
+
} | undefined;
|
|
122
|
+
}>;
|
|
123
|
+
type Hunk = z.infer<typeof hunkSchema>;
|
|
124
|
+
/**
|
|
125
|
+
* Style options for line markers.
|
|
126
|
+
*/
|
|
127
|
+
declare const markerStyleSchema: z.ZodEnum<["symbol", "word", "none"]>;
|
|
128
|
+
type MarkerStyle = z.infer<typeof markerStyleSchema>;
|
|
129
|
+
/**
|
|
130
|
+
* Schema for diff component input.
|
|
131
|
+
*/
|
|
132
|
+
declare const diffInputSchema: z.ZodObject<{
|
|
133
|
+
/**
|
|
134
|
+
* Array of hunks containing diff lines.
|
|
135
|
+
*/
|
|
136
|
+
hunks: z.ZodArray<z.ZodObject<{
|
|
137
|
+
/**
|
|
138
|
+
* Hunk header information.
|
|
139
|
+
*/
|
|
140
|
+
header: z.ZodOptional<z.ZodObject<{
|
|
141
|
+
oldStart: z.ZodNumber;
|
|
142
|
+
oldCount: z.ZodNumber;
|
|
143
|
+
newStart: z.ZodNumber;
|
|
144
|
+
newCount: z.ZodNumber;
|
|
145
|
+
}, "strip", z.ZodTypeAny, {
|
|
146
|
+
oldStart: number;
|
|
147
|
+
oldCount: number;
|
|
148
|
+
newStart: number;
|
|
149
|
+
newCount: number;
|
|
150
|
+
}, {
|
|
151
|
+
oldStart: number;
|
|
152
|
+
oldCount: number;
|
|
153
|
+
newStart: number;
|
|
154
|
+
newCount: number;
|
|
155
|
+
}>>;
|
|
156
|
+
/**
|
|
157
|
+
* Lines in the hunk.
|
|
158
|
+
*/
|
|
159
|
+
lines: z.ZodArray<z.ZodObject<{
|
|
160
|
+
/**
|
|
161
|
+
* Type of the line.
|
|
162
|
+
*/
|
|
163
|
+
type: z.ZodEnum<["addition", "deletion", "context"]>;
|
|
164
|
+
/**
|
|
165
|
+
* Content of the line.
|
|
166
|
+
*/
|
|
167
|
+
content: z.ZodString;
|
|
168
|
+
/**
|
|
169
|
+
* Optional line number in the old file (for deletions and context).
|
|
170
|
+
*/
|
|
171
|
+
oldLineNumber: z.ZodOptional<z.ZodNumber>;
|
|
172
|
+
/**
|
|
173
|
+
* Optional line number in the new file (for additions and context).
|
|
174
|
+
*/
|
|
175
|
+
newLineNumber: z.ZodOptional<z.ZodNumber>;
|
|
176
|
+
}, "strip", z.ZodTypeAny, {
|
|
177
|
+
type: "addition" | "deletion" | "context";
|
|
178
|
+
content: string;
|
|
179
|
+
oldLineNumber?: number | undefined;
|
|
180
|
+
newLineNumber?: number | undefined;
|
|
181
|
+
}, {
|
|
182
|
+
type: "addition" | "deletion" | "context";
|
|
183
|
+
content: string;
|
|
184
|
+
oldLineNumber?: number | undefined;
|
|
185
|
+
newLineNumber?: number | undefined;
|
|
186
|
+
}>, "many">;
|
|
187
|
+
}, "strip", z.ZodTypeAny, {
|
|
188
|
+
lines: {
|
|
189
|
+
type: "addition" | "deletion" | "context";
|
|
190
|
+
content: string;
|
|
191
|
+
oldLineNumber?: number | undefined;
|
|
192
|
+
newLineNumber?: number | undefined;
|
|
193
|
+
}[];
|
|
194
|
+
header?: {
|
|
195
|
+
oldStart: number;
|
|
196
|
+
oldCount: number;
|
|
197
|
+
newStart: number;
|
|
198
|
+
newCount: number;
|
|
199
|
+
} | undefined;
|
|
200
|
+
}, {
|
|
201
|
+
lines: {
|
|
202
|
+
type: "addition" | "deletion" | "context";
|
|
203
|
+
content: string;
|
|
204
|
+
oldLineNumber?: number | undefined;
|
|
205
|
+
newLineNumber?: number | undefined;
|
|
206
|
+
}[];
|
|
207
|
+
header?: {
|
|
208
|
+
oldStart: number;
|
|
209
|
+
oldCount: number;
|
|
210
|
+
newStart: number;
|
|
211
|
+
newCount: number;
|
|
212
|
+
} | undefined;
|
|
213
|
+
}>, "many">;
|
|
214
|
+
/**
|
|
215
|
+
* Optional old file name for header.
|
|
216
|
+
*/
|
|
217
|
+
oldFile: z.ZodOptional<z.ZodString>;
|
|
218
|
+
/**
|
|
219
|
+
* Optional new file name for header.
|
|
220
|
+
*/
|
|
221
|
+
newFile: z.ZodOptional<z.ZodString>;
|
|
222
|
+
/**
|
|
223
|
+
* Show line numbers.
|
|
224
|
+
* @default false
|
|
225
|
+
*/
|
|
226
|
+
showLineNumbers: z.ZodDefault<z.ZodBoolean>;
|
|
227
|
+
/**
|
|
228
|
+
* Style for line markers.
|
|
229
|
+
* @default "symbol"
|
|
230
|
+
*/
|
|
231
|
+
markerStyle: z.ZodDefault<z.ZodEnum<["symbol", "word", "none"]>>;
|
|
232
|
+
/**
|
|
233
|
+
* Show hunk headers (@@ -x,y +a,b @@).
|
|
234
|
+
* @default true
|
|
235
|
+
*/
|
|
236
|
+
showHunkHeaders: z.ZodDefault<z.ZodBoolean>;
|
|
237
|
+
/**
|
|
238
|
+
* Number of context lines to show around changes.
|
|
239
|
+
* This is informational only - the component renders what you provide.
|
|
240
|
+
*/
|
|
241
|
+
contextLines: z.ZodOptional<z.ZodNumber>;
|
|
242
|
+
}, "strip", z.ZodTypeAny, {
|
|
243
|
+
hunks: {
|
|
244
|
+
lines: {
|
|
245
|
+
type: "addition" | "deletion" | "context";
|
|
246
|
+
content: string;
|
|
247
|
+
oldLineNumber?: number | undefined;
|
|
248
|
+
newLineNumber?: number | undefined;
|
|
249
|
+
}[];
|
|
250
|
+
header?: {
|
|
251
|
+
oldStart: number;
|
|
252
|
+
oldCount: number;
|
|
253
|
+
newStart: number;
|
|
254
|
+
newCount: number;
|
|
255
|
+
} | undefined;
|
|
256
|
+
}[];
|
|
257
|
+
showLineNumbers: boolean;
|
|
258
|
+
markerStyle: "symbol" | "word" | "none";
|
|
259
|
+
showHunkHeaders: boolean;
|
|
260
|
+
oldFile?: string | undefined;
|
|
261
|
+
newFile?: string | undefined;
|
|
262
|
+
contextLines?: number | undefined;
|
|
263
|
+
}, {
|
|
264
|
+
hunks: {
|
|
265
|
+
lines: {
|
|
266
|
+
type: "addition" | "deletion" | "context";
|
|
267
|
+
content: string;
|
|
268
|
+
oldLineNumber?: number | undefined;
|
|
269
|
+
newLineNumber?: number | undefined;
|
|
270
|
+
}[];
|
|
271
|
+
header?: {
|
|
272
|
+
oldStart: number;
|
|
273
|
+
oldCount: number;
|
|
274
|
+
newStart: number;
|
|
275
|
+
newCount: number;
|
|
276
|
+
} | undefined;
|
|
277
|
+
}[];
|
|
278
|
+
oldFile?: string | undefined;
|
|
279
|
+
newFile?: string | undefined;
|
|
280
|
+
showLineNumbers?: boolean | undefined;
|
|
281
|
+
markerStyle?: "symbol" | "word" | "none" | undefined;
|
|
282
|
+
showHunkHeaders?: boolean | undefined;
|
|
283
|
+
contextLines?: number | undefined;
|
|
284
|
+
}>;
|
|
285
|
+
type DiffInput = z.input<typeof diffInputSchema>;
|
|
286
|
+
type DiffInputWithDefaults = z.output<typeof diffInputSchema>;
|
|
287
|
+
|
|
288
|
+
/**
|
|
289
|
+
* Diff component for rendering unified diff output.
|
|
290
|
+
*/
|
|
291
|
+
declare class DiffComponent extends BaseTuiComponent<DiffInput, typeof diffInputSchema> {
|
|
292
|
+
readonly metadata: ComponentMetadata<DiffInput>;
|
|
293
|
+
readonly schema: zod.ZodObject<{
|
|
294
|
+
hunks: zod.ZodArray<zod.ZodObject<{
|
|
295
|
+
header: zod.ZodOptional<zod.ZodObject<{
|
|
296
|
+
oldStart: zod.ZodNumber;
|
|
297
|
+
oldCount: zod.ZodNumber;
|
|
298
|
+
newStart: zod.ZodNumber;
|
|
299
|
+
newCount: zod.ZodNumber;
|
|
300
|
+
}, "strip", zod.ZodTypeAny, {
|
|
301
|
+
oldStart: number;
|
|
302
|
+
oldCount: number;
|
|
303
|
+
newStart: number;
|
|
304
|
+
newCount: number;
|
|
305
|
+
}, {
|
|
306
|
+
oldStart: number;
|
|
307
|
+
oldCount: number;
|
|
308
|
+
newStart: number;
|
|
309
|
+
newCount: number;
|
|
310
|
+
}>>;
|
|
311
|
+
lines: zod.ZodArray<zod.ZodObject<{
|
|
312
|
+
type: zod.ZodEnum<["addition", "deletion", "context"]>;
|
|
313
|
+
content: zod.ZodString;
|
|
314
|
+
oldLineNumber: zod.ZodOptional<zod.ZodNumber>;
|
|
315
|
+
newLineNumber: zod.ZodOptional<zod.ZodNumber>;
|
|
316
|
+
}, "strip", zod.ZodTypeAny, {
|
|
317
|
+
type: "addition" | "deletion" | "context";
|
|
318
|
+
content: string;
|
|
319
|
+
oldLineNumber?: number | undefined;
|
|
320
|
+
newLineNumber?: number | undefined;
|
|
321
|
+
}, {
|
|
322
|
+
type: "addition" | "deletion" | "context";
|
|
323
|
+
content: string;
|
|
324
|
+
oldLineNumber?: number | undefined;
|
|
325
|
+
newLineNumber?: number | undefined;
|
|
326
|
+
}>, "many">;
|
|
327
|
+
}, "strip", zod.ZodTypeAny, {
|
|
328
|
+
lines: {
|
|
329
|
+
type: "addition" | "deletion" | "context";
|
|
330
|
+
content: string;
|
|
331
|
+
oldLineNumber?: number | undefined;
|
|
332
|
+
newLineNumber?: number | undefined;
|
|
333
|
+
}[];
|
|
334
|
+
header?: {
|
|
335
|
+
oldStart: number;
|
|
336
|
+
oldCount: number;
|
|
337
|
+
newStart: number;
|
|
338
|
+
newCount: number;
|
|
339
|
+
} | undefined;
|
|
340
|
+
}, {
|
|
341
|
+
lines: {
|
|
342
|
+
type: "addition" | "deletion" | "context";
|
|
343
|
+
content: string;
|
|
344
|
+
oldLineNumber?: number | undefined;
|
|
345
|
+
newLineNumber?: number | undefined;
|
|
346
|
+
}[];
|
|
347
|
+
header?: {
|
|
348
|
+
oldStart: number;
|
|
349
|
+
oldCount: number;
|
|
350
|
+
newStart: number;
|
|
351
|
+
newCount: number;
|
|
352
|
+
} | undefined;
|
|
353
|
+
}>, "many">;
|
|
354
|
+
oldFile: zod.ZodOptional<zod.ZodString>;
|
|
355
|
+
newFile: zod.ZodOptional<zod.ZodString>;
|
|
356
|
+
showLineNumbers: zod.ZodDefault<zod.ZodBoolean>;
|
|
357
|
+
markerStyle: zod.ZodDefault<zod.ZodEnum<["symbol", "word", "none"]>>;
|
|
358
|
+
showHunkHeaders: zod.ZodDefault<zod.ZodBoolean>;
|
|
359
|
+
contextLines: zod.ZodOptional<zod.ZodNumber>;
|
|
360
|
+
}, "strip", zod.ZodTypeAny, {
|
|
361
|
+
hunks: {
|
|
362
|
+
lines: {
|
|
363
|
+
type: "addition" | "deletion" | "context";
|
|
364
|
+
content: string;
|
|
365
|
+
oldLineNumber?: number | undefined;
|
|
366
|
+
newLineNumber?: number | undefined;
|
|
367
|
+
}[];
|
|
368
|
+
header?: {
|
|
369
|
+
oldStart: number;
|
|
370
|
+
oldCount: number;
|
|
371
|
+
newStart: number;
|
|
372
|
+
newCount: number;
|
|
373
|
+
} | undefined;
|
|
374
|
+
}[];
|
|
375
|
+
showLineNumbers: boolean;
|
|
376
|
+
markerStyle: "symbol" | "word" | "none";
|
|
377
|
+
showHunkHeaders: boolean;
|
|
378
|
+
oldFile?: string | undefined;
|
|
379
|
+
newFile?: string | undefined;
|
|
380
|
+
contextLines?: number | undefined;
|
|
381
|
+
}, {
|
|
382
|
+
hunks: {
|
|
383
|
+
lines: {
|
|
384
|
+
type: "addition" | "deletion" | "context";
|
|
385
|
+
content: string;
|
|
386
|
+
oldLineNumber?: number | undefined;
|
|
387
|
+
newLineNumber?: number | undefined;
|
|
388
|
+
}[];
|
|
389
|
+
header?: {
|
|
390
|
+
oldStart: number;
|
|
391
|
+
oldCount: number;
|
|
392
|
+
newStart: number;
|
|
393
|
+
newCount: number;
|
|
394
|
+
} | undefined;
|
|
395
|
+
}[];
|
|
396
|
+
oldFile?: string | undefined;
|
|
397
|
+
newFile?: string | undefined;
|
|
398
|
+
showLineNumbers?: boolean | undefined;
|
|
399
|
+
markerStyle?: "symbol" | "word" | "none" | undefined;
|
|
400
|
+
showHunkHeaders?: boolean | undefined;
|
|
401
|
+
contextLines?: number | undefined;
|
|
402
|
+
}>;
|
|
403
|
+
/**
|
|
404
|
+
* Override getJsonSchema to use direct schema generation.
|
|
405
|
+
*/
|
|
406
|
+
getJsonSchema(): object;
|
|
407
|
+
render(input: DiffInput, context: RenderContext): RenderResult;
|
|
408
|
+
private calculateLineNumberWidths;
|
|
409
|
+
private renderHunk;
|
|
410
|
+
private renderLine;
|
|
411
|
+
}
|
|
412
|
+
/**
|
|
413
|
+
* Factory function to create a diff component.
|
|
414
|
+
*/
|
|
415
|
+
declare function createDiff(): DiffComponent;
|
|
416
|
+
|
|
417
|
+
export { DiffComponent, type DiffInput, type DiffInputWithDefaults, type DiffLine, type Hunk, type LineType, type MarkerStyle, createDiff, diffInputSchema, diffLineSchema, hunkSchema, lineTypeSchema, markerStyleSchema };
|