@playpilot/tpi 8.10.4-beta.1 → 8.10.4-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@playpilot/tpi",
-	"version": "8.10.4-beta.1",
+	"version": "8.10.4-beta.3",
 	"type": "module",
 	"scripts": {
 		"dev": "vite dev",

package/src/lib/api/externalPages.ts

@@ -6,6 +6,7 @@ import type { LinkInjectionResponse, LinkInjection } from '../types/injection'
 import { getFullUrlPath } from '../url'
 import { api } from './api'
 import { getApiToken } from '$lib/token'
+import { getPageTextAndElements } from '$lib/injectionElements'
 
 let pollTimeout: ReturnType<typeof setTimeout> | null = null
 
@@ -13,9 +14,8 @@ let pollTimeout: ReturnType<typeof setTimeout> | null = null
  * 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.
  */
 export async function fetchLinkInjections(
-  pageText: string | null,
-  { url = getFullUrlPath(), hash = stringToHash(pageText || ''), params = {}, method = 'GET' }:
-  { url?: string, hash?: string, params?: Record<string, any>, method?: 'GET' | 'POST' } = {},
+  { url = getFullUrlPath(), params = {}, method = 'GET' }:
+  { url?: string, params?: Record<string, any>, method?: 'GET' | 'POST' } = {},
 ): Promise<LinkInjectionResponse> {
   const apiToken = getApiToken()
   const isEditorialMode = isEditorialModeEnabled() ? await authorize() : false
@@ -26,13 +26,13 @@ export async function fetchLinkInjections(
   const apiUrl = `/external-pages/?api-token=${apiToken}&include_title_details=true${isEditorialMode ? '&editorial_mode_enabled=true' : ''}&language=${language}`
   let response: LinkInjectionResponse
 
-  console.log('page text in fetchLinkInjections', { pageText })
-
   // 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 (method === 'POST') {
+    const { pageText } = getPageTextAndElements()
+
     if (params.run_ai) {
-      params.hash = hash
+      params.hash = stringToHash(pageText || '')
       params.page_text = pageText
     }
 
@@ -62,7 +62,6 @@ export async function fetchLinkInjections(
  * The results return `injections_ready=false` while the injections are not yet ready.
  */
 export async function pollLinkInjections(
-  pageText: string,
   { requireCompletedResult = false, runAiWhenRelevant = false, pollInterval = 3000, maxTries = 600, onpoll = () => null }:
   { requireCompletedResult?: boolean, runAiWhenRelevant?: boolean, pollInterval?: number, maxTries?: number, onpoll?: (_response: LinkInjectionResponse) => void } = {},
 ): Promise<LinkInjectionResponse> {
@@ -72,8 +71,6 @@ export async function pollLinkInjections(
   // This is mostly handy during HMR, but also during navigation changes
   if (pollTimeout) clearTimeout(pollTimeout)
 
-  console.log('page text in pollLinkInjections', { pageText })
-
   const poll = async (resolve: Function, reject: Function): Promise<void> => {
     let response
     try {
@@ -81,19 +78,25 @@ export async function pollLinkInjections(
       // if it does. We're still interested in handling the response from here and don't want it to short circuit
       // just because the fetch failed.
       try {
-        response = await fetchLinkInjections(pageText)
+        response = await fetchLinkInjections()
       } catch(error: any) {
+        console.error(error)
         if (error?.status === 404) {
           // If the GET endpoint returns a 404 no article has been generated yet and we can safely generate
           // a new article. We can safely throw here (meaning we poll again) as nothing will be returned.
           // The first POST indexes the article, the second runs the AI if needed.
-          response = await fetchLinkInjections(pageText, { method: 'POST' })
-          if (response.ai_enabled) response = await fetchLinkInjections(pageText, { params: { run_ai: true }, method: 'POST' })
+          response = await fetchLinkInjections({ method: 'POST' })
+          if (response.ai_enabled) response = await fetchLinkInjections({ params: { run_ai: true }, method: 'POST' })
         }
 
         throw new Error
       }
 
+      const { pageText } = getPageTextAndElements()
+
+      console.log(pageText)
+      console.log(document.querySelector('#content')?.innerText)
+
       if (response && runAiWhenRelevant) response = await runAiBasedOnResponse(pageText, response)
       if (requireCompletedResult && (response.ai_enabled && response.ai_running)) throw new Error
 
@@ -137,10 +140,10 @@ export async function runAiBasedOnResponse(pageText: string, response: LinkInjec
   if (response.ai_last_run && isCurrentTimeEqualToResponseTime) return response
   if (new Date(currentModifiedTime || 0) <= new Date(responseModifiedTime || 0)) return response
 
-  return await fetchLinkInjections(pageText, { params: { run_ai: true }, method: 'POST' })
+  return await fetchLinkInjections({ params: { run_ai: true }, method: 'POST' })
 }
 
-export async function saveLinkInjections(linkInjections: LinkInjection[], pageText: string): Promise<LinkInjection[]> {
+export async function saveLinkInjections(linkInjections: LinkInjection[]): Promise<LinkInjection[]> {
   const selector = window.PlayPilotLinkInjections?.selector
 
   // Only save manual injections, AI injections should be left intact and can't be saved over
@@ -160,7 +163,7 @@ export async function saveLinkInjections(linkInjections: LinkInjection[], pageTe
     removed: !!linkInjection.removed,
   }))
 
-  const response = await fetchLinkInjections(pageText, {
+  const response = await fetchLinkInjections({
     method: 'POST',
     params: {
       private_token: getAuthToken(),

package/src/lib/api/session.ts

@@ -11,10 +11,9 @@ export const sessionPeriodMilliseconds = sessionPollPeriodMilliseconds * 2
  * where we save the session.
  * Along with that, we also return ai_enabled and injections_enabled as they are used to update the state of
  * the current editing session.
- * @param pageText Despite not being used, the request still requires a valid pageText string
  */
-export async function fetchAsSession(pageText: string): Promise<SessionResponse> {
-  const { ai_enabled, injections_enabled, ai_last_run, session_id, session_last_ping } = await fetchLinkInjections(pageText)
+export async function fetchAsSession(): Promise<SessionResponse> {
+  const { ai_enabled, injections_enabled, ai_last_run, session_id, session_last_ping } = await fetchLinkInjections()
 
   const isCurrentlyAllowToEdit = isAllowedToEdit(session_id || null, session_last_ping || null)
 
@@ -28,15 +27,14 @@ export async function fetchAsSession(pageText: string): Promise<SessionResponse>
 
   if (!isCurrentlyAllowToEdit) return response
 
-  return await saveCurrentSession(pageText)
+  return await saveCurrentSession()
 }
 
 /**
  * Save the current users session id as the currently active session. This is always completed regardless of if the user
  * is the current owner of the session, so check that first if necessary!
- * @param pageText Despite not being used, the request still requires a valid pageText string
  */
-export async function saveCurrentSession(pageText: string): Promise<SessionResponse> {
+export async function saveCurrentSession(): Promise<SessionResponse> {
   const sessionId = getSessionId()
   const now = new Date(Date.now()).toISOString()
 
@@ -45,7 +43,7 @@ export async function saveCurrentSession(pageText: string): Promise<SessionRespo
     session_last_ping: now.toString(),
   }
 
-  const { ai_enabled, injections_enabled, ai_last_run } = await fetchLinkInjections(pageText, { params })
+  const { ai_enabled, injections_enabled, ai_last_run } = await fetchLinkInjections({ params })
 
   return {
     ai_enabled,

package/src/lib/injectionElements.ts

@@ -91,7 +91,7 @@ export function getPageText(elements: HTMLElement[]): string {
   return elements.map(element => element.innerText).join('\n\n')
 }
 
-export function getPageTextAndElements(config: ConfigResponse | null): { parentElement: HTMLElement, elements: HTMLElement[], pageText: string } {
+export function getPageTextAndElements(config: ConfigResponse | null = window.PlayPilotLinkInjections?.config || null): { parentElement: HTMLElement, elements: HTMLElement[], pageText: string } {
   const parentElement = getLinkInjectionsParentElement()
   const elements = getLinkInjectionElements(parentElement, config?.exclude_elements_selector || '')
   const pageText = getPageText(elements)

package/src/main.ts

@@ -3,7 +3,6 @@ import { fetchConfig } from '$lib/api/config'
 import { pollLinkInjections } from '$lib/api/externalPages'
 import { setConsent } from '$lib/consent'
 import { isCrawler } from '$lib/crawler'
-import { getPageTextAndElements } from '$lib/injectionElements'
 import { isUrlExcludedViaConfig } from '$lib/url'
 
 window.PlayPilotLinkInjections ||= {
@@ -70,9 +69,7 @@ window.PlayPilotLinkInjections ||= {
 
     if (isUrlExcludedViaConfig(this.config)) return
 
-    const { pageText } = getPageTextAndElements(this.config)
-
-    this.initial_link_injections_promise = pollLinkInjections(pageText, { maxTries: 1, runAiWhenRelevant: !isCrawler() })
+    this.initial_link_injections_promise = pollLinkInjections({ maxTries: 1, runAiWhenRelevant: !isCrawler() })
 
     this.mount()
   },

package/src/routes/+page.svelte

@@ -2,7 +2,6 @@
   import { onDestroy } from 'svelte'
   import { pollLinkInjections } from '$lib/api/externalPages'
   import { clearLinkInjections, injectLinksInDocument, separateLinkInjectionTypes } from '$lib/injection'
-  import { getPageText, getPageTextAndElements } from '$lib/injectionElements'
   import { fireQueuedTrackingEvents, setTrackingSids, track } from '$lib/tracking'
   import { isUrlExcludedViaConfig } from '$lib/url'
   import { isCrawler } from '$lib/crawler'
@@ -11,6 +10,7 @@
   import { fetchConfig } from '$lib/api/config'
   import { insertExplore, insertExploreIntoNavigation } from '$lib/explore'
   import { authorize, getAuthToken, isEditorialModeEnabled, removeAuthCookie, setEditorialParamInUrl } from '$lib/api/auth'
+  import { getPageTextAndElements } from '$lib/injectionElements'
   import type { LinkInjectionResponse, LinkInjection, LinkInjectionTypes } from '$lib/types/injection'
   import Editor from './components/Editorial/Editor.svelte'
   import EditorTrigger from './components/Editorial/EditorTrigger.svelte'
@@ -22,8 +22,6 @@
   import PostersScrollReveal from './components/PostersScrollReveal.svelte'
   import TrackingPixelsForTitleDataPerLink from './components/TrackingPixelsForTitleDataPerLink.svelte'
 
-  let elements: HTMLElement[] = $state([])
-
   let response: LinkInjectionResponse | null = $state(null)
   let isEditorialMode = $state(isEditorialModeEnabled())
   let hasAuthToken = $state(!!getAuthToken())
@@ -35,10 +33,6 @@
   // @ts-ignore It's ok if the response is empty
   const { ai_injections: aiInjections = [], manual_injections: manualInjections = [] } = $derived(response || {})
 
-  const pageText = $derived(getPageText(elements))
-
-  $inspect({ thing: 'pageText in page.svelte', pageText })
-
   const initializePromise = initialize()
 
   $effect(() => {
@@ -88,8 +82,6 @@
       if (isUrlExcluded) return
 
       if (config?.html_selector) window.PlayPilotLinkInjections.selector = config?.html_selector
-
-      elements = getPageTextAndElements(window.PlayPilotLinkInjections.config).elements
     } catch(error) {
       // We return if the config did not get fetched properly, as we can't determine what should and should
       // get injected without it.
@@ -100,7 +92,7 @@
 
     try {
       response = await window.PlayPilotLinkInjections.initial_link_injections_promise || null
-      response ||= await pollLinkInjections(pageText, { maxTries: 1, runAiWhenRelevant: !isCrawler() })
+      response ||= await pollLinkInjections({ maxTries: 1, runAiWhenRelevant: !isCrawler() })
 
       loading = false
 
@@ -116,7 +108,7 @@
 
       if (!isEditorialMode || isCrawler()) return
 
-      response = await pollLinkInjections(pageText, { requireCompletedResult: true, onpoll: (update) => response = update })
+      response = await pollLinkInjections({ requireCompletedResult: true, onpoll: (update) => response = update })
       inject({ aiInjections, manualInjections })
     } catch(error: unknown) {
       console.error(error)
@@ -138,6 +130,7 @@
   }
 
   function inject(injections: LinkInjectionTypes = { aiInjections, manualInjections }): void {
+    const { elements } = getPageTextAndElements()
     const filteredInjections = injectLinksInDocument(elements, injections)
 
     if (JSON.stringify(filteredInjections) !== JSON.stringify(linkInjections)) {
@@ -208,7 +201,6 @@
       <svelte:boundary onerror={(error) => track(TrackingEvent.EditorError, null, { message: (error as Error).message })}>
         <Editor
           bind:linkInjections
-          {pageText}
           {loading}
           onreinitialize={reinitializeEditor}
           injectionsEnabled={response?.injections_enabled}

package/src/routes/components/Editorial/Editor.svelte

@@ -33,7 +33,6 @@
 
   let {
     linkInjections = $bindable(),
-    pageText = '',
     loading = false,
     injectionsEnabled = false,
     aiStatus = {},
@@ -46,6 +45,8 @@
   const position: Position = JSON.parse(localStorage.getItem(editorPositionKey) || '{ "x": 0, "y": 0 }')
   const height: number = parseInt(localStorage.getItem(editorHeightKey) || '0')
 
+
+
   let editorElement: HTMLElement | null = $state(null)
   let manualInjectionActive = $state(false)
   let saving = $state(false)
@@ -85,7 +86,7 @@
       saving = true
       hasError = false
 
-      linkInjections = await saveLinkInjections(linkInjections, pageText)
+      linkInjections = await saveLinkInjections(linkInjections)
       initialStateString = linkInjectionsString
     } catch {
       hasError = true
@@ -177,7 +178,6 @@
 
   {#if !loading}
     <Session
-      {pageText}
       onallow={() => allowEditing = true}
       ondisallow={() => allowEditing = false}
       ontakeover={onreinitialize}
@@ -231,7 +231,6 @@
       style:top="{scrollDistance}px"
       transition:fly={{ x: Math.min(window.innerWidth, 320), duration: 200, opacity: 1 }}>
       <ManualInjection
-        {pageText}
         onclose={() => manualInjectionActive = false}
         onsave={(linkInjection) => linkInjections.push(linkInjection)} />
     </div>

package/src/routes/components/Editorial/ManualInjection.svelte

@@ -4,7 +4,7 @@
   import { onMount } from 'svelte'
   import { playPilotBaseUrl } from '$lib/constants'
   import { generateInjectionKey } from '$lib/api/externalPages'
-  import { getLinkInjectionsParentElement } from '$lib/injectionElements'
+  import { getLinkInjectionsParentElement, getPageTextAndElements } from '$lib/injectionElements'
   import { heading } from '$lib/actions/heading'
   import { findSurroundingPhrases, cleanPhrase } from '$lib/text'
   import { getIndexOfSelection } from '$lib/selection'
@@ -15,12 +15,13 @@
   import TitleSearch from './Search/TitleSearch.svelte'
 
   interface Props {
-    pageText: string
     onsave: (linkInjection: LinkInjection) => void
     onclose?: () => void
   }
 
-  const { pageText = '', onsave, onclose = () => null }: Props = $props()
+  const { onsave, onclose = () => null }: Props = $props()
+
+  const { pageText } = getPageTextAndElements()
 
   let currentSelection = $state('')
   let selectionSentence = $state('')

package/src/routes/components/Editorial/Session.svelte

@@ -4,7 +4,6 @@
   import Alert from './Alert.svelte'
 
   interface Props {
-    pageText?: string,
     onpoll?: ({ injectionsEnabled, aiEnabled }: { injectionsEnabled: boolean, aiEnabled: boolean }) => void,
     onallow?: () => void,
     ondisallow?: () => void,
@@ -12,7 +11,6 @@
   }
 
   const {
-    pageText = '',
     onpoll = () => null,
     onallow = () => null,
     ondisallow = () => null,
@@ -36,7 +34,7 @@
   }
 
   async function setSession(): Promise<void> {
-    const result = await fetchAsSession(pageText)
+    const result = await fetchAsSession()
 
     if (!result) return
 
@@ -49,7 +47,7 @@
   }
 
   function takeOverEditing(): void {
-    saveCurrentSession(pageText)
+    saveCurrentSession()
     ontakeover()
   }
 </script>

package/src/routes/components/Explore/ExploreLayout.svelte

@@ -21,6 +21,7 @@
 
   let { navigate = () => null, searchQuery = $bindable(''), filter = $bindable({}), children }: Props = $props()
 
+  // svelte-ignore non_reactive_update
   let element: HTMLElement | null = null
   let height: string | null = $state(null)
   let clientWidth: number = $state(window.innerWidth)

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

@@ -36,7 +36,7 @@ describe('$lib/api/externalPages', () => {
     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' })
+      const response = await fetchLinkInjections({ url: 'https://some-url' })
 
       expect(response).toBe('Some response')
       expect(api).toHaveBeenCalledWith(
@@ -50,7 +50,7 @@ describe('$lib/api/externalPages', () => {
     it('Should call api with POST method and full details when fetching with method set to POST', async () => {
       vi.mocked(api).mockResolvedValueOnce('Some response')
 
-      const response = await fetchLinkInjections('Some text', { url: 'https://some-url', hash: 'some-hash', params: { key: 'value' }, method: 'POST' })
+      const response = await fetchLinkInjections({ url: 'https://some-url', params: { key: 'value' }, method: 'POST' })
 
       expect(response).toBe('Some response')
       expect(api).toHaveBeenCalledWith(
@@ -69,14 +69,14 @@ describe('$lib/api/externalPages', () => {
     it('Should call api with full details when fetching with run_ai as true and method is set to POST', async () => {
       vi.mocked(api).mockResolvedValueOnce('Some response')
 
-      const response = await fetchLinkInjections('Some text', { url: 'https://some-url', hash: 'some-hash', params: { run_ai: true }, method: 'POST' })
+      const response = await fetchLinkInjections({ url: 'https://some-url', params: { run_ai: true }, method: 'POST' })
 
       expect(response).toBe('Some response')
       expect(api).toHaveBeenCalledWith(
         expect.stringContaining('api-token'),
         expect.objectContaining({
           body: {
-            hash: 'some-hash',
+            hash: expect.any(String),
             url: 'https://some-url',
             run_ai: true,
             metadata: {
@@ -84,7 +84,7 @@ describe('$lib/api/externalPages', () => {
               content_modified_time: null,
               content_published_time: null,
             },
-            page_text: 'Some text',
+            page_text: expect.any(String),
           },
           method: 'POST',
         }),
@@ -95,13 +95,13 @@ describe('$lib/api/externalPages', () => {
       // @ts-ignore
       window.PlayPilotLinkInjections = null
 
-      await expect(async () => await fetchLinkInjections('Some text', { hash: 'some-hash' })).rejects.toThrowError('No token was provided')
+      await expect(async () => await fetchLinkInjections()).rejects.toThrowError('No token was provided')
     })
 
     it('Should throw when response was incorrect', async () => {
       vi.mocked(api).mockRejectedValueOnce({ ok: false })
 
-      await expect(async () => await fetchLinkInjections('Some text', { hash: 'some-hash' })).rejects.toThrowError()
+      await expect(async () => await fetchLinkInjections()).rejects.toThrowError()
     })
 
     it('Should use given api token', async () => {
@@ -110,7 +110,7 @@ describe('$lib/api/externalPages', () => {
       // @ts-ignore
       window.PlayPilotLinkInjections = { token: 'token' }
 
-      await fetchLinkInjections('Some text', { hash: 'some-hash' })
+      await fetchLinkInjections()
 
       expect(api).toHaveBeenCalledWith(
         expect.stringContaining('api-token=token'),
@@ -124,7 +124,7 @@ describe('$lib/api/externalPages', () => {
       // @ts-ignore
       window.PlayPilotLinkInjections = null
 
-      await expect(async () => await fetchLinkInjections('Some text', { hash: 'some-hash' })).rejects.toThrowError()
+      await expect(async () => await fetchLinkInjections()).rejects.toThrowError()
       expect(api).not.toHaveBeenCalled()
     })
 
@@ -134,7 +134,7 @@ describe('$lib/api/externalPages', () => {
       vi.mocked(authorize).mockResolvedValueOnce(true)
       vi.mocked(isEditorialModeEnabled).mockResolvedValueOnce(true)
 
-      const response = await fetchLinkInjections('Some text', { hash: 'some-hash' })
+      const response = await fetchLinkInjections()
 
       expect(response).toBe('Some response')
       expect(api).toHaveBeenCalledWith(
@@ -146,7 +146,7 @@ describe('$lib/api/externalPages', () => {
     it('Should call api with given language', async () => {
       vi.mocked(api).mockResolvedValueOnce('Some response')
 
-      await fetchLinkInjections('Some text', { hash: 'some-hash' })
+      await fetchLinkInjections()
 
       expect(api).toHaveBeenCalledWith(
         expect.stringContaining(`&language=${Language.English}`),
@@ -156,7 +156,7 @@ describe('$lib/api/externalPages', () => {
       // @ts-ignore
       window.PlayPilotLinkInjections = { token: 'token', language: Language.Swedish }
 
-      await fetchLinkInjections('Some text', { hash: 'some-hash' })
+      await fetchLinkInjections()
 
       expect(api).toHaveBeenCalledWith(
         expect.stringContaining(`&language=${Language.Swedish}`),
@@ -169,7 +169,7 @@ describe('$lib/api/externalPages', () => {
     it('Should poll endpoint while results are not yet ready when requireCompletedResults is true', async () => {
       vi.mocked(api).mockResolvedValueOnce({ ai_enabled: true, ai_running: true })
 
-      pollLinkInjections('Some text', { requireCompletedResult: true, pollInterval: 500 })
+      pollLinkInjections({ requireCompletedResult: true, pollInterval: 500 })
 
       expect(api).toHaveBeenCalled()
 
@@ -184,7 +184,7 @@ describe('$lib/api/externalPages', () => {
       vi.mocked(api).mockResolvedValue({ ai_enabled: true, ai_running: true })
 
       const onpoll = vi.fn()
-      pollLinkInjections('Some text', { requireCompletedResult: true, pollInterval: 500, onpoll })
+      pollLinkInjections({ requireCompletedResult: true, pollInterval: 500, onpoll })
 
       await waitFor(() => {
         expect(onpoll).toHaveBeenCalledTimes(1)
@@ -201,7 +201,7 @@ describe('$lib/api/externalPages', () => {
       const response = { ai_enabled: true, ai_running: false, manual_injections: [{ title: 'value' }] }
       vi.mocked(api).mockResolvedValueOnce(response)
 
-      const result = await pollLinkInjections('Some text', { requireCompletedResult: true, pollInterval: 500 })
+      const result = await pollLinkInjections({ requireCompletedResult: true, pollInterval: 500 })
 
       expect(api).toHaveBeenCalled()
       expect(result).toEqual(response)
@@ -213,7 +213,7 @@ describe('$lib/api/externalPages', () => {
     it('Should stop polling if max limit was exceeded', async () => {
       vi.mocked(api).mockResolvedValueOnce({ ai_enabled: true, ai_running: true })
 
-      await pollLinkInjections('Some text', { requireCompletedResult: true, pollInterval: 200, maxTries: 2 })
+      await pollLinkInjections({ requireCompletedResult: true, pollInterval: 200, maxTries: 2 })
 
       await new Promise(res => setTimeout(res, 1000)) // Wait for a potential poll
       expect(api).toHaveBeenCalledTimes(2)
@@ -222,7 +222,7 @@ describe('$lib/api/externalPages', () => {
     it('Should continue polling if endpoint throws error', async () => {
       vi.mocked(api).mockRejectedValueOnce({ ok: false })
 
-      pollLinkInjections('Some text', { pollInterval: 500 })
+      pollLinkInjections({ pollInterval: 500 })
 
       expect(api).toHaveBeenCalled()
 
@@ -233,16 +233,16 @@ describe('$lib/api/externalPages', () => {
     it('Should return empty array if manual_injections are null', async () => {
       vi.mocked(api).mockResolvedValueOnce({ ai_enabled: null, ai_running: null })
 
-      const result = await pollLinkInjections('Some text')
+      const result = await pollLinkInjections()
       expect(result).toEqual(expect.objectContaining({ manual_injections: [], ai_injections: [] }))
     })
 
     it('Should call api twice if runAiWhenRelevant is true and results expects new run', async () => {
-      document.body.innerHTML = '<meta content="2025-04-20T00:00:00Z" property="article:modified_time">'
+      document.body.innerHTML = '<main>Some text</main> <meta content="2025-04-20T00:00:00Z" property="article:modified_time">'
 
       vi.mocked(api).mockResolvedValueOnce({ ai_enabled: true })
 
-      await pollLinkInjections('Some text', { runAiWhenRelevant: true, maxTries: 1 })
+      await pollLinkInjections({ runAiWhenRelevant: true, maxTries: 1 })
 
       expect(api).toHaveBeenCalledTimes(2)
     })
@@ -250,7 +250,7 @@ describe('$lib/api/externalPages', () => {
     it('Should call api twice if initial response returns 404', async () => {
       vi.mocked(api).mockRejectedValueOnce({ status: 404 })
 
-      await pollLinkInjections('Some text', { maxTries: 1 })
+      await pollLinkInjections({ maxTries: 1 })
 
       expect(api).toHaveBeenCalledTimes(2)
       expect(api).toHaveBeenCalledWith(
@@ -266,7 +266,7 @@ describe('$lib/api/externalPages', () => {
     it('Should call api three times if initial response returns 404 and second response returns ai_enabled set to true', async () => {
       vi.mocked(api).mockRejectedValueOnce({ status: 404 }).mockResolvedValueOnce({ ai_enabled: true })
 
-      await pollLinkInjections('Some text', { maxTries: 1 })
+      await pollLinkInjections({ maxTries: 1 })
 
       expect(api).toHaveBeenCalledTimes(3)
       expect(api).toHaveBeenCalledWith(
@@ -287,6 +287,28 @@ describe('$lib/api/externalPages', () => {
         }),
       )
     })
+
+    it('Should use the given selector when present', async () => {
+      vi.mocked(api).mockRejectedValueOnce({ status: 404 }).mockResolvedValueOnce({ ai_enabled: true })
+
+      document.body.innerHTML = '<div class="some-element"><p>Here</p></div> <p>Not here</p>'
+
+      // @ts-ignore
+      window.PlayPilotLinkInjections = { token: 'token', selector: '.some-element' }
+
+      await pollLinkInjections({ runAiWhenRelevant: true, maxTries: 1 })
+
+      await waitFor(() => {
+        expect(api).toHaveBeenCalledWith(
+          expect.any(String),
+          expect.objectContaining({
+            body: expect.objectContaining({
+              page_text: 'Here',
+            }),
+          }),
+        )
+      })
+    })
   })
 
   describe('runAiBasedOnResponse', () => {

package/src/tests/main.test.js

@@ -51,7 +51,6 @@ describe('main.ts', () => {
   describe('initialize', () => {
     it('Should not call setConsent when only a token is passed', () => {
       window.PlayPilotLinkInjections.initialize({ token: 'a' })
-      console.log(window.PlayPilotLinkInjections)
 
       expect(setConsent).not.toHaveBeenCalled()
 

package/src/tests/routes/+page.test.js

@@ -134,8 +134,8 @@ describe('$routes/+page.svelte', () => {
     render(page)
 
     await waitFor(() => {
-      expect(pollLinkInjections).toHaveBeenCalledWith(expect.any(String), { maxTries: 1, runAiWhenRelevant: true })
-      expect(pollLinkInjections).toHaveBeenCalledWith(expect.any(String), { requireCompletedResult: true, onpoll: expect.any(Function) })
+      expect(pollLinkInjections).toHaveBeenCalledWith({ maxTries: 1, runAiWhenRelevant: true })
+      expect(pollLinkInjections).toHaveBeenCalledWith({ requireCompletedResult: true, onpoll: expect.any(Function) })
     })
   })
 
@@ -158,7 +158,7 @@ describe('$routes/+page.svelte', () => {
     })
 
     await waitFor(() => {
-      expect(pollLinkInjections).toHaveBeenCalledWith(expect.any(String), { requireCompletedResult: true, onpoll: expect.any(Function) })
+      expect(pollLinkInjections).toHaveBeenCalledWith({ requireCompletedResult: true, onpoll: expect.any(Function) })
     })
 
     expect(pollLinkInjections).toHaveBeenCalledTimes(2)
@@ -221,7 +221,7 @@ describe('$routes/+page.svelte', () => {
     render(page)
 
     await waitFor(() => {
-      expect(pollLinkInjections).toHaveBeenCalledWith('Here', { maxTries: 1, runAiWhenRelevant: true })
+      expect(pollLinkInjections).toHaveBeenCalledWith({ maxTries: 1, runAiWhenRelevant: true })
     })
   })