Gathering detailed insights and metrics for jest-diff
Gathering detailed insights and metrics for jest-diff
Gathering detailed insights and metrics for jest-diff
Gathering detailed insights and metrics for jest-diff
npm install jest-diff
Typescript
Module System
Min. Node Version
Node Version
NPM Version
87.8
Supply Chain
98.5
Quality
83.4
Maintenance
100
Vulnerability
99.6
License
v30.0.0-alpha.6
Published on 08 Aug 2024
v30.0.0-alpha.5
Published on 30 May 2024
v30.0.0-alpha.4
Published on 12 May 2024
v30.0.0-alpha.3
Published on 20 Feb 2024
v30.0.0-alpha.2
Published on 16 Nov 2023
v30.0.0-alpha.1
Published on 30 Oct 2023
Updated on 05 Dec 2024
TypeScript (79.22%)
JavaScript (20.12%)
CSS (0.57%)
Prolog (0.08%)
Shell (0.01%)
Handlebars (0.01%)
Cumulative downloads
Total Downloads
Last day
-0.7%
Compared to previous day
Last week
-17.4%
Compared to previous week
Last month
21.9%
Compared to previous month
Last year
5.6%
Compared to previous year
4
2
Display differences clearly so people can review changes confidently.
The diff
named export serializes JavaScript values, compares them line-by-line, and returns a string which includes comparison lines.
Two named exports compare strings character-by-character:
diffStringsUnified
returns a string.diffStringsRaw
returns an array of Diff
objects.Three named exports compare arrays of strings line-by-line:
diffLinesUnified
and diffLinesUnified2
return a string.diffLinesRaw
returns an array of Diff
objects.To add this package as a dependency of a project, run either of the following commands:
npm install jest-diff
yarn add jest-diff
diff()
Given JavaScript values, diff(a, b, options?)
does the following:
pretty-format
packagediff-sequences
packagechalk
packageTo use this function, write either of the following:
const {diff} = require('jest-diff');
in CommonJS modulesimport {diff} from 'jest-diff';
in ECMAScript modulesdiff()
1const a = ['delete', 'common', 'changed from']; 2const b = ['common', 'changed to', 'insert']; 3 4const difference = diff(a, b);
The returned string consists of:
Expected
lines are green, Received
lines are red, and common lines are dim (by default, see Options)1- Expected 2+ Received 3 4 Array [ 5- "delete", 6 "common", 7- "changed from", 8+ "changed to", 9+ "insert", 10 ]
diff()
Here are edge cases for the return value:
' Comparing two different types of values. …'
if the arguments have different types according to the jest-get-type
package (instances of different classes have the same 'object'
type)'Compared values have no visual difference.'
if the arguments have either referential identity according to Object.is
method or same serialization according to the pretty-format
packagenull
if either argument is a so-called asymmetric matcher in Jasmine or JestGiven strings, diffStringsUnified(a, b, options?)
does the following:
diff-sequences
packagechalk
packageAlthough the function is mainly for multiline strings, it compares any strings.
Write either of the following:
const {diffStringsUnified} = require('jest-diff');
in CommonJS modulesimport {diffStringsUnified} from 'jest-diff';
in ECMAScript modules1const a = 'common\nchanged from'; 2const b = 'common\nchanged to'; 3 4const difference = diffStringsUnified(a, b);
The returned string consists of:
from
has white-on-green and to
has white-on-red, which the following example does not show)1- Expected 2+ Received 3 4 common 5- changed from 6+ changed to
To get the benefit of changed substrings within the comparison lines, a character-by-character comparison has a higher computational cost (in time and space) than a line-by-line comparison.
If the input strings can have arbitrary length, we recommend that the calling code set a limit, beyond which splits the strings, and then calls diffLinesUnified
instead. For example, Jest falls back to line-by-line comparison if either string has length greater than 20K characters.
Given arrays of strings, diffLinesUnified(aLines, bLines, options?)
does the following:
diff-sequences
packagechalk
packageYou might call this function when strings have been split into lines and you do not need to see changed substrings within lines.
1const aLines = ['delete', 'common', 'changed from']; 2const bLines = ['common', 'changed to', 'insert']; 3 4const difference = diffLinesUnified(aLines, bLines);
1- Expected 2+ Received 3 4- delete 5 common 6- changed from 7+ changed to 8+ insert
Here are edge cases for arguments and return values:
a
and b
are empty strings: no comparison linesa
is empty string: all comparison lines have bColor
and bIndicator
(see Options)b
is empty string: all comparison lines have aColor
and aIndicator
(see Options)a
and b
are equal non-empty strings: all comparison lines have commonColor
and commonIndicator
(see Options)Given two pairs of arrays of strings, diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCompare, options?)
does the following:
Compare
arrays line-by-line using the diff-sequences
packageDisplay
arrays using the chalk
packageJest calls this function to consider lines as common instead of changed if the only difference is indentation.
You might call this function for case insensitive or Unicode equivalence comparison of lines.
1import {format} from 'pretty-format'; 2 3const a = { 4 text: 'Ignore indentation in serialized object', 5 time: '2019-09-19T12:34:56.000Z', 6 type: 'CREATE_ITEM', 7}; 8const b = { 9 payload: { 10 text: 'Ignore indentation in serialized object', 11 time: '2019-09-19T12:34:56.000Z', 12 }, 13 type: 'CREATE_ITEM', 14}; 15 16const difference = diffLinesUnified2( 17 // serialize with indentation to display lines 18 format(a).split('\n'), 19 format(b).split('\n'), 20 // serialize without indentation to compare lines 21 format(a, {indent: 0}).split('\n'), 22 format(b, {indent: 0}).split('\n'), 23);
The text
and time
properties are common, because their only difference is indentation:
1- Expected 2+ Received 3 4 Object { 5+ payload: Object { 6 text: 'Ignore indentation in serialized object', 7 time: '2019-09-19T12:34:56.000Z', 8+ }, 9 type: 'CREATE_ITEM', 10 }
The preceding example illustrates why (at least for indentation) it seems more intuitive that the function returns the common line from the bLinesDisplay
array instead of from the aLinesDisplay
array.
Given strings and a boolean option, diffStringsRaw(a, b, cleanup)
does the following:
diff-sequences
packageBecause diffStringsRaw
returns the difference as data instead of a string, you can format it as your application requires (for example, enclosed in HTML markup for browser instead of escape sequences for console).
The returned array describes substrings as instances of the Diff
class, which calling code can access like array tuples:
The value at index 0
is one of the following:
value | named export | description |
---|---|---|
0 | DIFF_EQUAL | in a and in b |
-1 | DIFF_DELETE | in a but not in b |
1 | DIFF_INSERT | in b but not in a |
The value at index 1
is a substring of a
or b
or both.
1const diffs = diffStringsRaw('changed from', 'changed to', true);
i | diffs[i][0] | diffs[i][1] |
---|---|---|
0 | 0 | 'changed ' |
1 | -1 | 'from' |
2 | 1 | 'to' |
1const diffs = diffStringsRaw('changed from', 'changed to', false);
i | diffs[i][0] | diffs[i][1] |
---|---|---|
0 | 0 | 'changed ' |
1 | -1 | 'fr' |
2 | 1 | 't' |
3 | 0 | 'o' |
4 | -1 | 'm' |
Here are all the named imports that you might need for the diffStringsRaw
function:
const {DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, diffStringsRaw} = require('jest-diff');
in CommonJS modulesimport {DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, diffStringsRaw} from 'jest-diff';
in ECMAScript modulesTo write a formatting function, you might need the named constants (and Diff
in TypeScript annotations).
If you write an application-specific cleanup algorithm, then you might need to call the Diff
constructor:
1const diffCommon = new Diff(DIFF_EQUAL, 'changed '); 2const diffDelete = new Diff(DIFF_DELETE, 'from'); 3const diffInsert = new Diff(DIFF_INSERT, 'to');
Given arrays of strings, diffLinesRaw(aLines, bLines)
does the following:
diff-sequences
packageBecause diffLinesRaw
returns the difference as data instead of a string, you can format it as your application requires.
1const aLines = ['delete', 'common', 'changed from']; 2const bLines = ['common', 'changed to', 'insert']; 3 4const diffs = diffLinesRaw(aLines, bLines);
i | diffs[i][0] | diffs[i][1] |
---|---|---|
0 | -1 | 'delete' |
1 | 0 | 'common' |
2 | -1 | 'changed from' |
3 | 1 | 'changed to' |
4 | 1 | 'insert' |
If you call string.split('\n')
for an empty string:
['']
an array which contains an empty string[]
an empty arrayDepending of your application, you might call diffLinesRaw
with either array.
1import {diffLinesRaw} from 'jest-diff'; 2 3const a = 'non-empty string'; 4const b = ''; 5 6const diffs = diffLinesRaw(a.split('\n'), b.split('\n'));
i | diffs[i][0] | diffs[i][1] |
---|---|---|
0 | -1 | 'non-empty string' |
1 | 1 | '' |
Which you might format as follows:
1- Expected - 1 2+ Received + 1 3 4- non-empty string 5+
For edge case behavior like the diffLinesUnified
function, you might define a splitLines0
function, which given an empty string, returns []
an empty array:
1export const splitLines0 = string => 2 string.length === 0 ? [] : string.split('\n');
1import {diffLinesRaw} from 'jest-diff'; 2 3const a = ''; 4const b = 'line 1\nline 2\nline 3'; 5 6const diffs = diffLinesRaw(a.split('\n'), b.split('\n'));
i | diffs[i][0] | diffs[i][1] |
---|---|---|
0 | 1 | 'line 1' |
1 | 1 | 'line 2' |
2 | 1 | 'line 3' |
Which you might format as follows:
1- Expected - 0 2+ Received + 3 3 4+ line 1 5+ line 2 6+ line 3
In contrast to the diffLinesRaw
function, the diffLinesUnified
and diffLinesUnified2
functions automatically convert array arguments computed by string split
method, so callers do not need a splitLine0
function.
The default options are for the report when an assertion fails from the expect
package used by Jest.
For other applications, you can provide an options object as a third argument:
diff(a, b, options)
diffStringsUnified(a, b, options)
diffLinesUnified(aLines, bLines, options)
diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCompare, options)
name | default |
---|---|
aAnnotation | 'Expected' |
aColor | chalk.green |
aIndicator | '-' |
bAnnotation | 'Received' |
bColor | chalk.red |
bIndicator | '+' |
changeColor | chalk.inverse |
changeLineTrailingSpaceColor | string => string |
commonColor | chalk.dim |
commonIndicator | ' ' |
commonLineTrailingSpaceColor | string => string |
compareKeys | undefined |
contextLines | 5 |
emptyFirstOrLastLinePlaceholder | '' |
expand | true |
includeChangeCounts | false |
omitAnnotationLines | false |
patchColor | chalk.yellow |
For more information about the options, see the following examples.
If the application is code modification, you might replace the labels:
1const options = { 2 aAnnotation: 'Original', 3 bAnnotation: 'Modified', 4};
1- Original 2+ Modified 3 4 common 5- changed from 6+ changed to
The jest-diff
package does not assume that the 2 labels have equal length.
For consistency with most diff tools, you might exchange the colors:
1import chalk = require('chalk'); 2 3const options = { 4 aColor: chalk.red, 5 bColor: chalk.green, 6};
Although the default inverse of foreground and background colors is hard to beat for changed substrings within lines, especially because it highlights spaces, if you want bold font weight on yellow background color:
1import chalk = require('chalk'); 2 3const options = { 4 changeColor: chalk.bold.bgYellowBright, 5};
Because diff()
does not display substring differences within lines, formatting can help you see when lines differ by the presence or absence of trailing spaces found by /\s+$/
regular expression.
1const options = { 2 aColor: chalk.rgb(128, 0, 128).bgRgb(255, 215, 255), // magenta 3 bColor: chalk.rgb(0, 95, 0).bgRgb(215, 255, 215), // green 4 commonLineTrailingSpaceColor: chalk.bgYellow, 5};
The value of a Color option is a function, which given a string, returns a string.
If you want to replace trailing spaces with middle dot characters:
1const replaceSpacesWithMiddleDot = string => '·'.repeat(string.length); 2 3const options = { 4 changeLineTrailingSpaceColor: replaceSpacesWithMiddleDot, 5 commonLineTrailingSpaceColor: replaceSpacesWithMiddleDot, 6};
If you need the TypeScript type of a Color option:
1import {DiffOptionsColor} from 'jest-diff';
To store the difference in a file without escape codes for colors, provide an identity function:
1const noColor = string => string; 2 3const options = { 4 aColor: noColor, 5 bColor: noColor, 6 changeColor: noColor, 7 commonColor: noColor, 8 patchColor: noColor, 9};
For consistency with the diff
command, you might replace the indicators:
1const options = { 2 aIndicator: '<', 3 bIndicator: '>', 4};
The jest-diff
package assumes (but does not enforce) that the 3 indicators have equal length.
By default, the output includes all common lines.
To emphasize the changes, you might limit the number of common “context” lines:
1const options = { 2 contextLines: 1, 3 expand: false, 4};
A patch mark like @@ -12,7 +12,9 @@
accounts for omitted common lines.
If you want patch marks to have the same dim color as common lines:
1import chalk = require('chalk'); 2 3const options = { 4 expand: false, 5 patchColor: chalk.dim, 6};
To display the number of changed lines at the right of annotation lines:
1const a = ['common', 'changed from']; 2const b = ['common', 'changed to', 'insert']; 3 4const options = { 5 includeChangeCounts: true, 6}; 7 8const difference = diff(a, b, options);
1- Expected - 1 2+ Received + 2 3 4 Array [ 5 "common", 6- "changed from", 7+ "changed to", 8+ "insert", 9 ]
To display only the comparison lines:
1const a = 'common\nchanged from'; 2const b = 'common\nchanged to'; 3 4const options = { 5 omitAnnotationLines: true, 6}; 7 8const difference = diffStringsUnified(a, b, options);
1 common 2- changed from 3+ changed to
If the first or last comparison line is empty, because the content is empty and the indicator is a space, you might not notice it.
The replacement option is a string whose default value is ''
empty string.
Because Jest trims the report when a matcher fails, it deletes an empty last line.
Therefore, Jest uses as placeholder the downwards arrow with corner leftwards:
1const options = { 2 emptyFirstOrLastLinePlaceholder: '↵', // U+21B5 3};
If a content line is empty, then the corresponding comparison line is automatically trimmed to remove the margin space (represented as a middle dot below) for the default indicators:
Indicator | untrimmed | trimmed |
---|---|---|
aIndicator | '-·' | '-' |
bIndicator | '+·' | '+' |
commonIndicator | ' ·' | '' |
When two objects are compared their keys are printed in alphabetical order by default. If this was not the original order of the keys the diff becomes harder to read as the keys are not in their original position.
Use compareKeys
to pass a function which will be used when sorting the object keys.
1const a = {c: 'c', b: 'b1', a: 'a'}; 2const b = {c: 'c', b: 'b2', a: 'a'}; 3 4const options = { 5 // The keys will be in their original order 6 compareKeys: () => 0, 7}; 8 9const difference = diff(a, b, options);
1- Expected 2+ Received 3 4 Object { 5 "c": "c", 6- "b": "b1", 7+ "b": "b2", 8 "a": "a", 9 }
Depending on the implementation of compareKeys
any sort order can be used.
1const a = {c: 'c', b: 'b1', a: 'a'}; 2const b = {c: 'c', b: 'b2', a: 'a'}; 3 4const options = { 5 // The keys will be in reverse order 6 compareKeys: (a, b) => (a > b ? -1 : 1), 7}; 8 9const difference = diff(a, b, options);
1- Expected 2+ Received 3 4 Object { 5 "a": "a", 6- "b": "b1", 7+ "b": "b2", 8 "c": "c", 9 }
No vulnerabilities found.
No security vulnerabilities found.