@symbiote-native/video 0.0.0-stage → 0.0.0

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

@@ -0,0 +1,12 @@
+/** Whether the device supports Picture in Picture */
+export declare function isPictureInPictureSupported(): boolean;
+/** Clears the video cache, only while no `VideoPlayer` exists */
+export declare function clearVideoCacheAsync(): Promise<void>;
+/**
+ * Sets the cache size in bytes, 1GB by default, and the value persists
+ *
+ * Only while no `VideoPlayer` exists, and the real size may be slightly larger
+ */
+export declare function setVideoCacheSizeAsync(sizeBytes: number): Promise<void>;
+/** The space the video cache occupies, in bytes */
+export declare function getCurrentVideoCacheSize(): number;

package/build/core/video-module.js

@@ -0,0 +1,21 @@
+import { expoVideo } from './native-module.js';
+/** Whether the device supports Picture in Picture */
+export function isPictureInPictureSupported() {
+    return expoVideo.isPictureInPictureSupported();
+}
+/** Clears the video cache, only while no `VideoPlayer` exists */
+export function clearVideoCacheAsync() {
+    return expoVideo.clearVideoCacheAsync();
+}
+/**
+ * Sets the cache size in bytes, 1GB by default, and the value persists
+ *
+ * Only while no `VideoPlayer` exists, and the real size may be slightly larger
+ */
+export function setVideoCacheSizeAsync(sizeBytes) {
+    return expoVideo.setVideoCacheSizeAsync(sizeBytes);
+}
+/** The space the video cache occupies, in bytes */
+export function getCurrentVideoCacheSize() {
+    return expoVideo.getCurrentVideoCacheSize();
+}

package/build/core/video-player-controller.d.ts

@@ -0,0 +1,15 @@
+import type { IResourceController } from '@symbiote-native/engine';
+import type { IVideoPlayerBuilderOptions, IVideoSource, VideoPlayer } from './player-types';
+type IVideoPlayerKey = {
+    source: IVideoSource;
+    options?: IVideoPlayerBuilderOptions;
+};
+export type IVideoPlayerController = {
+    /** `setup` runs only on a player this call creates */
+    resolve: (source: IVideoSource, options?: IVideoPlayerBuilderOptions, setup?: (player: VideoPlayer) => void) => VideoPlayer;
+    flushDispose: IResourceController<IVideoPlayerKey, VideoPlayer>['flushDispose'];
+    dispose: IResourceController<IVideoPlayerKey, VideoPlayer>['dispose'];
+};
+/** Twin of `useVideoPlayer`'s releasing shared object, one per mounted owner */
+export declare function createVideoPlayerController(): IVideoPlayerController;
+export {};

package/build/core/video-player-controller.js

@@ -0,0 +1,21 @@
+import { createJsonKeyedResourceController } from '@symbiote-native/engine';
+import { createVideoPlayer } from './video-player.js';
+import { parseSource } from './video-source.js';
+/** Twin of `useVideoPlayer`'s releasing shared object, one per mounted owner */
+export function createVideoPlayerController() {
+    // The latest setup, it is not part of the key and must not recreate the player
+    let latestSetup;
+    const controller = createJsonKeyedResourceController(key => {
+        const player = createVideoPlayer(key.source, key.options);
+        latestSetup?.(player);
+        return player;
+    }, player => player.release());
+    return {
+        resolve: (source, options, setup) => {
+            latestSetup = setup;
+            return controller.resolve({ source: parseSource(source), options });
+        },
+        flushDispose: controller.flushDispose,
+        dispose: controller.dispose,
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { IVideoPlayerBuilderOptions, IVideoSource, VideoPlayer } from './player-types';
+/**
+ * Creates a player that does not release automatically, call `release()` when done
+ *
+ * The adapter hooks release it on unmount
+ */
+export declare function createVideoPlayer(source: IVideoSource, playerBuilderOptions?: IVideoPlayerBuilderOptions): VideoPlayer;

package/build/core/video-player.js

@@ -0,0 +1,22 @@
+import { expoVideo } from './native-module.js';
+import { parseSource } from './video-source.js';
+const SYNC_REPLACE_WARNING = 'On iOS `VideoPlayer.replace` loads the asset data synchronously on the main thread, which can lead to UI freezes and will be deprecated in a future release. Switch to `replaceAsync` for better user experience.';
+// Upstream patches these two methods onto the native prototype at load, a subclass does the same
+class SourceParsingVideoPlayer extends expoVideo.VideoPlayer {
+    replace(source, disableWarning = false) {
+        if (!disableWarning)
+            console.warn(SYNC_REPLACE_WARNING);
+        super.replace(parseSource(source));
+    }
+    replaceAsync(source) {
+        return super.replaceAsync(parseSource(source));
+    }
+}
+/**
+ * Creates a player that does not release automatically, call `release()` when done
+ *
+ * The adapter hooks release it on unmount
+ */
+export function createVideoPlayer(source, playerBuilderOptions) {
+    return new SourceParsingVideoPlayer(parseSource(source), false, playerBuilderOptions);
+}

package/build/core/video-source.d.ts

@@ -0,0 +1,3 @@
+import type { IVideoSource } from './player-types';
+/** What the native player takes: a `require`d asset and a string both become a uri */
+export declare function parseSource(source: IVideoSource): IVideoSource;

package/build/core/video-source.js

@@ -0,0 +1,20 @@
+import { resolveAssetSource } from '@symbiote-native/engine';
+function uriOfAsset(assetId) {
+    const resolved = resolveAssetSource(assetId);
+    const uri = Reflect.get(Object(resolved), 'uri');
+    if (typeof uri !== 'string') {
+        throw new Error(`The asset ${assetId} could not be resolved`);
+    }
+    return uri;
+}
+/** What the native player takes: a `require`d asset and a string both become a uri */
+export function parseSource(source) {
+    if (typeof source === 'number')
+        return { uri: uriOfAsset(source) };
+    if (typeof source === 'string')
+        return { uri: source };
+    if (typeof source?.assetId === 'number' && !source.uri) {
+        return { ...source, uri: uriOfAsset(source.assetId) };
+    }
+    return source;
+}

package/build/core/video-thumbnail.d.ts

@@ -0,0 +1,4 @@
+import type { VideoThumbnail as IVideoThumbnailInstance } from './player-types';
+/** The native class of a thumbnail, `generateThumbnailsAsync` resolves to instances of it */
+export declare const VideoThumbnail: typeof IVideoThumbnailInstance;
+export type VideoThumbnail = IVideoThumbnailInstance;

package/build/core/video-thumbnail.js

@@ -0,0 +1,3 @@
+import { expoVideo } from './native-module.js';
+/** The native class of a thumbnail, `generateThumbnailsAsync` resolves to instances of it */
+export const VideoThumbnail = expoVideo.VideoThumbnail;

package/build/core/video-view.d.ts

@@ -0,0 +1,18 @@
+import type { IDescriptor } from '@symbiote-native/components';
+import type { ISymbioteNode } from '@symbiote-native/engine';
+export type IVideoViewHandle = {
+    /** Always shows the native controls */
+    enterFullscreen(): Promise<void>;
+    /** On Android it works only from a native listener, the JS runtime sleeps in fullscreen */
+    exitFullscreen(): Promise<void>;
+    /** Needs `supportsPictureInPicture` of the app setup, one player at a time */
+    startPictureInPicture(): Promise<void>;
+    stopPictureInPicture(): Promise<void>;
+};
+export type IVideoView = {
+    handle: IVideoViewHandle;
+    /** `null` means the view cannot register and the caller renders nothing */
+    render(props: object): IDescriptor | null;
+};
+/** One per mounted view, `getNode` answers the host node once it exists */
+export declare function createVideoView(getNode: () => ISymbioteNode | null | undefined): IVideoView;

package/build/core/video-view.js

@@ -0,0 +1,63 @@
+// Ядро `VideoView`: нативный view плеера, функции вызываются через `ViewPrototypes`
+import { Platform, requireNativeModule, requireNativeViewManager, } from 'expo-modules-core';
+import { el } from '@symbiote-native/components';
+import { defineExpoNativeViews, defineExpoViewMethods, getNativeTag, isDevBuild, } from '@symbiote-native/engine';
+import { VIDEO_MODULE_NAME, VIDEO_VIEW_NAMES } from './constants.js';
+import { expoVideo } from './native-module.js';
+const VIEW_NAMES = {
+    video: VIDEO_VIEW_NAMES.video,
+    surface: VIDEO_VIEW_NAMES.surface,
+    texture: VIDEO_VIEW_NAMES.texture,
+};
+// Регистрация идёт при рендере: побочный эффект барреля теряется в release
+const views = defineExpoNativeViews(requireNativeViewManager, VIDEO_MODULE_NAME, VIEW_NAMES);
+const callers = {
+    video: defineExpoViewMethods(requireNativeModule, VIDEO_MODULE_NAME, VIEW_NAMES.video),
+    surface: defineExpoViewMethods(requireNativeModule, VIDEO_MODULE_NAME, VIEW_NAMES.surface),
+    texture: defineExpoViewMethods(requireNativeModule, VIDEO_MODULE_NAME, VIEW_NAMES.texture),
+};
+function viewKeyFor(surfaceType) {
+    return Platform.select({
+        android: surfaceType === 'textureView' ? 'texture' : 'surface',
+        default: 'video',
+    });
+}
+// The native view takes the id of the shared object, not the player itself
+function playerIdOf(player) {
+    if (player instanceof expoVideo.VideoPlayer) {
+        const id = Reflect.get(player, '__expo_shared_object_id__');
+        return typeof id === 'number' ? id : null;
+    }
+    return typeof player === 'number' ? player : null;
+}
+/** One per mounted view, `getNode` answers the host node once it exists */
+export function createVideoView(getNode) {
+    let renderedKey = viewKeyFor(undefined);
+    async function call(method) {
+        const node = getNode();
+        if (!node || getNativeTag(node) === undefined)
+            return;
+        await callers[renderedKey](node, method, []);
+    }
+    return {
+        handle: {
+            enterFullscreen: () => call('enterFullscreen'),
+            exitFullscreen: () => call('exitFullscreen'),
+            startPictureInPicture: () => call('startPictureInPicture'),
+            stopPictureInPicture: () => call('stopPictureInPicture'),
+        },
+        render: props => {
+            renderedKey = viewKeyFor(Reflect.get(props, 'surfaceType'));
+            const view = views[renderedKey];
+            if (!view.ensureRegistered()) {
+                if (isDevBuild())
+                    console.warn("'VideoView' is not available.");
+                return null;
+            }
+            return el(view.name(), {
+                ...Object.fromEntries(Object.entries(props)),
+                player: playerIdOf(Reflect.get(props, 'player')),
+            });
+        },
+    };
+}

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

@@ -0,0 +1,90 @@
+import type { IAccessibilityProps, IAriaProps, IResponderProps } from '@symbiote-native/components';
+import type { IColorValue, IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
+import type { VideoPlayer } from './player-types';
+/** `fill` stretches the video, `cover` crops it, `contain` letterboxes it */
+export type IVideoContentFit = 'contain' | 'cover' | 'fill';
+/** Android only: `textureView` for overlapping views, `surfaceView` otherwise */
+export type IVideoSurfaceType = 'textureView' | 'surfaceView';
+/** Android only, which buttons the native controls show */
+export type IVideoButtonOptions = {
+    /** `false` by default */
+    showNext?: boolean;
+    /** `false` by default */
+    showPrevious?: boolean;
+    /** `true` by default */
+    showSeekForward?: boolean;
+    /** `true` by default */
+    showSeekBackward?: boolean;
+    /** `true` always, `false` never, `null` only when subtitles exist */
+    showSubtitles?: boolean | null;
+    /** `true` by default */
+    showSettings?: boolean;
+    /** `true` by default */
+    showPlayPause?: boolean;
+    /** `true` by default, fullscreen shows it anyway */
+    showBottomBar?: boolean;
+};
+export type IVideoFullscreenOrientation = 'default' | 'portrait' | 'portraitUp' | 'portraitDown' | 'landscape' | 'landscapeLeft' | 'landscapeRight';
+export type IVideoKeepFullscreenOnPiPStop = 'always' | 'autoEnter' | 'never';
+export type IVideoFullscreenOptions = {
+    /** Shows the fullscreen button, `true` by default */
+    enable: boolean;
+    orientation?: IVideoFullscreenOrientation;
+    /** Leaves fullscreen when the device turns away from `orientation` */
+    autoExitOnRotate?: boolean;
+    /** iOS only, `autoEnter` by default */
+    keepFullscreenOnPiPStop?: IVideoKeepFullscreenOnPiPStop;
+};
+export type IVideoViewProps = IAccessibilityProps & IAriaProps & IResponderProps & {
+    /** From `useVideoPlayer` */
+    player?: VideoPlayer | null;
+    /** Always on in fullscreen, `true` by default */
+    nativeControls?: boolean;
+    /** `contain` by default */
+    contentFit?: IVideoContentFit;
+    fullscreenOptions?: IVideoFullscreenOptions;
+    /** iOS only, `true` by default */
+    showsTimecodes?: boolean;
+    /** Forbids skipping, `false` by default */
+    requiresLinearPlayback?: boolean;
+    buttonOptions?: IVideoButtonOptions;
+    /** Android only, must not change at runtime */
+    surfaceType?: IVideoSurfaceType;
+    /** iOS only, `{ dx: 0, dy: 0 }` by default */
+    contentPosition?: {
+        dx?: number;
+        dy?: number;
+    };
+    onPictureInPictureStart?: () => void;
+    onPictureInPictureStop?: () => void;
+    /** Needs `supportsPictureInPicture` of the app setup */
+    allowsPictureInPicture?: boolean;
+    /** Android 12+ and iOS, `false` by default */
+    startsPictureInPictureAutomatically?: boolean;
+    /** iOS 16+, `true` by default */
+    allowsVideoFrameAnalysis?: boolean;
+    onFullscreenEnter?: () => void;
+    onFullscreenExit?: () => void;
+    /** The first frame is rendered, also when the video track changes */
+    onFirstFrameRender?: () => void;
+    /** Android only, `false` by default */
+    useExoShutter?: boolean;
+    style?: IStyleProp<IViewStyle>;
+    testID?: string;
+    nativeID?: string;
+    onLayout?: (event: ISymbioteEvent) => void;
+};
+export type IVideoAirPlayButtonProps = IAccessibilityProps & IAriaProps & {
+    /** The icon colour while AirPlay is not active */
+    tint?: IColorValue;
+    /** The icon colour while AirPlay is active */
+    activeTint?: IColorValue;
+    /** Lists the video outputs first, `true` by default */
+    prioritizeVideoDevices?: boolean;
+    onBeginPresentingRoutes?: () => void;
+    onEndPresentingRoutes?: () => void;
+    style?: IStyleProp<IViewStyle>;
+    testID?: string;
+    nativeID?: string;
+    onLayout?: (event: ISymbioteEvent) => void;
+};

package/build/core/view-types.js

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

package/build/react/index.d.ts

@@ -0,0 +1,4 @@
+export { VideoAirPlayButton, VideoView } from './video-view';
+export type { IVideoViewReactProps } from './video-view';
+export { useVideoPlayer } from './use-video-player';
+export * from '../core';

package/build/react/index.js

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

package/build/react/use-video-player.d.ts

@@ -0,0 +1,7 @@
+import type { IVideoPlayerBuilderOptions, IVideoSource, VideoPlayer } from '../core';
+/**
+ * Creates a player that is released when the component unmounts
+ *
+ * `setup` runs once on each new player, a changed source or options make a new one
+ */
+export declare function useVideoPlayer(source: IVideoSource, setup?: (player: VideoPlayer) => void, playerBuilderOptions?: IVideoPlayerBuilderOptions): VideoPlayer;

package/build/react/use-video-player.js

@@ -0,0 +1,11 @@
+import { createResourceHook } from '@symbiote-native/react';
+import { createVideoPlayerController } from '../core/video-player-controller.js';
+const usePlayerResource = createResourceHook(createVideoPlayerController);
+/**
+ * Creates a player that is released when the component unmounts
+ *
+ * `setup` runs once on each new player, a changed source or options make a new one
+ */
+export function useVideoPlayer(source, setup, playerBuilderOptions) {
+    return usePlayerResource(source, playerBuilderOptions, setup);
+}

package/build/react/video-view.d.ts

@@ -0,0 +1,13 @@
+import type { ReactElement, Ref } from 'react';
+import type { IVideoAirPlayButtonProps, IVideoViewHandle, IVideoViewProps } from '../core';
+export type IVideoViewReactProps = IVideoViewProps & {
+    ref?: Ref<IVideoViewHandle>;
+    className?: string;
+};
+export type IVideoAirPlayButtonReactProps = IVideoAirPlayButtonProps & {
+    className?: string;
+};
+/** React twin of `expo-video`'s `VideoView` */
+export declare function VideoView({ ref, ...props }: IVideoViewReactProps): ReactElement | null;
+/** React twin of `expo-video`'s `VideoAirPlayButton`, a plain view off iOS */
+export declare function VideoAirPlayButton(props: IVideoAirPlayButtonReactProps): ReactElement;

package/build/react/video-view.js

@@ -0,0 +1,10 @@
+import { descriptorToReact, useNativeViewController, } from '@symbiote-native/react';
+import { createVideoView, renderVideoAirPlayButton } from '../core/index.js';
+/** React twin of `expo-video`'s `VideoView` */
+export function VideoView({ ref, ...props }) {
+    return useNativeViewController(ref, createVideoView, props);
+}
+/** React twin of `expo-video`'s `VideoAirPlayButton`, a plain view off iOS */
+export function VideoAirPlayButton(props) {
+    return descriptorToReact(renderVideoAirPlayButton(props));
+}

package/build/solid/index.d.ts

@@ -0,0 +1,3 @@
+export { VideoAirPlayButton, VideoView } from './video-view';
+export { useVideoPlayer } from './use-video-player';
+export * from '../core';

package/build/solid/index.js

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

package/build/solid/use-video-player.d.ts

@@ -0,0 +1,8 @@
+import type { Accessor } from 'solid-js';
+import type { IVideoPlayerBuilderOptions, IVideoSource, VideoPlayer } from '../core';
+/**
+ * Solid twin of `expo-video`'s `useVideoPlayer`, released when the owner is disposed
+ *
+ * `setup` runs once on each new player, a changed source or options make a new one
+ */
+export declare function useVideoPlayer(source: Accessor<IVideoSource>, setup?: (player: VideoPlayer) => void, playerBuilderOptions?: Accessor<IVideoPlayerBuilderOptions | undefined>): Accessor<VideoPlayer>;

package/build/solid/use-video-player.js

@@ -0,0 +1,11 @@
+import { createResourceHook } from '@symbiote-native/solid';
+import { createVideoPlayerController } from '../core/video-player-controller.js';
+const usePlayerResource = createResourceHook(createVideoPlayerController);
+/**
+ * Solid twin of `expo-video`'s `useVideoPlayer`, released when the owner is disposed
+ *
+ * `setup` runs once on each new player, a changed source or options make a new one
+ */
+export function useVideoPlayer(source, setup, playerBuilderOptions = () => undefined) {
+    return usePlayerResource(() => [source(), playerBuilderOptions(), setup]);
+}

package/build/solid/video-view.d.ts

@@ -0,0 +1,33 @@
+import type { IVideoAirPlayButtonProps, IVideoViewHandle } from '../core';
+/** Solid twin of `expo-video`'s `VideoView`, `ref` gets the handle of the view */
+export declare const VideoView: (props: import("@symbiote-native/components").IAccessibilityProps & import("@symbiote-native/components").IAriaProps & import("@symbiote-native/components").IResponderProps & {
+    player?: import(".").VideoPlayer | null;
+    nativeControls?: boolean;
+    contentFit?: import(".").IVideoContentFit;
+    fullscreenOptions?: import(".").IVideoFullscreenOptions;
+    showsTimecodes?: boolean;
+    requiresLinearPlayback?: boolean;
+    buttonOptions?: import(".").IVideoButtonOptions;
+    surfaceType?: import(".").IVideoSurfaceType;
+    contentPosition?: {
+        dx?: number;
+        dy?: number;
+    };
+    onPictureInPictureStart?: () => void;
+    onPictureInPictureStop?: () => void;
+    allowsPictureInPicture?: boolean;
+    startsPictureInPictureAutomatically?: boolean;
+    allowsVideoFrameAnalysis?: boolean;
+    onFullscreenEnter?: () => void;
+    onFullscreenExit?: () => void;
+    onFirstFrameRender?: () => void;
+    useExoShutter?: boolean;
+    style?: import("@symbiote-native/engine").IStyleProp<import("@symbiote-native/engine").IViewStyle>;
+    testID?: string;
+    nativeID?: string;
+    onLayout?: (event: import("@symbiote-native/engine").ISymbioteEvent) => void;
+} & {
+    ref?: ((handle: IVideoViewHandle) => void) | undefined;
+}) => import("@symbiote-native/engine").ISymbioteNode | null;
+/** Solid twin of `expo-video`'s `VideoAirPlayButton`, a plain view off iOS */
+export declare const VideoAirPlayButton: (props: IVideoAirPlayButtonProps) => import("@symbiote-native/engine").ISymbioteNode | null;

package/build/solid/video-view.js

@@ -0,0 +1,6 @@
+import { defineNativeViewComponent, defineOptionalDescriptorComponent, } from '@symbiote-native/solid';
+import { createVideoView, renderVideoAirPlayButton } from '../core/index.js';
+/** Solid twin of `expo-video`'s `VideoView`, `ref` gets the handle of the view */
+export const VideoView = defineNativeViewComponent(createVideoView);
+/** Solid twin of `expo-video`'s `VideoAirPlayButton`, a plain view off iOS */
+export const VideoAirPlayButton = defineOptionalDescriptorComponent(renderVideoAirPlayButton);

package/build/svelte/index.d.ts

@@ -0,0 +1,5 @@
+export { default as VideoView } from './video-view.svelte';
+export { default as VideoAirPlayButton } from './video-airplay-button.svelte';
+export { useVideoPlayer } from './use-video-player.svelte';
+export type { IUseVideoPlayerResult } from './use-video-player.svelte';
+export * from '../core';

package/build/svelte/index.js

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

package/build/svelte/use-video-player.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { IVideoPlayerBuilderOptions, IVideoSource, VideoPlayer } from '../core';
+export type IUseVideoPlayerResult = {
+    readonly current: VideoPlayer;
+};
+/**
+ * Svelte twin of `expo-video`'s `useVideoPlayer`, boxed getter shape of the other resource hooks
+ *
+ * `setup` runs once on each new player, a changed source or options make a new one
+ */
+export declare function useVideoPlayer(getSource: () => IVideoSource, setup?: (player: VideoPlayer) => void, getPlayerBuilderOptions?: () => IVideoPlayerBuilderOptions | undefined): IUseVideoPlayerResult;

package/build/svelte/use-video-player.svelte.js

@@ -0,0 +1,11 @@
+import { createResourceHook } from '@symbiote-native/svelte/runes/create-resource-hook';
+import { createVideoPlayerController } from '../core/video-player-controller.js';
+const usePlayerResource = createResourceHook(createVideoPlayerController);
+/**
+ * Svelte twin of `expo-video`'s `useVideoPlayer`, boxed getter shape of the other resource hooks
+ *
+ * `setup` runs once on each new player, a changed source or options make a new one
+ */
+export function useVideoPlayer(getSource, setup, getPlayerBuilderOptions = () => undefined) {
+    return usePlayerResource(() => [getSource(), getPlayerBuilderOptions(), setup]);
+}

package/build/svelte/video-airplay-button.svelte

@@ -0,0 +1,12 @@
+<script lang="ts">
+  // The native view name is mixed-case, which a literal tag would parse as a component reference,
+  // so the tag is dynamic
+  import { hostProps } from '@symbiote-native/svelte/native-view-bridge';
+  import { renderVideoAirPlayButton } from '../core';
+  import type { IVideoAirPlayButtonProps } from '../core';
+
+  const props: IVideoAirPlayButtonProps = $props();
+  const descriptor = $derived(renderVideoAirPlayButton({ ...props }));
+</script>
+
+<svelte:element this={descriptor.type} {@attach hostProps(descriptor.props)} />

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

@@ -0,0 +1,4 @@
+import type { IVideoAirPlayButtonProps } from '../core';
+declare const VideoAirplayButton: import("svelte").Component<IVideoAirPlayButtonProps, {}, "">;
+type VideoAirplayButton = ReturnType<typeof VideoAirplayButton>;
+export default VideoAirplayButton;

package/build/svelte/video-view.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+  // The native view name is mixed-case, which a literal tag would parse as a component reference,
+  // so the tag is dynamic
+  import { hostProps } from '@symbiote-native/svelte/native-view-bridge';
+  import { useNativeViewController } from '@symbiote-native/svelte/runes/use-native-view-controller';
+  import { createVideoView } from '../core';
+  import type { IVideoViewProps } from '../core';
+
+  const props: IVideoViewProps = $props();
+  const view = useNativeViewController(createVideoView, () => ({ ...props }));
+
+  // The functions of the view are instance members, `bind:this` reaches them
+  export const enterFullscreen = view.handle.enterFullscreen;
+  export const exitFullscreen = view.handle.exitFullscreen;
+  export const startPictureInPicture = view.handle.startPictureInPicture;
+  export const stopPictureInPicture = view.handle.stopPictureInPicture;
+</script>
+
+{#if view.descriptor}
+  <svelte:element
+    this={view.descriptor.type}
+    {@attach view.attachHost}
+    {@attach hostProps(view.descriptor.props)}
+  />
+{/if}

package/build/svelte/video-view.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { IVideoViewProps } from '../core';
+declare const VideoView: import("svelte").Component<IVideoViewProps, {
+    enterFullscreen: () => Promise<void>;
+    exitFullscreen: () => Promise<void>;
+    startPictureInPicture: () => Promise<void>;
+    stopPictureInPicture: () => Promise<void>;
+}, "">;
+type VideoView = ReturnType<typeof VideoView>;
+export default VideoView;

package/build/vue/index.d.ts

@@ -0,0 +1,3 @@
+export { VideoAirPlayButton, VideoView } from './video-view';
+export { useVideoPlayer } from './use-video-player';
+export * from '../core';

package/build/vue/index.js

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

package/build/vue/use-video-player.d.ts

@@ -0,0 +1,8 @@
+import { type ComputedRef, type MaybeRefOrGetter } from '@vue/runtime-core';
+import type { IVideoPlayerBuilderOptions, IVideoSource, VideoPlayer } from '../core';
+/**
+ * Vue twin of `expo-video`'s `useVideoPlayer`, released when the owner unmounts
+ *
+ * `setup` runs once on each new player, a changed source or options make a new one
+ */
+export declare function useVideoPlayer(source: MaybeRefOrGetter<IVideoSource>, setup?: (player: VideoPlayer) => void, playerBuilderOptions?: MaybeRefOrGetter<IVideoPlayerBuilderOptions | undefined>): ComputedRef<VideoPlayer>;

package/build/vue/use-video-player.js

@@ -0,0 +1,16 @@
+import { toValue, } from '@vue/runtime-core';
+import { createResourceHook } from '@symbiote-native/vue';
+import { createVideoPlayerController } from '../core/video-player-controller.js';
+const usePlayerResource = createResourceHook(createVideoPlayerController);
+/**
+ * Vue twin of `expo-video`'s `useVideoPlayer`, released when the owner unmounts
+ *
+ * `setup` runs once on each new player, a changed source or options make a new one
+ */
+export function useVideoPlayer(source, setup, playerBuilderOptions) {
+    return usePlayerResource(() => [
+        toValue(source),
+        toValue(playerBuilderOptions),
+        setup,
+    ]);
+}

package/build/vue/video-view.d.ts

@@ -0,0 +1,5 @@
+import { type VNode } from '@vue/runtime-core';
+/** Vue twin of `expo-video`'s `VideoView` */
+export declare const VideoView: import("vue").DefineComponent<{}, () => VNode | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/** Vue twin of `expo-video`'s `VideoAirPlayButton`, a plain view off iOS */
+export declare const VideoAirPlayButton: import("vue").DefineComponent<{}, () => VNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/build/vue/video-view.js

@@ -0,0 +1,14 @@
+import { defineComponent } from '@vue/runtime-core';
+import { defineNativeViewComponent, descriptorToVue, normalizeVueAttrs, } from '@symbiote-native/vue';
+import { createVideoView, renderVideoAirPlayButton } from '../core/index.js';
+/** Vue twin of `expo-video`'s `VideoView` */
+export const VideoView = defineNativeViewComponent('VideoView', createVideoView);
+/** Vue twin of `expo-video`'s `VideoAirPlayButton`, a plain view off iOS */
+export const VideoAirPlayButton = defineComponent({
+    name: 'VideoAirPlayButton',
+    // Все атрибуты это пропсы нативного view, на обёртку ничего не должно просочиться
+    inheritAttrs: false,
+    setup(_props, { attrs }) {
+        return () => descriptorToVue(renderVideoAirPlayButton(normalizeVueAttrs(attrs)));
+    },
+});

package/build-ngc/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-ngc/angular/index.js

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