@moviie/player-expo 0.4.0

package/src/index.ts

@@ -0,0 +1,90 @@
+import './apply-expo-moviie-endpoints'
+export * from '@moviie/player-sdk'
+
+export {
+  MOVIIE_PLAYER_EXPO_PKG_VERSION,
+  MOVIIE_PLAYBACK_MEMORY_CACHE_TTL_MS,
+  MOVIIE_PLAYBACK_PROFILE,
+  MOVIIE_VIDEO_DEFAULT_CONTENT_FIT,
+  MOVIIE_SKIN_CONTROLS_AUTO_HIDE_MS,
+  MOVIIE_SKIN_CONTROL_ICON_PX,
+  MOVIIE_SKIN_DEFAULT_ACCENT_HEX,
+  MOVIIE_SKIN_VOLUME_LOW_ICON_THRESHOLD,
+  MOVIIE_SKIN_TIMELINE_END_SNAP_EPSILON_SECONDS,
+  MOVIIE_REMEMBER_POSITION_DEBOUNCE_MS,
+  MOVIIE_REMEMBER_POSITION_STORAGE_PREFIX,
+  EXPO_PUBLIC_MOVIIE_API_BASE_URL_ENV,
+  EXPO_PUBLIC_MOVIIE_EVENTS_BASE_URL_ENV,
+  MOVIIE_WATCH_ORIGIN_DEFAULT,
+  MOVIIE_WATCH_EMBED_JS_PATH,
+  MOVIIE_PLAYER_EXPO_EMBED_JS_MARKER_ATTR,
+  EXPO_PUBLIC_MOVIIE_WATCH_ORIGIN_ENV,
+} from './constants'
+
+export {
+  MOVIIE_VIEWER_TOKEN_SECURE_STORE_KEY,
+  SecureStoreViewerTokenStore,
+} from './secure-store-viewer-token-store'
+
+export { MoviieProvider, useMoviieContext } from './provider/moviie-provider'
+export type { MoviieContextValue } from './provider/moviie-provider'
+
+export { useMoviiePlayback } from './hooks/use-moviie-playback'
+export type { UseMoviiePlaybackArgs, UseMoviiePlaybackResult } from './hooks/use-moviie-playback'
+
+export { useMoviiePlayer } from './hooks/use-moviie-player'
+export type { UseMoviiePlayerOptions, UseMoviiePlayerResult } from './hooks/use-moviie-player-types'
+
+export {
+  buildMoviieVideoPresentationProps,
+  type MoviieVideoPresentationProps,
+} from './lib/build-moviie-video-presentation'
+
+export { useMoviieEvent } from './hooks/use-moviie-event'
+
+export { useMoviiePlaybackEnded } from './hooks/use-moviie-playback-ended'
+
+export {
+  computeMoviiePlaybackEnded,
+  type MoviiePlaybackEndedUiArgs,
+} from './lib/compute-moviie-playback-ended'
+
+export {
+  addMoviiePlaybackEndedListener,
+  type MoviiePlaybackEndedSubscription,
+} from './lib/add-moviie-playback-ended-listener'
+
+export {
+  buildMoviieWatchEmbedUrl,
+  normalizeWatchOrigin,
+  resolveMoviieWatchOrigin,
+} from './lib/build-moviie-watch-embed-url'
+
+export type {
+  MoviieCastAdapter,
+  MoviieCastMediaPayload,
+  MoviieCastState,
+} from './lib/moviie-cast-adapter'
+
+export { MoviieVideo } from './components/moviie-video'
+export type {
+  MoviieVideoProps,
+  MoviieWatchEmbedIframeHandle,
+  MoviieWatchEmbedIframeRefCallback,
+} from './components/moviie-video-props'
+
+export { MoviieErrorBoundary } from './components/moviie-error-boundary'
+export type { MoviieErrorBoundaryProps } from './components/moviie-error-boundary'
+
+export type {
+  MoviieTelemetryErrorContext,
+  MoviieTelemetryErrorPhase,
+  MoviieTelemetryLifecycleEvent,
+  MoviieTelemetryLifecycleEventName,
+  MoviieTelemetryOnError,
+  MoviieTelemetryOnEvent,
+} from './lib/moviie-telemetry-callbacks'
+
+export type { MoviieVideoSurfaceRef } from './components/controls/moviie-controls'
+
+export { PLAYER_API_EVENTS, PLAYER_API_METHODS, PLAYER_API_PROPERTIES } from '@moviie/player-types'

package/src/layout.ts

@@ -0,0 +1,4 @@
+import "./apply-expo-moviie-endpoints"
+
+export { MoviieProvider, useMoviieContext } from "./provider/moviie-provider"
+export type { MoviieContextValue } from "./provider/moviie-provider"

package/src/lib/add-moviie-playback-ended-listener.ts

@@ -0,0 +1,16 @@
+import type { VideoPlayer } from "expo-video"
+
+export type MoviiePlaybackEndedSubscription = {
+  remove: () => void
+}
+
+/**
+ * Imperative listener for expo-video `playToEnd`. Prefer {@link useMoviiePlaybackEnded} in React components.
+ */
+export function addMoviiePlaybackEndedListener(
+  player: VideoPlayer,
+  onEnded: () => void
+): MoviiePlaybackEndedSubscription {
+  const sub = player.addListener("playToEnd", onEnded)
+  return { remove: () => sub.remove() }
+}

package/src/lib/build-moviie-branding-marketing-url.ts

@@ -0,0 +1,14 @@
+import {
+  MOVIIE_BRANDING_MARKETING_ORIGIN,
+  MOVIIE_BRANDING_UTM_MEDIUM_VALUE,
+  MOVIIE_BRANDING_UTM_PARAM_MEDIUM,
+  MOVIIE_BRANDING_UTM_PARAM_SOURCE,
+  MOVIIE_BRANDING_UTM_SOURCE_VALUE,
+} from "../constants"
+
+export function buildMoviieBrandingMarketingUrl(): string {
+  const url = new URL(MOVIIE_BRANDING_MARKETING_ORIGIN)
+  url.searchParams.set(MOVIIE_BRANDING_UTM_PARAM_SOURCE, MOVIIE_BRANDING_UTM_SOURCE_VALUE)
+  url.searchParams.set(MOVIIE_BRANDING_UTM_PARAM_MEDIUM, MOVIIE_BRANDING_UTM_MEDIUM_VALUE)
+  return url.toString()
+}

package/src/lib/build-moviie-embed-brand-home-url.ts

@@ -0,0 +1,16 @@
+import {
+  MOVIIE_BRANDING_MARKETING_ORIGIN,
+  MOVIIE_BRANDING_UTM_PARAM_CAMPAIGN,
+  MOVIIE_BRANDING_UTM_PARAM_MEDIUM,
+  MOVIIE_BRANDING_UTM_PARAM_SOURCE,
+  MOVIIE_EMBED_BRAND_UTM,
+} from "../constants"
+
+/** Espelha `buildPlayerBrandHomeHref` do embed web (`apps/web/src/app/embed/[id]/utils.ts`). */
+export function buildMoviieEmbedBrandHomeUrl(): string {
+  const url = new URL(`${MOVIIE_BRANDING_MARKETING_ORIGIN}/`)
+  url.searchParams.set(MOVIIE_BRANDING_UTM_PARAM_SOURCE, MOVIIE_EMBED_BRAND_UTM.SOURCE)
+  url.searchParams.set(MOVIIE_BRANDING_UTM_PARAM_MEDIUM, MOVIIE_EMBED_BRAND_UTM.MEDIUM)
+  url.searchParams.set(MOVIIE_BRANDING_UTM_PARAM_CAMPAIGN, MOVIIE_EMBED_BRAND_UTM.CAMPAIGN)
+  return url.toString()
+}

package/src/lib/build-moviie-skin-layout-metrics.ts

@@ -0,0 +1,166 @@
+import {
+  MOVIIE_SKIN_BRAND_MARK_ARTBOARD_HEIGHT_PX,
+  MOVIIE_SKIN_BRAND_MARK_ARTBOARD_WIDTH_PX,
+  MOVIIE_SKIN_BRAND_MARK_TARGET_WIDTH_AT_REFERENCE_PT,
+  MOVIIE_SKIN_BUFFERING_INDICATOR_SLOT_PX,
+  MOVIIE_SKIN_CENTER_CLUSTER_COLUMN_GAP_PX,
+  MOVIIE_SKIN_CENTER_PLAY_ICON_PX,
+  MOVIIE_SKIN_CENTER_PLAY_SCRIM_DIAMETER_AT_REFERENCE_PT,
+  MOVIIE_SKIN_CUSTOM_FULLSCREEN_HUD_EDGE_BOOST_REFERENCE_PT,
+  MOVIIE_SKIN_CHROME_EDGE_GRADIENT_HEIGHT_AT_REFERENCE_PT,
+  MOVIIE_SKIN_CLOCK_TEXT_FONT_SIZE_AT_REFERENCE_PT,
+  MOVIIE_SKIN_CONTROL_ICON_PX,
+  MOVIIE_SKIN_FLOATING_FULLSCREEN_ICON_AT_REFERENCE_PT,
+  MOVIIE_SKIN_FLOATING_FULLSCREEN_SCRIM_DIAMETER_AT_REFERENCE_PT,
+  MOVIIE_SKIN_FLOATING_FULLSCREEN_TOP_ICON_AT_REFERENCE_PT,
+  MOVIIE_SKIN_FLOATING_HUD_BUTTON_GAP_AT_REFERENCE_PT,
+  MOVIIE_SKIN_FLOATING_HUD_CLOCK_CORNER_RADIUS_PX,
+  MOVIIE_SKIN_FLOATING_HUD_EDGE_INSET_PX,
+  MOVIIE_SKIN_FLOATING_HUD_ABOVE_TIMELINE_GAP_AT_REFERENCE_PT,
+  MOVIIE_SKIN_SEEK_ICON_PX,
+  MOVIIE_SKIN_CENTER_SEEK_SCRIM_DIAMETER_AT_REFERENCE_PT,
+  MOVIIE_SKIN_TIMELINE_BAR_HEIGHT_PX,
+  MOVIIE_SKIN_TIMELINE_THUMB_DIAMETER_PX,
+  MOVIIE_SKIN_TIMELINE_TOUCH_PADDING_VERTICAL_PX,
+} from '../constants'
+
+import { resolveMoviieSkinLayoutScale } from './resolve-moviie-skin-layout-scale'
+
+/**
+ * Métricas em unidades lógicas (o mesmo tipo de número que `StyleSheet`: dp/pt por plataforma).
+ * O React Native já aplica a densidade do ecrã — evitar arredondamento manual com PixelRatio aqui.
+ * O único escalonamento extra é {@link resolveMoviieSkinLayoutScale} pela largura da janela (layout responsivo).
+ */
+export type MoviieSkinLayoutMetrics = {
+  readonly layoutScale: number
+  readonly brandMarkWidthPx: number
+  readonly brandMarkHeightPx: number
+  readonly hudEdgeInsetPx: number
+  readonly floatingHudAboveTimelineGapPx: number
+  readonly hudClockCornerRadiusPx: number
+  readonly controlIconPx: number
+  readonly seekIconPx: number
+  readonly seekScrimOuterDiameterPx: number
+  readonly centerPlayIconPx: number
+  readonly centerClusterColumnGapPx: number
+  readonly playScrimOuterDiameterPx: number
+  readonly clockTextFontSizePx: number
+  readonly timelineThumbDiameterPx: number
+  readonly timelineTouchPaddingVerticalPx: number
+  readonly timelineBarHeightPx: number
+  readonly timelineThumbBottomInsetPx: number
+  readonly timelineStackHeightChromeVisiblePx: number
+  readonly bufferingIndicatorSlotPx: number
+  readonly chromeEdgeGradientHeightPx: number
+  readonly floatingHudFullscreenScrimDiameterPx: number
+  readonly floatingHudFullscreenIconPx: number
+  readonly floatingHudFullscreenTopIconPx: number
+  readonly floatingHudButtonGapPx: number
+}
+
+function scaleSkinLayoutDp(layoutScale: number, baseAtReference: number): number {
+  return baseAtReference * layoutScale
+}
+
+export type BuildMoviieSkinLayoutMetricsOptions = {
+  /** Fullscreen JS rotacionado: inset extra no HUD/timeline para não encostar à zona segura. */
+  fullscreenHudProtection?: boolean
+}
+
+export function buildMoviieSkinLayoutMetrics(
+  windowWidth: number,
+  options?: BuildMoviieSkinLayoutMetricsOptions
+): MoviieSkinLayoutMetrics {
+  const layoutScale = resolveMoviieSkinLayoutScale(windowWidth)
+
+  const brandMarkWidthPx = scaleSkinLayoutDp(
+    layoutScale,
+    MOVIIE_SKIN_BRAND_MARK_TARGET_WIDTH_AT_REFERENCE_PT
+  )
+  const brandMarkHeightPx =
+    brandMarkWidthPx *
+    (MOVIIE_SKIN_BRAND_MARK_ARTBOARD_HEIGHT_PX / MOVIIE_SKIN_BRAND_MARK_ARTBOARD_WIDTH_PX)
+
+  const timelineThumbDiameterPx = scaleSkinLayoutDp(
+    layoutScale,
+    MOVIIE_SKIN_TIMELINE_THUMB_DIAMETER_PX
+  )
+  const timelineBarHeightPx = scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_TIMELINE_BAR_HEIGHT_PX)
+  const timelineThumbBottomInsetPx = timelineBarHeightPx / 2 - timelineThumbDiameterPx / 2
+
+  const timelineTouchPaddingVerticalPx = scaleSkinLayoutDp(
+    layoutScale,
+    MOVIIE_SKIN_TIMELINE_TOUCH_PADDING_VERTICAL_PX
+  )
+
+  const fullscreenHudBoostPx =
+    options?.fullscreenHudProtection === true
+      ? scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_CUSTOM_FULLSCREEN_HUD_EDGE_BOOST_REFERENCE_PT)
+      : 0
+
+  const hudEdgeInsetPx =
+    scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_FLOATING_HUD_EDGE_INSET_PX) + fullscreenHudBoostPx
+
+  return {
+    layoutScale,
+    brandMarkWidthPx,
+    brandMarkHeightPx,
+    hudEdgeInsetPx,
+    floatingHudAboveTimelineGapPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_HUD_ABOVE_TIMELINE_GAP_AT_REFERENCE_PT
+    ),
+    hudClockCornerRadiusPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_HUD_CLOCK_CORNER_RADIUS_PX
+    ),
+    controlIconPx: scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_CONTROL_ICON_PX),
+    seekIconPx: scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_SEEK_ICON_PX),
+    seekScrimOuterDiameterPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_CENTER_SEEK_SCRIM_DIAMETER_AT_REFERENCE_PT
+    ),
+    centerPlayIconPx: scaleSkinLayoutDp(layoutScale, MOVIIE_SKIN_CENTER_PLAY_ICON_PX),
+    centerClusterColumnGapPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_CENTER_CLUSTER_COLUMN_GAP_PX
+    ),
+    playScrimOuterDiameterPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_CENTER_PLAY_SCRIM_DIAMETER_AT_REFERENCE_PT
+    ),
+    clockTextFontSizePx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_CLOCK_TEXT_FONT_SIZE_AT_REFERENCE_PT
+    ),
+    timelineThumbDiameterPx,
+    timelineTouchPaddingVerticalPx,
+    timelineBarHeightPx,
+    timelineThumbBottomInsetPx,
+    timelineStackHeightChromeVisiblePx: timelineTouchPaddingVerticalPx + timelineThumbDiameterPx,
+    bufferingIndicatorSlotPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_BUFFERING_INDICATOR_SLOT_PX
+    ),
+    chromeEdgeGradientHeightPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_CHROME_EDGE_GRADIENT_HEIGHT_AT_REFERENCE_PT
+    ),
+    floatingHudFullscreenScrimDiameterPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_FULLSCREEN_SCRIM_DIAMETER_AT_REFERENCE_PT
+    ),
+    floatingHudFullscreenIconPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_FULLSCREEN_ICON_AT_REFERENCE_PT
+    ),
+    floatingHudFullscreenTopIconPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_FULLSCREEN_TOP_ICON_AT_REFERENCE_PT
+    ),
+    floatingHudButtonGapPx: scaleSkinLayoutDp(
+      layoutScale,
+      MOVIIE_SKIN_FLOATING_HUD_BUTTON_GAP_AT_REFERENCE_PT
+    ),
+  }
+}

package/src/lib/build-moviie-video-presentation.ts

@@ -0,0 +1,42 @@
+import { MOVIIE_PLAYBACK_PROFILE } from "../constants"
+
+export type MoviieVideoPresentationProps = {
+  allowsPictureInPicture: boolean
+  startsPictureInPictureAutomatically: boolean
+  requiresLinearPlayback: boolean
+}
+
+export interface BuildMoviieVideoPresentationArgs {
+  profile: string
+  showPip: boolean
+  /**
+   * Integrator override: when set, replaces embed `showPip` for `allowsPictureInPicture`.
+   * When omitted, `showPip` is used.
+   */
+  pictureInPicture?: boolean
+  /**
+   * Integrator override for `startsPictureInPictureAutomatically`.
+   * When omitted, defaults to `false` (no embed field today).
+   */
+  pictureInPictureAutoStart?: boolean
+}
+
+/**
+ * Maps embed playback flags onto `VideoView` presentation props.
+ * Optional fields let integrators override embed defaults explicitly; omit them to follow the API.
+ */
+export function buildMoviieVideoPresentationProps(
+  args: BuildMoviieVideoPresentationArgs
+): MoviieVideoPresentationProps {
+  const allowsPictureInPicture =
+    args.pictureInPicture !== undefined
+      ? args.pictureInPicture
+      : args.showPip
+
+  return {
+    allowsPictureInPicture,
+    startsPictureInPictureAutomatically:
+      args.pictureInPictureAutoStart ?? false,
+    requiresLinearPlayback: args.profile === MOVIIE_PLAYBACK_PROFILE.VSL,
+  }
+}

package/src/lib/build-moviie-watch-embed-url.ts

@@ -0,0 +1,30 @@
+import { MOVIIE_WATCH_ORIGIN_DEFAULT } from "../constants"
+
+export function normalizeWatchOrigin(origin: string): string {
+  return origin.trim().replace(/\/+$/, "")
+}
+
+export function buildMoviieWatchEmbedUrl(embedId: string, watchOrigin: string): string {
+  const base = normalizeWatchOrigin(watchOrigin)
+  const id = embedId.trim()
+  return `${base}/embed/${encodeURIComponent(id)}`
+}
+
+/**
+ * Resolve o origin público da página watch/embed.
+ * Usa `process.env.EXPO_PUBLIC_MOVIIE_WATCH_ORIGIN` quando definido (nome documentado como `EXPO_PUBLIC_MOVIIE_WATCH_ORIGIN_ENV` em `@moviie/player-expo`).
+ */
+export function resolveMoviieWatchOrigin(): string {
+  try {
+    const raw =
+      typeof process !== "undefined"
+        ? process.env.EXPO_PUBLIC_MOVIIE_WATCH_ORIGIN?.trim()
+        : undefined
+    if (raw) {
+      return normalizeWatchOrigin(raw)
+    }
+  } catch {
+    /* ignore */
+  }
+  return MOVIIE_WATCH_ORIGIN_DEFAULT
+}

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

@@ -0,0 +1,13 @@
+import type { MoviieCastAdapter } from './moviie-cast-adapter'
+
+let _registered: MoviieCastAdapter | null = null
+
+/** Called automatically when `@moviie/player-expo/cast` is imported. */
+export function _registerCastAdapter(adapter: MoviieCastAdapter): void {
+  _registered = adapter
+}
+
+/** Returns the auto-registered adapter, or null if cast subpath was never imported. */
+export function getRegisteredCastAdapter(): MoviieCastAdapter | null {
+  return _registered
+}

package/src/lib/clamp-unit-interval.ts

@@ -0,0 +1,3 @@
+export function clampUnitInterval(value: number): number {
+  return Math.min(1, Math.max(0, value))
+}

package/src/lib/compute-custom-fullscreen-stage-dimensions.ts

@@ -0,0 +1,39 @@
+import type { EdgeInsets } from "react-native-safe-area-context"
+
+export type CustomFullscreenStageDimensions = {
+  longSide: number
+  shortSide: number
+  layoutMetricsBasisWidth: number
+}
+
+export function computeCustomFullscreenStageDimensions(args: {
+  windowWidth: number
+  windowHeight: number
+  safeInsets: EdgeInsets
+  stageOverscanPx: number
+}): CustomFullscreenStageDimensions {
+  const pad = args.stageOverscanPx
+  const usableW = Math.max(
+    0,
+    args.windowWidth -
+      args.safeInsets.left -
+      args.safeInsets.right -
+      2 * pad
+  )
+  const usableH = Math.max(
+    0,
+    args.windowHeight -
+      args.safeInsets.top -
+      args.safeInsets.bottom -
+      2 * pad
+  )
+
+  const longSide = Math.max(usableW, usableH)
+  const shortSide = Math.min(usableW, usableH)
+
+  return {
+    longSide,
+    shortSide,
+    layoutMetricsBasisWidth: longSide,
+  }
+}

package/src/lib/compute-moviie-playback-ended.ts

@@ -0,0 +1,31 @@
+import { MOVIIE_SKIN_TIMELINE_END_SNAP_EPSILON_SECONDS } from "../constants"
+
+export type MoviiePlaybackEndedUiArgs = {
+  playing: boolean
+  currentTime: number
+  duration: number
+  isLive: boolean
+  loop: boolean
+}
+
+export function computeMoviiePlaybackEnded(args: MoviiePlaybackEndedUiArgs): boolean {
+  if (args.loop) {
+    return false
+  }
+  if (args.isLive) {
+    return false
+  }
+  if (args.playing) {
+    return false
+  }
+  if (!Number.isFinite(args.duration) || args.duration <= 0) {
+    return false
+  }
+  if (!Number.isFinite(args.currentTime)) {
+    return false
+  }
+  return (
+    args.currentTime >=
+    args.duration - MOVIIE_SKIN_TIMELINE_END_SNAP_EPSILON_SECONDS
+  )
+}

package/src/lib/compute-playback-buffering.ts

@@ -0,0 +1,41 @@
+import { MOVIIE_SKIN_BUFFER_UNDERRUN_LEAD_SECONDS } from "../constants"
+import { computeMoviiePlaybackEnded } from "./compute-moviie-playback-ended"
+
+const PLAYER_STATUS_LOADING = "loading" as const
+
+export function computePlaybackBuffering(state: {
+  bufferedPosition: number
+  currentTime: number
+  duration: number
+  playing: boolean
+  status: string
+  isLive: boolean
+  loop: boolean
+}): boolean {
+  if (
+    computeMoviiePlaybackEnded({
+      playing: state.playing,
+      currentTime: state.currentTime,
+      duration: state.duration,
+      isLive: state.isLive,
+      loop: state.loop,
+    })
+  ) {
+    return false
+  }
+  if (state.status === PLAYER_STATUS_LOADING) {
+    return true
+  }
+  if (
+    state.playing &&
+    Number.isFinite(state.duration) &&
+    state.duration > 0 &&
+    state.bufferedPosition >= 0 &&
+    state.currentTime > 0.08 &&
+    state.bufferedPosition <
+      state.currentTime + MOVIIE_SKIN_BUFFER_UNDERRUN_LEAD_SECONDS
+  ) {
+    return true
+  }
+  return false
+}

package/src/lib/compute-playback-progress-ratio.ts

@@ -0,0 +1,33 @@
+import { MOVIIE_SKIN_TIMELINE_END_SNAP_EPSILON_SECONDS } from "../constants"
+
+import { clampUnitInterval } from "./clamp-unit-interval"
+
+export function computePlaybackProgressRatio(state: {
+  durationOk: boolean
+  currentTime: number
+  duration: number
+  playing: boolean
+}): number {
+  if (
+    !state.durationOk ||
+    !Number.isFinite(state.currentTime) ||
+    !Number.isFinite(state.duration) ||
+    state.duration <= 0
+  ) {
+    return 0
+  }
+
+  const raw = state.currentTime / state.duration
+  if (raw >= 1) {
+    return 1
+  }
+
+  const snapToEndWhilePaused =
+    !state.playing &&
+    state.currentTime >=
+      state.duration - MOVIIE_SKIN_TIMELINE_END_SNAP_EPSILON_SECONDS
+
+  const ratio = snapToEndWhilePaused ? 1 : raw
+
+  return clampUnitInterval(ratio)
+}

package/src/lib/compute-timeline-scrub-commit-time.ts

@@ -0,0 +1,40 @@
+import { MOVIIE_SKIN_TIMELINE_CHAPTER_SNAP_THRESHOLD_SECONDS } from "../constants"
+
+export type TimelineChapterBoundary = {
+  readonly startTimeSeconds: number
+}
+
+/**
+ * Converte um `ratio` [0–1] de scrub em segundos absolutos, com snap automático
+ * ao boundary de capítulo mais próximo dentro do threshold configurado.
+ */
+export function computeTimelineScrubCommitTime(params: {
+  ratio: number
+  durationSeconds: number
+  chapters: ReadonlyArray<TimelineChapterBoundary>
+  snapThresholdSeconds?: number
+}): number {
+  const {
+    ratio,
+    durationSeconds,
+    chapters,
+    snapThresholdSeconds = MOVIIE_SKIN_TIMELINE_CHAPTER_SNAP_THRESHOLD_SECONDS,
+  } = params
+
+  const rawTime = ratio * durationSeconds
+
+  let nearest: number | null = null
+  let nearestDist = Infinity
+
+  for (const chapter of chapters) {
+    const dist = Math.abs(chapter.startTimeSeconds - rawTime)
+    if (dist < nearestDist) {
+      nearestDist = dist
+      nearest = chapter.startTimeSeconds
+    }
+  }
+
+  return nearest !== null && nearestDist <= snapThresholdSeconds
+    ? nearest
+    : rawTime
+}

package/src/lib/custom-fullscreen-native-orientation.ts

@@ -0,0 +1,88 @@
+import {
+  OrientationLock,
+  getOrientationLockAsync,
+  lockAsync,
+  unlockAsync,
+} from "expo-screen-orientation"
+import { Platform } from "react-native"
+
+import type { MoviieExpoOrientationLockValue } from "../constants"
+
+async function restoreOrientationLockPolicy(
+  previousLock: OrientationLock | undefined
+): Promise<void> {
+  try {
+    if (
+      previousLock === undefined ||
+      previousLock === OrientationLock.DEFAULT ||
+      previousLock === OrientationLock.UNKNOWN
+    ) {
+      await unlockAsync()
+      return
+    }
+    await lockAsync(previousLock)
+  } catch {
+    try {
+      await unlockAsync()
+    } catch {
+      // noop
+    }
+  }
+}
+
+export type CustomFullscreenNativeOrientationSubscription = {
+  finish: () => Promise<void>
+}
+
+export function subscribeCustomFullscreenNativeOrientation(
+  targetLock: MoviieExpoOrientationLockValue
+): CustomFullscreenNativeOrientationSubscription {
+  if (Platform.OS === "web") {
+    return { finish: async () => {} }
+  }
+
+  let cancelled = false
+  let locked = false
+  let previousLock: OrientationLock | undefined
+
+  const setup = (async () => {
+    try {
+      previousLock = await getOrientationLockAsync()
+      if (cancelled) {
+        return
+      }
+
+      await lockAsync(targetLock as OrientationLock)
+      if (cancelled) {
+        await restoreOrientationLockPolicy(previousLock)
+        return
+      }
+
+      locked = true
+    } catch {
+      // noop
+    }
+  })()
+
+  let finishPromise: Promise<void> | null = null
+
+  return {
+    finish: () => {
+      if (finishPromise != null) {
+        return finishPromise
+      }
+
+      cancelled = true
+
+      finishPromise = (async () => {
+        await setup
+        if (locked) {
+          locked = false
+          await restoreOrientationLockPolicy(previousLock)
+        }
+      })()
+
+      return finishPromise
+    },
+  }
+}