@symbiote-native/video 0.0.0-stage → 0.1.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,241 @@
-# 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.
+
+Built the same way as [`@symbiote-native/clipboard`](../clipboard)'s `ClipboardPasteButton`, an
+`expo-modules-core` native view reached through `requireNativeViewManager` (see the
+`symbiote-expo-native-module` project skill: why `expo-modules-core` is depended on directly and never
+the `expo` meta-package, why the upstream JS is hand-ported into `core/`, and how autolinking finds the
+native module). One render function in `core/` returns a descriptor and every adapter only turns it into
+its own element.
+
+## Install
+
+**New app:**
+
+```bash
+npx @symbiote-native/cli new my-app --video
+```
+
+**Existing SymbioteNative app:**
+
+```bash
+npx @symbiote-native/cli add --video
+```
+
+Either way: installs `@symbiote-native/video` and wires the native autolinking automatically,
+see [`@symbiote-native/cli`](../cli).
+
+<details>
+<summary>Manual install (no CLI - installing and wiring native autolinking by hand)</summary>
+
+```bash
+npm install @symbiote-native/video
+```
+
+Depends on `expo-video` and `expo-modules-core` directly (regular dependencies, pinned to exact
+versions, since this package's `core/` is hand-ported against one specific native API shape).
+Never install `expo-video` yourself, and never add the `expo` package to this project: it bundles
+its own Metro/Babel pipeline that conflicts with this project's own.
+
+### Required one-time step: native autolinking wiring
+
+`expo-video`'s native code is discovered by `expo-modules-autolinking`, not by RN's own
+`react-native.config.cjs` mechanism. Wire it into the native host app **once**, it covers this package
+and every other `expo-modules-core` package with zero further changes. The steps and the
+mechanics behind them are in the `symbiote-expo-native-module` skill and in
+[`@symbiote-native/network`](../network)'s README; the reference app is `examples/expo-react`.
+
+### Background playback and Picture in Picture
+
+The package writes nothing by default. For iOS add `audio` to `UIBackgroundModes` in `Info.plist`.
+For Android choose the "Background video playback" bundle (the foreground service and its permissions),
+and give the main activity `android:supportsPictureInPicture="true"` for Picture in Picture.
+
+</details>
+
+## Shape
+
+```
+src/core/                video-player.ts and video-player-controller.ts (the player and its lifecycle over
+                         the engine's createJsonKeyedResourceController), video-view.ts
+                         (createVideoView(getNode)), video-airplay-button.ts, video-source.ts,
+                         video-module.ts (cache and Picture in Picture functions), video-thumbnail.ts.
+src/react/               @symbiote-native/video/react   - VideoView, useVideoPlayer
+src/vue/                 @symbiote-native/video/vue     - VideoView, useVideoPlayer (a computed ref)
+src/svelte/              @symbiote-native/video/svelte  - VideoView, useVideoPlayer ({ current })
+src/solid/               @symbiote-native/video/solid   - VideoView, useVideoPlayer (an accessor)
+src/angular/             @symbiote-native/video/angular - VideoView, injectVideoPlayer (a signal)
+```
+
+`VideoView` is one component per platform (`VideoView` on iOS, `SurfaceVideoView` or `TextureVideoView` on
+Android), and the view functions follow the surface the last render chose. `VideoAirPlayButton` is a plain
+view off iOS. `useEvent` and `useEventListener` come from each adapter, not from this package.
+
+## Use it
+
+### React
+
+```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 />;
+```
+
+### Vue
+
+```vue
+<script setup lang="ts">
+import { VideoView, useVideoPlayer } from '@symbiote-native/video/vue';
+
+const player = useVideoPlayer(
+  () => 'https://example.com/video.mp4',
+  instance => {
+    instance.loop = true;
+    instance.play();
+  },
+);
+</script>
+
+<template>
+  <VideoView :player="player" :style="{ width: 320, height: 180 }" :nativeControls="true" />
+</template>
+```
+
+### Angular
+
+```ts
+import { Component } from '@angular/core';
+import { VideoView, injectVideoPlayer } from '@symbiote-native/video/angular';
+
+@Component({
+  standalone: true,
+  imports: [VideoView],
+  template: `
+    <VideoView [player]="player()" [style]="{ width: 320, height: 180 }" [nativeControls]="true" />
+  `,
+})
+export class Clip {
+  readonly player = injectVideoPlayer(
+    () => 'https://example.com/video.mp4',
+    instance => {
+      instance.loop = true;
+      instance.play();
+    },
+  );
+}
+```
+
+### Svelte
+
+```svelte
+<script lang="ts">
+  import { VideoView, useVideoPlayer } from '@symbiote-native/video/svelte';
+
+  const player = useVideoPlayer(
+    () => 'https://example.com/video.mp4',
+    instance => {
+      instance.loop = true;
+      instance.play();
+    },
+  );
+</script>
+
+<VideoView player={player.current} style={{ width: 320, height: 180 }} nativeControls />
+```
+
+### Solid
+
+```tsx
+import { VideoView, useVideoPlayer } from '@symbiote-native/video/solid';
+
+const player = useVideoPlayer(
+  () => 'https://example.com/video.mp4',
+  instance => {
+    instance.loop = true;
+    instance.play();
+  },
+);
+
+<VideoView player={player()} style={{ width: 320, height: 180 }} nativeControls />;
+```
+
+## API
+
+```ts
+useVideoPlayer(source, setup?, options?): VideoPlayer     // released on unmount, per adapter see Shape
+createVideoPlayer(source, options?): VideoPlayer          // you call player.release()
+
+<VideoView player nativeControls? contentFit? surfaceType?={'surfaceView' | 'textureView'}   // Android
+           allowsPictureInPicture? ... />
+<VideoAirPlayButton ... />                                // plain view off iOS
+
+isPictureInPictureSupported(): boolean
+setVideoCacheSizeAsync(sizeBytes): Promise<void>   clearVideoCacheAsync(): Promise<void>
+getCurrentVideoCacheSize(): number                // all three work only while no player exists
+```
+
+The player is the native `VideoPlayer` shared object, `{ uri, useCaching }` sources enable the cache.
+Ported from upstream's `VideoPlayer.ts`, `VideoView.tsx`, `VideoAirPlayButton.tsx` and `index.ts`.
+
+## Notes
+
+- **One player, one `VideoView` on Android.** Mounting several views with the same player does not
+  work there, a platform limitation. iOS accepts it. Create a player per visible view, or move the
+  player to the new view only after the old one is gone.
+- **`useVideoPlayer` releases the player for you.** It disposes of it when the component unmounts,
+  and a changed source or options make a new one. A player from `createVideoPlayer` is yours:
+  call `release()` when you are done, or it leaks.
+- **Android renders on a surface by default.** `surfaceType="surfaceView"` is the efficient choice,
+  `surfaceType="textureView"` composes like an ordinary view and costs more performance.
+- **Caching is per source.** Set `useCaching: true` on the source object. The cache is persistent
+  and trimmed least-recently-used, 1 GB by default, and works offline for what it holds.
+  iOS cannot cache HLS, and DRM-protected video is not cached on either platform.
+- **The cache functions work only while no player exists**, so call `setVideoCacheSizeAsync` and
+  `clearVideoCacheAsync` before you create one.
+- **`useEvent` and `useEventListener` come from the adapter**, not from this package. See the aside
+  above.
+- **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.
+
+## Common questions
+
+- **Black screen on Android.** One player in several `VideoView`s does not work there. Keep one view
+  per player and unmount the old view first.
+- **Overlap or out of bounds on Android.** An ExoPlayer bug with `contentFit="cover"`. Set
+  `surfaceType="textureView"`.
+- **`zIndex` ignored on Android.** The default surface draws above its surroundings. Try
+  `surfaceType="textureView"`.
+- **Touch handlers do not fire on Android.** Put the handler on a wrapping view.
+- **Not released.** `useVideoPlayer` releases on unmount, a player from `createVideoPlayer` needs
+  `player.release()`.
+- **Fullscreen will not rotate on Android.** It follows the app's orientation lock, unlock it with
+  `@symbiote-native/screen-orientation`.
+- **Caching.** `{ uri, useCaching: true }`. 1 GB by default, not for HLS on iOS or DRM. The cache
+  functions work only while no player exists.
+
+Sources: [Expo docs: Video](https://docs.expo.dev/versions/latest/sdk/video/),
+[expo/expo#35012](https://github.com/expo/expo/issues/35012),
+[expo/expo#31248](https://github.com/expo/expo/issues/31248),
+[expo/expo#31722](https://github.com/expo/expo/issues/31722),
+[expo/expo#30275](https://github.com/expo/expo/issues/30275),
+[expo/expo#34630](https://github.com/expo/expo/issues/34630),
+[expo/expo#33804](https://github.com/expo/expo/issues/33804),
+[expo/expo#9899](https://github.com/expo/expo/issues/9899).
+
+## Test it
+
+No device is needed for the logic. The core tests (`src/core/*.test.ts`) replace `expo-modules-core`
+(`requireNativeViewManager`, `Platform`) and assert the descriptor a render function returns. The
+adapter tests (`src/{react,vue,solid,angular}/**/*.test.*`, `vitest`) render the real component over the
+recording Fabric with an injected view config and assert the committed payload, and Svelte's
+`*.smoke.test.ts` compile the `.svelte` files and mount them. Painting itself is verified on a device in
+the six `examples/expo-*` canary apps (`examples/expo-react`, `examples/expo-vue-sfc`,
+`examples/expo-vue-tsx`, `examples/expo-svelte`, `examples/expo-solid`, `examples/expo-angular`), see the
+parent [README](../../README.md).

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);