@quicktvui/web-renderer 1.0.0

package/src/modules/FocusModule.js

@@ -0,0 +1,145 @@
+// FocusModule - Web adapter for focus border styling
+// Provides focus border configuration for TV focus management
+
+import { resolveAddon } from '../core/moduleUtils'
+
+// Global focus configuration
+const focusConfig = {
+  // Focus border corner radius
+  cornerRadius: 0,
+  cornerEnabled: false,
+
+  // Focus border color
+  borderColor: '#FFFFFF',
+  borderColorEnabled: false,
+
+  // Focus border width
+  borderWidth: 2,
+  borderWidthEnabled: false,
+
+  // Focus border inset (inward offset)
+  borderInset: 0,
+  borderInsetEnabled: false,
+
+  // Inner border (black border inside)
+  innerBorderEnabled: true,
+
+  // Focus scale factor
+  focusScale: 1.0,
+}
+
+/**
+ * Get current focus configuration
+ * @returns {object}
+ */
+export function getFocusConfig() {
+  return { ...focusConfig }
+}
+
+/**
+ * Apply focus config to TVFocusManager if available
+ */
+function applyFocusConfigToManager() {
+  const focusManager = global.__TV_FOCUS_MANAGER__
+  if (focusManager && typeof focusManager.updateFocusConfig === 'function') {
+    focusManager.updateFocusConfig(focusConfig)
+  }
+}
+
+export class FocusModule {
+  constructor(context) {
+    this.context = context
+    this.name = ''
+    this.mode = 'normal'
+  }
+
+  /**
+   * Set default focus border corner radius
+   * @param {number} radius - corner radius in pixels
+   */
+  setDefaultFocusBorderCorner(radius, ...args) {
+    focusConfig.cornerRadius = typeof radius === 'number' ? radius : 0
+    focusConfig.cornerEnabled = true
+    console.log('[FocusModule] setDefaultFocusBorderCorner:', focusConfig.cornerRadius)
+    applyFocusConfigToManager()
+    return resolveAddon(args, null)
+  }
+
+  /**
+   * Set default focus border color
+   * @param {string} color - CSS color value
+   */
+  setDefaultFocusBorderColor(color, ...args) {
+    focusConfig.borderColor = color || '#FFFFFF'
+    focusConfig.borderColorEnabled = true
+    console.log('[FocusModule] setDefaultFocusBorderColor:', focusConfig.borderColor)
+    applyFocusConfigToManager()
+    return resolveAddon(args, null)
+  }
+
+  /**
+   * Set default focus border width
+   * @param {number} width - border width in pixels
+   */
+  setDefaultFocusBorderWidth(width, ...args) {
+    focusConfig.borderWidth = typeof width === 'number' ? width : 2
+    focusConfig.borderWidthEnabled = true
+    console.log('[FocusModule] setDefaultFocusBorderWidth:', focusConfig.borderWidth)
+    applyFocusConfigToManager()
+    return resolveAddon(args, null)
+  }
+
+  /**
+   * Set focus border inset value (inward offset)
+   * @param {number} inset - inset in pixels
+   */
+  setFocusBorderInsetValue(inset, ...args) {
+    focusConfig.borderInset = typeof inset === 'number' ? inset : 0
+    focusConfig.borderInsetEnabled = true
+    console.log('[FocusModule] setFocusBorderInsetValue:', focusConfig.borderInset)
+    applyFocusConfigToManager()
+    return resolveAddon(args, null)
+  }
+
+  /**
+   * Enable/disable inner border (black border inside focus border)
+   * @param {boolean} enabled
+   */
+  setDefaultFocusInnerBorderEnable(enabled, ...args) {
+    focusConfig.innerBorderEnabled = enabled === true
+    console.log('[FocusModule] setDefaultFocusInnerBorderEnable:', focusConfig.innerBorderEnabled)
+    applyFocusConfigToManager()
+    return resolveAddon(args, null)
+  }
+
+  /**
+   * Set default focus scale factor
+   * @param {number} scale - scale factor (e.g., 1.1 for 10% enlargement)
+   */
+  setDefaultPlaceholderFocusScale(scale, ...args) {
+    focusConfig.focusScale = typeof scale === 'number' ? scale : 1.0
+    console.log('[FocusModule] setDefaultPlaceholderFocusScale:', focusConfig.focusScale)
+    applyFocusConfigToManager()
+    return resolveAddon(args, null)
+  }
+
+  /**
+   * Get current focus configuration
+   */
+  getFocusConfig(...args) {
+    return resolveAddon(args, focusConfig)
+  }
+
+  async init(...args) {
+    const addon = args && args.length ? args[args.length - 1] : null
+    if (addon && typeof addon.resolve === 'function') {
+      addon.resolve(true)
+    }
+    return Promise.resolve(true)
+  }
+
+  destroy() {}
+}
+
+// Export singleton instance for patches.js
+export const focusModuleInstance = new FocusModule()

package/src/modules/RuntimeDeviceModule.js

@@ -0,0 +1,176 @@
+// RuntimeDeviceModule - Web adapter for device info
+// Provides getRuntimeDeviceInfo for web environment
+
+import { resolveAddon, createModuleInit } from '../core/moduleUtils'
+
+const STORAGE_KEY = 'quicktvui_device_id'
+
+// Generate UUID v4
+// Use crypto.randomUUID() if available (cryptographically secure)
+// Fallback to Math.random() for older browsers
+function generateUUID() {
+  // Modern browsers: crypto.randomUUID() is cryptographically secure
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID()
+  }
+
+  // Fallback for older browsers
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    const r = (Math.random() * 16) | 0
+    const v = c === 'x' ? r : (r & 0x3) | 0x8
+    return v.toString(16)
+  })
+}
+
+// Get or create device ID
+async function getOrCreateDeviceId() {
+  // Try to get existing ID from localStorage
+  try {
+    const existingId = await localStorage.getItem(STORAGE_KEY)
+    if (existingId) {
+      return existingId
+    }
+  } catch (e) {
+    // localStorage not available
+  }
+
+  // Generate a new UUID
+  const id = generateUUID()
+
+  // Try to persist it
+  try {
+    localStorage.setItem(STORAGE_KEY, id)
+  } catch (e) {
+    // localStorage not available
+  }
+
+  return id
+}
+
+// Get browser/device info
+function getBrowserInfo() {
+  const ua = navigator.userAgent
+
+  let browser = 'unknown'
+  let os = 'unknown'
+  let osVersion = ''
+
+  // Detect OS
+  if (/Windows/i.test(ua)) {
+    os = 'windows'
+    const match = ua.match(/Windows NT (\d+\.?\d*)/)
+    osVersion = match ? match[1] : ''
+  } else if (/Mac/i.test(ua)) {
+    os = 'mac'
+    const match = ua.match(/Mac OS X (\d+[._]\d+[._]?\d*)/)
+    osVersion = match ? match[1].replace(/_/g, '.') : ''
+  } else if (/Linux/i.test(ua)) {
+    os = 'linux'
+  } else if (/Android/i.test(ua)) {
+    os = 'android'
+    const match = ua.match(/Android (\d+\.?\d*\.?\d*)/)
+    osVersion = match ? match[1] : ''
+  } else if (/iOS|iPhone|iPad/i.test(ua)) {
+    os = 'ios'
+    const match = ua.match(/OS (\d+_\d+_?\d*)/)
+    osVersion = match ? match[1].replace(/_/g, '.') : ''
+  }
+
+  // Detect browser
+  if (/Chrome/i.test(ua) && !/Edge|Edg/i.test(ua)) {
+    browser = 'chrome'
+  } else if (/Safari/i.test(ua) && !/Chrome/i.test(ua)) {
+    browser = 'safari'
+  } else if (/Firefox/i.test(ua)) {
+    browser = 'firefox'
+  } else if (/Edge|Edg/i.test(ua)) {
+    browser = 'edge'
+  }
+
+  return { browser, os, osVersion }
+}
+
+export class RuntimeDeviceModuleClass {
+  constructor(context) {
+    this.context = context
+    this.name = ''
+    this.mode = 'normal'
+    this._deviceId = null
+  }
+
+  // Get cached or generate device ID
+  async _getDeviceId() {
+    if (!this._deviceId) {
+      this._deviceId = await getOrCreateDeviceId()
+    }
+    return this._deviceId
+  }
+
+  // Get device ID only
+  async getRuntimeDeviceId(...args) {
+    const deviceId = await this._getDeviceId()
+    console.log(
+      '[RuntimeDeviceModule] getRuntimeDeviceId called, deviceId:',
+      deviceId,
+      'args:',
+      args
+    )
+    return resolveAddon(args, deviceId)
+  }
+
+  // Get device type only
+  async getRuntimeDeviceType(...args) {
+    return resolveAddon(args, 'web')
+  }
+
+  // Main method: getRuntimeDeviceInfo
+  async getRuntimeDeviceInfo(...args) {
+    const { browser, os, osVersion } = getBrowserInfo()
+    const deviceId = await this._getDeviceId()
+
+    const deviceInfo = {
+      // Device identification
+      deviceId: deviceId,
+      deviceSerial: deviceId,
+
+      // Device type
+      deviceType: 'web',
+      deviceModel: browser,
+      deviceBrand: 'web',
+
+      // OS info
+      osName: os,
+      osVersion: osVersion,
+      osApiLevel: '',
+
+      // Screen info
+      screenWidth: window.screen.width || 0,
+      screenHeight: window.screen.height || 0,
+      screenDensity: window.devicePixelRatio || 1,
+
+      // App info
+      appVersion: '',
+      appVersionCode: 0,
+
+      // Network info
+      networkType: 'unknown',
+
+      // Platform
+      platform: 'web',
+    }
+
+    return resolveAddon(args, deviceInfo)
+  }
+
+  destroy() {}
+
+  async init(...args) {
+    return createModuleInit(args)
+  }
+}
+
+// Export class for HippyWebEngine (needs constructor)
+export { RuntimeDeviceModuleClass as RuntimeDeviceModule }
+
+// Also export singleton instance for patches.js
+export const runtimeDeviceModuleInstance = new RuntimeDeviceModuleClass()