@moviie/player-expo 0.4.0

package/src/lib/format-playback-clock.ts

@@ -0,0 +1,27 @@
+function pad2(value: number): string {
+  return String(Math.floor(value)).padStart(2, "0")
+}
+
+function formatSegment(totalSeconds: number): string {
+  if (!Number.isFinite(totalSeconds) || totalSeconds < 0) {
+    return "0:00"
+  }
+  const seconds = totalSeconds % 60
+  const minutes = Math.floor(totalSeconds / 60) % 60
+  const hours = Math.floor(totalSeconds / 3600)
+  if (hours > 0) {
+    return `${hours}:${pad2(minutes)}:${pad2(seconds)}`
+  }
+  return `${Math.floor(minutes)}:${pad2(seconds)}`
+}
+
+export function formatPlaybackClock(
+  currentSeconds: number,
+  durationSeconds: number
+): string {
+  const current = formatSegment(currentSeconds)
+  if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) {
+    return current
+  }
+  return `${current} / ${formatSegment(durationSeconds)}`
+}

package/src/lib/jsx-native-bridge.ts

@@ -0,0 +1,45 @@
+import type { ComponentPropsWithRef, ComponentType, PropsWithChildren } from 'react'
+import { Animated as RNAnimated, View, type ViewProps } from 'react-native'
+import AnimatedReanimated from 'react-native-reanimated'
+import type { AnimateProps } from 'react-native-reanimated'
+import RNSvg, {
+  Defs as RNDefs,
+  LinearGradient as RNLinearGradient,
+  Path as RNPath,
+  Rect as RNRect,
+  Stop as RNStop,
+  Text as RNText,
+} from 'react-native-svg'
+import type {
+  LinearGradientProps,
+  PathProps,
+  RectProps,
+  StopProps,
+  SvgProps,
+  TextProps,
+} from 'react-native-svg'
+
+type RNCoreAnimatedViewProps = RNAnimated.AnimatedProps<ComponentPropsWithRef<typeof View>>
+
+type ReanimatedViewBridgeProps = AnimateProps<ViewProps>
+
+export const Svg = RNSvg as unknown as ComponentType<SvgProps>
+
+export default Svg
+
+export const Path = RNPath as unknown as ComponentType<PathProps>
+
+export const Defs = RNDefs as unknown as ComponentType<PropsWithChildren>
+
+export const LinearGradient = RNLinearGradient as unknown as ComponentType<LinearGradientProps>
+
+export const Rect = RNRect as unknown as ComponentType<RectProps>
+
+export const Stop = RNStop as unknown as ComponentType<StopProps>
+
+export const SvgText = RNText as unknown as ComponentType<TextProps>
+
+export const AnimatedView = RNAnimated.View as unknown as ComponentType<RNCoreAnimatedViewProps>
+
+export const ReanimatedView =
+  AnimatedReanimated.View as unknown as ComponentType<ReanimatedViewBridgeProps>

package/src/lib/map-smart-progress-display-ratio.ts

@@ -0,0 +1,43 @@
+import { MOVIIE_SMART_PROGRESS_CONFIG } from "../constants"
+
+function easeOutQuad(t: number): number {
+  return t * (2 - t)
+}
+
+function easeInQuad(t: number): number {
+  return t * t
+}
+
+/**
+ * Maps real playback progress [0–1] to Smart Progress display [0–P_MAX_BEFORE_END],
+ * mirroring the embed inline script (`mapProgress` in `templates/player.ts`).
+ */
+export function mapSmartProgressRawRatio(realUnitInterval: number): number {
+  const r = Math.min(1, Math.max(0, realUnitInterval))
+  const {
+    R1,
+    P1,
+    R2,
+    P2,
+    P_MAX_BEFORE_END: pMax,
+  } = MOVIIE_SMART_PROGRESS_CONFIG
+
+  if (r <= 0) {
+    return 0
+  }
+  if (r >= 1) {
+    return pMax
+  }
+
+  if (r <= R1) {
+    return P1 * easeOutQuad(r / R1)
+  }
+
+  if (r <= R2) {
+    const t = (r - R1) / (R2 - R1)
+    return P1 + (P2 - P1) * t
+  }
+
+  const t = (r - R2) / (1 - R2)
+  return P2 + (pMax - P2) * easeInQuad(t)
+}

package/src/lib/moviie-cast-adapter.ts

@@ -0,0 +1,53 @@
+/**
+ * Contrato genérico para integração de cast (Chromecast / outras tecnologias futuras).
+ *
+ * **Zero dependências nativas**. O package `@moviie/player-expo` nunca importa
+ * a lib subjacente diretamente — a implementação fica num subpath opcional
+ * (`@moviie/player-expo/cast`) que o consumidor importa só se quiser usar.
+ *
+ * Padrão recomendado: o consumidor cria um adapter via factory do subpath e
+ * passa via prop `castAdapter` em `MoviieVideo`. Se omitido, o player funciona
+ * normalmente sem botão de cast.
+ */
+
+import type React from 'react'
+
+export type MoviieCastState = 'unavailable' | 'disconnected' | 'connecting' | 'connected'
+
+export interface MoviieCastMediaPayload {
+  uri: string
+  title: string
+  posterUrl: string | null
+  durationSeconds: number | null
+  startSeconds: number
+  /** Content type MIME do stream. Default `application/x-mpegURL` (HLS). */
+  contentType?: string
+}
+
+export interface MoviieCastAdapter {
+  /**
+   * True se a lib nativa está disponível (módulo carregado, plataforma suportada).
+   * Quando false, o botão de cast não aparece e o player funciona normalmente.
+   */
+  isAvailable(): boolean
+  /** Estado atual de discovery / conexão. */
+  getState(): MoviieCastState
+  /**
+   * Inscreve-se em mudanças de estado. Retorna função de unsubscribe que deve
+   * ser chamada no cleanup do `useEffect`.
+   */
+  subscribe(callback: (state: MoviieCastState) => void): () => void
+  /** Abre UI nativa de seleção de dispositivo. */
+  showDevicePicker(): Promise<void>
+  /** Carrega mídia no dispositivo conectado. No-op se desconectado. */
+  loadMedia(payload: MoviieCastMediaPayload): Promise<void>
+  /** Encerra sessão ativa de cast. */
+  endSession(): Promise<void>
+  /**
+   * Android only. Renderiza um proxy nativo invisível necessário para que
+   * `showDevicePicker()` funcione no Android (o SDK precisa de um
+   * `MediaRouteButton` montado na árvore de views).
+   * Retorna `null` em iOS / quando não necessário.
+   */
+  renderAndroidProxy?(): React.ReactNode
+}

package/src/lib/moviie-error-display.ts

@@ -0,0 +1,149 @@
+import type { MoviieErrorCode } from "@moviie/player-sdk"
+import {
+  MoviieAuthError,
+  MoviieBundleBlockedError,
+  MoviieNetworkError,
+  MoviieNotFoundError,
+  MoviieRateLimitError,
+  MoviieReferrerBlockedError,
+  MoviieSubscriptionInactiveError,
+} from "@moviie/player-sdk"
+
+import { MOVIIE_DASHBOARD_URL } from "./moviie-shell-tokens"
+
+export type MoviieShellCtaKind = "retry" | "external" | "none"
+
+export interface MoviieShellErrorDisplay {
+  code: MoviieErrorCode
+  numericCode: string
+  heading: string
+  description: string
+  ctaLabel: string | null
+  ctaKind: MoviieShellCtaKind
+  externalUrl: string | null
+}
+
+const ERROR_NUMERIC_CODE: Record<MoviieErrorCode, string> = {
+  auth: "E1001",
+  not_found: "E1002",
+  bundle_blocked: "E1003",
+  referrer_blocked: "E1004",
+  subscription_inactive: "E1005",
+  network: "E2001",
+  rate_limit: "E2002",
+  unknown: "E9999",
+}
+
+function resolveErrorCode(error: Error): MoviieErrorCode {
+  if (error instanceof MoviieAuthError) return "auth"
+  if (error instanceof MoviieNotFoundError) return "not_found"
+  if (error instanceof MoviieBundleBlockedError) return "bundle_blocked"
+  if (error instanceof MoviieReferrerBlockedError) return "referrer_blocked"
+  if (error instanceof MoviieSubscriptionInactiveError) return "subscription_inactive"
+  if (error instanceof MoviieNetworkError) return "network"
+  if (error instanceof MoviieRateLimitError) return "rate_limit"
+  const code = (error as { code?: unknown }).code
+  if (typeof code === "string") {
+    const known: MoviieErrorCode[] = [
+      "auth",
+      "not_found",
+      "bundle_blocked",
+      "referrer_blocked",
+      "subscription_inactive",
+      "network",
+      "rate_limit",
+    ]
+    if ((known as string[]).includes(code)) {
+      return code as MoviieErrorCode
+    }
+  }
+  return "unknown"
+}
+
+export function getErrorDisplay(error: Error): MoviieShellErrorDisplay {
+  const code = resolveErrorCode(error)
+
+  switch (code) {
+    case "auth":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Configuração inválida",
+        description: "Verifique a chave publicável do SDK.",
+        ctaLabel: "Acessar Moviie",
+        ctaKind: "external",
+        externalUrl: MOVIIE_DASHBOARD_URL,
+      }
+    case "not_found":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Reprodução indisponível",
+        description: "Não conseguimos encontrar este vídeo.",
+        ctaLabel: "Acessar Moviie",
+        ctaKind: "external",
+        externalUrl: MOVIIE_DASHBOARD_URL,
+      }
+    case "bundle_blocked":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Aplicativo não autorizado",
+        description: "Este aplicativo não está autorizado a reproduzir este vídeo.",
+        ctaLabel: "Ajustar permissões",
+        ctaKind: "external",
+        externalUrl: MOVIIE_DASHBOARD_URL,
+      }
+    case "referrer_blocked":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Origem não autorizada",
+        description: "Origem não autorizada para reprodução.",
+        ctaLabel: "Acessar Moviie",
+        ctaKind: "external",
+        externalUrl: MOVIIE_DASHBOARD_URL,
+      }
+    case "subscription_inactive":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Reprodução temporariamente indisponível",
+        description: "Acesse a Moviie para continuar assistindo.",
+        ctaLabel: "Ir para a Moviie",
+        ctaKind: "external",
+        externalUrl: MOVIIE_DASHBOARD_URL,
+      }
+    case "network":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Erro de conexão",
+        description: "Verifique sua conexão e tente novamente.",
+        ctaLabel: "Tentar de novo",
+        ctaKind: "retry",
+        externalUrl: null,
+      }
+    case "rate_limit":
+      return {
+        code,
+        numericCode: ERROR_NUMERIC_CODE[code],
+        heading: "Muitas solicitações",
+        description: "Aguarde alguns instantes e tente novamente.",
+        ctaLabel: "Tentar de novo",
+        ctaKind: "retry",
+        externalUrl: null,
+      }
+    case "unknown":
+    default:
+      return {
+        code: "unknown",
+        numericCode: ERROR_NUMERIC_CODE["unknown"],
+        heading: "Erro temporário",
+        description: "Tente novamente em instantes.",
+        ctaLabel: "Tentar de novo",
+        ctaKind: "retry",
+        externalUrl: null,
+      }
+  }
+}

package/src/lib/moviie-shell-tokens.ts

@@ -0,0 +1,27 @@
+export const MOVIIE_SHELL_BACKGROUND_HEX = "#0a0a0a" as const
+export const MOVIIE_SHELL_RADIAL_INNER_HEX = "#1a1a1a" as const
+export const MOVIIE_SHELL_RADIAL_OUTER_HEX = "#000000" as const
+
+export const MOVIIE_SHELL_HEADING_HEX = "#f8fafc" as const
+export const MOVIIE_SHELL_DESCRIPTION_HEX = "#e5e7eb" as const
+export const MOVIIE_SHELL_ERROR_CODE_HEX = "#4b5563" as const
+
+export const MOVIIE_SHELL_BUTTON_BG_HEX = "#0a0a0a" as const
+export const MOVIIE_SHELL_BUTTON_BORDER_RGBA = "rgba(255,255,255,0.15)" as const
+export const MOVIIE_SHELL_BUTTON_LABEL_HEX = "#f8fafc" as const
+
+export const MOVIIE_SHELL_HEADING_FONT_SIZE_PX = 22 as const
+export const MOVIIE_SHELL_DESCRIPTION_FONT_SIZE_PX = 14 as const
+export const MOVIIE_SHELL_BUTTON_LABEL_FONT_SIZE_PX = 14 as const
+
+export const MOVIIE_SHELL_CONTENT_MAX_WIDTH_PX = 280 as const
+
+export const MOVIIE_SHELL_BUTTON_PADDING_H_PX = 22 as const
+export const MOVIIE_SHELL_BUTTON_PADDING_V_PX = 12 as const
+export const MOVIIE_SHELL_BUTTON_RADIUS_PX = 9999 as const
+
+export const MOVIIE_SHELL_CROSSFADE_DURATION_MS = 240 as const
+
+export const MOVIIE_SHELL_DEFAULT_ASPECT_RATIO = 16 / 9
+
+export const MOVIIE_DASHBOARD_URL = "https://app.moviie.ai" as const

package/src/lib/moviie-telemetry-callbacks.ts

@@ -0,0 +1,76 @@
+/**
+ * Hooks opt-in para telemetria do consumer (Sentry, PostHog, Datadog, etc.).
+ *
+ * `@moviie/player-expo` já envia telemetria interna para o backend Moviie via
+ * `TelemetryClient` (impressions, playback duration). Estes callbacks servem
+ * exclusivamente para o consumer também observar eventos em **sua própria**
+ * pipeline de monitoring — não substituem nem ampliam a telemetria interna.
+ *
+ * **Garantias**:
+ * - Callbacks são síncronos e não-bloqueantes: exceções neles são engolidas e
+ *   loggadas via `console.warn` (não derrubam o player).
+ * - Sem PII: eventos só carregam `embedId` público e métricas técnicas.
+ * - Cada evento é entregue at-most-once por ciclo de vida do player.
+ */
+
+export type MoviieTelemetryErrorPhase =
+  /** Falha ao carregar metadata de playback (`useMoviiePlayback`). */
+  | 'playback_fetch'
+  /** Falha durante reprodução (network stall, decode error, DRM, etc.). */
+  | 'playback_runtime'
+  /** Falha capturada pelo `MoviieErrorBoundary` (render/effect throw). */
+  | 'render_boundary'
+
+export interface MoviieTelemetryErrorContext {
+  /** UUID público do embed em causa, se disponível. */
+  embedId?: string
+  /** Categorização da fase onde o erro ocorreu. */
+  phase: MoviieTelemetryErrorPhase
+  /** Código de erro classificado pelo SDK (quando aplicável). */
+  code?: string
+}
+
+export type MoviieTelemetryLifecycleEventName =
+  | 'playback_loaded'
+  | 'playback_started'
+  | 'playback_paused'
+  | 'playback_seeking'
+  | 'playback_ended'
+  | 'fullscreen_enter'
+  | 'fullscreen_exit'
+  | 'pip_enter'
+  | 'pip_exit'
+  | 'cast_session_started'
+  | 'cast_session_ended'
+
+export interface MoviieTelemetryLifecycleEvent {
+  name: MoviieTelemetryLifecycleEventName
+  embedId?: string
+  /** Posição (segundos) no momento do evento, quando relevante. */
+  positionSeconds?: number
+  /** Duração total (segundos) quando conhecida. */
+  durationSeconds?: number
+}
+
+export type MoviieTelemetryOnError = (error: Error, context: MoviieTelemetryErrorContext) => void
+
+export type MoviieTelemetryOnEvent = (event: MoviieTelemetryLifecycleEvent) => void
+
+/**
+ * Helper para invocar callbacks de consumer sem deixar exceções escalar.
+ * Use em vez de chamar `onError` / `onEvent` diretamente do hook/efeito.
+ */
+export function safeInvokeMoviieTelemetry<TArgs extends unknown[]>(
+  callback: ((...args: TArgs) => void) | undefined,
+  ...args: TArgs
+): void {
+  if (callback == null) {
+    return
+  }
+  try {
+    callback(...args)
+  } catch (err) {
+    // eslint-disable-next-line no-console
+    console.warn('[@moviie/player-expo] telemetry callback threw — ignorado', err)
+  }
+}

package/src/lib/optional-status-bar.ts

@@ -0,0 +1,48 @@
+/**
+ * Wrapper opcional para `expo-status-bar`. Quando o módulo não está instalado,
+ * `setStatusBarHidden` vira no-op e um warn é disparado uma única vez por sessão.
+ *
+ * Modo degradado: a status bar fica visível em fullscreen JS (overlay leve por
+ * cima do vídeo). Funcionalidade core do player não é afetada.
+ */
+import { warnOnce } from './warn-once'
+
+type StatusBarAnimation = 'none' | 'fade' | 'slide'
+
+type ExpoStatusBarModule = {
+  setStatusBarHidden: (hidden: boolean, animation?: StatusBarAnimation) => void
+}
+
+let cachedModule: ExpoStatusBarModule | null | undefined
+
+function loadModule(): ExpoStatusBarModule | null {
+  if (cachedModule !== undefined) {
+    return cachedModule
+  }
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    cachedModule = require('expo-status-bar') as ExpoStatusBarModule
+  } catch {
+    cachedModule = null
+    warnOnce(
+      'moviie:expo-status-bar-missing',
+      '[@moviie/player-expo] `expo-status-bar` não está instalado. Status bar não será ocultada em fullscreen JS. ' +
+        'Instala com `pnpm add expo-status-bar` se quiser este comportamento.'
+    )
+  }
+  return cachedModule
+}
+
+export function moviieSetStatusBarHidden(
+  hidden: boolean,
+  animation: StatusBarAnimation = 'fade'
+): void {
+  const mod = loadModule()
+  if (mod == null) return
+  try {
+    mod.setStatusBarHidden(hidden, animation)
+  } catch {
+    // Defensive: se o módulo está carregado mas o método explode, ignora —
+    // status bar não é critical path.
+  }
+}

package/src/lib/partition-moviie-video-host-style.ts

@@ -0,0 +1,54 @@
+import type { ViewStyle } from "react-native"
+
+type LooseViewStyle = Record<string, unknown>
+
+/** Props visuais da área do vídeo — não devem envolver a faixa de progresso abaixo do vídeo. */
+const VIDEO_SURFACE_STYLE_KEYS = new Set([
+  "backgroundColor",
+  "borderRadius",
+  "borderTopLeftRadius",
+  "borderTopRightRadius",
+  "borderBottomLeftRadius",
+  "borderBottomRightRadius",
+  "borderCurve",
+  "borderWidth",
+  "borderColor",
+])
+
+/**
+ * Espera `flatStyle` já planificado com `StyleSheet.flatten` no runtime RN
+ * (resolve IDs devolvidos por `StyleSheet.create`).
+ */
+export function partitionMoviieVideoHostStyle(
+  flatStyle: ViewStyle | undefined | null
+): {
+  columnStyle: ViewStyle | undefined
+  surfaceStyle: ViewStyle | undefined
+} {
+  if (flatStyle == null || Object.keys(flatStyle).length === 0) {
+    return { columnStyle: undefined, surfaceStyle: undefined }
+  }
+
+  const flat = flatStyle as LooseViewStyle
+  const column: LooseViewStyle = {}
+  const surface: LooseViewStyle = {}
+
+  for (const key of Object.keys(flat)) {
+    const value = flat[key]
+    if (value === undefined) {
+      continue
+    }
+    if (VIDEO_SURFACE_STYLE_KEYS.has(key)) {
+      surface[key] = value
+    } else {
+      column[key] = value
+    }
+  }
+
+  return {
+    columnStyle:
+      Object.keys(column).length > 0 ? (column as ViewStyle) : undefined,
+    surfaceStyle:
+      Object.keys(surface).length > 0 ? (surface as ViewStyle) : undefined,
+  }
+}

package/src/lib/remember-playback-position-storage.ts

@@ -0,0 +1,98 @@
+import { MOVIIE_REMEMBER_POSITION_STORAGE_PREFIX } from '../constants'
+import { warnOnce } from './warn-once'
+
+const RESUME_SECURE_STORE_MISSING_WARNING =
+  '[@moviie/player-expo] `expo-secure-store` não está instalado — resume position não será persistido. ' +
+  'Instala com `pnpm add expo-secure-store` se quiseres retomar onde o utilizador parou.'
+
+const SECURE_STORE_KEY_SAFE_PATTERN = /^[A-Za-z0-9._-]+$/
+
+function isSecureStoreSafeEmbedId(embedId: string): boolean {
+  return SECURE_STORE_KEY_SAFE_PATTERN.test(embedId)
+}
+
+export function rememberPlaybackPositionStorageKey(embedId: string): string {
+  return `${MOVIIE_REMEMBER_POSITION_STORAGE_PREFIX}${embedId}`
+}
+
+export function parseStoredResumeSeconds(raw: string | null): number | null {
+  if (raw == null || raw === '') {
+    return null
+  }
+  const n = Number(raw)
+  if (!Number.isFinite(n) || n < 0) {
+    return null
+  }
+  return n
+}
+
+export function clampResumeTimeSeconds(
+  seconds: number | null,
+  durationSeconds: number | null | undefined
+): number | null {
+  if (seconds == null || !Number.isFinite(seconds) || seconds < 0.25) {
+    return null
+  }
+  if (durationSeconds != null && Number.isFinite(durationSeconds) && durationSeconds > 0) {
+    if (seconds >= durationSeconds - 1) {
+      return null
+    }
+    return Math.min(seconds, durationSeconds - 0.25)
+  }
+  return seconds
+}
+
+async function loadSecureStore(): Promise<typeof import('expo-secure-store') | null> {
+  try {
+    return await import('expo-secure-store')
+  } catch {
+    warnOnce('moviie:expo-secure-store-missing-resume', RESUME_SECURE_STORE_MISSING_WARNING)
+    return null
+  }
+}
+
+export async function readStoredResumeSeconds(embedId: string): Promise<number | null> {
+  if (!isSecureStoreSafeEmbedId(embedId)) {
+    return null
+  }
+  const SecureStore = await loadSecureStore()
+  if (!SecureStore) {
+    return null
+  }
+  try {
+    const raw = await SecureStore.getItemAsync(rememberPlaybackPositionStorageKey(embedId))
+    return parseStoredResumeSeconds(raw)
+  } catch {
+    return null
+  }
+}
+
+export async function writeStoredResumeSeconds(embedId: string, seconds: number): Promise<void> {
+  if (!isSecureStoreSafeEmbedId(embedId)) {
+    return
+  }
+  const SecureStore = await loadSecureStore()
+  if (!SecureStore) {
+    return
+  }
+  try {
+    await SecureStore.setItemAsync(rememberPlaybackPositionStorageKey(embedId), String(seconds))
+  } catch {
+    return
+  }
+}
+
+export async function clearStoredResumeSeconds(embedId: string): Promise<void> {
+  if (!isSecureStoreSafeEmbedId(embedId)) {
+    return
+  }
+  const SecureStore = await loadSecureStore()
+  if (!SecureStore) {
+    return
+  }
+  try {
+    await SecureStore.deleteItemAsync(rememberPlaybackPositionStorageKey(embedId))
+  } catch {
+    return
+  }
+}

package/src/lib/resolve-moviie-skin-layout-scale.ts

@@ -0,0 +1,17 @@
+import {
+  MOVIIE_SKIN_LAYOUT_REFERENCE_WIDTH_PT,
+  MOVIIE_SKIN_LAYOUT_SCALE_MAX,
+  MOVIIE_SKIN_LAYOUT_SCALE_MIN,
+} from "../constants"
+
+function clampBetween(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max)
+}
+
+export function resolveMoviieSkinLayoutScale(windowWidth: number): number {
+  if (!Number.isFinite(windowWidth) || windowWidth <= 0) {
+    return 1
+  }
+  const raw = windowWidth / MOVIIE_SKIN_LAYOUT_REFERENCE_WIDTH_PT
+  return clampBetween(raw, MOVIIE_SKIN_LAYOUT_SCALE_MIN, MOVIIE_SKIN_LAYOUT_SCALE_MAX)
+}

package/src/lib/resolve-orientation-lock-for-rotate-z-deg.ts

@@ -0,0 +1,21 @@
+import {
+  MOVIIE_EXPO_SCREEN_ORIENTATION_LOCK_VALUE,
+  type MoviieExpoOrientationLockValue,
+} from "../constants"
+
+/**
+ * Mapeia a rotação Z do palco fullscreen para o valor de `OrientationLock` do `expo-screen-orientation`,
+ * usando {@link MOVIIE_EXPO_SCREEN_ORIENTATION_LOCK_VALUE} (espelho Enum SDK 52).
+ */
+export function resolveOrientationLockValueForRotateZDeg(
+  rotateZDeg: number
+): MoviieExpoOrientationLockValue {
+  const normalized = ((rotateZDeg % 360) + 360) % 360
+  if (normalized === 90) {
+    return MOVIIE_EXPO_SCREEN_ORIENTATION_LOCK_VALUE.LANDSCAPE_RIGHT
+  }
+  if (normalized === 270) {
+    return MOVIIE_EXPO_SCREEN_ORIENTATION_LOCK_VALUE.LANDSCAPE_LEFT
+  }
+  return MOVIIE_EXPO_SCREEN_ORIENTATION_LOCK_VALUE.LANDSCAPE
+}

package/src/lib/resolve-skin-accent-color.ts

@@ -0,0 +1,10 @@
+import { MOVIIE_SKIN_DEFAULT_ACCENT_HEX } from "../constants"
+
+const HEX_COLOR_REGEX = /^#[0-9A-Fa-f]{6}$/
+
+export function resolveSkinAccentColor(primaryColor: string | null): string {
+  if (primaryColor != null && HEX_COLOR_REGEX.test(primaryColor)) {
+    return primaryColor
+  }
+  return MOVIIE_SKIN_DEFAULT_ACCENT_HEX
+}