@volley/vwr-loader 1.1.0 → 1.3.0

package/src/getDeviceId.ts

@@ -1,4 +1,6 @@
-import { defaultLogger, type Logger } from "./logger"
+import { v4 as uuidv4 } from "uuid"
+
+import { logger } from "./logger"
 import type { LGDeviceIdResponse, MobileExtendedWindow } from "./types"
 
 /**
@@ -25,21 +27,18 @@ import type { LGDeviceIdResponse, MobileExtendedWindow } from "./types"
  * }
  * ```
  */
-export async function getDeviceId(
-    platform: string,
-    logger: Logger = defaultLogger
-): Promise<string | null> {
+export async function getDeviceId(platform: string): Promise<string | null> {
     const normalizedPlatform = platform.toUpperCase()
     switch (normalizedPlatform) {
         case "FIRE_TV":
-            return await getFireTVDeviceId(logger)
+            return await getFireTVDeviceId()
         case "SAMSUNG_TV":
-            return await getSamsungDeviceId(logger)
+            return await getSamsungDeviceId()
         case "LG_TV":
-            return await getLGDeviceId(logger)
+            return await getLGDeviceId()
         case "ANDROID_MOBILE":
         case "IOS_MOBILE":
-            return await getMobileDeviceId(logger)
+            return await getMobileDeviceId()
         case "WEB":
             return getLocalStorageDeviceId()
         default:
@@ -53,18 +52,20 @@ export async function getDeviceId(
  * Get or create device ID from localStorage (for Web platform)
  */
 function getLocalStorageDeviceId(): string {
-    let deviceId = localStorage.getItem("volley_device_id")
-    if (!deviceId) {
-        deviceId = crypto.randomUUID()
-        localStorage.setItem("volley_device_id", deviceId)
+    const existingDeviceId = localStorage.getItem("volley_device_id")
+    if (existingDeviceId) {
+        return existingDeviceId
     }
-    return deviceId
+
+    const newDeviceId = uuidv4()
+    localStorage.setItem("volley_device_id", newDeviceId)
+    return newDeviceId
 }
 
 /**
  * Attempt to get device ID from Capacitor DeviceInfo plugin (FireTV)
  */
-async function getFireTVDeviceId(logger: Logger): Promise<string | null> {
+async function getFireTVDeviceId(): Promise<string | null> {
     try {
         if (!window.Capacitor?.Plugins?.DeviceInfo?.getAndroidId) {
             return null
@@ -91,7 +92,7 @@ async function getFireTVDeviceId(logger: Logger): Promise<string | null> {
  * iOS exposes phoneDeviceId via window.iosAppContext
  * Android exposes phoneDeviceId via window.androidAppContext (also check window.top for iframes)
  */
-function getMobileDeviceId(logger: Logger): string | null {
+function getMobileDeviceId(): string | null {
     // Try iOS first
     const iosId = (window as MobileExtendedWindow).iosAppContext?.phoneDeviceId
     if (iosId && iosId.trim()) {
@@ -126,7 +127,7 @@ function getMobileDeviceId(logger: Logger): string | null {
 /**
  * Attempt to get device ID from Samsung TV webapis
  */
-async function getSamsungDeviceId(logger: Logger): Promise<string | null> {
+async function getSamsungDeviceId(): Promise<string | null> {
     try {
         if (!window.webapis?.productinfo?.getDuid) {
             return null
@@ -156,7 +157,7 @@ async function getSamsungDeviceId(logger: Logger): Promise<string | null> {
  */
 const LG_LUNA_SERVICE_TIMEOUT = 5000
 
-async function getLGDeviceId(logger: Logger): Promise<string | null> {
+async function getLGDeviceId(): Promise<string | null> {
     if (!window.webOS?.service?.request) {
         const message = "LG webOS service request not available"
         logger.error(message)

package/src/getEnvironment.test.ts

@@ -1,19 +1,21 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
 
 import { type Environment, getEnvironment } from "./getEnvironment"
+import { logger } from "./logger"
 
-describe("getEnvironment", () => {
-    const mockLogger = {
+vi.mock("./logger", () => ({
+    logger: {
         info: vi.fn(),
         warn: vi.fn(),
         error: vi.fn(),
-    }
+        debug: vi.fn(),
+        child: vi.fn(),
+    },
+}))
 
+describe("getEnvironment", () => {
     beforeEach(() => {
         vi.clearAllMocks()
-        mockLogger.info.mockClear()
-        mockLogger.warn.mockClear()
-        mockLogger.error.mockClear()
         // Clean up window properties
         delete (window as any).Capacitor
     })
@@ -42,15 +44,11 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("dev")
             expect(result.source).toBe("native")
-            expect(mockLogger.info).toHaveBeenCalledWith(
+            expect(logger.info).toHaveBeenCalledWith(
                 expect.stringContaining(
                     'Environment: "dev" (source: native BuildConfig.ENVIRONMENT="development")'
                 )
@@ -74,11 +72,7 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("prod")
             expect(result.source).toBe("native")
@@ -101,11 +95,7 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("staging")
             expect(result.source).toBe("native")
@@ -128,11 +118,7 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("staging")
             expect(result.source).toBe("native")
@@ -155,11 +141,7 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("dev")
             expect(result.source).toBe("native")
@@ -182,11 +164,7 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("dev")
             expect(result.source).toBe("native")
@@ -194,15 +172,11 @@ describe("getEnvironment", () => {
 
         it("should fallback to build-time when native plugin unavailable", async () => {
             // No Capacitor plugin available
-            const result = await getEnvironment(
-                "FIRE_TV",
-                "staging",
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", "staging")
 
             expect(result.environment).toBe("staging")
             expect(result.source).toBe("build-time")
-            expect(mockLogger.warn).toHaveBeenCalledWith(
+            expect(logger.warn).toHaveBeenCalledWith(
                 expect.stringContaining(
                     "Failed to read environment from native, falling back to build-time"
                 )
@@ -226,12 +200,12 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment("FIRE_TV", "prod", mockLogger)
+            const result = await getEnvironment("FIRE_TV", "prod")
 
             expect(result.environment).toBe("prod")
             expect(result.source).toBe("build-time")
-            expect(mockLogger.error).toHaveBeenCalled()
-            expect(mockLogger.warn).toHaveBeenCalledWith(
+            expect(logger.error).toHaveBeenCalled()
+            expect(logger.warn).toHaveBeenCalledWith(
                 expect.stringContaining("falling back to build-time")
             )
         })
@@ -253,11 +227,11 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result = await getEnvironment("FIRE_TV", "dev", mockLogger)
+            const result = await getEnvironment("FIRE_TV", "dev")
 
             expect(result.environment).toBe("dev")
             expect(result.source).toBe("build-time")
-            expect(mockLogger.error).toHaveBeenCalledWith(
+            expect(logger.error).toHaveBeenCalledWith(
                 expect.stringContaining(
                     "DeviceInfo.getNativeShellAppEnvironment returned empty"
                 )
@@ -266,15 +240,11 @@ describe("getEnvironment", () => {
 
         it("should fallback to default when both native and build-time fail", async () => {
             // No Capacitor plugin, no build-time env
-            const result = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result = await getEnvironment("FIRE_TV", undefined)
 
             expect(result.environment).toBe("dev")
             expect(result.source).toBe("default")
-            expect(mockLogger.warn).toHaveBeenCalledWith(
+            expect(logger.warn).toHaveBeenCalledWith(
                 expect.stringContaining(
                     'Environment: "dev" (source: default fallback'
                 )
@@ -298,16 +268,8 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            const result1 = await getEnvironment(
-                "fire_tv",
-                undefined,
-                mockLogger
-            )
-            const result2 = await getEnvironment(
-                "FIRE_TV",
-                undefined,
-                mockLogger
-            )
+            const result1 = await getEnvironment("fire_tv", undefined)
+            const result2 = await getEnvironment("FIRE_TV", undefined)
 
             expect(result1.environment).toBe("prod")
             expect(result2.environment).toBe("prod")
@@ -320,15 +282,11 @@ describe("getEnvironment", () => {
         platforms.forEach((platform) => {
             describe(`${platform}`, () => {
                 it("should use build-time environment when provided", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        "staging",
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, "staging")
 
                     expect(result.environment).toBe("staging")
                     expect(result.source).toBe("build-time")
-                    expect(mockLogger.info).toHaveBeenCalledWith(
+                    expect(logger.info).toHaveBeenCalledWith(
                         expect.stringContaining(
                             'Environment: "staging" (source: build-time CLI injection)'
                         )
@@ -336,48 +294,32 @@ describe("getEnvironment", () => {
                 })
 
                 it("should use build-time 'prod' environment", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        "prod",
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, "prod")
 
                     expect(result.environment).toBe("prod")
                     expect(result.source).toBe("build-time")
                 })
 
                 it("should use build-time 'dev' environment", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        "dev",
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, "dev")
 
                     expect(result.environment).toBe("dev")
                     expect(result.source).toBe("build-time")
                 })
 
                 it("should use build-time 'local' environment", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        "local",
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, "local")
 
                     expect(result.environment).toBe("local")
                     expect(result.source).toBe("build-time")
                 })
 
                 it("should fallback to default when build-time not provided", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        undefined,
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, undefined)
 
                     expect(result.environment).toBe("dev")
                     expect(result.source).toBe("default")
-                    expect(mockLogger.warn).toHaveBeenCalledWith(
+                    expect(logger.warn).toHaveBeenCalledWith(
                         expect.stringContaining(
                             'Environment: "dev" (source: default fallback'
                         )
@@ -385,11 +327,7 @@ describe("getEnvironment", () => {
                 })
 
                 it("should fallback to default when build-time is invalid", async () => {
-                    const result = await getEnvironment(
-                        platform,
-                        "invalid-env",
-                        mockLogger
-                    )
+                    const result = await getEnvironment(platform, "invalid-env")
 
                     expect(result.environment).toBe("dev")
                     expect(result.source).toBe("default")
@@ -403,7 +341,7 @@ describe("getEnvironment", () => {
             const validEnvs: Environment[] = ["local", "dev", "staging", "prod"]
 
             for (const env of validEnvs) {
-                const result = await getEnvironment("WEB", env, mockLogger)
+                const result = await getEnvironment("WEB", env)
                 expect(result.environment).toBe(env)
                 expect(result.source).toBe("build-time")
             }
@@ -420,7 +358,7 @@ describe("getEnvironment", () => {
             ]
 
             for (const env of invalidEnvs) {
-                const result = await getEnvironment("WEB", env, mockLogger)
+                const result = await getEnvironment("WEB", env)
                 expect(result.environment).toBe("dev")
                 expect(result.source).toBe("default")
             }
@@ -445,33 +383,33 @@ describe("getEnvironment", () => {
                 configurable: true,
             })
 
-            await getEnvironment("FIRE_TV", undefined, mockLogger)
+            await getEnvironment("FIRE_TV", undefined)
 
-            expect(mockLogger.info).toHaveBeenCalledWith(
+            expect(logger.info).toHaveBeenCalledWith(
                 '[Shell] Environment: "prod" (source: native BuildConfig.ENVIRONMENT="production")'
             )
         })
 
         it("should log build-time environment source", async () => {
-            await getEnvironment("SAMSUNG_TV", "staging", mockLogger)
+            await getEnvironment("SAMSUNG_TV", "staging")
 
-            expect(mockLogger.info).toHaveBeenCalledWith(
+            expect(logger.info).toHaveBeenCalledWith(
                 '[Shell] Environment: "staging" (source: build-time CLI injection)'
             )
         })
 
         it("should warn when falling back to default", async () => {
-            await getEnvironment("LG_TV", undefined, mockLogger)
+            await getEnvironment("LG_TV", undefined)
 
-            expect(mockLogger.warn).toHaveBeenCalledWith(
+            expect(logger.warn).toHaveBeenCalledWith(
                 '[Shell] Environment: "dev" (source: default fallback - no native or build-time env found)'
             )
         })
 
         it("should warn when native fails and falls back", async () => {
-            await getEnvironment("FIRE_TV", "prod", mockLogger)
+            await getEnvironment("FIRE_TV", "prod")
 
-            expect(mockLogger.warn).toHaveBeenCalledWith(
+            expect(logger.warn).toHaveBeenCalledWith(
                 "[Shell] Failed to read environment from native, falling back to build-time"
             )
         })

package/src/getEnvironment.ts

@@ -1,4 +1,4 @@
-import { defaultLogger, type Logger } from "./logger"
+import { logger } from "./logger"
 
 export type Environment = "local" | "dev" | "staging" | "prod"
 export type EnvironmentSource = "native" | "build-time" | "default"
@@ -26,14 +26,13 @@ export interface EnvironmentResult {
  */
 export async function getEnvironment(
     platform: string,
-    buildTimeEnv: string | undefined,
-    logger: Logger = defaultLogger
+    buildTimeEnv: string | undefined
 ): Promise<EnvironmentResult> {
     const normalizedPlatform = platform.toUpperCase()
 
     // For Fire TV, try to read from native first (safest - prevents env mismatch)
     if (normalizedPlatform === "FIRE_TV") {
-        const nativeEnv = await getFireTVEnvironment(logger)
+        const nativeEnv = await getFireTVEnvironment()
         if (nativeEnv) {
             const mapped = mapNativeEnvironment(nativeEnv)
             logger.info(
@@ -72,7 +71,7 @@ export async function getEnvironment(
 /**
  * Read environment from Fire TV native shell via Capacitor plugin.
  */
-async function getFireTVEnvironment(logger: Logger): Promise<string | null> {
+async function getFireTVEnvironment(): Promise<string | null> {
     try {
         if (
             !window.Capacitor?.Plugins?.DeviceInfo?.getNativeShellAppEnvironment

package/src/getShellVersion.test.ts

@@ -1,6 +1,17 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
 
 import { getShellVersion } from "./getShellVersion"
+import { logger } from "./logger"
+
+vi.mock("./logger", () => ({
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+        child: vi.fn(),
+    },
+}))
 
 describe("getShellVersion", () => {
     const originalLocation = window.location
@@ -369,10 +380,6 @@ describe("getShellVersion", () => {
 
     describe("Error Handling", () => {
         it("returns unknown and logs warning on error", async () => {
-            const consoleWarnSpy = vi
-                .spyOn(console, "warn")
-                .mockImplementation(() => {})
-
             // Force an error by making tizen.application.getAppInfo throw
             ;(window as any).tizen = {
                 application: {
@@ -385,12 +392,11 @@ describe("getShellVersion", () => {
             const version = await getShellVersion("SAMSUNG_TV")
 
             expect(version).toBe("unknown")
-            expect(consoleWarnSpy).toHaveBeenCalledWith(
+            expect(logger.warn).toHaveBeenCalledWith(
                 "[Shell] Failed to get shell version:",
                 { error: expect.any(Error) }
             )
 
-            consoleWarnSpy.mockRestore()
             delete (window as any).tizen
         })
     })

package/src/getShellVersion.ts

@@ -1,4 +1,4 @@
-import { defaultLogger, type Logger } from "./logger"
+import { logger } from "./logger"
 import type { MobileExtendedWindow } from "./types"
 
 /**
@@ -15,10 +15,7 @@ import type { MobileExtendedWindow } from "./types"
  * @param logger - Optional logger for warning reporting. Defaults to defaultLogger.
  * @returns Shell version string or 'unknown' if not available
  */
-export async function getShellVersion(
-    platform: string,
-    logger: Logger = defaultLogger
-): Promise<string> {
+export async function getShellVersion(platform: string): Promise<string> {
     try {
         const normalizedPlatform = platform.toUpperCase()
 
@@ -71,7 +68,7 @@ export async function getShellVersion(
             normalizedPlatform === "ANDROID_MOBILE" ||
             normalizedPlatform === "IOS_MOBILE"
         ) {
-            return getMobileAppVersion(logger)
+            return getMobileAppVersion()
         }
 
         // Web platform: Check for injected version at build time
@@ -99,7 +96,7 @@ export async function getShellVersion(
  * iOS exposes appVersion via window.iosAppContext
  * Android exposes appVersion via window.androidAppContext (also check window.top for iframes)
  */
-function getMobileAppVersion(logger: Logger): string {
+function getMobileAppVersion(): string {
     // Try iOS first
     const iosVersion = (window as MobileExtendedWindow).iosAppContext
         ?.appVersion

package/src/index.ts

@@ -2,7 +2,6 @@ export type { AmplitudeConfig, FlagResult } from "./amplitudeFlagFetcher"
 export { fetchAmplitudeFlags } from "./amplitudeFlagFetcher"
 export { getDeviceId } from "./getDeviceId"
 export { getShellVersion } from "./getShellVersion"
-export type { Logger } from "./loadVwr"
 export { loadVwr } from "./loadVwr"
 export type { VWRConfig, VWRConfigRequest } from "./vwrConfig"
 export { getVWRConfig } from "./vwrConfig"