@playpilot/tpi 3.10.1 → 4.0.0

package/src/tests/lib/text.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest'
-import { cleanPhrase, findTextNodeContaining, isNodeInLink, replaceStartingFrom, truncateAroundPhrase } from '$lib/text'
+import { cleanPhrase, findAllMatchesBetweenPhrases, findShortestMatchBetweenPhrases, findSurroundingPhrases, findTextNodeContaining, getFirstNumberOfWordsInString, getNumberOfLeadingAndTrailingSpaces, isNodeInLink, replaceStartingFrom, reverseString, truncateAroundPhrase } from '$lib/text'
 
 describe('text.js', () => {
   beforeEach(() => {
@@ -127,4 +127,223 @@ describe('text.js', () => {
       expect(truncateAroundPhrase('Some sentence with a word', 'sentence with a', 10)).toBe('…tence with…')
     })
   })
+
+  describe('getNumberOfLeadingAndTrailingSpaces', () => {
+    it('Should return the number of leading spaces and trailing spaces', () => {
+      expect(getNumberOfLeadingAndTrailingSpaces('  Some text ')).toEqual({ leadingSpaces: 2, trailingSpaces: 1 })
+      expect(getNumberOfLeadingAndTrailingSpaces(' Some text   ')).toEqual({ leadingSpaces: 1, trailingSpaces: 3 })
+    })
+
+    it('Should return 0 for no leading or trailing spaces were given', () => {
+      expect(getNumberOfLeadingAndTrailingSpaces('Some text ')).toEqual({ leadingSpaces: 0, trailingSpaces: 1 })
+      expect(getNumberOfLeadingAndTrailingSpaces(' Some text')).toEqual({ leadingSpaces: 1, trailingSpaces: 0 })
+      expect(getNumberOfLeadingAndTrailingSpaces('Some text')).toEqual({ leadingSpaces: 0, trailingSpaces: 0 })
+    })
+
+    it('Should return 0 when given text is empty', () => {
+      expect(getNumberOfLeadingAndTrailingSpaces('')).toEqual({ leadingSpaces: 0, trailingSpaces: 0 })
+    })
+  })
+
+  describe('findAllMatchesBetweenPhrases', () => {
+    it('Should find a match between the given delimiters', () => {
+      expect(findAllMatchesBetweenPhrases('Some text with a match', 'text', 'match')).toEqual([
+        { match: ' with a ', index: 9 },
+      ])
+    })
+
+    it('Should find multiple matches between the given delimiters when multiple are present', () => {
+      expect(findAllMatchesBetweenPhrases('text Some match text with a match', 'text', 'match')).toEqual([
+        { match: ' Some ', index: 4 },
+        { match: ' with a ', index: 20 },
+      ])
+    })
+
+    it('Should match from start of the string when no start string is given', () => {
+      expect(findAllMatchesBetweenPhrases('Some text with a match', '', 'with')).toEqual([
+        { match: 'Some text ', index: 0 },
+      ])
+    })
+
+    it('Should match to end of the string when no end string is given', () => {
+      expect(findAllMatchesBetweenPhrases('Some text with a match', 'with', '')).toEqual([
+        { match: ' a match', index: 14 },
+      ])
+    })
+
+    it('Should match from start to end of the string when no start and end string is given', () => {
+      expect(findAllMatchesBetweenPhrases('Some text with a match', '', '')).toEqual([
+        { match: 'Some text with a match', index: 0 },
+      ])
+    })
+  })
+
+  describe('findShortestMatchBetweenPhrases', () => {
+    it('Should return the shortest match', () => {
+      expect(findShortestMatchBetweenPhrases('A start with end and another start with another end', 'with', 'start', 'end')).toEqual({
+        match: ' with ',
+        index: 7,
+      })
+    })
+
+    it('Should correctly account for html elements', () => {
+      expect(findShortestMatchBetweenPhrases('A start <strong>with</strong> end and another start and end', 'with', 'start', 'end')).toEqual({
+        match: ' <strong>with</strong> ',
+        index: 7,
+      })
+    })
+
+    it('Should match phrase even if broken up by html', () => {
+      expect(findShortestMatchBetweenPhrases('A start wi<strong>th</strong> end and another start and end', 'with', 'start', 'end')).toEqual({
+        match: ' wi<strong>th</strong> ',
+        index: 7,
+      })
+    })
+
+    it('Should match phrase even if text contains incomplete html', () => {
+      expect(findShortestMatchBetweenPhrases('<a>A start with</strong> end <strong>and another start and end', 'with', 'start', 'end')).toEqual({
+        match: ' with</strong> ',
+        index: 10,
+      })
+    })
+
+    it('Should return null when no matches are found', () => {
+      expect(findShortestMatchBetweenPhrases('A string without matches', 'with', 'start', 'end')).toEqual(null)
+    })
+  })
+
+  describe('getFirstNumberOfWordsInString', () => {
+    it('Should return the first word in a given phrase, separated by spaces', () => {
+      expect(getFirstNumberOfWordsInString('Some sentence with words')).toBe('Some')
+    })
+
+    it('Should return the given number of words in a given phrase', () => {
+      expect(getFirstNumberOfWordsInString('Some sentence with words', 3)).toBe('Some sentence with')
+    })
+
+    it('Should return nothing if given string is empty', () => {
+      expect(getFirstNumberOfWordsInString('')).toBe('')
+    })
+
+    it('Should return word including special characters', () => {
+      expect(getFirstNumberOfWordsInString('("Some") sentence with words')).toBe('("Some")')
+    })
+
+    it('Should include special characters as words where relevant', () => {
+      expect(getFirstNumberOfWordsInString('Some & sentence with words', 2)).toBe('Some &')
+    })
+  })
+
+  describe('findSurroundingPhrases', () => {
+    it('Should return the first 2 words around the given indexes inside of a text node', () => {
+      document.body.innerHTML = 'A text with a phrase that can be matched'
+      const node = /** @type {Element} */ (document.querySelector('body')).childNodes[0]
+
+      expect(findSurroundingPhrases(node, 11, 20)).toEqual({
+        before: 'text with',
+        after: 'that can',
+      })
+    })
+
+    it('Should return the first 2 words around the given indexes inside of a html element', () => {
+      document.body.innerHTML = '<span>A text with a phrase that can be matched</span>'
+      const node = /** @type {Node} */ (document.querySelector('span'))
+
+      expect(findSurroundingPhrases(node, 11, 20)).toEqual({
+        before: 'text with',
+        after: 'that can',
+      })
+    })
+
+    it('Should return ignore html elements', () => {
+      document.body.innerHTML = '<span>A text <strong>with</strong> a <em>phrase</em> that can be matched</span>'
+      const node = /** @type {Node} */ (document.querySelector('span'))
+
+      expect(findSurroundingPhrases(node, 11, 20)).toEqual({
+        before: 'text with',
+        after: 'that can',
+      })
+    })
+
+    it('Should return ignore html elements on partial words', () => {
+      document.body.innerHTML = '<span>A text <strong>wi</strong>th a <em>phr</em><em>ase</em> that can be matched</span>'
+      const node = /** @type {Node} */ (document.querySelector('span'))
+
+      expect(findSurroundingPhrases(node, 11, 20)).toEqual({
+        before: 'text with',
+        after: 'that can',
+      })
+    })
+
+    it('Should return 1 word for before if start only contains 1 word', () => {
+      document.body.innerHTML = 'Text with a phrase that can be matched'
+      const node = /** @type {Element} */ (document.querySelector('body')).childNodes[0]
+
+      expect(findSurroundingPhrases(node, 4, 9)).toEqual({
+        before: 'Text',
+        after: 'a phrase',
+      })
+    })
+
+    it('Should return no words for before when starting at 0', () => {
+      document.body.innerHTML = 'A text with a phrase that can be matched'
+      const node = /** @type {Element} */ (document.querySelector('body')).childNodes[0]
+
+      expect(findSurroundingPhrases(node, 0, 6)).toEqual({
+        before: '',
+        after: 'with a',
+      })
+    })
+
+    it('Should return no words for before when no starting text is found', () => {
+      document.body.innerHTML = '   A text with a phrase that can be matched'
+      const node = /** @type {Element} */ (document.querySelector('body')).childNodes[0]
+
+      expect(findSurroundingPhrases(node, 3, 9)).toEqual({
+        before: '',
+        after: 'with a',
+      })
+    })
+
+    it('Should return no words for after when end is at the end of the string', () => {
+      document.body.innerHTML = 'A text with a phrase that can be matched'
+      const node = /** @type {Element} */ (document.querySelector('body')).childNodes[0]
+
+      expect(findSurroundingPhrases(node, 30, /** @type {string} */ (node.textContent).length)).toEqual({
+        before: 'that can',
+        after: '',
+      })
+    })
+
+    it('Should return no words for after when no after text is found', () => {
+      document.body.innerHTML = 'A text with a phrase that can be matched   '
+      const node = /** @type {Element} */ (document.querySelector('body')).childNodes[0]
+
+      expect(findSurroundingPhrases(node, 30, /** @type {string} */ (node.textContent).length - 3)).toEqual({
+        before: 'that can',
+        after: '',
+      })
+    })
+
+    it('Should return 1 word for after if start only contains 1 word', () => {
+      document.body.innerHTML = 'Text with a phrase that can be matched'
+      const node = /** @type {Element} */ (document.querySelector('body')).childNodes[0]
+
+      expect(findSurroundingPhrases(node, 19, 30)).toEqual({
+        before: 'a phrase',
+        after: 'matched',
+      })
+    })
+  })
+
+  describe('reverseString', () => {
+    it('Should reverse a given string', () => {
+      expect(reverseString('abc')).toBe('cba')
+      expect(reverseString('abc 123')).toBe('321 cba')
+    })
+
+    it('Should handle empty strings by returning an empty string', () => {
+      expect(reverseString('')).toBe('')
+    })
+  })
 })

package/src/tests/routes/components/Editorial/ManualInjection.test.js

@@ -4,6 +4,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import ManualInjection from '../../../../routes/components/Editorial/ManualInjection.svelte'
 import { searchTitles } from '$lib/search'
 import { title } from '$lib/fakeData'
+import { getIndexOfSelection } from '$lib/selection'
 
 function createSelectionMock() {
   const container = document.querySelector('div')
@@ -27,14 +28,20 @@ vi.mock('$lib/search', () => ({
   searchTitles: vi.fn(),
 }))
 
+vi.mock('$lib/selection', () => ({
+  getIndexOfSelection: vi.fn(),
+}))
+
 describe('ManualInjection.svelte', () => {
   beforeEach(() => {
     vi.resetAllMocks()
+    vi.mocked(getIndexOfSelection).mockReturnValueOnce({ start: 0, end: 0 })
 
     document.body.innerHTML = '<div>Some text in a sentence</div>'
   })
 
   it('Should input selected text in selected text input and search input', async () => {
+    vi.mocked(getIndexOfSelection).mockReturnValueOnce({ start: 0, end: 0 })
     createSelectionMock()
 
     const { getByLabelText } = render(ManualInjection, { pageText: document.body.innerText, onsave: () => null })
@@ -58,6 +65,7 @@ describe('ManualInjection.svelte', () => {
     createSelectionMock()
 
     vi.mocked(searchTitles).mockResolvedValueOnce([title])
+    vi.mocked(getIndexOfSelection).mockReturnValueOnce({ start: 0, end: 0 })
 
     const { getByText } = render(ManualInjection, { pageText: document.body.innerText, onsave: () => null })
 
@@ -72,6 +80,7 @@ describe('ManualInjection.svelte', () => {
     createSelectionMock()
 
     vi.mocked(searchTitles).mockResolvedValueOnce([title])
+    vi.mocked(getIndexOfSelection).mockReturnValueOnce({ start: 5, end: 10 })
 
     const onsave = vi.fn()
     const { getByText } = render(ManualInjection, { pageText: document.body.innerText, onsave })
@@ -88,11 +97,14 @@ describe('ManualInjection.svelte', () => {
       key: expect.any(String),
       title_details: title,
       manual: true,
+      phrase_before: 'Some',
+      phrase_after: 'in a',
     })
   })
 
   it('Should select content outside of element if content is too short', async () => {
     vi.mocked(searchTitles).mockResolvedValueOnce([title])
+    vi.mocked(getIndexOfSelection).mockReturnValueOnce({ start: 0, end: 0 })
 
     document.body.innerHTML = '<div>Some other sentence. Some <strong><span>text</span></strong> in a sentence</div>'
 
@@ -127,11 +139,14 @@ describe('ManualInjection.svelte', () => {
       key: expect.any(String),
       title_details: title,
       manual: true,
+      phrase_before: '',
+      phrase_after: '',
     })
   })
 
   it('Should not select content if it is outside of given parent', async () => {
     vi.mocked(searchTitles).mockResolvedValueOnce([title])
+    vi.mocked(getIndexOfSelection).mockReturnValueOnce({ start: 0, end: 0 })
 
     document.body.innerHTML = '<div>Some text <main><p>in a sentence</p></main></div>'
 
@@ -182,34 +197,4 @@ describe('ManualInjection.svelte', () => {
 
     await waitFor(() => expect(searchTitles).toHaveBeenCalled())
   })
-
-  it('Should not select content if it contains multiple child nodes with content', async () => {
-    document.body.innerHTML = '<main><div>Some text in a sentence</div></main>'
-
-    const container = document.querySelector('div')
-    const onsave = vi.fn()
-    const { getByText } = render(ManualInjection, { pageText: document.body.innerText, onsave })
-
-    // @ts-ignore
-    window.getSelection = vi.fn(() => ({
-      toString: () => 'Some text',
-      getRangeAt: () => ({
-        commonAncestorContainer: container,
-        startContainer: container,
-        startOffset: 0,
-        endOffset: 0,
-        cloneContents: () => ({ childNodes: [{ textContent: 'a' }, { textContent: 'b' }] }),
-      }),
-      anchorNode: container,
-      focusNode: container,
-    }))
-
-    await fireEvent.mouseUp(window)
-
-    expect(searchTitles).not.toHaveBeenCalled()
-
-    await waitFor(() => {
-      expect(getByText('Selection contains multiple items. Selection may not contain a mix of styled and non styled text. Please select the text more directly.')).toBeTruthy()
-    })
-  })
 })

package/src/tests/routes/components/Title.test.js

@@ -39,15 +39,6 @@ describe('Title.svelte', () => {
     expect(getByText(title.year)).toBeTruthy()
   })
 
-  it('Should include data attributes', () => {
-    const { container } = render(Title, { title })
-
-    const element = /** @type {HTMLElement} */ (container.querySelector('[data-playpilot-link-injections-title]'))
-
-    expect(element).toBeTruthy()
-    expect(element?.dataset.playpilotOriginalTitle).toBe(title.original_title)
-  })
-
   it('Should not have small class by default', () => {
     const { container } = render(Title, { title })