@symbiote-native/video 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,68 @@
-# Temporary Holding Version
+# @symbiote-native/video
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[`expo-video`](https://docs.expo.dev/versions/latest/sdk/video/) for **every**
+[SymbioteNative](../../README.md) adapter: React, Vue, Svelte, Solid and Angular. The player, the
+view, thumbnails, the video cache and the AirPlay button.
+
+## Install
+
+```bash
+npx @symbiote-native/cli new my-app --video   # new app
+npx @symbiote-native/cli add --video          # existing app
+```
+
+Manual: `npm install @symbiote-native/video`, then wire `expo-modules-autolinking` once per app.
+Never install `expo-video` or the `expo` meta-package yourself.
+
+## Usage
+
+```tsx
+import { VideoView, useVideoPlayer } from '@symbiote-native/video/react';
+
+const player = useVideoPlayer('https://example.com/video.mp4', player => {
+  player.loop = true;
+  player.play();
+});
+
+<VideoView player={player} style={{ width: 320, height: 180 }} nativeControls />;
+```
+
+`createVideoPlayer(source, builderOptions?)` makes a player that is not released by itself, call
+`player.release()`. The player is the native `VideoPlayer` object: its properties, `play()`,
+`pause()`, `replaceAsync()`, `generateThumbnailsAsync()` and `addListener(event, listener)` are
+the same on every adapter. The player is created by the hook of the framework, which releases it
+when the owner goes away:
+
+| Adapter | Player                                                                  |
+| ------- | ----------------------------------------------------------------------- |
+| React   | `useVideoPlayer(source, setup?, options?)`                              |
+| Vue     | `useVideoPlayer(source, setup?, options?)`, returns a computed ref      |
+| Solid   | `useVideoPlayer(() => source, setup?, () => options)`, returns an accessor |
+| Svelte  | `useVideoPlayer(() => source, setup?, () => options).current`           |
+| Angular | `injectVideoPlayer(() => source, setup?, () => options)`, a signal      |
+
+`setup` runs once on each new player, and a changed source or options make a new one.
+
+The functions of the view (`enterFullscreen`, `exitFullscreen`, `startPictureInPicture`,
+`stopPictureInPicture`) are reached by a `ref` in React and Solid (`ref={fn}`), the exposed members
+of a template ref in Vue, `bind:this` in Svelte and `@ViewChild` in Angular.
+
+Module functions: `isPictureInPictureSupported()`, `setVideoCacheSizeAsync(bytes)`,
+`clearVideoCacheAsync()`, `getCurrentVideoCacheSize()`. `VideoThumbnail` is the native class of the
+thumbnails. `VideoAirPlayButton` is the iOS route picker and a plain view elsewhere.
+
+## App setup
+
+Nothing is written by default. Background playback and Picture in Picture need what upstream's
+config plugin adds:
+
+- iOS: add `audio` to `UIBackgroundModes` in `Info.plist`.
+- Android: pick the "Background video playback" bundle for the foreground service and its
+  permissions. Picture in Picture needs `android:supportsPictureInPicture="true"` on the main
+  activity.
+
+## Not ported
+
+The web build. `useEvent` / `useEventListener` ship with the `expo` package upstream, here the
+adapters export them for any emitter (`useEvent(player, 'statusChange')`, `injectEvent` in
+Angular, `@symbiote-native/svelte/runes/use-event` in Svelte). Upstream ships no tests, the suites here are written against its behavior.

package/build/angular/index.d.ts

@@ -0,0 +1,4 @@
+export { VideoView } from './video-view';
+export { VideoAirPlayButton } from './video-airplay-button';
+export { injectVideoPlayer } from './inject-video-player';
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/video/angular: плеер, view, миниатюры, кэш и кнопка AirPlay на общем ядре
+export { VideoView } from './video-view/index.js';
+export { VideoAirPlayButton } from './video-airplay-button/index.js';
+export { injectVideoPlayer } from './inject-video-player.js';
+export * from '../core/index.js';

package/build/angular/inject-video-player.d.ts

@@ -0,0 +1,4 @@
+import type { Signal } from '@angular/core';
+import type { IVideoPlayerBuilderOptions, IVideoSource, VideoPlayer } from '../core';
+/** Released with the injection context, `setup` runs once on each new player */
+export declare const injectVideoPlayer: (source: () => IVideoSource, setup?: (player: VideoPlayer) => void, options?: () => IVideoPlayerBuilderOptions | undefined) => Signal<VideoPlayer>;

package/build/angular/inject-video-player.js

@@ -0,0 +1,6 @@
+// Angular twin of `useVideoPlayer`, `injectX` shape matching `injectAudioPlayer`
+import { createResourceHook } from '@symbiote-native/angular';
+import { createVideoPlayerController } from '../core/video-player-controller.js';
+const injectPlayerResource = createResourceHook(createVideoPlayerController);
+/** Released with the injection context, `setup` runs once on each new player */
+export const injectVideoPlayer = (source, setup, options) => injectPlayerResource(() => [source(), options?.(), setup]);

package/build/angular/video-airplay-button/index.d.ts

@@ -0,0 +1,12 @@
+import { NativeViewBase } from '@symbiote-native/angular';
+import type { IDescriptor } from '@symbiote-native/components';
+import type { IVideoAirPlayButtonProps } from '../../core';
+declare const AIRPLAY_INPUTS: readonly ["tint", "activeTint", "prioritizeVideoDevices", "onBeginPresentingRoutes", "onEndPresentingRoutes"];
+export interface VideoAirPlayButton extends Partial<Pick<IVideoAirPlayButtonProps, (typeof AIRPLAY_INPUTS)[number]>> {
+}
+/** Angular twin of `expo-video`'s `VideoAirPlayButton`, a plain view off iOS */
+export declare class VideoAirPlayButton extends NativeViewBase {
+    protected readonly propNames: readonly ["tint", "activeTint", "prioritizeVideoDevices", "onBeginPresentingRoutes", "onEndPresentingRoutes"];
+    protected renderView(props: object): IDescriptor | null;
+}
+export {};

package/build/angular/video-airplay-button/index.js

@@ -0,0 +1,78 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { DescriptorOutlet, NativeViewBase } from '@symbiote-native/angular';
+import { renderVideoAirPlayButton } from '../../core/index.js';
+// One list is the inputs of the component and the props it hands to the native view
+const AIRPLAY_INPUTS = [
+    'tint',
+    'activeTint',
+    'prioritizeVideoDevices',
+    'onBeginPresentingRoutes',
+    'onEndPresentingRoutes',
+];
+/** Angular twin of `expo-video`'s `VideoAirPlayButton`, a plain view off iOS */
+let VideoAirPlayButton = (() => {
+    let _classDecorators = [Component({
+            selector: 'VideoAirPlayButton',
+            standalone: true,
+            imports: [DescriptorOutlet],
+            inputs: [...AIRPLAY_INPUTS],
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            template: `@if (descriptor; as node) {
+    <symbiote-descriptor-outlet [node]="node" />
+  }`,
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = NativeViewBase;
+    var VideoAirPlayButton = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            VideoAirPlayButton = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        propNames = AIRPLAY_INPUTS;
+        renderView(props) {
+            return renderVideoAirPlayButton(props);
+        }
+    };
+    return VideoAirPlayButton = _classThis;
+})();
+export { VideoAirPlayButton };

package/build/angular/video-view/index.d.ts

@@ -0,0 +1,17 @@
+import { NativeViewBase } from '@symbiote-native/angular';
+import type { IDescriptor } from '@symbiote-native/components';
+import type { IVideoViewProps } from '../../core';
+declare const VIDEO_VIEW_INPUTS: readonly ["player", "nativeControls", "contentFit", "fullscreenOptions", "showsTimecodes", "requiresLinearPlayback", "buttonOptions", "surfaceType", "contentPosition", "onPictureInPictureStart", "onPictureInPictureStop", "allowsPictureInPicture", "startsPictureInPictureAutomatically", "allowsVideoFrameAnalysis", "onFullscreenEnter", "onFullscreenExit", "onFirstFrameRender", "useExoShutter"];
+export interface VideoView extends Partial<Pick<IVideoViewProps, (typeof VIDEO_VIEW_INPUTS)[number]>> {
+}
+/** Angular twin of `expo-video`'s `VideoView` */
+export declare class VideoView extends NativeViewBase {
+    private readonly view;
+    readonly enterFullscreen: () => Promise<void>;
+    readonly exitFullscreen: () => Promise<void>;
+    readonly startPictureInPicture: () => Promise<void>;
+    readonly stopPictureInPicture: () => Promise<void>;
+    protected readonly propNames: readonly ["player", "nativeControls", "contentFit", "fullscreenOptions", "showsTimecodes", "requiresLinearPlayback", "buttonOptions", "surfaceType", "contentPosition", "onPictureInPictureStart", "onPictureInPictureStop", "allowsPictureInPicture", "startsPictureInPictureAutomatically", "allowsVideoFrameAnalysis", "onFullscreenEnter", "onFullscreenExit", "onFirstFrameRender", "useExoShutter"];
+    protected renderView(props: object): IDescriptor | null;
+}
+export {};

package/build/angular/video-view/index.js

@@ -0,0 +1,97 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { DescriptorOutlet, NativeViewBase } from '@symbiote-native/angular';
+import { createVideoView } from '../../core/index.js';
+// One list is the inputs of the component and the props it hands to the native view
+const VIDEO_VIEW_INPUTS = [
+    'player',
+    'nativeControls',
+    'contentFit',
+    'fullscreenOptions',
+    'showsTimecodes',
+    'requiresLinearPlayback',
+    'buttonOptions',
+    'surfaceType',
+    'contentPosition',
+    'onPictureInPictureStart',
+    'onPictureInPictureStop',
+    'allowsPictureInPicture',
+    'startsPictureInPictureAutomatically',
+    'allowsVideoFrameAnalysis',
+    'onFullscreenEnter',
+    'onFullscreenExit',
+    'onFirstFrameRender',
+    'useExoShutter',
+];
+/** Angular twin of `expo-video`'s `VideoView` */
+let VideoView = (() => {
+    let _classDecorators = [Component({
+            selector: 'VideoView',
+            standalone: true,
+            imports: [DescriptorOutlet],
+            inputs: [...VIDEO_VIEW_INPUTS],
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            template: `@if (descriptor; as node) {
+    <symbiote-descriptor-outlet [node]="node" />
+  }`,
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = NativeViewBase;
+    var VideoView = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            VideoView = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        view = createVideoView(() => this.hostNode());
+        // The functions of the view are members of the component, a `@ViewChild` reaches them
+        enterFullscreen = this.view.handle.enterFullscreen;
+        exitFullscreen = this.view.handle.exitFullscreen;
+        startPictureInPicture = this.view.handle.startPictureInPicture;
+        stopPictureInPicture = this.view.handle.stopPictureInPicture;
+        propNames = VIDEO_VIEW_INPUTS;
+        renderView(props) {
+            return this.view.render(props);
+        }
+    };
+    return VideoView = _classThis;
+})();
+export { VideoView };

package/build/core/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const VIDEO_MODULE_NAME = "ExpoVideo";
+/** Upstream's label for its `UnavailabilityError` */
+export declare const VIDEO_PACKAGE_NAME = "expo-video";
+export declare const VIDEO_VIEW_NAMES: {
+    /** The one iOS view */
+    readonly video: "VideoView";
+    /** The Android default, renders into a `SurfaceView` */
+    readonly surface: "SurfaceVideoView";
+    /** Android, for overlapping views */
+    readonly texture: "TextureVideoView";
+    readonly airPlayButton: "VideoAirPlayButtonView";
+};

package/build/core/constants.js

@@ -0,0 +1,13 @@
+// Apart from `native-module`, which resolves the module on import: the views need the name too
+export const VIDEO_MODULE_NAME = 'ExpoVideo';
+/** Upstream's label for its `UnavailabilityError` */
+export const VIDEO_PACKAGE_NAME = 'expo-video';
+export const VIDEO_VIEW_NAMES = {
+    /** The one iOS view */
+    video: 'VideoView',
+    /** The Android default, renders into a `SurfaceView` */
+    surface: 'SurfaceVideoView',
+    /** Android, for overlapping views */
+    texture: 'TextureVideoView',
+    airPlayButton: 'VideoAirPlayButtonView',
+};

package/build/core/index.d.ts

@@ -0,0 +1,10 @@
+export { VIDEO_MODULE_NAME } from './constants';
+export type { IVideoAudioMixingMode, IVideoAudioTrack, IVideoBufferOptions, IVideoContentType, IVideoDrmOptions, IVideoDrmType, IVideoMetadata, IVideoPlayerBuilderOptions, IVideoPlayerError, IVideoPlayerEvents, IVideoPlayerStatus, IVideoRange, IVideoScrubbingModeOptions, IVideoSeekTolerance, IVideoSize, IVideoSource, IVideoSourceObject, IVideoSubtitleTrack, IVideoThumbnailOptions, IVideoTrack, VideoPlayer, } from './player-types';
+export { createVideoPlayer } from './video-player';
+export { createVideoPlayerController, type IVideoPlayerController, } from './video-player-controller';
+export { clearVideoCacheAsync, getCurrentVideoCacheSize, isPictureInPictureSupported, setVideoCacheSizeAsync, } from './video-module';
+export { parseSource } from './video-source';
+export { VideoThumbnail } from './video-thumbnail';
+export { createVideoView, type IVideoView, type IVideoViewHandle, } from './video-view';
+export { renderVideoAirPlayButton, videoAirPlayButtonViewName, } from './video-airplay-button';
+export type { IVideoAirPlayButtonProps, IVideoButtonOptions, IVideoContentFit, IVideoFullscreenOptions, IVideoFullscreenOrientation, IVideoKeepFullscreenOnPiPStop, IVideoSurfaceType, IVideoViewProps, } from './view-types';

package/build/core/index.js

@@ -0,0 +1,8 @@
+export { VIDEO_MODULE_NAME } from './constants.js';
+export { createVideoPlayer } from './video-player.js';
+export { createVideoPlayerController, } from './video-player-controller.js';
+export { clearVideoCacheAsync, getCurrentVideoCacheSize, isPictureInPictureSupported, setVideoCacheSizeAsync, } from './video-module.js';
+export { parseSource } from './video-source.js';
+export { VideoThumbnail } from './video-thumbnail.js';
+export { createVideoView, } from './video-view.js';
+export { renderVideoAirPlayButton, videoAirPlayButtonViewName, } from './video-airplay-button.js';

package/build/core/native-module.d.ts

@@ -0,0 +1,10 @@
+import type { VideoPlayer, VideoThumbnail } from './player-types';
+export type INativeVideoModule = {
+    VideoPlayer: typeof VideoPlayer;
+    VideoThumbnail: typeof VideoThumbnail;
+    isPictureInPictureSupported(): boolean;
+    setVideoCacheSizeAsync(sizeBytes: number): Promise<void>;
+    clearVideoCacheAsync(): Promise<void>;
+    getCurrentVideoCacheSize(): number;
+};
+export declare const expoVideo: INativeVideoModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+import { VIDEO_MODULE_NAME } from './constants.js';
+export const expoVideo = requireNativeModule(VIDEO_MODULE_NAME);

package/build/core/player-types.d.ts

@@ -0,0 +1,221 @@
+import type { SharedObject, SharedRef } from 'expo-modules-core';
+export type IVideoPlayerStatus = 'idle' | 'loading' | 'readyToPlay' | 'error';
+export type IVideoContentType = 'auto' | 'progressive' | 'hls' | 'dash' | 'smoothStreaming';
+export type IVideoDrmType = 'clearkey' | 'fairplay' | 'playready' | 'widevine';
+export type IVideoDrmOptions = {
+    type: IVideoDrmType;
+    licenseServer: string;
+    headers?: Record<string, string>;
+    /** Android only */
+    multiKey?: boolean;
+    /** iOS only */
+    contentId?: string;
+    /** iOS only */
+    certificateUrl?: string;
+    /** iOS only */
+    base64CertificateData?: string;
+};
+export type IVideoMetadata = {
+    title?: string;
+    artist?: string;
+    artwork?: string;
+};
+export type IVideoSourceObject = {
+    uri?: string;
+    /** A `require`d asset, `uri` wins when both are set */
+    assetId?: number;
+    drm?: IVideoDrmOptions;
+    metadata?: IVideoMetadata;
+    headers?: Record<string, string>;
+    /** Caches the video on disk, off by default */
+    useCaching?: boolean;
+    contentType?: IVideoContentType;
+};
+/** A URI, a `require`d asset or an object, `null` unloads the player */
+export type IVideoSource = string | number | null | IVideoSourceObject;
+export type IVideoPlayerError = {
+    message: string;
+};
+export type IVideoAudioMixingMode = 'mixWithOthers' | 'duckOthers' | 'auto' | 'doNotMix';
+export type IVideoBufferOptions = {
+    /** iOS only, in seconds */
+    readonly preferredForwardBufferDuration?: number;
+    /** iOS only */
+    readonly waitsToMinimizeStalling?: boolean;
+    /** Android only, in seconds */
+    readonly minBufferForPlayback?: number;
+    /** Android only, in bytes */
+    readonly maxBufferBytes?: number | null;
+    /** Android only */
+    readonly prioritizeTimeOverSizeThreshold?: boolean;
+};
+export type IVideoTextTrack = {
+    id?: string;
+    language: string;
+    label: string;
+    name?: string;
+    isDefault?: boolean;
+    autoSelect?: boolean;
+};
+export type IVideoSubtitleTrack = IVideoTextTrack;
+export type IVideoAudioTrack = IVideoTextTrack;
+export type IVideoSize = {
+    width: number;
+    height: number;
+};
+export type IVideoRange = 'sdr' | 'hlg' | 'pq';
+export type IVideoTrack = {
+    id: string;
+    url: string | null;
+    size: IVideoSize;
+    mimeType: string | null;
+    isSupported: boolean;
+    bitrate: number | null;
+    averageBitrate: number | null;
+    peakBitrate: number | null;
+    frameRate: number | null;
+    videoRange: IVideoRange;
+};
+export type IVideoSeekTolerance = {
+    /** iOS only, in seconds */
+    toleranceBefore?: number;
+    /** iOS only, in seconds */
+    toleranceAfter?: number;
+};
+export type IVideoScrubbingModeOptions = {
+    /** Android only */
+    scrubbingModeEnabled?: boolean;
+    increaseCodecOperatingRate?: boolean;
+    enableDynamicScheduling?: boolean;
+    useDecodeOnlyFlag?: boolean;
+    allowSkippingMediaCodecFlush?: boolean;
+};
+/** Options of the Android player builder, applied before the native constructor runs */
+export type IVideoPlayerBuilderOptions = {
+    /** In seconds */
+    seekBackwardIncrement?: number;
+    /** In seconds */
+    seekForwardIncrement?: number;
+};
+export type IVideoThumbnailOptions = {
+    maxWidth?: number;
+    maxHeight?: number;
+};
+export type IVideoPlayerEvents = {
+    statusChange(payload: {
+        status: IVideoPlayerStatus;
+        oldStatus?: IVideoPlayerStatus;
+        error?: IVideoPlayerError;
+    }): void;
+    playingChange(payload: {
+        isPlaying: boolean;
+        oldIsPlaying?: boolean;
+    }): void;
+    playbackRateChange(payload: {
+        playbackRate: number;
+        oldPlaybackRate?: number;
+    }): void;
+    volumeChange(payload: {
+        volume: number;
+        oldVolume?: number;
+    }): void;
+    mutedChange(payload: {
+        muted: boolean;
+        oldMuted?: boolean;
+    }): void;
+    playToEnd(): void;
+    timeUpdate(payload: {
+        currentTime: number;
+        currentLiveTimestamp: number | null;
+        currentOffsetFromLive: number | null;
+        bufferedPosition: number;
+    }): void;
+    sourceChange(payload: {
+        source: IVideoSource;
+        oldSource?: IVideoSource;
+    }): void;
+    availableSubtitleTracksChange(payload: {
+        availableSubtitleTracks: IVideoSubtitleTrack[];
+        oldAvailableSubtitleTracks?: IVideoSubtitleTrack[];
+    }): void;
+    subtitleTrackChange(payload: {
+        subtitleTrack: IVideoSubtitleTrack | null;
+        oldSubtitleTrack?: IVideoSubtitleTrack | null;
+    }): void;
+    availableAudioTracksChange(payload: {
+        availableAudioTracks: IVideoAudioTrack[];
+        oldAvailableAudioTracks?: IVideoAudioTrack[];
+    }): void;
+    audioTrackChange(payload: {
+        audioTrack: IVideoAudioTrack | null;
+        oldAudioTrack?: IVideoAudioTrack | null;
+    }): void;
+    videoTrackChange(payload: {
+        videoTrack: IVideoTrack | null;
+        oldVideoTrack?: IVideoTrack | null;
+    }): void;
+    sourceLoad(payload: {
+        videoSource: IVideoSource | null;
+        duration: number;
+        availableVideoTracks: IVideoTrack[];
+        availableSubtitleTracks: IVideoSubtitleTrack[];
+        availableAudioTracks: IVideoAudioTrack[];
+    }): void;
+    isExternalPlaybackActiveChange(payload: {
+        isExternalPlaybackActive: boolean;
+        oldIsExternalPlaybackActive?: boolean;
+    }): void;
+};
+/** The native thumbnail, `expo-image` takes it as an image source */
+export declare class VideoThumbnail extends SharedRef<'image'> {
+    width: number;
+    height: number;
+    /** In seconds */
+    requestedTime: number;
+    /** In seconds, iOS only */
+    actualTime: number;
+}
+export declare class VideoPlayer extends SharedObject<IVideoPlayerEvents> {
+    readonly playing: boolean;
+    loop: boolean;
+    /** iOS only */
+    allowsExternalPlayback: boolean;
+    audioMixingMode: IVideoAudioMixingMode;
+    muted: boolean;
+    /** In seconds, assigning seeks */
+    currentTime: number;
+    readonly currentLiveTimestamp: number | null;
+    readonly currentOffsetFromLive: number | null;
+    targetOffsetFromLive: number;
+    readonly duration: number;
+    volume: number;
+    preservesPitch: boolean;
+    /** In seconds, `0` turns the `timeUpdate` event off */
+    timeUpdateEventInterval: number;
+    playbackRate: number;
+    keepScreenOnWhilePlaying: boolean;
+    readonly isLive: boolean;
+    readonly status: IVideoPlayerStatus;
+    showNowPlayingNotification: boolean;
+    staysActiveInBackground: boolean;
+    readonly bufferedPosition: number;
+    bufferOptions: IVideoBufferOptions;
+    subtitleTrack: IVideoSubtitleTrack | null;
+    audioTrack: IVideoAudioTrack | null;
+    readonly availableAudioTracks: IVideoAudioTrack[];
+    readonly availableSubtitleTracks: IVideoSubtitleTrack[];
+    readonly videoTrack: IVideoTrack | null;
+    readonly availableVideoTracks: IVideoTrack[];
+    readonly isExternalPlaybackActive: boolean;
+    seekTolerance: IVideoSeekTolerance;
+    scrubbingModeOptions: IVideoScrubbingModeOptions;
+    constructor(source: IVideoSource, useSynchronousReplace?: boolean, playerBuilderOptions?: IVideoPlayerBuilderOptions);
+    play(): void;
+    pause(): void;
+    /** On iOS it loads the asset on the main thread, prefer `replaceAsync` */
+    replace(source: IVideoSource, disableWarning?: boolean): void;
+    replaceAsync(source: IVideoSource): Promise<void>;
+    seekBy(seconds: number): void;
+    replay(): void;
+    generateThumbnailsAsync(times: number | number[], options?: IVideoThumbnailOptions): Promise<VideoThumbnail[]>;
+}

package/build/core/player-types.js

@@ -0,0 +1 @@
+export {};

package/build/core/video-airplay-button.d.ts

@@ -0,0 +1,4 @@
+import type { IDescriptor } from '@symbiote-native/components';
+export declare const videoAirPlayButtonViewName: () => string;
+/** A plain view with the minimum size where the system route picker does not exist */
+export declare function renderVideoAirPlayButton(props: object): IDescriptor;

package/build/core/video-airplay-button.js

@@ -0,0 +1,29 @@
+import { Platform, requireNativeViewManager } from 'expo-modules-core';
+import { el } from '@symbiote-native/components';
+import { defineExpoNativeView } from '@symbiote-native/engine';
+import { VIDEO_MODULE_NAME, VIDEO_VIEW_NAMES } from './constants.js';
+// Регистрация идёт при рендере: побочный эффект барреля теряется в release
+const airPlayButton = defineExpoNativeView(requireNativeViewManager, VIDEO_MODULE_NAME, VIDEO_VIEW_NAMES.airPlayButton);
+export const videoAirPlayButtonViewName = airPlayButton.name;
+const MIN_SIZE = { minWidth: 30, minHeight: 30 };
+// What only the native route picker takes, the plain fallback view must not get it
+const AIRPLAY_ONLY_PROPS = new Set([
+    'tint',
+    'activeTint',
+    'prioritizeVideoDevices',
+    'onBeginPresentingRoutes',
+    'onEndPresentingRoutes',
+]);
+function isAirPlayAvailable() {
+    return (Platform.select({ ios: true, default: false }) &&
+        airPlayButton.ensureRegistered());
+}
+/** A plain view with the minimum size where the system route picker does not exist */
+export function renderVideoAirPlayButton(props) {
+    const style = [MIN_SIZE, Reflect.get(props, 'style')];
+    if (isAirPlayAvailable()) {
+        return el(airPlayButton.name(), { ...props, style });
+    }
+    const viewProps = Object.entries(props).filter(([key]) => !AIRPLAY_ONLY_PROPS.has(key));
+    return el('view', { ...Object.fromEntries(viewProps), style });
+}