@wyxos/vibe 3.1.35 → 4.0.0

package/lib/components/viewer-core/useDataSource.d.ts

@@ -1,99 +0,0 @@
-import type { VibeViewerItem } from '../viewer';
-import type { VibeEmptyStateMode } from './surfaceSlots';
-export type { VibeHandle, VibeRemoveResult } from './removalState';
-export type { VibeFillMode, VibeLoadPhase, VibeSurfaceMode } from './removalState';
-export interface VibeResolveParams {
-    cursor: string | null;
-    pageSize: number;
-    signal?: AbortSignal;
-}
-export interface VibeResolveResult {
-    items: VibeViewerItem[];
-    nextPage: string | null;
-    previousPage?: string | null;
-    total?: number | null;
-}
-export interface VibeInitialState {
-    items: VibeViewerItem[];
-    cursor: string | null;
-    nextCursor?: string | null;
-    previousCursor?: string | null;
-    activeIndex?: number;
-}
-export interface VibeProps {
-    bottomLoadBufferPx?: number;
-    emptyStateMode?: VibeEmptyStateMode;
-    fillDelayMaxMs?: number;
-    fillDelayMs?: number;
-    fillDelayStepMs?: number;
-    initialCursor?: string | null;
-    initialState?: VibeInitialState;
-    loopFullscreenVideo?: boolean;
-    pageSize?: number;
-    paginationDetail?: string | null;
-    resolve?: (params: VibeResolveParams) => Promise<VibeResolveResult>;
-    showDominantImageTone?: boolean;
-    showEndBadge?: boolean;
-    showStatusBadges?: boolean;
-    surfaceMode?: import('./removalState').VibeSurfaceMode;
-}
-export interface VibeEmit {
-    (event: 'update:activeIndex', value: number): void;
-    (event: 'update:surfaceMode', value: import('./removalState').VibeSurfaceMode): void;
-}
-export declare function useDataSource(props: Readonly<VibeProps>, emit: VibeEmit): {
-    activeIndex: import("vue").ComputedRef<number>;
-    canRefreshExhaustedNextPage: import("vue").ComputedRef<boolean>;
-    canRetryInitialLoad: import("vue").ComputedRef<boolean>;
-    cancel: () => void;
-    cancelFill: () => void;
-    clearRemoved: () => void;
-    commitPendingAppend: () => Promise<void>;
-    currentCursor: import("vue").ComputedRef<string | null>;
-    errorMessage: import("vue").Ref<string | null, string | null>;
-    fillCollectedCount: import("vue").Ref<number | null, number | null>;
-    fillCompletedCalls: import("vue").Ref<number, number>;
-    fillCursor: import("vue").Ref<string | null, string | null>;
-    fillDelayRemainingMs: import("vue").Ref<number | null, number | null>;
-    fillLoadedCount: import("vue").Ref<number, number>;
-    fillMode: import("vue").Ref<import("./removalState").VibeFillMode, import("./removalState").VibeFillMode>;
-    fillProgress: import("vue").Ref<number | null, number | null>;
-    fillTargetCalls: import("vue").Ref<number | null, number | null>;
-    fillTargetCount: import("vue").Ref<number | null, number | null>;
-    fillTotalCount: import("vue").Ref<number | null, number | null>;
-    fillUntil: (cursorOrCount: number | string) => Promise<void>;
-    fillUntilEnd: () => Promise<void>;
-    getItemByOccurrenceKey: (occurrenceKey: string) => VibeViewerItem | null;
-    getItems: () => VibeViewerItem[];
-    getRemovedIds: () => string[];
-    hasNextPage: import("vue").ComputedRef<boolean>;
-    hasPreviousPage: import("vue").ComputedRef<boolean>;
-    isPageLoadingLocked: import("vue").ComputedRef<boolean>;
-    items: import("vue").ComputedRef<VibeViewerItem[]>;
-    lockPageLoading: () => void;
-    loading: import("vue").ComputedRef<boolean>;
-    loadNext: () => Promise<void>;
-    loadPrevious: () => Promise<void>;
-    nextCursor: import("vue").ComputedRef<string | null>;
-    paginationDetail: import("vue").ComputedRef<string | null>;
-    pendingAppendItems: import("vue").ComputedRef<VibeViewerItem[]>;
-    phase: import("vue").Ref<import("./removalState").VibeLoadPhase, import("./removalState").VibeLoadPhase>;
-    prefetchNextPage: () => Promise<void>;
-    prefetchPreviousPage: () => Promise<void>;
-    previousCursor: import("vue").ComputedRef<string | null>;
-    removedCount: import("vue").ComputedRef<number>;
-    remove: (ids: string | string[]) => {
-        ids: string[];
-    };
-    restore: (ids: string | string[]) => {
-        ids: string[];
-    };
-    retry: () => Promise<void>;
-    retryInitialLoad: () => Promise<void>;
-    setActiveIndex: (nextIndex: number) => void;
-    setAutoPrefetchEnabled: (nextValue: boolean) => void;
-    undo: () => {
-        ids: string[];
-    } | null;
-    unlockPageLoading: () => void;
-};

package/lib/components/viewer-core/useEdgeBoundary.d.ts

@@ -1,18 +0,0 @@
-import { type Ref } from 'vue';
-export type VibeMasonryEdgeDirection = 'bottom' | 'top';
-export type VibeMasonryBoundarySyncSource = 'layout' | 'scroll';
-export declare function useEdgeBoundary(options: {
-    direction: VibeMasonryEdgeDirection;
-    interactionLocked?: Ref<boolean>;
-    hasPage: Ref<boolean>;
-    isAtBoundary: () => boolean;
-    loading: Ref<boolean>;
-    requestPage: Ref<(() => void | Promise<void>) | null | undefined>;
-    getAnimationLockMs: (addedItemCount: number) => number;
-}): {
-    maybeRequestPage: () => void;
-    onItemsMutated: (addedItemCount: number) => void;
-    onLoadingChange: (isLoading: boolean) => void;
-    onWheel: (event: WheelEvent) => void;
-    syncBoundary: (source?: VibeMasonryBoundarySyncSource) => void;
-};

package/lib/components/viewer-core/useFullscreen.d.ts

@@ -1 +0,0 @@
-export { useViewer as useFullscreen } from './useViewer';

package/lib/components/viewer-core/useFullscreenAssetEvents.d.ts

@@ -1,24 +0,0 @@
-import type { VibeViewerItem } from '../viewer';
-interface FullscreenAssetMediaController {
-    getItemKey: (item: VibeViewerItem) => string;
-    settleAssetPreload: (id: string) => void;
-    shouldHandleSlideAssetEvent: (index: number, item: VibeViewerItem) => boolean;
-}
-interface FullscreenAssetViewer {
-    onImageError: (id: string, url: string) => Promise<void>;
-    onImageLoad: (id: string, url: string) => void;
-    onMediaError: (id: string, url: string) => Promise<void>;
-    onMediaEvent: (id: string, event: Event) => void;
-}
-export declare function useFullscreenAssetEvents(options: {
-    fullscreenMedia: FullscreenAssetMediaController;
-    updateDominantToneFromImageElement: (id: string, image: HTMLImageElement) => void;
-    viewer: FullscreenAssetViewer;
-}): {
-    getHandledItemKey: (index: number, item: VibeViewerItem) => string | null;
-    onFullscreenImageError: (index: number, item: VibeViewerItem) => Promise<void>;
-    onFullscreenImageLoad: (event: Event, index: number, item: VibeViewerItem) => void;
-    onFullscreenMediaError: (index: number, item: VibeViewerItem) => Promise<void>;
-    onFullscreenMediaEvent: (index: number, item: VibeViewerItem, event: Event) => string | null;
-};
-export {};

package/lib/components/viewer-core/useFullscreenDominantTone.d.ts

@@ -1,12 +0,0 @@
-import { type Ref } from 'vue';
-import type { VibeViewerItem } from '../viewer';
-export declare function useFullscreenDominantTone(options: {
-    activeItem: Ref<VibeViewerItem | null>;
-    getItemKey: (item: VibeViewerItem) => string;
-    isImageReady: (id: string) => boolean;
-    showDominantImageTone: Ref<boolean | undefined>;
-}): {
-    activeStageToneStyle: import("vue").ComputedRef<Record<string, string> | undefined>;
-    activeSlideToneStyle: import("vue").ComputedRef<Record<string, string> | undefined>;
-    updateFromImageElement: (id: string, image: HTMLImageElement) => void;
-};

package/lib/components/viewer-core/useFullscreenPreloadController.d.ts

@@ -1,18 +0,0 @@
-import { type Ref } from 'vue';
-import type { VibeViewerItem } from '../viewer';
-export type FullscreenSlidePreloadState = 'idle' | 'queued' | 'loading' | 'ready';
-export declare function useFullscreenPreloadController(options: {
-    active: Ref<boolean | undefined>;
-    items: Ref<VibeViewerItem[]>;
-    resolvedActiveIndex: Ref<number>;
-    getItemKey: (item: VibeViewerItem) => string;
-    isAssetReady: (id: string, item: VibeViewerItem) => boolean;
-    onResetAssetState: (id: string) => void;
-}): {
-    clearPreloads: () => void;
-    getSlidePreloadState: (index: number) => FullscreenSlidePreloadState;
-    registerImageElement: (id: string, element: unknown) => void;
-    registerMediaElement: (id: string, element: unknown) => void;
-    settleAssetPreload: (id: string) => void;
-    shouldAttachSlideAsset: (index: number) => boolean;
-};

package/lib/components/viewer-core/useFullscreenSurfaceMedia.d.ts

@@ -1,32 +0,0 @@
-import type { Ref } from 'vue';
-import type { VibeViewerItem } from '../viewer';
-export declare function useFullscreenSurfaceMedia(options: {
-    active: Ref<boolean | undefined>;
-    items: Ref<VibeViewerItem[]>;
-    resolvedActiveIndex: Ref<number>;
-    viewer: {
-        getAssetErrorKind: (id: string) => unknown;
-        getAssetErrorLabel: (id: string) => string | null | undefined;
-        getImageSource: (item: VibeViewerItem) => string | undefined;
-        isImageReady: (id: string) => boolean;
-        isMediaReady: (id: string) => boolean;
-        resetAssetState: (id: string) => void;
-    };
-}): {
-    getAssetErrorKind: (item: VibeViewerItem) => unknown;
-    getAssetErrorLabel: (item: VibeViewerItem) => string;
-    getFullscreenAudioCoverSource: (item: VibeViewerItem) => string | null;
-    getFullscreenImageSource: (index: number, item: VibeViewerItem) => string | undefined;
-    getFullscreenMediaPreload: (index: number) => "none" | "metadata";
-    getFullscreenMediaSource: (index: number, item: VibeViewerItem) => string | undefined;
-    getItemKey: (item: VibeViewerItem) => string;
-    getMediaActionLabel: (action: "Play" | "Pause", item: VibeViewerItem) => string;
-    getSlidePreloadState: (index: number) => import("./useFullscreenPreloadController").FullscreenSlidePreloadState;
-    isAssetErrored: (index: number, item: VibeViewerItem) => boolean;
-    isAssetLoading: (index: number, item: VibeViewerItem) => boolean;
-    registerImageElement: (id: string, element: unknown) => void;
-    registerMediaElement: (id: string, element: unknown) => void;
-    settleAssetPreload: (id: string) => void;
-    shouldHandleSlideAssetEvent: (index: number, item: VibeViewerItem) => boolean;
-    shouldPreloadSlideAsset: (index: number) => boolean;
-};

package/lib/components/viewer-core/useListCardHealthCheck.d.ts

@@ -1,20 +0,0 @@
-import { type ComputedRef, type Ref } from 'vue';
-import type { VibeViewerItem } from '../viewer';
-import type { VibeAssetErrorReporter } from './assetErrors';
-import { type VibeAssetErrorKind } from './loadError';
-type UseListCardHealthCheckOptions = {
-    attachedAssetUrl: ComputedRef<string | null>;
-    getPriority: () => number;
-    isInView: Ref<boolean>;
-    isReady: Ref<boolean>;
-    item: ComputedRef<VibeViewerItem>;
-    loadErrorKind: Ref<VibeAssetErrorKind | null>;
-    reportAssetError?: VibeAssetErrorReporter | null;
-    surfaceActive: ComputedRef<boolean>;
-};
-export declare function useListCardHealthCheck(options: UseListCardHealthCheckOptions): {
-    errorKind: Ref<VibeAssetErrorKind | null, VibeAssetErrorKind | null>;
-    release: () => void;
-    retry: () => boolean;
-};
-export {};

package/lib/components/viewer-core/useMasonryList.d.ts

@@ -1,85 +0,0 @@
-import { type Ref } from 'vue';
-import type { VibeViewerItem } from '../viewer';
-export declare function useVibeMasonryList(options: {
-    active: Ref<boolean>;
-    allowExhaustedNextPageRefresh: Ref<boolean>;
-    bottomLoadBufferPx: Ref<number | undefined>;
-    items: Ref<VibeViewerItem[]>;
-    activeIndex: Ref<number>;
-    loading: Ref<boolean>;
-    hasNextPage: Ref<boolean>;
-    hasPreviousPage: Ref<boolean>;
-    paginationDetail: Ref<string | null>;
-    pendingAppendItems: Ref<VibeViewerItem[]>;
-    commitPendingAppend: Ref<(() => void | Promise<void>) | null | undefined>;
-    requestNextPage: Ref<(() => void | Promise<void>) | null | undefined>;
-    requestPreviousPage: Ref<(() => void | Promise<void>) | null | undefined>;
-    setActiveIndex: (index: number) => void;
-}): {
-    autoScroll: (speed: number) => void;
-    columnWidth: import("vue").ComputedRef<number>;
-    containerHeight: import("vue").ComputedRef<number>;
-    getCardStyle: (index: number) => {
-        height: string;
-        width: string;
-        transition: string | undefined;
-        transitionDelay: string | undefined;
-        transform: string;
-    };
-    getLeavingCardStyle: (item: VibeViewerItem) => {
-        opacity: string;
-        transform: string;
-        transition: string;
-        height?: undefined;
-        width?: undefined;
-    } | {
-        height: string;
-        opacity: string;
-        transform: string;
-        transition: string;
-        width: string;
-    };
-    getScrollbarThumbStyle: () => {
-        height: string;
-        transform: string;
-    };
-    leavingItems: import("vue").ComputedRef<{
-        height: number;
-        item: {
-            [x: string]: unknown;
-            id: string;
-            type: import("../viewer").VibeViewerType;
-            title?: string | undefined;
-            url: string;
-            preview?: {
-                url: string;
-                width?: number | undefined;
-                height?: number | undefined;
-                mediaType?: import("../viewer").VibeRenderableMediaType | undefined;
-            } | undefined;
-            healthCheck?: {
-                kind?: "playback" | undefined;
-                url: string;
-            } | null | undefined;
-            width?: number | undefined;
-            height?: number | undefined;
-        };
-        position: {
-            x: number;
-            y: number;
-        };
-    }[]>;
-    nextBoundaryLoadProgress: import("vue").ComputedRef<number>;
-    onScroll: () => void;
-    onWheel: (event: WheelEvent) => void;
-    paginationLabel: import("vue").ComputedRef<string>;
-    previousBoundaryLoadProgress: import("vue").ComputedRef<number>;
-    renderedItems: import("vue").ComputedRef<{
-        item: VibeViewerItem;
-        index: number;
-    }[]>;
-    resolvedActiveIndex: import("vue").ComputedRef<number>;
-    scrollToIndex: (index: number, alignment: "center" | "nearest") => void;
-    showScrollbar: import("vue").ComputedRef<boolean>;
-    scrollViewportRef: Ref<HTMLElement | null, HTMLElement | null>;
-};

package/lib/components/viewer-core/useMasonryMotion.d.ts

@@ -1,76 +0,0 @@
-import { type ComputedRef, type Ref } from 'vue';
-import type { VibeViewerItem } from '../viewer';
-import type { LayoutPosition } from './masonryLayout';
-export type VibeMasonryEnterDirection = 'bottom' | 'top';
-export interface VibeMasonryLeavingItem {
-    height: number;
-    item: VibeViewerItem;
-    position: LayoutPosition;
-}
-export declare function getVibeMasonryEnterOrder(itemIds: string[], direction: VibeMasonryEnterDirection): string[];
-export declare function getVibeMasonryEnterDuration(itemCount: number): number;
-export declare function shouldWindowVibeMasonryEnterTracking(pendingCount: number, addedCount: number, maxPendingItems?: number): boolean;
-export declare function getVibeMasonryLeaveDuration(): number;
-export declare function getVibeMasonryEnterStartY(options: {
-    direction: VibeMasonryEnterDirection;
-    itemHeight: number;
-    columnWidth: number;
-    scrollTop: number;
-    viewportHeight: number;
-}): number;
-export declare function useMasonryMotion(options: {
-    items: Ref<VibeViewerItem[]>;
-    visibleIndices: ComputedRef<number[]>;
-    positions: Ref<LayoutPosition[]>;
-    heights: Ref<number[]>;
-    indexById: Ref<Map<string, number>>;
-    columnWidth: ComputedRef<number>;
-    scrollTop: Ref<number>;
-    viewportHeight: Ref<number>;
-}): {
-    getCardTransform: (index: number) => string;
-    getCardTransition: (itemId: string) => string | undefined;
-    getCardTransitionDelay: (itemId: string) => string | undefined;
-    getLeavingCardStyle: (item: VibeViewerItem) => {
-        opacity: string;
-        transform: string;
-        transition: string;
-        height?: undefined;
-        width?: undefined;
-    } | {
-        height: string;
-        opacity: string;
-        transform: string;
-        transition: string;
-        width: string;
-    };
-    leavingItems: ComputedRef<{
-        height: number;
-        item: {
-            [x: string]: unknown;
-            id: string;
-            type: import("../viewer").VibeViewerType;
-            title?: string | undefined;
-            url: string;
-            preview?: {
-                url: string;
-                width?: number | undefined;
-                height?: number | undefined;
-                mediaType?: import("../viewer").VibeRenderableMediaType | undefined;
-            } | undefined;
-            healthCheck?: {
-                kind?: "playback" | undefined;
-                url: string;
-            } | null | undefined;
-            width?: number | undefined;
-            height?: number | undefined;
-        };
-        position: {
-            x: number;
-            y: number;
-        };
-    }[]>;
-    markEnter: (items: VibeViewerItem[], direction?: VibeMasonryEnterDirection) => void;
-    markLeave: (items: VibeMasonryLeavingItem[]) => void;
-    playFlipMoveAnimation: (oldPositionsById: Map<string, LayoutPosition>, skipIds?: Set<string>, durationMs?: number) => void;
-};

package/lib/components/viewer-core/useMedia.d.ts

@@ -1,44 +0,0 @@
-import { type Ref } from 'vue';
-import type { VibeViewerItem } from '../viewer';
-import type { VibeAssetErrorReporter, VibeAssetLoadReporter } from './assetErrors';
-import { type MediaUiState } from './assetState';
-import { type VibeAssetErrorKind } from './loadError';
-export declare function useMedia(options: {
-    items: Ref<VibeViewerItem[]>;
-    activeItem: Ref<VibeViewerItem | null>;
-    activeMediaItem: Ref<VibeViewerItem | null>;
-    isEnabled: Ref<boolean>;
-    itemCount: Ref<number>;
-    loopFullscreenVideo: Ref<boolean>;
-    onAssetError?: VibeAssetErrorReporter;
-    onAssetLoad?: VibeAssetLoadReporter;
-}): {
-    activeAssetErrorKind: import("vue").ComputedRef<VibeAssetErrorKind | null>;
-    activeMediaDuration: import("vue").ComputedRef<number>;
-    activeMediaProgress: import("vue").ComputedRef<number>;
-    activeMediaState: import("vue").ComputedRef<MediaUiState>;
-    getAssetErrorKind: (id: string) => VibeAssetErrorKind | null;
-    getAssetErrorLabel: (id: string) => "404" | "Load error" | null;
-    getAssetRenderKey: (id: string) => string;
-    getImageSource: (item: VibeViewerItem) => string;
-    isImageReady: (id: string) => boolean;
-    isMediaReady: (id: string) => boolean;
-    canRetryAsset: (id: string) => boolean;
-    mediaStates: Ref<Record<string, MediaUiState>, Record<string, MediaUiState>>;
-    onAudioCoverClick: (event: MouseEvent, id: string, suppressMediaToggleUntil: number) => void;
-    onImageError: (id: string, url: string) => Promise<void>;
-    onImageLoad: (id: string, url: string) => void;
-    onMediaError: (id: string, url: string) => Promise<void>;
-    onMediaEvent: (id: string, event: Event) => void;
-    onMediaSeekInput: (event: Event) => void;
-    onMediaVolumeInput: (event: Event) => void;
-    onMediaVolumeToggle: () => void;
-    onVideoClick: (event: MouseEvent, id: string, suppressMediaToggleUntil: number) => void;
-    registerAudioElement: (id: string, element: unknown) => void;
-    registerImageElement: (id: string, element: unknown) => void;
-    registerVideoElement: (id: string, element: unknown) => void;
-    resetAssetState: (id: string) => void;
-    resetMediaState: () => void;
-    retryAsset: (id: string) => Promise<void>;
-    syncMediaPlayback: () => Promise<void>;
-};

package/lib/components/viewer-core/useSurfaceEmptyState.d.ts

@@ -1,15 +0,0 @@
-import { type Ref } from 'vue';
-import type { VibeEmptyStateMode, VibeEmptyStateSlotProps } from './surfaceSlots';
-export declare const DEFAULT_VIBE_EMPTY_STATE_MESSAGE = "no items available";
-export declare function useSurfaceEmptyState(options: {
-    emptyStateMode: Ref<VibeEmptyStateMode | undefined>;
-    itemCount: Ref<number>;
-    loading: Ref<boolean | undefined>;
-    renderSlot?: ((props: VibeEmptyStateSlotProps) => unknown) | undefined;
-    surface: VibeEmptyStateSlotProps['surface'];
-}): {
-    emptyStateProps: import("vue").ComputedRef<VibeEmptyStateSlotProps | null>;
-    showBadgeEmptyState: import("vue").ComputedRef<boolean>;
-    showCustomEmptyState: import("vue").ComputedRef<boolean>;
-    showInlineEmptyState: import("vue").ComputedRef<boolean>;
-};

package/lib/components/viewer-core/useVideoFullscreen.d.ts

@@ -1,9 +0,0 @@
-import type { Ref } from 'vue';
-import type { VibeViewerItem } from '../viewer';
-export declare function useVideoFullscreen(options: {
-    activeItem: Ref<VibeViewerItem | null>;
-    getItemKey: (item: VibeViewerItem) => string;
-}): {
-    registerElement: (id: string, element: unknown) => void;
-    request: () => void;
-};

package/lib/components/viewer-core/useViewer.d.ts

@@ -1,78 +0,0 @@
-import { type Ref } from 'vue';
-import type { VibeViewerItem } from '../viewer';
-import type { VibeAssetErrorReporter, VibeAssetLoadReporter } from './assetErrors';
-import { formatPlaybackTime } from './format';
-import type { VibeLoadPhase } from './removalState';
-export type { VibeResolveParams, VibeResolveResult, VibeEmit, VibeHandle, VibeInitialState, VibeFillMode, VibeLoadPhase, VibeProps, VibeSurfaceMode, } from './useDataSource';
-export type { VibeAssetErrorKind } from './loadError';
-export type { VibeStatus } from './removalState';
-export type { VibeAssetErrorEvent, VibeAssetErrorReporter, VibeAssetErrorSurface, VibeAssetLoadEvent, VibeAssetLoadReporter, VibeAssetLoadSurface } from './assetErrors';
-export type { VibeEmptyStateMode, VibeEmptyStateSlotProps } from './surfaceSlots';
-export interface VibeViewerProps {
-    activeIndex?: number;
-    errorMessage?: string | null;
-    hasNextPage?: boolean;
-    items: VibeViewerItem[];
-    loading?: boolean;
-    loopFullscreenVideo?: boolean;
-    paginationDetail?: string | null;
-    phase?: VibeLoadPhase | null;
-}
-export declare function useViewer(props: Readonly<VibeViewerProps>, emit: (event: 'update:activeIndex', value: number) => void, options?: {
-    enabled?: Ref<boolean>;
-    onAssetError?: VibeAssetErrorReporter;
-    onAssetLoad?: VibeAssetLoadReporter;
-}): {
-    activeItem: import("vue").ComputedRef<VibeViewerItem>;
-    activeAssetErrorKind: import("vue").ComputedRef<import("./loadError").VibeAssetErrorKind | null>;
-    activeMediaDuration: import("vue").ComputedRef<number>;
-    activeMediaItem: import("vue").ComputedRef<VibeViewerItem | null>;
-    activeMediaProgress: import("vue").ComputedRef<number>;
-    activeMediaState: import("vue").ComputedRef<import("./assetState").MediaUiState>;
-    canRetryAsset: (id: string) => boolean;
-    canRetryInitialLoad: import("vue").ComputedRef<boolean>;
-    errorMessage: import("vue").ComputedRef<string | null>;
-    getAssetErrorKind: (id: string) => import("./loadError").VibeAssetErrorKind | null;
-    getAssetErrorLabel: (id: string) => "404" | "Load error" | null;
-    getAssetRenderKey: (id: string) => string;
-    formatPlaybackTime: typeof formatPlaybackTime;
-    getImageSource: (item: VibeViewerItem) => string;
-    getSlideStyle: (index: number) => import("vue").CSSProperties;
-    hasNextPage: import("vue").ComputedRef<boolean>;
-    isAtEnd: import("vue").ComputedRef<boolean>;
-    isAudio: (item: VibeViewerItem) => boolean;
-    isVisual: (item: VibeViewerItem) => boolean;
-    items: import("vue").ComputedRef<VibeViewerItem[]>;
-    loading: import("vue").ComputedRef<boolean>;
-    mediaStates: Ref<Record<string, import("./assetState").MediaUiState>, Record<string, import("./assetState").MediaUiState>>;
-    isImageReady: (id: string) => boolean;
-    isMediaReady: (id: string) => boolean;
-    onAudioCoverClick: (event: MouseEvent, id: string) => void;
-    onImageError: (id: string, url: string) => Promise<void>;
-    onImageLoad: (id: string, url: string) => void;
-    onMediaEvent: (id: string, event: Event) => void;
-    onMediaError: (id: string, url: string) => Promise<void>;
-    onMediaSeekInput: (event: Event) => void;
-    onMediaVolumeInput: (event: Event) => void;
-    onMediaVolumeToggle: () => void;
-    onPointerCancel: (event: PointerEvent) => void;
-    onPointerDown: (event: PointerEvent) => void;
-    onPointerMove: (event: PointerEvent) => void;
-    onPointerUp: (event: PointerEvent) => void;
-    onVideoClick: (event: MouseEvent, id: string) => void;
-    onWheel: (event: WheelEvent) => void;
-    registerAudioElement: (id: string, element: unknown) => void;
-    registerImageElement: (id: string, element: unknown) => void;
-    registerVideoElement: (id: string, element: unknown) => void;
-    renderedItems: import("vue").ComputedRef<import("./virtualization").VibeRenderedItem[]>;
-    renderedRange: import("vue").ComputedRef<import("./virtualization").VibeRenderedRange>;
-    resolvedActiveIndex: import("vue").ComputedRef<number>;
-    resetAssetState: (id: string) => void;
-    retryInitialLoad: () => Promise<void>;
-    retryAsset: (id: string) => Promise<void>;
-    stageRef: Ref<HTMLElement | null, HTMLElement | null>;
-    statusKind: import("vue").ComputedRef<import("./surfaceSlots").VibeSurfaceStatusKind | null>;
-    statusMessage: import("vue").ComputedRef<string | null>;
-    paginationDetail: import("vue").ComputedRef<string | null>;
-    phase: import("vue").ComputedRef<VibeLoadPhase>;
-};

package/lib/components/viewer-core/virtualization.d.ts

@@ -1,18 +0,0 @@
-import type { CSSProperties } from 'vue';
-import type { VibeViewerItem } from '../viewer';
-export interface VibeRenderedRange {
-    start: number;
-    end: number;
-}
-export interface VibeRenderedItem {
-    item: VibeViewerItem;
-    index: number;
-}
-export interface VibeRenderedOverscan {
-    backward: number;
-    forward: number;
-}
-export declare const VIBE_WINDOW_OVERSCAN: VibeRenderedOverscan;
-export declare function getRenderedRange(activeIndex: number, totalItems: number, overscan?: VibeRenderedOverscan): VibeRenderedRange;
-export declare function getRenderedItems(items: VibeViewerItem[], activeIndex: number, overscan?: VibeRenderedOverscan): VibeRenderedItem[];
-export declare function getVirtualSlideStyle(index: number, activeIndex: number, viewportHeight: number, dragOffset: number, isDragging: boolean): CSSProperties;

package/lib/components/viewer.d.ts

@@ -1,23 +0,0 @@
-export type VibeViewerType = 'image' | 'video' | 'audio' | 'other';
-export type VibeRenderableMediaType = 'image' | 'video';
-export interface VibeViewerAsset {
-    url: string;
-    width?: number;
-    height?: number;
-    mediaType?: VibeRenderableMediaType;
-}
-export interface VibeViewerHealthCheck {
-    kind?: 'playback';
-    url: string;
-}
-export interface VibeViewerItem {
-    id: string;
-    type: VibeViewerType;
-    title?: string;
-    url: string;
-    preview?: VibeViewerAsset;
-    healthCheck?: VibeViewerHealthCheck | null;
-    width?: number;
-    height?: number;
-    [key: string]: unknown;
-}