@mux/mux-react-native-player 0.1.0

package/build/MuxVideoPlayer.d.ts

@@ -0,0 +1,59 @@
+import type { MuxNativeViewRef, MuxPlayerStatus, MuxPlaybackStatus, MuxSourceErrorEvent, MuxSourceLoadEvent, MuxStatusChangeEvent, MuxTimeUpdateEvent, MuxVideoSource, NormalizedMuxVideoSource } from './types';
+type Listener = () => void;
+export type MuxVideoPlayerSnapshot = {
+    source?: NormalizedMuxVideoSource;
+    shouldPlay: boolean;
+    muted: boolean;
+    volume: number;
+    loop: boolean;
+    playbackRate: number;
+    status: MuxPlayerStatus;
+};
+export declare class MuxVideoPlayer {
+    private source?;
+    private nativeRef?;
+    private listeners;
+    private pendingCommands;
+    private statusState;
+    private snapshot;
+    private shouldPlay;
+    private resumeAt;
+    muted: boolean;
+    volume: number;
+    loop: boolean;
+    playbackRate: number;
+    constructor(source?: MuxVideoSource);
+    get status(): MuxPlaybackStatus;
+    get currentTime(): number;
+    get duration(): number;
+    get bufferedPosition(): number;
+    get error(): string | undefined;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    replay(): Promise<void>;
+    seekBy(seconds: number): Promise<void>;
+    seekTo(seconds: number): Promise<void>;
+    setMuted(muted: boolean): Promise<void>;
+    setVolume(volume: number): Promise<void>;
+    setLoop(loop: boolean): Promise<void>;
+    setPlaybackRate(rate: number): Promise<void>;
+    setCaptionTrack(trackId: string | null): Promise<void>;
+    preload(): Promise<void>;
+    replace(source: MuxVideoSource): void;
+    release(): Promise<void>;
+    _attachNativeRef(ref: MuxNativeViewRef | null): void;
+    _subscribe: (listener: Listener) => (() => void);
+    _getSnapshot: () => MuxVideoPlayerSnapshot;
+    _handleStatusChange(event: MuxStatusChangeEvent): void;
+    _handleTimeUpdate(event: MuxTimeUpdateEvent): void;
+    _handleSourceLoad(event: MuxSourceLoadEvent): void;
+    _markResumePoint(): void;
+    _handleSourceError(event: MuxSourceErrorEvent): void;
+    private runNativeCommand;
+    private emitChange;
+    private createSnapshot;
+    private updateSnapshot;
+}
+export declare function createMuxVideoPlayer(source?: MuxVideoSource): MuxVideoPlayer;
+export {};
+//# sourceMappingURL=MuxVideoPlayer.d.ts.map

package/build/MuxVideoPlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MuxVideoPlayer.d.ts","sourceRoot":"","sources":["../src/MuxVideoPlayer.ts"],"names":[],"mappings":"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"}

package/build/MuxVideoPlayer.js

@@ -0,0 +1,265 @@
+import { normalizeMuxVideoSource } from './normalizeSource';
+const idleStatus = {
+    status: 'idle',
+    currentTime: 0,
+    duration: 0,
+    bufferedPosition: 0,
+    muted: false,
+    volume: 1,
+    loop: false,
+    playbackRate: 1,
+    captionTracks: [],
+    selectedCaptionTrackId: null,
+};
+export class MuxVideoPlayer {
+    source;
+    nativeRef;
+    listeners = new Set();
+    pendingCommands = [];
+    statusState = { ...idleStatus };
+    snapshot = this.createSnapshot();
+    shouldPlay = false;
+    resumeAt = null;
+    muted = false;
+    volume = 1;
+    loop = false;
+    playbackRate = 1;
+    constructor(source) {
+        if (source != null) {
+            this.source = normalizeMuxVideoSource(source);
+            this.statusState = { ...this.statusState, status: 'loading' };
+            this.updateSnapshot();
+        }
+    }
+    get status() {
+        return this.statusState.status;
+    }
+    get currentTime() {
+        return this.statusState.currentTime;
+    }
+    get duration() {
+        return this.statusState.duration;
+    }
+    get bufferedPosition() {
+        return this.statusState.bufferedPosition;
+    }
+    get error() {
+        return this.statusState.error;
+    }
+    play() {
+        this.shouldPlay = true;
+        this.updateSnapshot();
+        this.emitChange();
+        return this.runNativeCommand('play');
+    }
+    pause() {
+        this.shouldPlay = false;
+        this.updateSnapshot();
+        this.emitChange();
+        return this.runNativeCommand('pause');
+    }
+    replay() {
+        this.shouldPlay = true;
+        this.updateSnapshot();
+        this.emitChange();
+        return this.runNativeCommand('replay');
+    }
+    seekBy(seconds) {
+        return this.runNativeCommand('seekBy', seconds);
+    }
+    seekTo(seconds) {
+        return this.runNativeCommand('seekTo', seconds);
+    }
+    setMuted(muted) {
+        this.muted = muted;
+        this.updateSnapshot();
+        this.emitChange();
+        return this.runNativeCommand('setMuted', muted);
+    }
+    setVolume(volume) {
+        this.volume = clamp(volume, 0, 1);
+        this.updateSnapshot();
+        this.emitChange();
+        return this.runNativeCommand('setVolume', this.volume);
+    }
+    setLoop(loop) {
+        this.loop = loop;
+        this.updateSnapshot();
+        this.emitChange();
+        return this.runNativeCommand('setLoop', loop);
+    }
+    setPlaybackRate(rate) {
+        this.playbackRate = clamp(rate, 0.25, 4);
+        this.updateSnapshot();
+        this.emitChange();
+        return this.runNativeCommand('setPlaybackRate', this.playbackRate);
+    }
+    setCaptionTrack(trackId) {
+        this.statusState = {
+            ...this.statusState,
+            selectedCaptionTrackId: trackId,
+        };
+        this.updateSnapshot();
+        this.emitChange();
+        return this.runNativeCommand('setCaptionTrack', trackId);
+    }
+    preload() {
+        return this.runNativeCommand('preload');
+    }
+    replace(source) {
+        this.source = normalizeMuxVideoSource(source);
+        this.resumeAt = null;
+        this.statusState = { ...idleStatus, muted: this.muted, volume: this.volume, loop: this.loop, playbackRate: this.playbackRate, status: 'loading' };
+        this.updateSnapshot();
+        this.emitChange();
+    }
+    release() {
+        this.shouldPlay = false;
+        this.source = undefined;
+        this.resumeAt = null;
+        this.statusState = { ...idleStatus };
+        this.updateSnapshot();
+        this.emitChange();
+        return this.runNativeCommand('release');
+    }
+    _attachNativeRef(ref) {
+        this.nativeRef = ref;
+        if (!ref || this.pendingCommands.length === 0) {
+            return;
+        }
+        const pending = this.pendingCommands.splice(0);
+        for (const command of pending) {
+            command().catch(() => {
+                // The caller already received a resolved promise while the command was queued.
+            });
+        }
+    }
+    _subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    };
+    _getSnapshot = () => this.snapshot;
+    _handleStatusChange(event) {
+        this.statusState = {
+            ...event,
+            captionTracks: event.captionTracks ?? this.statusState.captionTracks ?? [],
+            selectedCaptionTrackId: normalizeCaptionTrackId(event.selectedCaptionTrackId, this.statusState.selectedCaptionTrackId ?? null),
+        };
+        if (this.statusState.status === 'playing') {
+            this.shouldPlay = true;
+        }
+        else if (this.statusState.status === 'ended' || this.statusState.status === 'idle' || this.statusState.status === 'error') {
+            this.shouldPlay = false;
+        }
+        this.muted = this.statusState.muted;
+        this.volume = this.statusState.volume;
+        this.loop = this.statusState.loop;
+        this.playbackRate = this.statusState.playbackRate;
+        this.updateSnapshot();
+        this.emitChange();
+    }
+    _handleTimeUpdate(event) {
+        this.statusState = {
+            ...this.statusState,
+            currentTime: event.currentTime,
+            duration: event.duration,
+            bufferedPosition: event.bufferedPosition,
+        };
+        this.updateSnapshot();
+        this.emitChange();
+    }
+    _handleSourceLoad(event) {
+        const resumeAt = this.resumeAt;
+        this.resumeAt = null;
+        this.statusState = {
+            ...this.statusState,
+            status: this.statusState.status === 'loading' ? 'ready' : this.statusState.status,
+            duration: event.duration,
+            captionTracks: event.captionTracks ?? this.statusState.captionTracks ?? [],
+            selectedCaptionTrackId: normalizeCaptionTrackId(event.selectedCaptionTrackId, this.statusState.selectedCaptionTrackId ?? null),
+            error: undefined,
+        };
+        this.updateSnapshot();
+        this.emitChange();
+        if (resumeAt !== null && resumeAt > 0.5 && resumeAt < event.duration - 0.5) {
+            this.runNativeCommand('seekTo', resumeAt).catch(() => {
+                // Resume seek is best-effort; user can scrub if it fails.
+            });
+        }
+        if (this.shouldPlay) {
+            this.runNativeCommand('play').catch(() => {
+                // Source load means the command is retryable through a later user action.
+            });
+        }
+    }
+    _markResumePoint() {
+        if (this.statusState.currentTime > 0) {
+            this.resumeAt = this.statusState.currentTime;
+        }
+    }
+    _handleSourceError(event) {
+        this.statusState = {
+            ...this.statusState,
+            status: 'error',
+            error: event.message,
+        };
+        this.updateSnapshot();
+        this.emitChange();
+    }
+    runNativeCommand(command, value) {
+        const call = () => {
+            const ref = this.nativeRef;
+            if (!ref) {
+                return Promise.resolve();
+            }
+            if (typeof ref[command] !== 'function') {
+                return Promise.resolve();
+            }
+            if (value === undefined) {
+                return ref[command].call(ref);
+            }
+            return ref[command].call(ref, value);
+        };
+        if (!this.nativeRef) {
+            this.pendingCommands.push(call);
+            return Promise.resolve();
+        }
+        return call();
+    }
+    emitChange() {
+        for (const listener of this.listeners) {
+            listener();
+        }
+    }
+    createSnapshot() {
+        return {
+            source: this.source,
+            shouldPlay: this.shouldPlay,
+            muted: this.muted,
+            volume: this.volume,
+            loop: this.loop,
+            playbackRate: this.playbackRate,
+            status: this.statusState,
+        };
+    }
+    updateSnapshot() {
+        this.snapshot = this.createSnapshot();
+    }
+}
+export function createMuxVideoPlayer(source) {
+    return new MuxVideoPlayer(source);
+}
+function clamp(value, min, max) {
+    if (!Number.isFinite(value)) {
+        return min;
+    }
+    return Math.min(max, Math.max(min, value));
+}
+function normalizeCaptionTrackId(trackId, fallback) {
+    if (trackId === undefined) {
+        return fallback;
+    }
+    return trackId === '' ? null : trackId;
+}

package/build/MuxVideoView.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import { MuxVideoPlayer } from './MuxVideoPlayer';
+import type { MuxVideoSource } from './types';
+export type MuxVideoViewRef = {
+    play: () => Promise<void>;
+    pause: () => Promise<void>;
+    replay: () => Promise<void>;
+    seekBy: (seconds: number) => Promise<void>;
+    seekTo: (seconds: number) => Promise<void>;
+    setMuted: (muted: boolean) => Promise<void>;
+    setVolume: (volume: number) => Promise<void>;
+    setLoop: (loop: boolean) => Promise<void>;
+    setPlaybackRate: (rate: number) => Promise<void>;
+    setCaptionTrack: (trackId: string | null) => Promise<void>;
+    preload: () => Promise<void>;
+    release: () => Promise<void>;
+    enterFullscreen: () => void;
+    exitFullscreen: () => void;
+};
+export declare const MuxVideoView: React.ForwardRefExoticComponent<import("react-native").ViewProps & {
+    player: import("./MuxVideoPlayer").MuxVideoPlayer;
+    controls?: import("./types").MuxVideoControls;
+    controlsTheme?: import("./types").MuxVideoControlsTheme;
+    robots?: import("./types").MuxVideoRobotsConfig;
+    nativeControls?: boolean;
+    contentFit?: import("./types").MuxContentFit;
+    allowsFullscreen?: boolean;
+    allowsPictureInPicture?: boolean;
+    timeUpdateEventInterval?: number;
+    startupBufferDuration?: number;
+    onStatusChange?: (event: import("./types").MuxStatusChangeEvent) => void;
+    onPlayingChange?: (event: import("./types").MuxPlayingChangeEvent) => void;
+    onTimeUpdate?: (event: import("./types").MuxTimeUpdateEvent) => void;
+    onSourceLoad?: (event: import("./types").MuxSourceLoadEvent) => void;
+    onSourceError?: (event: import("./types").MuxSourceErrorEvent) => void;
+    onFullscreenChange?: (isFullscreen: boolean) => void;
+} & React.RefAttributes<MuxVideoViewRef>>;
+export declare function useMuxVideoPlayer(source?: MuxVideoSource, setup?: (player: MuxVideoPlayer) => void): MuxVideoPlayer;
+//# sourceMappingURL=MuxVideoView.d.ts.map

package/build/MuxVideoView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MuxVideoView.d.ts","sourceRoot":"","sources":["../src/MuxVideoView.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAOlD,OAAO,KAAK,EAIV,cAAc,EAGf,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;yCA+TxB,CAAC;AAIF,wBAAgB,iBAAiB,CAC/B,MAAM,CAAC,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,GACvC,cAAc,CA8BhB"}

package/build/MuxVideoView.js

@@ -0,0 +1,254 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import * as React from 'react';
+import { Dimensions, Modal, Platform, StyleSheet, View } from 'react-native';
+const IOS_LANDSCAPE_SAFE_INSET = 50;
+import { MuxVideoPlayer } from './MuxVideoPlayer';
+import { MuxVideoControls } from './MuxVideoControls';
+import NativeMuxVideoView from './NativeMuxVideoView';
+import { lockOrientationLandscape, unlockOrientation, } from './screenOrientation';
+export const MuxVideoView = React.forwardRef(({ player, controls, controlsTheme, robots, nativeControls = true, contentFit = 'contain', allowsFullscreen = true, allowsPictureInPicture = false, timeUpdateEventInterval = 0.5, startupBufferDuration, onStatusChange, onPlayingChange, onTimeUpdate, onSourceLoad, onSourceError, onFullscreenChange, ...viewProps }, ref) => {
+    const nativeRef = React.useRef(null);
+    const [fullscreen, setFullscreen] = React.useState(false);
+    const [fullscreenReady, setFullscreenReady] = React.useState(false);
+    const enteredViaRotationRef = React.useRef(false);
+    const suppressRotationEntryRef = React.useRef(false);
+    const pendingExitRef = React.useRef(false);
+    const [generatedSummary, setGeneratedSummary] = React.useState();
+    const [generatedChapters, setGeneratedChapters] = React.useState();
+    const [generatedKeyMoments, setGeneratedKeyMoments] = React.useState();
+    const snapshot = React.useSyncExternalStore(player._subscribe, player._getSnapshot, player._getSnapshot);
+    const enterFullscreen = React.useCallback(() => {
+        player._markResumePoint();
+        enteredViaRotationRef.current = false;
+        suppressRotationEntryRef.current = false;
+        pendingExitRef.current = false;
+        const { width, height } = Dimensions.get('window');
+        setFullscreenReady(width > height);
+        setFullscreen(true);
+    }, [player]);
+    const beginExit = React.useCallback(() => {
+        player._markResumePoint();
+        enteredViaRotationRef.current = false;
+        suppressRotationEntryRef.current = true;
+        setFullscreenReady(false);
+        const { width, height } = Dimensions.get('window');
+        if (width <= height) {
+            pendingExitRef.current = false;
+            setFullscreen(false);
+            return;
+        }
+        pendingExitRef.current = true;
+        void unlockOrientation();
+        setTimeout(() => {
+            if (pendingExitRef.current) {
+                pendingExitRef.current = false;
+                setFullscreen(false);
+            }
+        }, 600);
+    }, [player]);
+    const exitFullscreen = React.useCallback(() => {
+        beginExit();
+    }, [beginExit]);
+    const toggleFullscreen = React.useCallback(() => {
+        if (fullscreen) {
+            beginExit();
+            return;
+        }
+        player._markResumePoint();
+        enteredViaRotationRef.current = false;
+        suppressRotationEntryRef.current = false;
+        pendingExitRef.current = false;
+        const { width, height } = Dimensions.get('window');
+        setFullscreenReady(width > height);
+        setFullscreen(true);
+    }, [beginExit, fullscreen, player]);
+    React.useEffect(() => {
+        if (!allowsFullscreen) {
+            return;
+        }
+        const subscription = Dimensions.addEventListener('change', ({ window }) => {
+            const isLandscape = window.width > window.height;
+            if (!isLandscape) {
+                suppressRotationEntryRef.current = false;
+                if (pendingExitRef.current) {
+                    pendingExitRef.current = false;
+                    setFullscreenReady(false);
+                    setFullscreen(false);
+                    return;
+                }
+            }
+            else if (pendingExitRef.current) {
+                pendingExitRef.current = false;
+            }
+            setFullscreenReady(isLandscape);
+            setFullscreen(prev => {
+                if (isLandscape && !prev) {
+                    if (suppressRotationEntryRef.current) {
+                        return prev;
+                    }
+                    enteredViaRotationRef.current = true;
+                    player._markResumePoint();
+                    return true;
+                }
+                if (!isLandscape && prev && enteredViaRotationRef.current) {
+                    enteredViaRotationRef.current = false;
+                    player._markResumePoint();
+                    return false;
+                }
+                return prev;
+            });
+        });
+        return () => subscription.remove();
+    }, [allowsFullscreen, player]);
+    React.useImperativeHandle(ref, () => ({
+        play: () => player.play(),
+        pause: () => player.pause(),
+        replay: () => player.replay(),
+        seekBy: seconds => player.seekBy(seconds),
+        seekTo: seconds => player.seekTo(seconds),
+        setMuted: muted => player.setMuted(muted),
+        setVolume: volume => player.setVolume(volume),
+        setLoop: loop => player.setLoop(loop),
+        setPlaybackRate: rate => player.setPlaybackRate(rate),
+        setCaptionTrack: trackId => player.setCaptionTrack(trackId),
+        preload: () => player.preload(),
+        release: () => player.release(),
+        enterFullscreen,
+        exitFullscreen,
+    }), [player, enterFullscreen, exitFullscreen]);
+    React.useEffect(() => {
+        player._attachNativeRef(nativeRef.current);
+        return () => {
+            player._attachNativeRef(null);
+        };
+    }, [player, fullscreen]);
+    React.useEffect(() => {
+        onFullscreenChange?.(fullscreen);
+        if (!fullscreen) {
+            return;
+        }
+        const entryViaRotation = enteredViaRotationRef.current;
+        if (!entryViaRotation) {
+            void lockOrientationLandscape();
+        }
+        return () => {
+            if (!entryViaRotation) {
+                void unlockOrientation();
+            }
+        };
+    }, [fullscreen, onFullscreenChange]);
+    const controlsMode = controls ?? (nativeControls ? 'native' : 'none');
+    const showCustomControls = controlsMode === 'custom';
+    const showNativeControls = controlsMode === 'native';
+    const controlsRobots = React.useMemo(() => robots && robots.assetId == null && snapshot.source?.assetId
+        ? { ...robots, assetId: snapshot.source.assetId }
+        : robots, [robots, snapshot.source?.assetId]);
+    const robotsAssetId = controlsRobots?.assetId;
+    React.useEffect(() => {
+        setGeneratedSummary(undefined);
+        setGeneratedChapters(undefined);
+        setGeneratedKeyMoments(undefined);
+    }, [robotsAssetId]);
+    const sharedNativeProps = {
+        startupBufferDuration,
+        source: snapshot.source,
+        playWhenReady: snapshot.shouldPlay,
+        muted: snapshot.muted,
+        volume: snapshot.volume,
+        loop: snapshot.loop,
+        playbackRate: snapshot.playbackRate,
+        contentFit,
+        allowsFullscreen,
+        allowsPictureInPicture,
+        timeUpdateEventInterval,
+        onStatusChange: (event) => {
+            player._handleStatusChange(event.nativeEvent);
+            onStatusChange?.(event.nativeEvent);
+        },
+        onPlayingChange: (event) => {
+            onPlayingChange?.(event.nativeEvent);
+        },
+        onTimeUpdate: (event) => {
+            player._handleTimeUpdate(event.nativeEvent);
+            onTimeUpdate?.(event.nativeEvent);
+        },
+        onSourceLoad: (event) => {
+            player._handleSourceLoad(event.nativeEvent);
+            onSourceLoad?.(event.nativeEvent);
+        },
+        onSourceError: (event) => {
+            player._handleSourceError(event.nativeEvent);
+            onSourceError?.(event.nativeEvent);
+        },
+    };
+    if (showNativeControls) {
+        return (_jsx(NativeMuxVideoView, { ...viewProps, ...sharedNativeProps, ref: nativeRef, nativeControls: true }));
+    }
+    const renderManagedBody = (containerStyle, controlsInset = { left: 0, right: 0 }) => (_jsxs(View, { style: containerStyle, children: [_jsx(NativeMuxVideoView, { ...sharedNativeProps, ref: nativeRef, nativeControls: false, style: StyleSheet.absoluteFill }), showCustomControls ? (_jsx(View, { pointerEvents: "box-none", style: {
+                    position: 'absolute',
+                    top: 0,
+                    bottom: 0,
+                    left: controlsInset.left,
+                    right: controlsInset.right,
+                }, children: _jsx(MuxVideoControls, { player: player, status: snapshot.status, shouldPlay: snapshot.shouldPlay, theme: controlsTheme, robots: controlsRobots, allowsFullscreen: allowsFullscreen, isFullscreen: fullscreen, onToggleFullscreen: allowsFullscreen ? toggleFullscreen : undefined, generatedSummary: generatedSummary, generatedChapters: generatedChapters, generatedKeyMoments: generatedKeyMoments, onGeneratedSummaryChange: setGeneratedSummary, onGeneratedChaptersChange: setGeneratedChapters, onGeneratedKeyMomentsChange: setGeneratedKeyMoments }) })) : null] }));
+    const inlineContainerStyle = [
+        styles.customControlsContainer,
+        viewProps.style,
+    ];
+    if (!fullscreen) {
+        return renderManagedBody(inlineContainerStyle);
+    }
+    const fullscreenControlsInset = Platform.OS === 'ios' && fullscreenReady
+        ? { left: IOS_LANDSCAPE_SAFE_INSET, right: IOS_LANDSCAPE_SAFE_INSET }
+        : { left: 0, right: 0 };
+    return (_jsxs(_Fragment, { children: [_jsx(View, { ...viewProps, style: [inlineContainerStyle, styles.placeholderInline], pointerEvents: "none" }), _jsx(Modal, { animationType: "fade", visible: true, supportedOrientations: [
+                    'portrait',
+                    'landscape',
+                    'landscape-left',
+                    'landscape-right',
+                ], statusBarTranslucent: true, presentationStyle: "overFullScreen", transparent: true, onRequestClose: exitFullscreen, children: _jsxs(View, { style: styles.fullscreenContainer, children: [renderManagedBody(StyleSheet.absoluteFill, fullscreenControlsInset), !fullscreenReady ? (_jsx(View, { pointerEvents: "none", style: [StyleSheet.absoluteFill, styles.fullscreenCover] })) : null] }) })] }));
+});
+MuxVideoView.displayName = 'MuxVideoView';
+export function useMuxVideoPlayer(source, setup) {
+    const playerRef = React.useRef(null);
+    const sourceKey = source == null ? undefined : JSON.stringify(source);
+    if (playerRef.current == null) {
+        playerRef.current = new MuxVideoPlayer(source);
+    }
+    React.useEffect(() => {
+        if (source != null) {
+            playerRef.current?.replace(source);
+        }
+    }, [sourceKey]);
+    React.useEffect(() => {
+        if (playerRef.current && setup) {
+            setup(playerRef.current);
+        }
+    }, [setup]);
+    React.useEffect(() => {
+        const player = playerRef.current;
+        return () => {
+            player?.release().catch(() => {
+                // React cleanup may run after the native view has already detached.
+            });
+        };
+    }, []);
+    return playerRef.current;
+}
+const styles = StyleSheet.create({
+    customControlsContainer: {
+        backgroundColor: 'transparent',
+        overflow: 'hidden',
+        position: 'relative',
+    },
+    placeholderInline: {
+        backgroundColor: 'transparent',
+    },
+    fullscreenContainer: {
+        backgroundColor: '#000',
+        flex: 1,
+    },
+    fullscreenCover: {
+        backgroundColor: '#000',
+    },
+});

package/build/NativeMuxVideoView.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import type { MuxNativeViewRef, NativeMuxVideoViewProps } from './types';
+declare const NativeMuxVideoView: React.ComponentType<NativeMuxVideoViewProps & React.RefAttributes<MuxNativeViewRef>>;
+export default NativeMuxVideoView;
+//# sourceMappingURL=NativeMuxVideoView.d.ts.map

package/build/NativeMuxVideoView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeMuxVideoView.d.ts","sourceRoot":"","sources":["../src/NativeMuxVideoView.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAIzE,QAAA,MAAM,kBAAkB,EAAuD,KAAK,CAAC,aAAa,CAChG,uBAAuB,GAAG,KAAK,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAChE,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/build/NativeMuxVideoView.js

@@ -0,0 +1,4 @@
+import { requireNativeViewManager, requireOptionalNativeModule, } from 'expo-modules-core';
+requireOptionalNativeModule('MuxReactNativePlayer');
+const NativeMuxVideoView = requireNativeViewManager('MuxReactNativePlayer');
+export default NativeMuxVideoView;

package/build/index.d.ts

@@ -0,0 +1,6 @@
+export { createMuxVideoPlayer, MuxVideoPlayer } from './MuxVideoPlayer';
+export { MuxVideoView, useMuxVideoPlayer } from './MuxVideoView';
+export { muxResolutionSupport, normalizeMuxVideoSource } from './normalizeSource';
+export type { MuxContentFit, MuxVideoControls, MuxVideoControlsTheme, MuxCustomData, MuxMaxResolution, MuxMinResolution, MuxNativeViewRef, MuxPlaybackStatus, MuxPlayerStatus, MuxPlayingChangeEvent, MuxRenditionOrder, MuxSourceErrorEvent, MuxSourceLoadEvent, MuxStatusChangeEvent, MuxTimeUpdateEvent, MuxVideoChapter, MuxVideoCaptionTrack, MuxVideoClipping, MuxVideoMetadata, MuxVideoKeyMoment, MuxVideoRobotsConfig, MuxVideoRobotsContext, MuxVideoSource, MuxVideoSourceObject, MuxVideoSummary, MuxVideoViewProps, } from './types';
+export type { MuxVideoViewRef } from './MuxVideoView';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAClF,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,qBAAqB,EACrB,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,cAAc,EACd,oBAAoB,EACpB,eAAe,EACf,iBAAiB,GAClB,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/build/index.js

@@ -0,0 +1,3 @@
+export { createMuxVideoPlayer, MuxVideoPlayer } from './MuxVideoPlayer';
+export { MuxVideoView, useMuxVideoPlayer } from './MuxVideoView';
+export { muxResolutionSupport, normalizeMuxVideoSource } from './normalizeSource';

package/build/normalizeSource.d.ts

@@ -0,0 +1,7 @@
+import type { MuxMaxResolution, MuxMinResolution, MuxVideoSource, NormalizedMuxVideoSource } from './types';
+export declare function normalizeMuxVideoSource(source: MuxVideoSource): NormalizedMuxVideoSource;
+export declare const muxResolutionSupport: {
+    readonly min: MuxMinResolution[];
+    readonly max: MuxMaxResolution[];
+};
+//# sourceMappingURL=normalizeSource.d.ts.map

package/build/normalizeSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeSource.d.ts","sourceRoot":"","sources":["../src/normalizeSource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,wBAAwB,EACzB,MAAM,SAAS,CAAC;AAMjB,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,cAAc,GAAG,wBAAwB,CA0BxF;AA2DD,eAAO,MAAM,oBAAoB;;;CAGvB,CAAC"}