@volley/vwr-loader 1.1.0 → 1.3.0

package/src/main.ts

@@ -1,25 +1,113 @@
+// Load polyfills FIRST before any other code
+import "./polyfills"
+
+import { initRumGlobal } from "./datadog"
+import { InitializationError, isVWRInitializationError } from "./errors"
+import { exitIfBackNavigation, setupLGBackButtonHandler } from "./exitHandler"
 import { loadVwr } from "./loadVwr"
+import { logger } from "./logger"
 
 const PLATFORM = import.meta.env.VITE_PLATFORM
 const HUB_URL = import.meta.env.VITE_HUB_URL
+const ENVIRONMENT = import.meta.env.VITE_ENVIRONMENT as string | undefined
+const SHELL_VERSION = import.meta.env.VITE_SHELL_VERSION as string | undefined
+
+/**
+ * Handle initialization errors with structured logging and RUM tracking.
+ * Logger automatically sends errors to both Datadog Logs and RUM Error Tracking.
+ */
+function handleInitializationError(error: unknown) {
+    if (
+        error instanceof InitializationError ||
+        isVWRInitializationError(error)
+    ) {
+        logger.error(
+            {
+                context: error.getContext(),
+                error_type: error.name,
+                error: error,
+            },
+            `[Shell] FALLBACK TO HUB - ${error.message}`
+        )
+    } else {
+        // Unknown error - normalize to Error instance
+        const normalizedError =
+            error instanceof Error ? error : new Error(String(error))
+
+        logger.error(
+            {
+                reason: normalizedError.message,
+                error_type: normalizedError.name,
+                error: normalizedError,
+            },
+            "[Shell] FALLBACK TO HUB - Init failed (unknown error)"
+        )
+    }
+}
 
 async function init() {
+    // Exit app if user pressed back - safety net for Samsung/LG TVs
+    // when VWR fails to load and user navigates back to loader
+    exitIfBackNavigation(PLATFORM)
+
+    // Initialize Datadog RUM early (if credentials provided)
+    // For mobile webviews with WebViewTracking.enable(), events are
+    // automatically forwarded to the mobile app's RUM session
+    logger.info("VWR loader starting init flow")
+
+    const rum = initRumGlobal({
+        env: ENVIRONMENT ?? "unknown",
+        version: SHELL_VERSION,
+        service: "vwr-loader",
+    })
+
+    // Set up LG back button handler while loader is active.
+    // On LG with disableBackHistoryAPI: true, the platform doesn't handle back automatically.
+    // Once VWR loads, it will take over with PSDK's custom exit modal.
+    let cleanupLGBackHandler: (() => void) | undefined
+    if (PLATFORM === "LG_TV") {
+        cleanupLGBackHandler = setupLGBackButtonHandler()
+    }
+
     try {
-        await loadVwr()
+        await loadVwr(rum)
+        // VWR loaded successfully - remove our back handler, PSDK takes over
+        cleanupLGBackHandler?.()
     } catch (error) {
+        // Keep LG back handler active during fallback - it will handle exit
+        // if user presses back on the Hub page and navigates back here
         try {
-            console.error("[Shell] ⚠️  FALLBACK TO HUB - Init failed:", error)
+            handleInitializationError(error)
+        } finally {
+            // Fallback to gameControllerUrl if it exists
+            // Otherwise fallback to HUB_URL with volley_platform param
+            let fallbackUrl: URL
+            const gameControllerUrl =
+                new URLSearchParams(window.location.search)
+                    .get("gameControllerUrl")
+                    ?.trim() || null
+
+            if (gameControllerUrl) {
+                fallbackUrl = new URL(gameControllerUrl)
 
-            if ((window as any).DD_LOGS) {
-                ;(window as any).DD_LOGS.logger.error("shell_init_failed", {
-                    error: (error as Error).message,
-                    platform: PLATFORM,
-                })
+                logger.info(
+                    {
+                        gameControllerUrl,
+                    },
+                    "[Shell] Using gameControllerUrl as fallback"
+                )
+            } else {
+                fallbackUrl = new URL(HUB_URL)
+                fallbackUrl.searchParams.set("volley_platform", PLATFORM)
+
+                logger.info(
+                    {
+                        PLATFORM,
+                    },
+                    "[Shell] No gameControllerUrl, redirecting to Hub"
+                )
             }
-        } finally {
-            //Fallback, can't trust config exists
-            const fallbackUrl = new URL(HUB_URL)
-            fallbackUrl.searchParams.set("volley_platform", PLATFORM)
+
             window.location.href = fallbackUrl.toString()
         }
     }

package/src/polyfills.ts

@@ -0,0 +1,32 @@
+/**
+ * Polyfills for Chrome 68+ compatibility (Samsung/LG TVs)
+ *
+ * Import this at the top of main.ts BEFORE any other code runs.
+ * Conservative approach: polyfill all features not available in Chrome 68.
+ *
+ * ECMAScript polyfills (via core-js):
+ * - globalThis (Chrome 71)
+ * - Array.prototype.flat/flatMap (Chrome 69)
+ * - Object.fromEntries (Chrome 73)
+ * - String.prototype.matchAll (Chrome 73)
+ * - Promise.allSettled (Chrome 76)
+ * - String.prototype.replaceAll (Chrome 85)
+ * - Array.prototype.at / String.prototype.at (Chrome 92)
+ *
+ * Web API polyfills:
+ * - focus-visible (Chrome 86) - critical for TV remote navigation
+ */
+
+// ECMAScript polyfills via core-js
+import "core-js/modules/es.global-this.js"
+import "core-js/modules/es.array.flat.js"
+import "core-js/modules/es.array.flat-map.js"
+import "core-js/modules/es.object.from-entries.js"
+import "core-js/modules/es.string.match-all.js"
+import "core-js/modules/es.promise.all-settled.js"
+import "core-js/modules/es.string.replace-all.js"
+import "core-js/modules/es.array.at.js"
+import "core-js/modules/es.string.at-alternative.js"
+// Web API polyfills
+// focus-visible - Critical for TV remote focus rings
+import "focus-visible"

package/src/test-setup.ts

@@ -0,0 +1,5 @@
+import { vi } from "vitest"
+
+// Global mocks for Datadog browser SDKs
+vi.mock("@datadog/browser-rum")
+vi.mock("@datadog/browser-logs")

package/src/types.ts

@@ -67,10 +67,14 @@ declare global {
             fetchAppInfo?: (
                 callback: (appInfo?: { version?: string }) => void
             ) => void
+            platformBack?: () => void
         }
         tizen?: {
             application?: {
                 getAppInfo: () => { version?: string }
+                getCurrentApplication: () => {
+                    exit: () => void
+                }
             }
         }
     }

package/src/vite-env.d.ts

@@ -1,16 +1,30 @@
+/**
+ * Supported platform identifiers.
+ * These must be uppercase - invalid values will cause build-time TypeScript errors.
+ */
+type Platform =
+    | "FIRE_TV"
+    | "SAMSUNG_TV"
+    | "LG_TV"
+    | "ANDROID_MOBILE"
+    | "IOS_MOBILE"
+    | "WEB"
+
 interface ImportMetaEnv {
     readonly VITE_HUB_URL: string
     readonly VITE_VWR_URL: string
     readonly VITE_LAUNCH_URL: string
     readonly VITE_AMPLITUDE_DEPLOYMENT_KEY: string
     readonly VITE_ENVIRONMENT: string
-    readonly VITE_PLATFORM: string
+    readonly VITE_PLATFORM: Platform
     readonly VITE_SHELL_VERSION: string
     readonly VITE_CONFIG_URL: string
     readonly VITE_CONFIG_FILE: string
     readonly VITE_PLATFORM_API_URL: string
     readonly VITE_PLATFORM_AUTH_API_URL: string
     readonly VITE_TRUSTED_ORIGINS: string
+    readonly VITE_DATADOG_APPLICATION_ID: string
+    readonly VITE_DATADOG_CLIENT_TOKEN: string
 }
 
 interface ImportMeta {

package/src/vwrConfig.test.ts

@@ -1,3 +1,4 @@
+import type { ILogger } from "@volley/logger"
 import { describe, expect, it, vi } from "vitest"
 
 // Stub environment to use "production" which maps to ENV_DEFAULTS["production"]
@@ -5,6 +6,14 @@ vi.stubEnv("VITE_ENVIRONMENT", "production")
 
 import type { VWRConfig, VWRConfigRequest } from "./vwrConfig"
 
+const mockLogger = {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+    child: vi.fn(() => mockLogger),
+} as unknown as ILogger
+
 describe("vwrConfig", async () => {
     const { getVWRConfig, validateConfig } = await import("./vwrConfig")
     describe("validateConfig", () => {
@@ -13,6 +22,8 @@ describe("vwrConfig", async () => {
             hubUrl: "https://hub.example.com",
             launchUrl: "https://launch.example.com",
             trustedDomains: ["example.com"],
+            platformApiUrl: "https://api.example.com",
+            platformAuthApiUrl: "https://auth.example.com",
         }
 
         it("returns false for empty vwrUrl", () => {
@@ -83,16 +94,31 @@ describe("vwrConfig", async () => {
 
         const fetchSpy = vi.spyOn(global, "fetch")
 
+        vi.spyOn(global, "Request").mockImplementation(
+            (_input: URL | RequestInfo, _init?: RequestInit) => {
+                return {} as Request
+            }
+        )
+
         it("returns default config when no configs are found", async () => {
-            const config = await getVWRConfig(configRequest)
+            const result = await getVWRConfig(configRequest, mockLogger)
             // Defaults come from ENV_DEFAULTS["production"]
-            expect(config.vwrUrl).toBe("https://vwr.volley.tv/v1/latest/vwr.js")
-            expect(config.hubUrl).toBe("https://game-clients.volley.tv/hub")
-            expect(config.launchUrl).toBeUndefined() // Optional, not set by default
-            expect(config.trustedDomains).toEqual([
+            expect(result.config.vwrUrl).toBe(
+                "https://vwr.volley.tv/v1/latest/vwr.js"
+            )
+            expect(result.config.hubUrl).toBe(
+                "https://game-clients.volley.tv/hub"
+            )
+            expect(result.config.launchUrl).toBeUndefined() // Optional, not set by default
+            // trustedDomains includes: hubUrl origin, vwrUrl origin, plus trustedOrigins from env defaults
+            expect(result.config.trustedDomains).toEqual([
                 "https://game-clients.volley.tv",
                 "https://vwr.volley.tv",
+                "https://volley.tv",
+                "https://vl.ly",
+                "https://vly.gg",
             ])
+            expect(result.source).toBe("defaults")
         })
 
         it("returns local config when available", async () => {
@@ -152,19 +178,25 @@ describe("vwrConfig", async () => {
                     })
                 )
             )
-            const config = await getVWRConfig(configRequest)
-            expect(validateConfig(config)).toBe(true)
-            expect(config.vwrUrl).toBe("https://local-vwr.example.com")
-            expect(config.hubUrl).toBe("https://local-hub.example.com")
-            expect(config.launchUrl).toBe("https://local-launch.example.com")
-            expect(config.trustedDomains).toEqual([
+            const result = await getVWRConfig(configRequest, mockLogger)
+            expect(validateConfig(result.config)).toBe(true)
+            expect(result.config.vwrUrl).toBe("https://local-vwr.example.com")
+            expect(result.config.hubUrl).toBe("https://local-hub.example.com")
+            expect(result.config.launchUrl).toBe(
+                "https://local-launch.example.com"
+            )
+            expect(result.config.trustedDomains).toEqual([
                 "https://local-hub.example.com",
                 "https://local-vwr.example.com",
                 "https://local-launch.example.com",
             ])
+            expect(result.source).toBe("local")
         })
 
         it("returns device config when available", async () => {
+            // local - 404 (not found)
+            fetchSpy.mockResolvedValueOnce(new Response(null, { status: 404 }))
+            // device - success
             fetchSpy.mockResolvedValueOnce(
                 new Response(
                     JSON.stringify({
@@ -179,6 +211,7 @@ describe("vwrConfig", async () => {
                     })
                 )
             )
+            // shellVersion - success (but lower priority)
             fetchSpy.mockResolvedValueOnce(
                 new Response(
                     JSON.stringify({
@@ -193,6 +226,7 @@ describe("vwrConfig", async () => {
                     })
                 )
             )
+            // environment - success (but lower priority)
             fetchSpy.mockResolvedValueOnce(
                 new Response(
                     JSON.stringify({
@@ -207,19 +241,27 @@ describe("vwrConfig", async () => {
                     })
                 )
             )
-            const config = await getVWRConfig(configRequest)
-            expect(validateConfig(config)).toBe(true)
-            expect(config.vwrUrl).toBe("https://device-vwr.example.com")
-            expect(config.hubUrl).toBe("https://device-hub.example.com")
-            expect(config.launchUrl).toBe("https://device-launch.example.com")
-            expect(config.trustedDomains).toEqual([
+            const result = await getVWRConfig(configRequest, mockLogger)
+            expect(validateConfig(result.config)).toBe(true)
+            expect(result.config.vwrUrl).toBe("https://device-vwr.example.com")
+            expect(result.config.hubUrl).toBe("https://device-hub.example.com")
+            expect(result.config.launchUrl).toBe(
+                "https://device-launch.example.com"
+            )
+            expect(result.config.trustedDomains).toEqual([
                 "https://device-hub.example.com",
                 "https://device-vwr.example.com",
                 "https://device-launch.example.com",
             ])
+            expect(result.source).toBe("device")
         })
 
         it("returns shell config when available", async () => {
+            // local - 404 (not found)
+            fetchSpy.mockResolvedValueOnce(new Response(null, { status: 404 }))
+            // device - 404 (not found)
+            fetchSpy.mockResolvedValueOnce(new Response(null, { status: 404 }))
+            // shellVersion - success
             fetchSpy.mockResolvedValueOnce(
                 new Response(
                     JSON.stringify({
@@ -234,6 +276,7 @@ describe("vwrConfig", async () => {
                     })
                 )
             )
+            // environment - success (but lower priority)
             fetchSpy.mockResolvedValueOnce(
                 new Response(
                     JSON.stringify({
@@ -248,19 +291,29 @@ describe("vwrConfig", async () => {
                     })
                 )
             )
-            const config = await getVWRConfig(configRequest)
-            expect(validateConfig(config)).toBe(true)
-            expect(config.vwrUrl).toBe("https://shell-vwr.example.com")
-            expect(config.hubUrl).toBe("https://shell-hub.example.com")
-            expect(config.launchUrl).toBe("https://shell-launch.example.com")
-            expect(config.trustedDomains).toEqual([
+            const result = await getVWRConfig(configRequest, mockLogger)
+            expect(validateConfig(result.config)).toBe(true)
+            expect(result.config.vwrUrl).toBe("https://shell-vwr.example.com")
+            expect(result.config.hubUrl).toBe("https://shell-hub.example.com")
+            expect(result.config.launchUrl).toBe(
+                "https://shell-launch.example.com"
+            )
+            expect(result.config.trustedDomains).toEqual([
                 "https://shell-hub.example.com",
                 "https://shell-vwr.example.com",
                 "https://shell-launch.example.com",
             ])
+            expect(result.source).toBe("shellVersion")
         })
 
         it("returns environment config when available", async () => {
+            // local - 404 (not found)
+            fetchSpy.mockResolvedValueOnce(new Response(null, { status: 404 }))
+            // device - 404 (not found)
+            fetchSpy.mockResolvedValueOnce(new Response(null, { status: 404 }))
+            // shellVersion - 404 (not found)
+            fetchSpy.mockResolvedValueOnce(new Response(null, { status: 404 }))
+            // environment - success
             fetchSpy.mockResolvedValueOnce(
                 new Response(
                     JSON.stringify({
@@ -275,21 +328,33 @@ describe("vwrConfig", async () => {
                     })
                 )
             )
-            const config = await getVWRConfig(configRequest)
-            expect(validateConfig(config)).toBe(true)
-            expect(config.vwrUrl).toBe("https://environment-vwr.example.com")
-            expect(config.hubUrl).toBe("https://environment-hub.example.com")
-            expect(config.launchUrl).toBe(
+            const result = await getVWRConfig(configRequest, mockLogger)
+            expect(validateConfig(result.config)).toBe(true)
+            expect(result.config.vwrUrl).toBe(
+                "https://environment-vwr.example.com"
+            )
+            expect(result.config.hubUrl).toBe(
+                "https://environment-hub.example.com"
+            )
+            expect(result.config.launchUrl).toBe(
                 "https://environment-launch.example.com"
             )
-            expect(config.trustedDomains).toEqual([
+            expect(result.config.trustedDomains).toEqual([
                 "https://environment-hub.example.com",
                 "https://environment-vwr.example.com",
                 "https://environment-launch.example.com",
             ])
+            expect(result.source).toBe("environment")
         })
 
         it("returns default config for missing values", async () => {
+            // local - 404 (not found)
+            fetchSpy.mockResolvedValueOnce(new Response(null, { status: 404 }))
+            // device - 404 (not found)
+            fetchSpy.mockResolvedValueOnce(new Response(null, { status: 404 }))
+            // shellVersion - 404 (not found)
+            fetchSpy.mockResolvedValueOnce(new Response(null, { status: 404 }))
+            // environment - success (partial config, missing launchUrl)
             fetchSpy.mockResolvedValueOnce(
                 new Response(
                     JSON.stringify({
@@ -302,15 +367,20 @@ describe("vwrConfig", async () => {
                     })
                 )
             )
-            const config = await getVWRConfig(configRequest)
-            expect(config.vwrUrl).toBe("https://environment-vwr.example.com")
-            expect(config.hubUrl).toBe("https://environment-hub.example.com")
+            const result = await getVWRConfig(configRequest, mockLogger)
+            expect(result.config.vwrUrl).toBe(
+                "https://environment-vwr.example.com"
+            )
+            expect(result.config.hubUrl).toBe(
+                "https://environment-hub.example.com"
+            )
             // launchUrl is optional, not filled when missing
-            expect(config.launchUrl).toBeUndefined()
-            expect(config.trustedDomains).toEqual([
+            expect(result.config.launchUrl).toBeUndefined()
+            expect(result.config.trustedDomains).toEqual([
                 "https://environment-hub.example.com",
                 "https://environment-vwr.example.com",
             ])
+            expect(result.source).toBe("environment")
         })
     })
 })