@createiq/htmldiff 1.0.0

package/test/HtmlDiff.spec.ts

@@ -0,0 +1,251 @@
+import { describe, expect, it } from 'vitest'
+
+import HtmlDiff from '../src/HtmlDiff'
+
+describe('HtmlDiff', () => {
+  // Shamelessly copied specs from here with a few modifications: https://github.com/myobie/htmldiff/blob/master/spec/htmldiff_spec.rb
+  it.for([
+    [
+      'a word is here',
+      'a nother word is there',
+      "a<ins class='diffins'>&nbsp;nother</ins> word is <del class='diffmod'>here</del><ins class='diffmod'>there</ins>",
+    ],
+    ['a c', 'a b c', "a <ins class='diffins'>b </ins>c"],
+    ['a b c', 'a c', "a <del class='diffdel'>b </del>c"],
+    ['a b c', 'a <strong>b</strong> c', "a <strong><ins class='mod'>b</ins></strong> c"],
+    ['a b c', 'a d c', "a <del class='diffmod'>b</del><ins class='diffmod'>d</ins> c"],
+    ["<a title='xx'>test</a>", "<a title='yy'>test</a>", "<a title='yy'>test</a>"],
+    ["<img src='logo.jpg'/>", '', "<del class='diffdel'><img src='logo.jpg'/></del>"],
+    ['', "<img src='logo.jpg'/>", "<ins class='diffins'><img src='logo.jpg'/></ins>"],
+    [
+      "symbols 'should not' belong <b>to</b> words",
+      'symbols should not belong <b>"to"</b> words',
+      "symbols <del class='diffdel'>'</del>should not<del class='diffdel'>'</del> belong <b><ins class='diffins'>\"</ins>to<ins class='diffins'>\"</ins></b> words",
+    ],
+    [
+      'entities are separate amp;words',
+      'entities are&nbsp;separate &amp;words',
+      "entities are<del class='diffmod'>&nbsp;</del><ins class='diffmod'>&nbsp;</ins>separate <del class='diffmod'>amp;</del><ins class='diffmod'>&amp;</ins>words",
+    ],
+    [
+      'This is a longer piece of text to ensure the new blocksize algorithm works',
+      'This is a longer piece of text to <strong>ensure</strong> the new blocksize algorithm works decently',
+      "This is a longer piece of text to <strong><ins class='mod'>ensure</ins></strong> the new blocksize algorithm works<ins class='diffins'>&nbsp;decently</ins>",
+    ],
+    [
+      'By virtue of an agreement between xxx and the <b>yyy schools</b>, ...',
+      'By virtue of an agreement between xxx and the <b>yyy</b> schools, ...',
+      'By virtue of an agreement between xxx and the <b>yyy</b> schools, ...',
+    ],
+    [
+      'Some plain text',
+      'Some <strong><i>plain</i></strong> text',
+      "Some <strong><i><ins class='mod'>plain</ins></i></strong> text",
+    ],
+    [
+      'Some <strong><i>formatted</i></strong> text',
+      'Some formatted text',
+      "Some <ins class='mod'>formatted</ins> text",
+    ],
+    [
+      '<table><tr><td>col1</td><td>col2</td></tr><tr><td>Data 1</td><td>Data 2</td></tr></table>',
+      '<table><tr><td>col1</td><td>col2</td></tr></table>',
+      "<table><tr><td>col1</td><td>col2</td></tr><tr><td><del class='diffdel'>Data 1</del></td><td><del class='diffdel'>Data 2</del></td></tr></table>",
+    ],
+    [
+      'text',
+      '<span style="text-decoration: line-through;">text</span>',
+      '<span style="text-decoration: line-through;"><ins class=\'mod\'>text</ins></span>',
+    ],
+
+    // TODO: Don't speak Chinese, this needs to be validated
+    [
+      '这个是中文内容, CSharp is the bast',
+      '这是中国语内容，CSharp is the best language.',
+      "这<del class='diffdel'>个</del>是中<del class='diffmod'>文</del><ins class='diffmod'>国语</ins>内容<del class='diffmod'>, </del><ins class='diffmod'>，</ins>CSharp is the <del class='diffmod'>bast</del><ins class='diffmod'>best language.</ins>",
+    ],
+  ] as const)('should diff (%s, %s) -> %s', ([oldText, newText, expected]) => {
+    expect(HtmlDiff.execute(oldText, newText)).toEqual(expected)
+  })
+
+  it.for([
+    [
+      'one a word is somewhere',
+      'two a nother word is somewhere',
+      "<del class='diffmod'>one a</del><ins class='diffmod'>two a nother</ins> word is somewhere",
+      0.2,
+    ],
+    [
+      'one a word is somewhere',
+      'two a nother word is somewhere',
+      "<del class='diffmod'>one</del><ins class='diffmod'>two</ins> a<ins class='diffins'>&nbsp;nother</ins> word is somewhere",
+      0.1,
+    ],
+  ] as const)(
+    'should diff (%s, %s) -> %s with orphanMatchThreshold %d',
+    ([oldText, newText, expected, orphanMatchThreshold]) => {
+      const diff = new HtmlDiff(oldText, newText)
+      diff.orphanMatchThreshold = orphanMatchThreshold
+      expect(diff.build()).toEqual(expected)
+    }
+  )
+
+  it.for([
+    [
+      'This is a date 1 Jan 2016 that will change',
+      'This is a date 22 Feb 2017 that did change',
+      "This is a date<del class='diffmod'> 1 Jan 2016</del><ins class='diffmod'> 22 Feb 2017</ins> that <del class='diffmod'>will</del><ins class='diffmod'>did</ins> change",
+      /\d{1,2}\s*(Jan|Feb)\s*\d{4}/g,
+    ],
+    [
+      'This is a date 1 Jan 2016 that will change',
+      "This is a date 22 Feb 2017 that won't change",
+      "This is a date <del class='diffmod'>1</del><ins class='diffmod'>22</ins> <del class='diffmod'>Jan</del><ins class='diffmod'>Feb</ins> <del class='diffmod'>2016</del><ins class='diffmod'>2017</ins> that <del class='diffmod'>will</del><ins class='diffmod'>won't</ins> change",
+      null,
+    ],
+  ] as const)(
+    'should diff (%s, %s) %s with grouping expression %s',
+    ([oldText, newText, expected, groupExpression]) => {
+      const diff = new HtmlDiff(oldText, newText)
+      if (groupExpression) {
+        diff.addBlockExpression(groupExpression)
+      }
+      expect(diff.build()).toEqual(expected)
+    }
+  )
+
+  it('should throw ArgumentException with invalid overlapping groups', () => {
+    const oldText = 'This is a date 1 Jan 2016 that will change'
+    const newText = "This is a date 22 Feb 2017 that won't change"
+    const diff = new HtmlDiff(oldText, newText)
+
+    // purposefully cause an overlapping expression
+    const pattern = /\d{1,2}\s*(Jan|Feb)\s*\d{4}/g
+    diff.addBlockExpression(pattern)
+    diff.addBlockExpression(pattern)
+
+    expect(() => diff.build()).toThrowError(
+      'One or more block expressions result in a text sequence that overlaps. Current expression: /\\d{1,2}\\s*(Jan|Feb)\\s*\\d{4}/'
+    )
+  })
+
+  // https://github.com/Rohland/htmldiff.net/issues/3
+  it('should not include prefix in diff when non-alphanumeric characters are adjoined to the word diff', () => {
+    const oldText = 'The Dealer.'
+    const newText = 'The Dealer info,'
+
+    expect(HtmlDiff.execute(oldText, newText)).toEqual(
+      "The Dealer<del class='diffmod'>.</del><ins class='diffmod'>&nbsp;info,</ins>"
+    )
+  })
+
+  // https://github.com/Rohland/htmldiff.net/issues/20
+  it.for([
+    // Original Testcase from Issue 20, but with the correct expected result (the original expected result was missing the <ins class='mod'>[...]</ins>)
+    [
+      '<div class="dumb">Thiis a text without any sup-tags and other special things</div>',
+      '<div class="dumb">Thiis a text <sup>1</sup>without any sup-tags and other special things</div>',
+      "<div class=\"dumb\">Thiis a text <sup><ins class='mod'><ins class='diffins'>1</ins></ins></sup>without any sup-tags and other special things</div>",
+    ],
+
+    // Inserting a new word at the end of the reformatted text
+    [
+      '<span>text remains</span>',
+      '<span><strong>text remains Test</strong></span>',
+      "<span><strong><ins class='mod'>text remains<ins class='diffins'>&nbsp;Test</ins></ins></strong></span>",
+    ],
+
+    // Inserting a new word at the end of a reformatted text and another word at the end outside the reformatted text
+    [
+      '<span>text remains</span>',
+      '<span><strong>text remains Test</strong> Test</span>',
+      "<span><strong><ins class='mod'>text remains<ins class='diffins'>&nbsp;Test</ins></ins></strong><ins class='diffins'>&nbsp;Test</ins></span>",
+    ],
+
+    // Twice reformatted text with an offset at the end
+    [
+      '<span>text remains</span>',
+      '<span><strong><big>text </big>remains</strong></span>',
+      "<span><strong><big><ins class='mod'>text </big>remains</ins></strong></span>",
+    ],
+
+    // Inserting a new word at the beginning of a reformatted text.
+    [
+      '<span>text remains</span>',
+      '<span><strong>Test text remains</strong></span>',
+      "<span><strong><ins class='mod'><ins class='diffins'>Test </ins>text remains</ins></strong></span>",
+    ],
+  ] as const)('should handle missing closing tag in diff (%s, %s) -> %s', ([oldText, newText, expected]) => {
+    expect(HtmlDiff.execute(oldText, newText)).toEqual(expected)
+  })
+
+  it.for([
+    [
+      '<p>The additional term only applies where 5 years have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where <strong><em>5 years</em></strong> have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where <strong><em><ins class='mod'>5 years</ins></em></strong> have elapsed since the execution of this language.</p>`,
+    ],
+    [
+      '<p>The additional term only applies where 5 years have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where <em><strong>5 years</strong></em> have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where <em><strong><ins class='mod'>5 years</ins></strong></em> have elapsed since the execution of this language.</p>`,
+    ],
+    [
+      '<p>The additional term only applies where 5 years have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where [5 years] have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where <ins class='diffins'>[</ins>5 years<ins class='diffins'>]</ins> have elapsed since the execution of this language.</p>`,
+    ],
+    [
+      '<p>The additional term only applies where 5 years have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where [<strong><em>5 years</em></strong>] have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where <ins class='diffins'>[</ins><strong><em><ins class='mod'>5 years</ins></em></strong><ins class='diffins'>]</ins> have elapsed since the execution of this language.</p>`,
+    ],
+    [
+      '<p>The additional term only applies where 5 years have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where [<em><strong>5 years</strong></em>] have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where <ins class='diffins'>[</ins><em><strong><ins class='mod'>5 years</ins></strong></em><ins class='diffins'>]</ins> have elapsed since the execution of this language.</p>`,
+    ],
+  ] as const)('should work when the comparison adds styling', ([oldText, newText, expected]) => {
+    expect(HtmlDiff.execute(oldText, newText)).toEqual(expected)
+  })
+
+  it.for([
+    [
+      '<p>The additional term only applies where <strong><em>5 years</em></strong> have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where 5 years have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where <ins class='mod'>5 years</ins> have elapsed since the execution of this language.</p>`,
+    ],
+    [
+      '<p>The additional term only applies where <em><strong>5 years</strong></em> have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where 5 years have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where <ins class='mod'>5 years</ins> have elapsed since the execution of this language.</p>`,
+    ],
+    [
+      '<p>The additional term only applies where [5 years] have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where 5 years have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where <del class='diffdel'>[</del>5 years<del class='diffdel'>]</del> have elapsed since the execution of this language.</p>`,
+    ],
+    [
+      '<p>The additional term only applies where [<strong><em>5 years</em></strong>] have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where 5 years have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where <del class='diffdel'>[</del><ins class='mod'>5 years</ins><del class='diffdel'>]</del> have elapsed since the execution of this language.</p>`,
+    ],
+    [
+      '<p>The additional term only applies where [<em><strong>5 years</strong></em>] have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where 5 years have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where <del class='diffdel'>[</del><ins class='mod'>5 years</ins><del class='diffdel'>]</del> have elapsed since the execution of this language.</p>`,
+    ],
+    [
+      '<p>The additional term only applies where [<strong><em>5 years</em></strong>] have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where [<strong>5 years</strong>] have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where [<strong><ins class='mod'>5 years</ins></strong>] have elapsed since the execution of this language.</p>`,
+    ],
+    [
+      '<p>The additional term only applies where <strong><em>5 years</em></strong> have elapsed since the execution of this language.</p>',
+      '<p>The additional term only applies where [5 years] have elapsed since the execution of this language.</p>',
+      `<p>The additional term only applies where <ins class='mod'><ins class='diffmod'>[</ins>5 years</ins><ins class='diffmod'>]</ins> have elapsed since the execution of this language.</p>`,
+    ],
+  ] as const)('should work when the comparison removes styling', ([oldText, newText, expected]) => {
+    expect(HtmlDiff.execute(oldText, newText)).toEqual(expected)
+  })
+})

package/test/MatchFinder.spec.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest'
+
+import Match from '../src/Match'
+import MatchFinder from '../src/MatchFinder'
+
+describe('MatchFinder', () => {
+  describe('findMatch()', () => {
+    it("if matches wasn't found - return null", () => {
+      const oldWords = ['this', ' ', 'is', ' ', 'old', ' ', 'text']
+      const newWords = ['different', 'words', 'here']
+      const finder = new MatchFinder(oldWords, newWords, 0, oldWords.length, 0, newWords.length, {
+        blockSize: 3,
+        ignoreWhitespaceDifferences: false,
+        repeatingWordsAccuracy: 1.0,
+      })
+
+      expect(finder.findMatch()).toEqual(null)
+    })
+
+    it('find matches in two sequenses of words and return Match (its position in old sequence and new one, and size)', () => {
+      const oldWords = ['this', ' ', 'is', ' ', 'old', ' ', 'text']
+      const newWords = ['this', ' ', 'is', ' ', 'new', ' ', 'text']
+      const finder = new MatchFinder(
+        oldWords,
+        newWords,
+        0,
+        oldWords.length, // will check all text from start to finish
+        0,
+        newWords.length, // will check all text from start to finish
+        {
+          blockSize: 4,
+          ignoreWhitespaceDifferences: false,
+          repeatingWordsAccuracy: 1.0,
+        }
+      )
+
+      const expectedMatch = new Match(0, 0, 4)
+
+      expect(finder.findMatch()).toEqual(expectedMatch) // will return that sequence - "this is " is the same in old and new
+    })
+
+    it(`if you reduce block size and change pointers (starts and ends in old and new)
+            - it will return more precise positions which could be skiped in first runthrough`, () => {
+      const finder = new MatchFinder(
+        ['this', ' ', 'is', ' ', 'old', ' ', 'text'],
+        ['this', ' ', 'is', ' ', 'new', ' ', 'text'],
+        4, // we change pointers for it to look only part of the text
+        7,
+        4, // we change pointers for it to look only part of the text
+        7,
+        {
+          blockSize: 2, // we change block size in order to notice smaller changes
+          ignoreWhitespaceDifferences: false,
+          repeatingWordsAccuracy: 1.0,
+        }
+      )
+
+      const expectedMatch = new Match(5, 5, 2)
+
+      expect(finder.findMatch()).toEqual(expectedMatch) // will return that sequence - " text" is the same in old and new
+    })
+
+    it('when have repeating sentences will return all sentence', () => {
+      const oldWords = ['this', ' ', 'is', ' ', 'this', ' ', 'is']
+      const newWords = ['this', ' ', 'is', ' ', 'this', ' ', 'is']
+      const finder = new MatchFinder(oldWords, newWords, 0, oldWords.length, 0, newWords.length, {
+        blockSize: 2,
+        ignoreWhitespaceDifferences: false,
+        repeatingWordsAccuracy: 1.0,
+      })
+
+      const expectedMatch = new Match(0, 0, 7)
+
+      expect(finder.findMatch()).toEqual(expectedMatch) // will return that all sequence - "this is this is" is the same in old and new
+    })
+  })
+})

package/test/Utils.spec.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest'
+
+import Utils from '../src/Utils'
+
+describe('Utils', () => {
+  describe('getTagName()', () => {
+    it.for([
+      ['', ''],
+      [null, ''],
+      ['test', ''],
+      ['<test', ''],
+      ['< div >', ''],
+      ['</ div>', ''],
+      ['<div>', 'div'],
+      [' \t<div> \t', 'div'],
+      ['<DIV>', 'div'],
+      ['</div>', 'div'],
+      ["<div attr='test'>", 'div'],
+      ['<div attr=test>', 'div'],
+    ] as const)('should map %s to tag name %s', ([input, expected]) => {
+      expect(Utils.getTagName(input)).toEqual(expected)
+    })
+  })
+
+  describe('isTag()', () => {
+    it('accept string and return true if it is tag', () => {
+      expect(Utils.isTag('')).toBe(false)
+
+      expect(Utils.isTag('<span>')).toBe(true)
+      expect(Utils.isTag('<video />')).toBe(true)
+    })
+
+    it('if it is "<img" tag - return false', () => {
+      expect(Utils.isTag('<img />')).toBe(false)
+    })
+  })
+
+  describe('stripTagAttributes()', () => {
+    it('accept string and return stripped tag - without any attributes', () => {
+      expect(Utils.stripTagAttributes('')).toBe('')
+
+      expect(Utils.stripTagAttributes('<span class="bold" style="font-size: 8px;" id="id-1" >')).toBe('<span>')
+      expect(Utils.stripTagAttributes('<img src="./image-1.png" />')).toBe('<img/>')
+    })
+  })
+
+  describe('wrapText()', () => {
+    it('create tag with passed text inside', () => {
+      expect(Utils.wrapText('text', 'span', '')).toBe("<span class=''>text</span>")
+    })
+
+    it('set passed css class to tag ', () => {
+      expect(Utils.wrapText('text', 'span', 'bold')).toBe("<span class='bold'>text</span>")
+    })
+  })
+
+  describe('isStartOfTag()', () => {
+    it('return true if it is start of the tag', () => {
+      expect(Utils.isStartOfTag('')).toBe(false)
+      expect(Utils.isStartOfTag('>')).toBe(false)
+
+      expect(Utils.isStartOfTag('<')).toBe(true)
+    })
+  })
+
+  describe('isEndOfTag()', () => {
+    it('return true if it is end of the tag', () => {
+      expect(Utils.isEndOfTag('')).toBe(false)
+      expect(Utils.isEndOfTag('<')).toBe(false)
+
+      expect(Utils.isEndOfTag('>')).toBe(true)
+    })
+  })
+
+  describe('isStartOfEntity()', () => {
+    it('return true if it is start of the enitity', () => {
+      expect(Utils.isStartOfEntity('')).toBe(false)
+      expect(Utils.isStartOfEntity('<')).toBe(false)
+
+      expect(Utils.isStartOfEntity('&')).toBe(true)
+    })
+  })
+
+  describe('isEndOfEntity()', () => {
+    it('return true if it is end of the enitity', () => {
+      expect(Utils.isEndOfEntity('')).toBe(false)
+      expect(Utils.isEndOfEntity('<')).toBe(false)
+
+      expect(Utils.isEndOfEntity(';')).toBe(true)
+    })
+  })
+
+  describe('isWhiteSpace()', () => {
+    it('return true if it is whitespace', () => {
+      expect(Utils.isWhiteSpace('')).toBe(false)
+      expect(Utils.isWhiteSpace('<')).toBe(false)
+
+      expect(Utils.isWhiteSpace(' ')).toBe(true)
+      expect(Utils.isWhiteSpace('&nbsp;')).toBe(true)
+    })
+  })
+
+  describe('stripAnyAttributes()', () => {
+    it('if passed tag - strip attirbutes otherwise return same string', () => {
+      expect(Utils.stripAnyAttributes('<tag atribute="value" />')).toBe('<tag/>')
+      expect(Utils.stripAnyAttributes('word')).toBe('word')
+    })
+  })
+
+  describe('isWord()', () => {
+    it('return true if it is number', () => {
+      expect(Utils.isWord('+')).toBe(false)
+      expect(Utils.isWord('[')).toBe(false)
+      expect(Utils.isWord(';')).toBe(false)
+
+      expect(Utils.isWord('a')).toBe(true)
+      expect(Utils.isWord('b')).toBe(true)
+    })
+  })
+})

package/test/WordSplitter.spec.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest'
+
+import WordSplitter from '../src/WordSplitter'
+
+describe('WordSplitter', () => {
+  it.for([
+    ['<td>a b c</td><td>d e f</td>', ['<td>a b c</td>', '<td>d e f</td>'], /<td>(.*?)<\/td>/gi],
+    ['<td>a b</td><br/><td>c d</td>', ['<td>a b</td>', '<br/>', '<td>c d</td>'], /<td>(.*?)<\/td>/gi],
+  ] as const)('should map %s to %s with custom blocks %s', ([text, expected, regex]) => {
+    expect(WordSplitter.convertHtmlToListOfWords(text, [regex])).toEqual(expected)
+  })
+
+  it.for([
+    ['old words', ['old', ' ', 'words']],
+    ['new text', ['new', ' ', 'text']],
+    // ['12345', ['12345']],
+    ['12345<img src="123" />', ['12345', '<img src="123" />']],
+    ['123&entity', ['123', '&entity']],
+    ['123[] 123 ', ['123', '[', ']', ' ', '123', ' ']],
+    [' &entity  ', [' ', '&entity', '  ']],
+    [' [&entity]', [' ', '[', '&entity', ']']],
+    ['[text]', ['[', 'text', ']']],
+    ['<tag>some text </tag>', ['<tag>', 'some', ' ', 'text', ' ', '</tag>']],
+  ] as const satisfies [string, string[]][])('should split inputs into words, %s -> %s', ([input, expected]) => {
+    expect(WordSplitter.convertHtmlToListOfWords(input, [])).toEqual(expected)
+  })
+})

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "@tsconfig/recommended/tsconfig.json",
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "declaration": true,
+    "declarationDir": "dist",
+    "outDir": "dist",
+    "strict": true,
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}

package/tsup.config.ts

@@ -0,0 +1,14 @@
+import * as path from 'node:path'
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  name: '@createiq/htmldiff',
+  entry: ['src/HtmlDiff.ts'],
+  format: ['esm', 'cjs'],
+  target: 'esnext',
+  outDir: 'dist',
+  clean: true,
+  dts: true,
+  sourcemap: true,
+  tsconfig: path.resolve(__dirname, 'tsconfig.json'),
+})

package/vitest.config.mts

@@ -0,0 +1,24 @@
+import path from 'node:path'
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    reporters: [
+      'default',
+      [
+        'junit',
+        { outputFile: path.resolve(process.env.CI_PROJECT_DIR || '.', 'junit.xml'), includeConsoleOutput: true },
+      ],
+    ],
+    coverage: {
+      provider: 'istanbul',
+      reporter: ['html', 'text', 'cobertura', 'lcov'],
+      reportsDirectory: path.resolve(process.env.CI_PROJECT_DIR || '.', 'coverage'),
+      include: ['src/**'],
+    },
+    clearMocks: true,
+    expect: {
+      requireAssertions: true,
+    },
+  },
+})