@wyxos/vibe 5.9.0 → 5.10.1

package/lib/components/MediaControls.vue.d.ts

@@ -1,8 +1,9 @@
-import type { VibeLayout } from '../types';
+import type { VibeLayout, VibeMediaType } from '../types';
 type __VLS_Props = {
     currentTime: number;
     duration: number;
     layout: VibeLayout;
+    mediaType: Extract<VibeMediaType, 'audio' | 'video'>;
     muted: boolean;
     playing: boolean;
     volume: number;

package/lib/components/useMediaCardAudio.d.ts

@@ -6,12 +6,12 @@ interface MediaCardAudioOptions {
     mediaCard: () => VibeMediaCardOptions | undefined;
     onChange: (state: VibeReelAudioState) => void;
     reelAudioState: () => VibeReelAudioState | undefined;
-    videoElement: Ref<HTMLVideoElement | null>;
+    mediaElement: Ref<HTMLMediaElement | null>;
 }
 export declare function useMediaCardAudio(options: MediaCardAudioOptions): {
     apply: () => void;
     setVolume: (volume: number) => void;
-    sync: (video: HTMLVideoElement, syncMuted: boolean) => void;
+    sync: (media: HTMLMediaElement, syncMuted: boolean) => void;
     toggleMute: () => void;
     videoIsMuted: import("vue").ShallowRef<boolean, boolean>;
     videoVolume: import("vue").ShallowRef<number, number>;

package/lib/components/useMediaCarouselNavigation.d.ts

@@ -0,0 +1,15 @@
+import type { VibeItem, VibeLayout } from '../types';
+interface MediaCarouselNavigationOptions {
+    item: () => VibeItem;
+    layout: () => VibeLayout;
+    mediaIndex: () => number;
+    onChange: (mediaIndex: number) => void;
+}
+export declare function useMediaCarouselNavigation(options: MediaCarouselNavigationOptions): {
+    change: (index: number, event?: MouseEvent) => void;
+    direction: import("vue").ShallowRef<"next" | "previous", "next" | "previous">;
+    onTouchEnd: (event: TouchEvent) => void;
+    onTouchStart: (event: TouchEvent) => void;
+    onWheel: (event: WheelEvent) => void;
+};
+export {};

package/lib/components/useMediaLoading.d.ts

@@ -6,11 +6,11 @@ interface MediaLoadingOptions {
     layout: () => VibeLayout;
     mediaSource: () => string;
     mediaType: () => VibeMediaType | undefined;
-    videoElement: ShallowRef<HTMLVideoElement | null>;
+    mediaElement: ShallowRef<HTMLMediaElement | null>;
 }
 export declare function useMediaLoading(options: MediaLoadingOptions): {
     imageLoading: import("vue").ComputedRef<"lazy" | "eager">;
     mediaIsTimed: import("vue").ComputedRef<boolean>;
-    videoPreload: import("vue").ComputedRef<"none" | "metadata" | "auto">;
+    timedMediaPreload: import("vue").ComputedRef<"none" | "metadata" | "auto">;
 };
 export {};

package/lib/components/useMediaReadiness.d.ts

@@ -15,6 +15,6 @@ export declare function useMediaReadiness(options: MediaReadinessOptions): {
     retrySource: () => void;
     retrying: import("vue").ShallowRef<boolean, boolean>;
     sourceGeneration: import("vue").ShallowRef<number, number>;
-    videoElement: import("vue").ShallowRef<HTMLVideoElement | null, HTMLVideoElement | null>;
+    mediaElement: import("vue").ShallowRef<HTMLMediaElement | null, HTMLMediaElement | null>;
 };
 export {};

package/lib/components/useReelVideoActivity.d.ts

@@ -1,13 +1,13 @@
 import { type Ref } from 'vue';
 import type { VibeLayout } from '../types';
-interface ReelVideoActivityOptions {
+interface ReelTimedMediaActivityOptions {
     active: () => boolean | undefined;
     layout: () => VibeLayout;
-    videoElement: Ref<HTMLVideoElement | null>;
-    videoIsMuted: Ref<boolean>;
-    videoIsPlaying: Ref<boolean>;
+    mediaElement: Ref<HTMLMediaElement | null>;
+    mediaIsMuted: Ref<boolean>;
+    mediaIsPlaying: Ref<boolean>;
 }
-export declare function useReelVideoActivity(options: ReelVideoActivityOptions): {
+export declare function useReelTimedMediaActivity(options: ReelTimedMediaActivityOptions): {
     effectiveMuted: import("vue").ComputedRef<boolean>;
     onPlaying: () => void;
     playbackAllowed: import("vue").ComputedRef<boolean>;

package/lib/components/useTimedMediaCard.d.ts

@@ -0,0 +1,30 @@
+import { type Ref } from 'vue';
+import type { VibeLayout, VibeMediaCardOptions, VibeReelAudioState } from '../types';
+interface TimedMediaCardOptions {
+    active: () => boolean | undefined;
+    layout: () => VibeLayout;
+    mediaCard: () => VibeMediaCardOptions | undefined;
+    mediaElement: Ref<HTMLMediaElement | null>;
+    onAudioChange: (state: VibeReelAudioState) => void;
+    onEnded: () => void;
+    onReady: (event: Event) => void;
+    reelAudioState: () => VibeReelAudioState | undefined;
+}
+export declare function useTimedMediaCard(options: TimedMediaCardOptions): {
+    currentTime: import("vue").ShallowRef<number, number>;
+    duration: import("vue").ShallowRef<number, number>;
+    effectiveMuted: import("vue").ComputedRef<boolean>;
+    isMuted: import("vue").ShallowRef<boolean, boolean>;
+    isPlaying: import("vue").ShallowRef<boolean, boolean>;
+    onEnded: () => void;
+    onLoadedMetadata: (event: Event) => void;
+    onPlaying: () => void;
+    playbackAllowed: import("vue").ComputedRef<boolean>;
+    seek: (time: number) => void;
+    setVolume: (volume: number) => void;
+    sync: (event?: Event) => void;
+    toggleMute: () => void;
+    togglePlayback: () => Promise<void>;
+    volume: import("vue").ShallowRef<number, number>;
+};
+export {};

package/lib/core/masonry.d.ts

@@ -1,7 +1,7 @@
 export interface MasonryMediaDimensions {
     width: number | null;
     height: number | null;
-    preview: {
+    preview?: {
         width: number | null;
         height: number | null;
     };

package/lib/core/mediaAsset.d.ts

@@ -1,5 +1,7 @@
 import type { VibeItem, VibeItemId, VibeMediaAsset, VibeMediaSource, VibeMediaVariant } from '../types';
 export declare function mediaVariantForSource(asset: VibeMediaAsset, source: VibeMediaSource): VibeMediaVariant;
+export declare function audioCoverVariant(asset: VibeMediaAsset): VibeMediaVariant | null;
+export declare function mediaPlaybackVariantForSource(asset: VibeMediaAsset, source: VibeMediaSource): VibeMediaVariant;
 export declare function mediaAssets(item: VibeItem): readonly VibeMediaAsset[];
 export declare function clampMediaIndex(item: VibeItem, index: number): number;
 export declare function mediaAssetAt(item: VibeItem, index: number): VibeMediaAsset;

package/lib/core/mediaType.d.ts

@@ -1,3 +1,5 @@
 import type { VibeMediaType } from '../types';
+export declare function inferMediaType(src: string): VibeMediaType;
+export declare function resolveMediaType(type: VibeMediaType | undefined, src: string): VibeMediaType;
 export declare function isTimedMediaSource(src: string): boolean;
 export declare function isTimedMedia(type: VibeMediaType | undefined, src: string): boolean;