@moviie/player-expo 0.4.0

package/src/lib/resolve-web-embed-iframe-src.ts

@@ -0,0 +1,17 @@
+import type { MoviiePlaybackData } from "@moviie/player-sdk"
+
+import {
+  buildMoviieWatchEmbedUrl,
+  resolveMoviieWatchOrigin,
+} from "./build-moviie-watch-embed-url"
+
+export function resolveWebEmbedIframeSrc(
+  playback: MoviiePlaybackData | null | undefined,
+  watchOriginResolver: () => string = resolveMoviieWatchOrigin
+): string | null {
+  const embedId = playback?.embedId?.trim()
+  if (!embedId) {
+    return null
+  }
+  return buildMoviieWatchEmbedUrl(embedId, watchOriginResolver())
+}

package/src/lib/warn-once.ts

@@ -0,0 +1,23 @@
+/**
+ * Console warning idempotente por chave. Útil para dependências opcionais ausentes:
+ * dispara uma única vez por sessão para a mesma chave, evitando ruído no console.
+ *
+ * Reusável para qualquer feature gated por dep opcional (cast, DRM custom,
+ * analytics provider, etc.).
+ */
+
+const FIRED_KEYS = new Set<string>()
+
+export function warnOnce(key: string, message: string): void {
+  if (FIRED_KEYS.has(key)) {
+    return
+  }
+  FIRED_KEYS.add(key)
+  // eslint-disable-next-line no-console
+  console.warn(message)
+}
+
+/** Limpa o set de chaves disparadas. Use apenas em testes. */
+export function __resetWarnOnceForTests(): void {
+  FIRED_KEYS.clear()
+}

package/src/platform/native-application-id.ts

@@ -0,0 +1,10 @@
+import * as Application from "expo-application"
+
+export function readNativeApplicationId(): string | undefined {
+  try {
+    const id = Application.applicationId
+    return id ?? undefined
+  } catch {
+    return undefined
+  }
+}

package/src/platform/platform-client-info.ts

@@ -0,0 +1,31 @@
+import { Platform } from "react-native"
+
+import type { MoviieClientInfo } from "@moviie/player-sdk"
+
+import { readNativeApplicationId } from "./native-application-id"
+
+let cached: MoviieClientInfo | null = null
+
+export function buildPlatformClientInfo(sdkVersion: string): MoviieClientInfo {
+  if (cached) {
+    return cached
+  }
+
+  const os = Platform.OS
+  const platform: MoviieClientInfo["platform"] =
+    os === "ios" ? "ios" : os === "android" ? "android" : "web"
+
+  const bundleId =
+    platform === "web" ? undefined : readNativeApplicationId()
+
+  cached = {
+    platform,
+    bundleId,
+    sdkVersion,
+  }
+  return cached
+}
+
+export function resetPlatformClientInfoCache(): void {
+  cached = null
+}

package/src/playback/fetch-playback-fresh.ts

@@ -0,0 +1,27 @@
+import type { MoviiePlaybackData } from "@moviie/player-sdk"
+
+import { writePlaybackCache } from "./playback-memory-cache"
+
+export async function fetchPlaybackFreshWriteCache(
+  scope: string | null | undefined,
+  embedId: string,
+  signal: AbortSignal,
+  getPlayback: (
+    embedId: string,
+    signal: AbortSignal,
+  ) => Promise<MoviiePlaybackData>,
+): Promise<
+  { ok: true; data: MoviiePlaybackData } | { ok: false; error: Error }
+> {
+  try {
+    const data = await getPlayback(embedId, signal)
+    writePlaybackCache(scope, embedId, data)
+    return { ok: true, data }
+  } catch (unknownError) {
+    const error =
+      unknownError instanceof Error
+        ? unknownError
+        : new Error(String(unknownError))
+    return { ok: false, error }
+  }
+}

package/src/playback/playback-memory-cache.ts

@@ -0,0 +1,52 @@
+import type { MoviiePlaybackData } from "@moviie/player-sdk"
+
+import { MOVIIE_PLAYBACK_MEMORY_CACHE_TTL_MS } from "../constants"
+
+interface CacheEntry {
+  data: MoviiePlaybackData
+  expiresAt: number
+}
+
+const playbackCache = new Map<string, CacheEntry>()
+
+function cacheKey(scope: string | null | undefined, embedId: string): string {
+  return `${scope ?? "__anon__"}::${embedId}`
+}
+
+function resolveEntryExpiry(data: MoviiePlaybackData): number {
+  const now = Date.now()
+  const fallback = now + MOVIIE_PLAYBACK_MEMORY_CACHE_TTL_MS
+  const serverExpiry = data.playback?.expiresAt
+  if (!serverExpiry) return fallback
+  const parsed = Date.parse(serverExpiry)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.min(fallback, parsed)
+}
+
+export function readPlaybackCache(
+  scope: string | null | undefined,
+  embedId: string
+): MoviiePlaybackData | null {
+  const key = cacheKey(scope, embedId)
+  const hit = playbackCache.get(key)
+  if (!hit || hit.expiresAt <= Date.now()) {
+    playbackCache.delete(key)
+    return null
+  }
+  return hit.data
+}
+
+export function writePlaybackCache(
+  scope: string | null | undefined,
+  embedId: string,
+  data: MoviiePlaybackData
+): void {
+  playbackCache.set(cacheKey(scope, embedId), {
+    data,
+    expiresAt: resolveEntryExpiry(data),
+  })
+}
+
+export function clearPlaybackMemoryCache(): void {
+  playbackCache.clear()
+}

package/src/provider/moviie-provider.tsx

@@ -0,0 +1,99 @@
+import {
+  createContext,
+  useContext,
+  useMemo,
+  type ReactNode,
+} from "react"
+
+import {
+  buildClientHeaders,
+  MemoryViewerTokenStore,
+  MoviieClient,
+  type MoviieClientInfo,
+  type ViewerTokenStore,
+} from "@moviie/player-sdk"
+
+import { MOVIIE_PLAYER_EXPO_PKG_VERSION } from "../constants"
+import { buildPlatformClientInfo } from "../platform/platform-client-info"
+import { SecureStoreViewerTokenStore } from "../secure-store-viewer-token-store"
+
+export interface MoviieContextValue {
+  client: MoviieClient
+  viewerTokenStore: ViewerTokenStore
+  publishableKey: string | null
+  clientInfo: MoviieClientInfo
+  sdkVersion: string
+  /** Headers reused by TelemetryClient (Bearer + X-Moviie-Client when aplicável) */
+  telemetryHeaders: Record<string, string>
+}
+
+const MoviieContext = createContext<MoviieContextValue | null>(null)
+
+let fallbackContext: MoviieContextValue | null = null
+
+function getOrCreateFallbackContext(): MoviieContextValue {
+  if (!fallbackContext) {
+    const sdkVersion = MOVIIE_PLAYER_EXPO_PKG_VERSION
+    const clientInfo = buildPlatformClientInfo(sdkVersion)
+    const viewerTokenStore = new MemoryViewerTokenStore()
+    const client = new MoviieClient({
+      publishableKey: undefined,
+      clientInfo,
+      sdkVersion,
+    })
+    fallbackContext = {
+      client,
+      viewerTokenStore,
+      publishableKey: null,
+      clientInfo,
+      sdkVersion,
+      telemetryHeaders: buildClientHeaders({
+        clientInfo,
+        sdkVersion,
+      }),
+    }
+  }
+  return fallbackContext
+}
+
+export function useMoviieContext(): MoviieContextValue {
+  const ctx = useContext(MoviieContext)
+  return ctx ?? getOrCreateFallbackContext()
+}
+
+export function MoviieProvider({
+  publishableKey,
+  children,
+}: {
+  publishableKey?: string | null
+  children: ReactNode
+}) {
+  const value = useMemo((): MoviieContextValue => {
+    const sdkVersion = MOVIIE_PLAYER_EXPO_PKG_VERSION
+    const clientInfo = buildPlatformClientInfo(sdkVersion)
+    const trimmedKey = publishableKey?.trim()
+    const viewerTokenStore = new SecureStoreViewerTokenStore()
+    const client = new MoviieClient({
+      publishableKey: trimmedKey || undefined,
+      clientInfo,
+      sdkVersion,
+    })
+    const telemetryHeaders = buildClientHeaders({
+      publishableKey: trimmedKey || undefined,
+      clientInfo,
+      sdkVersion,
+    })
+    return {
+      client,
+      viewerTokenStore,
+      publishableKey: trimmedKey ?? null,
+      clientInfo,
+      sdkVersion,
+      telemetryHeaders,
+    }
+  }, [publishableKey])
+
+  return (
+    <MoviieContext.Provider value={value}>{children}</MoviieContext.Provider>
+  )
+}

package/src/secure-store-viewer-token-store.ts

@@ -0,0 +1,80 @@
+import type { ViewerTokenStore } from '@moviie/player-sdk'
+import { MemoryViewerTokenStore } from '@moviie/player-sdk'
+
+import { warnOnce } from './lib/warn-once'
+
+export const MOVIIE_VIEWER_TOKEN_SECURE_STORE_KEY = 'moviie_viewer_token_v1' as const
+
+const SECURE_STORE_MISSING_WARNING =
+  '[@moviie/player-expo] `expo-secure-store` não está instalado — viewer token será mantido apenas em memória (perde ao matar app). ' +
+  'Instala com `pnpm add expo-secure-store` se quiseres persistência entre sessões.'
+
+interface StoredEnvelope {
+  token: string
+  expiresAt: number
+}
+
+function isStoredEnvelope(value: unknown): value is StoredEnvelope {
+  if (!value || typeof value !== 'object') return false
+  const v = value as Record<string, unknown>
+  return typeof v.token === 'string' && typeof v.expiresAt === 'number'
+}
+
+export class SecureStoreViewerTokenStore implements ViewerTokenStore {
+  private readonly fallback: ViewerTokenStore
+  private readonly storageKey: string
+
+  constructor(options?: { fallback?: ViewerTokenStore; storageKey?: string }) {
+    this.fallback = options?.fallback ?? new MemoryViewerTokenStore()
+    this.storageKey = options?.storageKey ?? MOVIIE_VIEWER_TOKEN_SECURE_STORE_KEY
+  }
+
+  private async loadSecureStore(): Promise<typeof import('expo-secure-store') | null> {
+    try {
+      return await import('expo-secure-store')
+    } catch {
+      warnOnce('moviie:expo-secure-store-missing', SECURE_STORE_MISSING_WARNING)
+      return null
+    }
+  }
+
+  async get(): Promise<string | null> {
+    const SecureStore = await this.loadSecureStore()
+    if (!SecureStore) {
+      return this.fallback.get()
+    }
+    try {
+      const raw = await SecureStore.getItemAsync(this.storageKey)
+      if (!raw) return null
+      const parsed: unknown = JSON.parse(raw)
+      if (!isStoredEnvelope(parsed)) {
+        await SecureStore.deleteItemAsync(this.storageKey).catch(() => {})
+        return null
+      }
+      if (parsed.expiresAt <= Date.now()) {
+        await SecureStore.deleteItemAsync(this.storageKey).catch(() => {})
+        return null
+      }
+      return parsed.token
+    } catch {
+      return this.fallback.get()
+    }
+  }
+
+  async set(token: string, ttlSec: number): Promise<void> {
+    const SecureStore = await this.loadSecureStore()
+    const envelope: StoredEnvelope = {
+      token,
+      expiresAt: Date.now() + Math.max(0, ttlSec) * 1000,
+    }
+    if (!SecureStore) {
+      await this.fallback.set(token, ttlSec)
+      return
+    }
+    try {
+      await SecureStore.setItemAsync(this.storageKey, JSON.stringify(envelope))
+    } catch {
+      await this.fallback.set(token, ttlSec)
+    }
+  }
+}