@mixpeek/prebid 1.0.0

package/src/extractors/imageExtractor.js

@@ -0,0 +1,142 @@
+/**
+ * Mixpeek Context Adapter - Image Content Extractor
+ * @module extractors/imageExtractor
+ */
+
+import { sanitizeText } from '../utils/helpers.js'
+import logger from '../utils/logger.js'
+
+/**
+ * Extract primary images from the page
+ * @param {number} maxImages - Maximum number of images to extract
+ * @returns {array} Array of image objects
+ */
+export function extractImages(maxImages = 5) {
+  logger.time('extractImages')
+
+  try {
+    const images = findPrimaryImages()
+    const extracted = images.slice(0, maxImages).map(img => ({
+      src: img.src,
+      alt: sanitizeText(img.alt || ''),
+      title: sanitizeText(img.title || ''),
+      width: img.naturalWidth || img.width || 0,
+      height: img.naturalHeight || img.height || 0,
+      aspectRatio: calculateAspectRatio(img)
+    }))
+
+    logger.timeEnd('extractImages')
+    logger.info(`Extracted ${extracted.length} images`)
+
+    return extracted
+  } catch (error) {
+    logger.error('Error extracting images:', error)
+    logger.timeEnd('extractImages')
+    return []
+  }
+}
+
+/**
+ * Find primary/hero images on the page
+ * @private
+ * @returns {array} Array of image elements
+ */
+function findPrimaryImages() {
+  const images = Array.from(document.querySelectorAll('img'))
+  
+  return images
+    .filter(img => {
+      // Filter out small images (likely icons/thumbnails)
+      const width = img.naturalWidth || img.width || 0
+      const height = img.naturalHeight || img.height || 0
+      return width >= 200 && height >= 200
+    })
+    .filter(img => {
+      // Filter out hidden images
+      const style = window.getComputedStyle(img)
+      return style.display !== 'none' && style.visibility !== 'hidden'
+    })
+    .filter(img => {
+      // Filter out ad images
+      const isAd = img.closest('.ad, .advertisement, [id*="ad-"], [class*="ad-"]')
+      return !isAd
+    })
+    .sort((a, b) => {
+      // Sort by size (largest first)
+      const aSize = (a.naturalWidth || a.width || 0) * (a.naturalHeight || a.height || 0)
+      const bSize = (b.naturalWidth || b.width || 0) * (b.naturalHeight || b.height || 0)
+      return bSize - aSize
+    })
+}
+
+/**
+ * Calculate aspect ratio
+ * @private
+ * @param {HTMLImageElement} img - Image element
+ * @returns {number} Aspect ratio
+ */
+function calculateAspectRatio(img) {
+  const width = img.naturalWidth || img.width || 0
+  const height = img.naturalHeight || img.height || 0
+  return height > 0 ? width / height : 0
+}
+
+/**
+ * Extract Open Graph image
+ * @returns {object|null} OG image data
+ */
+export function extractOGImage() {
+  const ogImage = document.querySelector('meta[property="og:image"]')
+  if (ogImage) {
+    return {
+      src: ogImage.content,
+      alt: document.querySelector('meta[property="og:image:alt"]')?.content || '',
+      width: parseInt(document.querySelector('meta[property="og:image:width"]')?.content || '0'),
+      height: parseInt(document.querySelector('meta[property="og:image:height"]')?.content || '0')
+    }
+  }
+  return null
+}
+
+/**
+ * Extract featured/hero image
+ * @returns {object|null} Featured image data
+ */
+export function extractFeaturedImage() {
+  // Check for common featured image patterns
+  const selectors = [
+    '[class*="featured-image"]',
+    '[class*="hero-image"]',
+    '[class*="header-image"]',
+    'article img:first-of-type',
+    '.post-thumbnail img'
+  ]
+
+  for (const selector of selectors) {
+    const img = document.querySelector(selector)
+    if (img) {
+      return {
+        src: img.src,
+        alt: sanitizeText(img.alt || ''),
+        width: img.naturalWidth || img.width || 0,
+        height: img.naturalHeight || img.height || 0
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Check if page has significant image content
+ * @returns {boolean}
+ */
+export function hasImages() {
+  const images = document.querySelectorAll('img')
+  return Array.from(images).some(img => {
+    const width = img.naturalWidth || img.width || 0
+    const height = img.naturalHeight || img.height || 0
+    return width >= 200 && height >= 200
+  })
+}
+

package/src/extractors/pageExtractor.js

@@ -0,0 +1,196 @@
+/**
+ * Mixpeek Context Adapter - Page Content Extractor
+ * @module extractors/pageExtractor
+ */
+
+import { PERFORMANCE } from '../config/constants.js'
+import { sanitizeText, truncateText, extractDomain } from '../utils/helpers.js'
+import logger from '../utils/logger.js'
+
+/**
+ * Extract content from the current page
+ * @returns {object} Extracted page content
+ */
+export function extractPageContent() {
+  logger.time('extractPageContent')
+
+  try {
+    const content = {
+      url: window.location.href,
+      domain: extractDomain(window.location.href),
+      title: document.title,
+      description: extractMetaDescription(),
+      text: extractBodyText(),
+      keywords: extractMetaKeywords(),
+      ogTags: extractOpenGraphTags(),
+      structuredData: extractStructuredData(),
+      language: document.documentElement.lang || 'en'
+    }
+
+    logger.timeEnd('extractPageContent')
+    logger.info('Extracted page content:', {
+      url: content.url,
+      textLength: content.text.length,
+      keywords: content.keywords.length
+    })
+
+    return content
+  } catch (error) {
+    logger.error('Error extracting page content:', error)
+    logger.timeEnd('extractPageContent')
+    return null
+  }
+}
+
+/**
+ * Extract meta description
+ * @private
+ * @returns {string} Meta description
+ */
+function extractMetaDescription() {
+  const metaDesc = document.querySelector('meta[name="description"]') ||
+                   document.querySelector('meta[property="og:description"]')
+  return metaDesc ? sanitizeText(metaDesc.content) : ''
+}
+
+/**
+ * Extract meta keywords
+ * @private
+ * @returns {array} Keywords array
+ */
+function extractMetaKeywords() {
+  const metaKeywords = document.querySelector('meta[name="keywords"]')
+  if (metaKeywords) {
+    return metaKeywords.content.split(',').map(k => k.trim()).filter(Boolean)
+  }
+  return []
+}
+
+/**
+ * Extract body text content
+ * @private
+ * @returns {string} Body text
+ */
+function extractBodyText() {
+  // Remove script, style, and other non-content elements
+  const clone = document.body.cloneNode(true)
+  const elementsToRemove = clone.querySelectorAll('script, style, iframe, nav, footer, aside, .ad, .advertisement')
+  elementsToRemove.forEach(el => el.remove())
+
+  // Get text content
+  const text = clone.textContent || clone.innerText || ''
+  
+  // Sanitize and truncate
+  return truncateText(sanitizeText(text), PERFORMANCE.MAX_CONTENT_SIZE)
+}
+
+/**
+ * Extract Open Graph tags
+ * @private
+ * @returns {object} Open Graph data
+ */
+function extractOpenGraphTags() {
+  const ogTags = {}
+  const metaTags = document.querySelectorAll('meta[property^="og:"]')
+  
+  metaTags.forEach(tag => {
+    const property = tag.getAttribute('property').replace('og:', '')
+    ogTags[property] = tag.content
+  })
+
+  return ogTags
+}
+
+/**
+ * Extract structured data (JSON-LD)
+ * @private
+ * @returns {array} Structured data objects
+ */
+function extractStructuredData() {
+  const structuredData = []
+  const scripts = document.querySelectorAll('script[type="application/ld+json"]')
+  
+  scripts.forEach(script => {
+    try {
+      const data = JSON.parse(script.textContent)
+      structuredData.push(data)
+    } catch (e) {
+      logger.warn('Failed to parse structured data:', e)
+    }
+  })
+
+  return structuredData
+}
+
+/**
+ * Extract article-specific content
+ * @returns {object|null} Article content
+ */
+export function extractArticleContent() {
+  try {
+    const article = document.querySelector('article') || 
+                   document.querySelector('[role="article"]') ||
+                   document.querySelector('.article') ||
+                   document.querySelector('.post')
+
+    if (!article) return null
+
+    return {
+      headline: extractHeadline(article),
+      author: extractAuthor(article),
+      datePublished: extractPublishDate(article),
+      content: sanitizeText(article.textContent || article.innerText || '')
+    }
+  } catch (error) {
+    logger.warn('Error extracting article content:', error)
+    return null
+  }
+}
+
+/**
+ * Extract headline
+ * @private
+ * @param {Element} article - Article element
+ * @returns {string} Headline
+ */
+function extractHeadline(article) {
+  const h1 = article.querySelector('h1')
+  const headline = article.querySelector('[itemprop="headline"]')
+  return sanitizeText((h1 || headline)?.textContent || '')
+}
+
+/**
+ * Extract author
+ * @private
+ * @param {Element} article - Article element
+ * @returns {string} Author
+ */
+function extractAuthor(article) {
+  const author = article.querySelector('[itemprop="author"]') ||
+                article.querySelector('[rel="author"]') ||
+                article.querySelector('.author')
+  return sanitizeText(author?.textContent || '')
+}
+
+/**
+ * Extract publish date
+ * @private
+ * @param {Element} article - Article element
+ * @returns {string} Publish date
+ */
+function extractPublishDate(article) {
+  const dateEl = article.querySelector('[itemprop="datePublished"]') ||
+                article.querySelector('time[datetime]')
+  return dateEl?.getAttribute('datetime') || dateEl?.textContent || ''
+}
+
+/**
+ * Check if current page is an article
+ * @returns {boolean}
+ */
+export function isArticlePage() {
+  return document.querySelector('article') !== null ||
+         document.querySelector('[itemtype*="Article"]') !== null ||
+         document.querySelector('meta[property="og:type"][content="article"]') !== null
+}
+

package/src/extractors/videoExtractor.js

@@ -0,0 +1,228 @@
+/**
+ * Mixpeek Context Adapter - Video Content Extractor
+ * @module extractors/videoExtractor
+ */
+
+import { sanitizeText } from '../utils/helpers.js'
+import logger from '../utils/logger.js'
+
+/**
+ * Extract video content from the page
+ * @param {string} selector - CSS selector for video element
+ * @returns {object|null} Extracted video content
+ */
+export function extractVideoContent(selector = 'video') {
+  logger.time('extractVideoContent')
+
+  try {
+    const videos = findVideoElements(selector)
+    
+    if (videos.length === 0) {
+      logger.info('No video elements found')
+      logger.timeEnd('extractVideoContent')
+      return null
+    }
+
+    // Use the first (typically largest/main) video
+    const video = videos[0]
+    const content = {
+      src: getVideoSource(video),
+      poster: video.poster || '',
+      title: extractVideoTitle(video),
+      description: extractVideoDescription(video),
+      duration: video.duration || 0,
+      currentTime: video.currentTime || 0,
+      dimensions: {
+        width: video.videoWidth || video.width || 0,
+        height: video.videoHeight || video.height || 0
+      },
+      metadata: extractVideoMetadata(video)
+    }
+
+    logger.timeEnd('extractVideoContent')
+    logger.info('Extracted video content:', {
+      src: content.src,
+      title: content.title,
+      duration: content.duration
+    })
+
+    return content
+  } catch (error) {
+    logger.error('Error extracting video content:', error)
+    logger.timeEnd('extractVideoContent')
+    return null
+  }
+}
+
+/**
+ * Find video elements on the page
+ * @private
+ * @param {string} selector - CSS selector
+ * @returns {array} Array of video elements
+ */
+function findVideoElements(selector) {
+  const videos = Array.from(document.querySelectorAll(selector))
+  
+  // Sort by size (largest first)
+  return videos.sort((a, b) => {
+    const aSize = (a.videoWidth || a.width || 0) * (a.videoHeight || a.height || 0)
+    const bSize = (b.videoWidth || b.width || 0) * (b.videoHeight || b.height || 0)
+    return bSize - aSize
+  })
+}
+
+/**
+ * Get video source URL
+ * @private
+ * @param {HTMLVideoElement} video - Video element
+ * @returns {string} Video source URL
+ */
+function getVideoSource(video) {
+  // Check src attribute
+  if (video.src) return video.src
+
+  // Check source elements
+  const source = video.querySelector('source')
+  if (source && source.src) return source.src
+
+  // Check currentSrc
+  if (video.currentSrc) return video.currentSrc
+
+  return ''
+}
+
+/**
+ * Extract video title
+ * @private
+ * @param {HTMLVideoElement} video - Video element
+ * @returns {string} Video title
+ */
+function extractVideoTitle(video) {
+  // Check data attributes
+  const title = video.getAttribute('data-title') ||
+                video.getAttribute('title') ||
+                video.getAttribute('aria-label')
+  
+  if (title) return sanitizeText(title)
+
+  // Check parent container
+  const container = video.closest('[data-video-title]')
+  if (container) {
+    return sanitizeText(container.getAttribute('data-video-title'))
+  }
+
+  // Check nearby heading
+  const heading = video.previousElementSibling?.querySelector('h1, h2, h3') ||
+                 video.parentElement?.querySelector('h1, h2, h3')
+  if (heading) {
+    return sanitizeText(heading.textContent)
+  }
+
+  return ''
+}
+
+/**
+ * Extract video description
+ * @private
+ * @param {HTMLVideoElement} video - Video element
+ * @returns {string} Video description
+ */
+function extractVideoDescription(video) {
+  const desc = video.getAttribute('data-description') ||
+              video.getAttribute('aria-description')
+  
+  if (desc) return sanitizeText(desc)
+
+  // Check parent container
+  const container = video.closest('[data-video-description]')
+  if (container) {
+    return sanitizeText(container.getAttribute('data-video-description'))
+  }
+
+  return ''
+}
+
+/**
+ * Extract video metadata
+ * @private
+ * @param {HTMLVideoElement} video - Video element
+ * @returns {object} Video metadata
+ */
+function extractVideoMetadata(video) {
+  const metadata = {}
+  
+  // Extract all data attributes
+  Array.from(video.attributes).forEach(attr => {
+    if (attr.name.startsWith('data-')) {
+      const key = attr.name.replace('data-', '').replace(/-/g, '_')
+      metadata[key] = attr.value
+    }
+  })
+
+  return metadata
+}
+
+/**
+ * Capture video frame as base64 image
+ * @param {HTMLVideoElement} video - Video element
+ * @param {number} quality - JPEG quality (0-1)
+ * @returns {string|null} Base64 encoded image
+ */
+export function captureVideoFrame(video, quality = 0.8) {
+  try {
+    const canvas = document.createElement('canvas')
+    canvas.width = video.videoWidth || video.width || 640
+    canvas.height = video.videoHeight || video.height || 360
+    
+    const ctx = canvas.getContext('2d')
+    ctx.drawImage(video, 0, 0, canvas.width, canvas.height)
+    
+    return canvas.toDataURL('image/jpeg', quality)
+  } catch (error) {
+    logger.warn('Error capturing video frame:', error)
+    return null
+  }
+}
+
+/**
+ * Extract video player information (YouTube, Vimeo, etc.)
+ * @returns {object|null} Video player info
+ */
+export function extractVideoPlayerInfo() {
+  // YouTube
+  const ytPlayer = document.querySelector('iframe[src*="youtube.com"]')
+  if (ytPlayer) {
+    const src = ytPlayer.src
+    const videoIdMatch = src.match(/embed\/([^?]+)/)
+    return {
+      platform: 'youtube',
+      videoId: videoIdMatch ? videoIdMatch[1] : '',
+      src
+    }
+  }
+
+  // Vimeo
+  const vimeoPlayer = document.querySelector('iframe[src*="vimeo.com"]')
+  if (vimeoPlayer) {
+    const src = vimeoPlayer.src
+    const videoIdMatch = src.match(/video\/(\d+)/)
+    return {
+      platform: 'vimeo',
+      videoId: videoIdMatch ? videoIdMatch[1] : '',
+      src
+    }
+  }
+
+  return null
+}
+
+/**
+ * Check if page has video content
+ * @returns {boolean}
+ */
+export function hasVideo() {
+  return document.querySelector('video') !== null ||
+         document.querySelector('iframe[src*="youtube.com"]') !== null ||
+         document.querySelector('iframe[src*="vimeo.com"]') !== null
+}
+