@playpilot/tpi 5.28.0 → 5.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@playpilot/tpi",
-	"version": "5.28.0",
+	"version": "5.30.0",
 	"type": "module",
 	"scripts": {
 		"dev": "vite dev",

package/src/lib/api/externalPages.ts

@@ -10,7 +10,7 @@ import { getApiToken } from '$lib/token'
 let pollTimeout: ReturnType<typeof setTimeout> | null = null
 
 /**
- * Fetch link injections for a URL.
+ * Fetch link injections for a URL. This will be either a POST or a GET request depending on whether on not the AI should run.
  * @param pageText Text content of the article
  * @param options
  * @param [options.url] URL of the given article
@@ -28,21 +28,34 @@ export async function fetchLinkInjections(
 
   if (!apiToken) throw new Error('No token was provided')
 
-  params.url = url
-  params.metadata = getPageMetaData()
+  const apiUrl = `/external-pages/?api-token=${apiToken}&include_title_details=true${isEditorialMode ? '&editorial_mode_enabled=true' : ''}&language=${language}`
+  let response: LinkInjectionResponse
+
+  // We use separate requests when running the AI or setting the editor session vs when only getting the results.
+  // For regular requests we use a GET endpoint, but when saving data we POST to the same url.
+  if (Object.entries(params).length) {
+    // Additional params are added when re-running AI. These are necessary for the API
+    if (params.run_ai) {
+      params.hash = hash
+      params.page_text = pageText
+      params.metadata = getPageMetaData()
+    }
 
-  // Add additional parameters if request is made to run the AI. We only include these when saving new data.
-  // Most requests will not include these.
-  if (params.run_ai) {
-    params.hash = hash
-    params.page_text = pageText
+    // Always add the given URL, this is used to match the article to the API record
+    params.url = url
+
+    response = await api<LinkInjectionResponse>(apiUrl, {
+      method: 'POST',
+      body: params,
+    })
+  } else {
+    // When getting injections without posting we append the URL of the page to the URL for the request.
+    // All other params are only relevant during the POST request.
+    response = await api<LinkInjectionResponse>(apiUrl + `&url=${url}`, {
+      method: 'GET',
+    })
   }
 
-  const response = await api<LinkInjectionResponse>(`/external-pages/?api-token=${apiToken}&include_title_details=true${isEditorialMode ? '&editorial_mode_enabled=true' : ''}&language=${language}`, {
-    method: 'POST',
-    body: params,
-  })
-
   // This is used when debugging (using window.PlayPilotLinkInjections.debug())
   window.PlayPilotLinkInjections.last_successful_fetch = response
 

package/src/routes/components/Rails/ParticipantsRail.svelte

@@ -1,7 +1,9 @@
 <script lang="ts">
   import { fetchParticipantsForTitle } from '$lib/api/participants'
   import { TrackingEvent } from '$lib/enums/TrackingEvent'
+  import { getLinkInjectionElements, getLinkInjectionsParentElement, getPageText } from '$lib/injection'
   import { openModal } from '$lib/modal'
+  import { cleanPhrase, findNumberOfMatchesInString } from '$lib/text'
   import { track } from '$lib/tracking'
   import type { ParticipantData } from '$lib/types/participant'
   import type { TitleData } from '$lib/types/title'
@@ -13,6 +15,31 @@
 
   const { title }: Props = $props()
 
+  /**
+   * Order participants by how often their name appears in an the page text. This only takes into account
+   * their full name. If an actor is mentioned by first name only, which is often the case, they won't get
+   * boosted. Often times if an actor is mentioned at least once, their full name will be somewhere in the
+   * page text, so the goal is still the same; to list participants that are mentioned in the page text before
+   * other participants.
+   */
+  function orderParticipantsByPageTextOccurrence(participants: ParticipantData[]): ParticipantData[] {
+    const pageText = cleanPhrase(getPageText(getLinkInjectionElements(getLinkInjectionsParentElement())))
+
+    // Create a new object with all participants by their sid with the number of times their names appear in the page text
+    const participantsByOccurrence: Record<string, { participant: ParticipantData, count: number }> = {}
+    for(const participant of participants) {
+      const count = findNumberOfMatchesInString(pageText, cleanPhrase(participant.name))
+
+      participantsByOccurrence[participant.sid] = { participant, count }
+    }
+
+    // Sort all participants by their occurrences. If a participant did not occur their positioned will be retained
+    // relative to where it was before
+    const participantsSortedByCount = Object.values(participantsByOccurrence).sort((a, b) => b.count - a.count)
+
+    return participantsSortedByCount.map(({ participant }) => participant)
+  }
+
   function onclick(event: MouseEvent, participant: ParticipantData): void {
     openModal({ event, type: 'participant', data: participant })
     track(TrackingEvent.ParticipantClick, null, { title_source: title.original_title, participant: participant.name })
@@ -28,7 +55,7 @@
 {:then participants}
   {#if participants?.length}
     <Rail heading="Cast">
-      {#each participants.slice(0, 15) as participant}
+      {#each orderParticipantsByPageTextOccurrence(participants).slice(0, 15) as participant}
         <button class="participant" data-testid="participant" onclick={event => onclick(event, participant)}>
           <span class="truncate">{participant.name}</span>
 

package/src/tests/lib/api/externalPages.test.js

@@ -33,22 +33,32 @@ describe('$lib/api/externalPages', () => {
       window.PlayPilotLinkInjections = { token: 'a' }
     })
 
-    it('Should call api with given url and body', async () => {
+    it('Should call api with GET method with given url', async () => {
       vi.mocked(api).mockResolvedValueOnce('Some response')
 
       const response = await fetchLinkInjections('Some text', { url: 'https://some-url', hash: 'some-hash' })
 
+      expect(response).toBe('Some response')
+      expect(api).toHaveBeenCalledWith(
+        '/external-pages/?api-token=a&include_title_details=true&language=en-US&url=https://some-url',
+        expect.objectContaining({
+          method: 'GET',
+        }),
+      )
+    })
+
+    it('Should call api with POST method and full details when fetching with run_ai as true', async () => {
+      vi.mocked(api).mockResolvedValueOnce('Some response')
+
+      const response = await fetchLinkInjections('Some text', { url: 'https://some-url', hash: 'some-hash', params: { key: 'value' } })
+
       expect(response).toBe('Some response')
       expect(api).toHaveBeenCalledWith(
         expect.stringContaining('api-token'),
         expect.objectContaining({
           body: {
             url: 'https://some-url',
-            metadata: {
-              content_heading: null,
-              content_modified_time: null,
-              content_published_time: null,
-            },
+            key: 'value',
           },
           method: 'POST',
         }),

package/src/tests/routes/components/Rails/ParticipantsRail.test.js

@@ -1,5 +1,5 @@
 import { fireEvent, render, waitFor } from '@testing-library/svelte'
-import { describe, expect, it, vi } from 'vitest'
+import { describe, expect, it, vi, beforeEach } from 'vitest'
 
 import ParticipantsRail from '../../../../routes/components/Rails/ParticipantsRail.svelte'
 import { openModal } from '$lib/modal'
@@ -21,10 +21,13 @@ vi.mock('$lib/api/participants', () => ({
 }))
 
 describe('ParticipantsRail.svelte', () => {
+  beforeEach(() => {
+    document.body.innerHTML = ''
+  })
+
   it('Should render each given participant', async () => {
     vi.mocked(fetchParticipantsForTitle).mockResolvedValueOnce(participants)
 
-    // @ts-ignore
     const { getByText } = render(ParticipantsRail, { title })
 
     await waitFor(() => {
@@ -33,6 +36,19 @@ describe('ParticipantsRail.svelte', () => {
     })
   })
 
+  it('Should order participants by their number of occurrences on the page', async () => {
+    document.body.innerHTML = `<main>${participants[1].name}. ${participants[2].name}, ${participants[2].name}</main>`
+    vi.mocked(fetchParticipantsForTitle).mockResolvedValueOnce(participants)
+
+    const { getAllByTestId } = render(ParticipantsRail, { title })
+
+    await waitFor(() => {
+      expect(getAllByTestId('participant')[0].innerText).toContain(participants[2].name)
+      expect(getAllByTestId('participant')[1].innerText).toContain(participants[1].name)
+      expect(getAllByTestId('participant')[2].innerText).toContain(participants[0].name)
+    })
+  })
+
   it('Should not render when no participants are returned', async () => {
     vi.mocked(fetchParticipantsForTitle).mockResolvedValueOnce([])