@byomakase/omakase-player 0.0.2

package/dist/timeline/thumbnail/index.d.ts

@@ -0,0 +1 @@
+export { ThumbnailLane } from './thumbnail-lane';

package/dist/timeline/thumbnail/thumbnail-lane.d.ts

@@ -0,0 +1,54 @@
+import Konva from "konva";
+import { Thumbnail } from "./thumbnail";
+import { Subject } from "rxjs";
+import { BaseTimelineLane, TimelaneLaneConfig, TimelineLaneStyle } from "../timeline-lane";
+import { ThumbnailVttFile } from "../../track/thumbnail-vtt-file";
+import { ThumbnailEvent } from "../../types";
+import { ComponentConfigStyleComposed } from "../../common/component";
+export interface ThumbnailLaneStyle extends TimelineLaneStyle {
+    thumbnailHeight: number;
+    thumbnailStroke: string;
+    thumbnailStrokeWidth: number;
+    thumbnailHoverScale: number;
+    thumbnailHoverStroke: string;
+    thumbnailHoverStrokeWidth: number;
+}
+export interface ThumbnailLaneConfig extends TimelaneLaneConfig<ThumbnailLaneStyle> {
+    thumbnailVttUrl: string;
+}
+export declare class ThumbnailLane extends BaseTimelineLane<ThumbnailLaneConfig, ThumbnailLaneStyle> {
+    private _thumbnailVttUrl;
+    protected readonly thumbnailsMap: Map<number, Thumbnail>;
+    protected readonly thumbnailsVisibleSet: Set<number>;
+    protected thumbnailHover: Thumbnail;
+    protected timecodedGroup: Konva.Group;
+    protected timecodedEventCatcher: Konva.Rect;
+    protected thumbnailsGroup: Konva.Group;
+    private thumbnailVttFile;
+    private thumbnailWidth;
+    private readonly onSettleLayout$;
+    private eventStreamBreaker$;
+    readonly onClick$: Subject<ThumbnailEvent>;
+    constructor(config: ComponentConfigStyleComposed<ThumbnailLaneConfig>);
+    protected createCanvasNode(): Konva.Group;
+    protected settleLayout(): void;
+    protected afterCanvasNodeInit(): void;
+    onMeasurementsChange(): void;
+    destroy(): void;
+    clearContent(): void;
+    private clearItems;
+    private fireEventStreamBreaker;
+    private createAndAdjustThumbnails;
+    private adjustThumbnails;
+    private resolveVisibleTimestamps;
+    private createThumbnail;
+    private showThumbnailHover;
+    private hideThumbnailHover;
+    private resolveThumbnailHoverPosition;
+    private fetchAndCreateThumbnails;
+    private fetchThumbnailVttFile;
+    isVttLoaded(): boolean;
+    getThumbnailVttFile(): ThumbnailVttFile;
+    get thumbnailVttUrl(): string;
+    set thumbnailVttUrl(value: string);
+}

package/dist/timeline/thumbnail/thumbnail.d.ts

@@ -0,0 +1,46 @@
+import { BaseComponent, ComponentConfig, ComponentConfigStyleComposed } from "../../common/component";
+import Konva from "konva";
+import { Dimension, HasRectMeasurement, OnMeasurementsChange, Position, RectMeasurement } from "../../common/measurement";
+import { Comparable, ThumbnailEvent, ThumbnailVttCue } from "../../types";
+import { Subject } from "rxjs";
+export interface ThumbnailStyle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    stroke: string;
+    strokeWidth: number;
+    visible: boolean;
+}
+export interface ThumbnailConfig extends ComponentConfig<ThumbnailStyle> {
+    listening: boolean;
+}
+export declare class Thumbnail extends BaseComponent<ThumbnailConfig, ThumbnailStyle, Konva.Group> implements OnMeasurementsChange, HasRectMeasurement, Comparable<Thumbnail> {
+    private listening;
+    private thumbnailVttCue;
+    private group;
+    private backgroundRect;
+    private image;
+    readonly onClick$: Subject<ThumbnailEvent>;
+    readonly onMouseOver$: Subject<ThumbnailEvent>;
+    readonly onMouseMove$: Subject<ThumbnailEvent>;
+    readonly onMouseOut$: Subject<ThumbnailEvent>;
+    readonly onMouseLeave$: Subject<ThumbnailEvent>;
+    constructor(config: Partial<ComponentConfigStyleComposed<ThumbnailConfig>>);
+    protected createCanvasNode(): Konva.Group;
+    protected afterCanvasNodeInit(): void;
+    destroy(): void;
+    onMeasurementsChange(): void;
+    setImage(image: Konva.Image): void;
+    setVisible(visible: boolean): void;
+    setPosition(position: Position): void;
+    setVisibleAndX(visible: boolean, x: number): void;
+    getPosition(): Position;
+    getDimension(): Dimension;
+    setDimension(dimension: Dimension): void;
+    getRect(): RectMeasurement;
+    getThumbnailVttCue(): ThumbnailVttCue;
+    setThumbnailVttCue(thumbnailVttCue: ThumbnailVttCue): void;
+    getImage(): Konva.Image;
+    compareTo(o: Thumbnail): number;
+}

package/dist/timeline/timecode-display.d.ts

@@ -0,0 +1,32 @@
+import { BaseComponent, ComponentConfig, ComponentConfigStyleComposed } from "../common/component";
+import Konva from "konva";
+import { HasRectMeasurement, OnMeasurementsChange, Position, RectMeasurement } from "../common/measurement";
+import { VideoController } from "../video/video-controller";
+import { StylesProvider } from "../common/styles-provider";
+export interface TimecodeDisplayStyle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    textFontSize: number;
+    textFill: string;
+    visible: boolean;
+}
+export interface TimecodeDisplayConfig extends ComponentConfig<TimecodeDisplayStyle> {
+}
+export declare class TimecodeDisplay extends BaseComponent<TimecodeDisplayConfig, TimecodeDisplayStyle, Konva.Group> implements OnMeasurementsChange, HasRectMeasurement {
+    protected readonly stylesProvider: StylesProvider;
+    private group;
+    private text;
+    private videoController;
+    private videoEventStreamBreaker$;
+    constructor(config: Partial<ComponentConfigStyleComposed<TimecodeDisplayConfig>>, videoController: VideoController);
+    protected createCanvasNode(): Konva.Group;
+    protected afterCanvasNodeInit(): void;
+    onMeasurementsChange(): void;
+    private fireVideoEventStreamBreaker;
+    private onVideoLoadedEvent;
+    setVisible(visible: boolean): void;
+    setPosition(position: Position): void;
+    getRect(): RectMeasurement;
+}

package/dist/timeline/timeline-lane.d.ts

@@ -0,0 +1,70 @@
+import { BaseComponent, Component, ComponentConfig } from "../common/component";
+import Konva from "konva";
+import { Dimension, OnMeasurementsChange, Position, RectMeasurement } from "../common/measurement";
+import { Timeline } from "./timeline";
+import { StylesProvider } from "../common/styles-provider";
+import { VideoController } from "../video/video-controller";
+export interface TimelineLaneStyle {
+    height: number;
+    backgroundFill: string;
+    backgroundOpacity: number;
+    descriptionTextFill: string;
+    descriptionFontSize: number;
+    leftBackgroundFill: string;
+    leftBackgroundOpacity: number;
+}
+export declare const TIMELINE_LANE_STYLE_DEFAULT: TimelineLaneStyle;
+export interface TimelaneLaneConfig<S extends TimelineLaneStyle> extends ComponentConfig<S> {
+    id: string;
+    description: string;
+}
+export interface TimelaneLane<C extends TimelaneLaneConfig<S>, S extends TimelineLaneStyle> extends Component<C, S, Konva.Group>, OnMeasurementsChange {
+    style: S;
+    getId(): string;
+    getDescription(): string;
+    getRect(): RectMeasurement;
+    getPosition(): Position;
+    getDimension(): Dimension;
+    setTimelinePosition(position: Position): any;
+    getTimelinePosition(): Position;
+    clearContent(): any;
+    setTimeline(timeline: Timeline): any;
+    setVideoController(videoController: VideoController): any;
+}
+export type GenericTimelaneLane = TimelaneLane<TimelaneLaneConfig<TimelineLaneStyle>, TimelineLaneStyle>;
+export declare abstract class BaseTimelineLane<C extends TimelaneLaneConfig<S>, S extends TimelineLaneStyle> extends BaseComponent<C, S, Konva.Group> implements TimelaneLane<C, S> {
+    protected readonly stylesProvider: StylesProvider;
+    protected id: string;
+    protected description: string;
+    protected timelinePosition: Position;
+    protected bodyGroup: Konva.Group;
+    protected bodyBackground: Konva.Rect;
+    protected leftGroup: Konva.Group;
+    protected leftBackground: Konva.Rect;
+    protected leftPanelText: Konva.Text;
+    protected timeline: Timeline;
+    protected videoController: VideoController;
+    protected constructor(config: C);
+    protected createCanvasNode(): Konva.Group;
+    protected afterCanvasNodeInit(): void;
+    onMeasurementsChange(): void;
+    /***
+     * Global styles
+     */
+    onStylesProviderChange(): void;
+    onStyleChange(): void;
+    protected settleLayout(): void;
+    protected isTimelineReady(): boolean;
+    clearContent(): void;
+    setTimeline(timeline: Timeline): void;
+    setVideoController(videoController: VideoController): void;
+    get style(): S;
+    set style(value: Partial<S>);
+    getRect(): RectMeasurement;
+    getPosition(): Position;
+    getDimension(): Dimension;
+    getId(): string;
+    getDescription(): string;
+    setTimelinePosition(position: Position): void;
+    getTimelinePosition(): Position;
+}

package/dist/timeline/timeline.d.ts

@@ -0,0 +1,222 @@
+import { BaseComponent, ComponentConfig, ComponentConfigStyleComposed } from "../common/component";
+import Konva from "konva";
+import { ScrollableHorizontally, Scrollbar } from "./scrollbar";
+import { Dimension, HasRectMeasurement, HorizontalMeasurement, OnMeasurementsChange, Position, RectMeasurement } from "../common/measurement";
+import { VideoController } from "../video/video-controller";
+import { Observable, Subject } from "rxjs";
+import { TimelineScrollEvent, TimelineZoomEvent } from "../types";
+import { ThumbnailVttFile } from "../track/thumbnail-vtt-file";
+import { GenericTimelaneLane } from "./timeline-lane";
+import { ScrubberLane } from "./scrubber-lane";
+import { TimelineApi } from "../api/timeline-api";
+import { MarkerLane } from "./marker";
+import { ThumbnailLane } from "./thumbnail";
+import { SubtitlesLane } from "./subtitles";
+import { AudioTrackLane } from "./audio-track";
+import { MarkerLaneConfig } from "./marker/marker-lane";
+import { ThumbnailLaneConfig } from "./thumbnail/thumbnail-lane";
+import { SubtitlesLaneConfig } from "./subtitles/subtitles-lane";
+export interface TimelineStyle {
+    stageMinWidth: number;
+    backgroundFill: string;
+    headerBackgroundFill: string;
+    footerBackgroundFill: string;
+    scrollbarHeight: number;
+    thumbnailHoverWidth: number;
+    thumbnailHoverStroke: string;
+    thumbnailHoverStrokeWidth: number;
+    thumbnailHoverYOffset: number;
+    headerHeight: number;
+    footerHeight: number;
+    leftPanelWidth: number;
+    rightPanelLeftGutterWidth: number;
+    rightPanelRightGutterWidth: number;
+    timecodedContainerClipPadding: number;
+    playheadVisible: boolean;
+    playheadFill: string;
+    playheadLineWidth: number;
+    playheadSymbolHeight: number;
+    playheadScrubberHeight: number;
+    playheadBackgroundFill: string;
+    playheadBackgroundOpacity: number;
+    playheadPlayProgressFill: string;
+    playheadPlayProgressOpacity: number;
+    playheadBufferedFill: string;
+    playheadBufferedOpacity: number;
+}
+export interface TimelineConfig extends ComponentConfig<TimelineStyle> {
+    thumbnailVttUrl?: string;
+    timelineHTMLElementId: string;
+    playheadHoverSnapArea: number;
+    zoomScale: number;
+    zoomBaseline: number;
+    zoomMax: number;
+}
+export declare class Timeline extends BaseComponent<TimelineConfig, TimelineStyle, Konva.Stage> implements OnMeasurementsChange, HasRectMeasurement, ScrollableHorizontally, TimelineApi {
+    private timelineHTMLElementId;
+    private thumbnailVttUrl;
+    private width;
+    private zoomScale;
+    private zoomBaseline;
+    private zoomMax;
+    private playheadHoverSnapArea;
+    private timelineHTMLElement;
+    private stage;
+    private layer;
+    private layoutGroup;
+    private layoutBackground;
+    private headerGroup;
+    private headerBackground;
+    private bodyGroup;
+    private footerGroup;
+    private footerBackground;
+    private bodyContentGroup;
+    private leftPanel;
+    private rightPanel;
+    private timecodedContainer;
+    private timecodedGroup;
+    private timecodedBaseGroup;
+    private timecodedThumbnailsGroup;
+    private timecodedSubtitlesGroup;
+    private timecodedAudioGroup;
+    private timecodedMarkersGroup;
+    private timecodedSurfaceGroup;
+    private timecodedBackground;
+    private timecodedEventCatcher;
+    private timecodedGroupNodes;
+    private videoController;
+    private scrollbar;
+    private playheadHover;
+    private playhead;
+    private timelaneLanes;
+    private timelaneLanesMap;
+    private scrubberLane;
+    private thumbnailHover;
+    private headerTimecodeDisplay;
+    private maxTimecodedGroupWidth;
+    private thumbnailVttFile;
+    private scrollWithPlayhead;
+    private syncTimelineWithPlayheadInProgress;
+    private mouseWheelEnabled;
+    private leftPanelVisible;
+    private videoEventBreaker$;
+    readonly onScroll$: Subject<TimelineScrollEvent>;
+    readonly onZoom$: Subject<TimelineZoomEvent>;
+    constructor(config: Partial<ComponentConfigStyleComposed<TimelineConfig>>, videoController: VideoController);
+    protected createCanvasNode(): Konva.Stage;
+    protected afterCanvasNodeInit(): void;
+    private settleLayout;
+    onMeasurementsChange(): void;
+    private onWindowResize;
+    private calculateHeights;
+    private resolveStageDimension;
+    private getTimelineHTMLElementRect;
+    private showThumbnailHover;
+    private hideThumbnailHover;
+    private resolveThumbnailPosition;
+    private createScrollEvent;
+    private createZoomEvent;
+    getHorizontalScrollPercent(): number;
+    setHorizontalScrollPercent(percent: number): void;
+    getScrollHandleHorizontalMeasurement(scrollbarWidth: number): HorizontalMeasurement;
+    scrollTo(percent: number): Observable<number>;
+    scrollToPlayhead(): Observable<number>;
+    private scrollToPercent;
+    private scrollToPercentEased;
+    private scrollToEased;
+    private isPlayheadInTimecodedView;
+    private updateScrollWithPlayhead;
+    /***
+     * Scrolls timecoded group so that playhead is at left most position
+     * @private
+     */
+    private syncTimelineWithPlayhead;
+    private setTimelinePosition;
+    private scrollTimeline;
+    private calculateTimelineXFromScrollPercent;
+    getZoomPercent(): number;
+    zoomTo(percent: number): Observable<number>;
+    zoomIn(): Observable<number>;
+    zoomOut(): Observable<number>;
+    private zoomToEased;
+    private zoomStep;
+    private zoomByPercent;
+    private zoomByWidth;
+    /***
+     * Move group proportionally to reposition focus
+     *
+     * @param newWidth
+     * @param repositionFocus
+     * @private
+     */
+    private calculateNewPosition;
+    private resolveZoomFocus;
+    private calculateWidthFromZoomRatioPercent;
+    private getConstrainedWidth;
+    private getConstrainedZoomPercent;
+    private getConstrainedScrollPercent;
+    private playheadHoverMove;
+    private resolvePlayheadSyncPosition;
+    private onVideoLoadedEvent;
+    private fireVideoEventBreaker;
+    setThumbnailVttFile(thumbnailVttFile: ThumbnailVttFile): void;
+    private syncVideoMetadata;
+    addLane(timelaneLane: GenericTimelaneLane): void;
+    removeLane(id: string): void;
+    getScrollbar(): Scrollbar;
+    addLanes(timelaneLanes: GenericTimelaneLane[]): void;
+    getLanes(): GenericTimelaneLane[];
+    getLane(id: string): GenericTimelaneLane;
+    getScrubberLane(): ScrubberLane;
+    getMarkerLane(id: string): MarkerLane;
+    getThumbnailLane(id: string): ThumbnailLane;
+    getSubtitlesLane(id: string): SubtitlesLane;
+    getAudioTrackLane(id: string): AudioTrackLane;
+    createMarkerLane(config: MarkerLaneConfig): MarkerLane;
+    createThumbnailLane(config: ThumbnailLaneConfig): ThumbnailLane;
+    createSubtitlesLane(config: SubtitlesLaneConfig): SubtitlesLane;
+    isTimelineReady(): boolean;
+    addToTimecodedBaseGroup(node: Konva.Group | Konva.Shape): void;
+    addToTimecodedSurfaceGroup(node: Konva.Group | Konva.Shape): void;
+    addToTimecodedMarkersGroup(node: Konva.Group | Konva.Shape): void;
+    addToTimecodedThumbnailsGroup(node: Konva.Group | Konva.Shape): void;
+    addToTimecodedSubtitlesGroup(node: Konva.Group | Konva.Shape): void;
+    addToTimecodedAudioGroup(node: Konva.Group | Konva.Shape): void;
+    constrainTimelinePosition(x: number): number;
+    timelinePositionToTime(xOnTimeline: number): number;
+    timelinePositionToTimeFormatted(x: number): string;
+    timelinePositionToFrame(x: number): number;
+    timeToTimelinePosition(time: number): number;
+    private getConstrainedTimelineX;
+    getBodyGroupRect(): RectMeasurement;
+    getLeftPanelRect(): RectMeasurement;
+    getLeftPanelVisible(): boolean;
+    getRightPanelRect(): RectMeasurement;
+    getTimecodedContainerDimension(): Dimension;
+    getTimecodedContainerPosition(): Position;
+    getTimecodedContainerRect(): RectMeasurement;
+    getTimecodedGroupDimension(): Dimension;
+    getTimecodedGroupPosition(): Position;
+    getTimecodedGroupRect(): RectMeasurement;
+    getTimecodedGroupHorizontalMeasurement(): HorizontalMeasurement;
+    getRelativePointerPosition(): Position;
+    getLayoutGroupDimension(): Dimension;
+    getLayoutGroupPosition(): Position;
+    getRect(): RectMeasurement;
+    getVisiblePositionRange(): {
+        start: number;
+        end: number;
+    };
+    isInVisiblePositionRange(x: number): boolean;
+    isSnappedStart(): boolean;
+    isSnappedEnd(): boolean;
+    getVisibleTimeRange(): {
+        start: number;
+        end: number;
+    };
+    private getZoomBaseline;
+    private getZoomMax;
+    private fetchThumbnailVttFile;
+    toggleLeftPanelVisible(visible: boolean): void;
+    clearContent(): void;
+}

package/dist/track/audio-vtt-file.d.ts

@@ -0,0 +1,8 @@
+import { BaseOmakaseVttFile, VttCueParsed } from "./vtt-file";
+import { AudioVttCue } from "../types";
+import { Observable } from "rxjs";
+export declare class AudioVttFile extends BaseOmakaseVttFile<AudioVttCue> {
+    protected constructor(url: string);
+    static create(url: string): Observable<AudioVttFile>;
+    protected mapCue(vttCueParsed: VttCueParsed): AudioVttCue;
+}

package/dist/track/subtitles-vtt-file.d.ts

@@ -0,0 +1,8 @@
+import { BaseOmakaseVttFile, VttCueParsed } from "./vtt-file";
+import { SubtitlesVttCue } from "../types";
+import { Observable } from "rxjs";
+export declare class SubtitlesVttFile extends BaseOmakaseVttFile<SubtitlesVttCue> {
+    protected constructor(url: string);
+    static create(url: string): Observable<SubtitlesVttFile>;
+    protected mapCue(vttCueParsed: VttCueParsed): SubtitlesVttCue;
+}

package/dist/track/subtitles-vtt-track.d.ts

@@ -0,0 +1,5 @@
+import { BaseOmakaseTrack } from "./track";
+import { SubtitlesVttCue, SubtitlesVttTrackConfig } from "../types";
+export declare class SubtitlesVttTrack extends BaseOmakaseTrack<SubtitlesVttCue> {
+    constructor(config: SubtitlesVttTrackConfig);
+}

package/dist/track/thumbnail-vtt-file.d.ts

@@ -0,0 +1,11 @@
+import { BaseOmakaseVttFile, VttCueParsed } from "./vtt-file";
+import { ThumbnailVttCue } from "../types";
+import { Observable } from "rxjs";
+export declare class ThumbnailVttFile extends BaseOmakaseVttFile<ThumbnailVttCue> {
+    protected constructor(url: string);
+    static create(url: string): Observable<ThumbnailVttFile>;
+    protected mapCue(vttCueParsed: VttCueParsed): ThumbnailVttCue;
+    private resolveThumbnailUrl;
+    private createThumbnailUrlFromRelativeUrl;
+    private isUrlAbsolute;
+}

package/dist/track/track.d.ts

@@ -0,0 +1,12 @@
+import { OmakaseTextTrack, OmakaseTextTrackCue, OmakaseTrackConfig } from "../types";
+export declare abstract class BaseOmakaseTrack<T extends OmakaseTextTrackCue> implements OmakaseTextTrack<T> {
+    id: string;
+    src: string;
+    default: boolean;
+    label: string;
+    language: string;
+    cues: T[];
+    hidden: boolean;
+    element: HTMLTrackElement;
+    protected constructor(config: OmakaseTrackConfig);
+}

package/dist/track/vtt-file.d.ts

@@ -0,0 +1,32 @@
+import { Observable } from "rxjs";
+import { OmakaseVttCue, OmakaseVttFile } from "../types";
+export interface VttCueParsed {
+    identifier: string;
+    start: number;
+    end: number;
+    text: string;
+    styles: string;
+}
+export interface VttFileMetaParsed {
+    kind: string;
+    language: string;
+}
+export interface VttFileParsed {
+    valid: any;
+    meta: VttFileMetaParsed;
+    cues: VttCueParsed[];
+}
+export declare abstract class BaseOmakaseVttFile<T extends OmakaseVttCue> implements OmakaseVttFile<T> {
+    protected url: string;
+    protected cues: Map<number, T>;
+    protected cuesKeysSorted: number[];
+    protected constructor(url: string);
+    fetch(): Observable<boolean>;
+    protected abstract mapCue(vttCueParsed: VttCueParsed): T;
+    getUrl(): string;
+    hasCues(): boolean;
+    findCue(time: number): T;
+    findCues(startTime: number, endTime: number): T[];
+    getCues(): T[];
+    protected findCueIndex(time: number): number;
+}

package/dist/types/common.d.ts

@@ -0,0 +1,6 @@
+export interface Comparable<T> {
+    compareTo(o: T): number;
+}
+export type AtLeastOne<T, U = {
+    [K in keyof T]: Pick<T, K>;
+}> = Partial<T> & U[keyof U];

package/dist/types/events.d.ts

@@ -0,0 +1,125 @@
+import { Position } from "../common/measurement";
+import { MomentObservation, PeriodObservation } from "./model";
+import { Thumbnail } from "../timeline/thumbnail/thumbnail";
+import { Video } from "../video/video";
+import { CamelToSnakeCase } from "./types";
+import { OmakaseTextTrack, OmakaseTextTrackCue } from "./track";
+import { GenericMarker } from "../timeline/marker/marker";
+export declare const OmakasePlayerEvents: OmakasePlayerEventsType;
+export type OmakasePlayerEventsType = OmakasePlayerEventsMappingType<OmakasePlayerEventMap>;
+export type OmakasePlayerEventsMappingType<T> = {
+    [K in keyof T as Uppercase<CamelToSnakeCase<string & K>>]: K;
+};
+export type OmakasePlayerEventMap = VideoEventMap & AudioEventMap & SubtitlesEventMap & TimelineEventMap;
+export type VideoEventMap = {
+    'omakaseVideoLoaded': VideoLoadedEvent;
+    'omakaseVideoPlay': VideoPlayEvent;
+    'omakaseVideoPause': VideoPlayEvent;
+    'omakaseVideoTimeChange': VideoTimeChangeEvent;
+    'omakaseVideoSeeking': VideoSeekingEvent;
+    'omakaseVideoSeeked': VideoSeekedEvent;
+    'omakaseVideoEnded': VideoEndedEvent;
+    'omakaseVideoAudioSwitched': AudioEvent;
+    'omakaseVideoBuffering': VideoBufferingEvent;
+};
+export type AudioEventMap = {
+    'omakaseAudioSwitched': AudioEvent;
+};
+export type SubtitlesEventMap = {
+    'omakaseSubtitlesCreate': SubtitlesCreateEvent;
+    'omakaseSubtitlesRemove': SubtitlesEvent;
+    'omakaseSubtitlesShow': SubtitlesEvent;
+    'omakaseSubtitlesHide': SubtitlesEvent;
+};
+export type TimelineEventMap = {
+    'omakaseTimelineScroll': TimelineScrollEvent;
+    'omakaseTimelineZoom': TimelineZoomEvent;
+};
+export interface OmakaseEvent {
+}
+export interface OmakaseMouseEvent extends OmakaseEvent {
+    evt: MouseEvent;
+    position: Position;
+}
+export interface ClickEvent extends OmakaseMouseEvent {
+}
+export interface MouseEnterEvent extends OmakaseMouseEvent {
+}
+export interface MouseMoveEvent extends OmakaseMouseEvent {
+}
+export interface MouseLeaveEvent extends OmakaseMouseEvent {
+}
+export interface MouseOutEvent extends OmakaseMouseEvent {
+}
+export interface MouseOverEvent extends OmakaseMouseEvent {
+}
+export interface VideoEvent extends OmakaseEvent {
+}
+export interface VideoLoadingEvent extends VideoEvent {
+    sourceUrl: string;
+    frameRate: number;
+}
+export interface VideoLoadedEvent extends VideoEvent {
+    video: Video;
+}
+export interface VideoPlayEvent extends VideoEvent {
+}
+export interface VideoTimeChangeEvent extends VideoEvent {
+    currentTime: number;
+    frame: number;
+}
+export interface VideoSeekingEvent extends VideoEvent {
+    currentTime: number;
+    newTime: number;
+}
+export interface VideoSeekedEvent extends VideoEvent {
+    currentTime: number;
+}
+export interface VideoBufferingEvent extends VideoEvent {
+    bufferedTimespans: {
+        start: number;
+        end: number;
+    }[];
+}
+export interface VideoEndedEvent extends VideoEvent {
+}
+export interface AudioEvent extends OmakaseEvent {
+    audioTrack: any;
+}
+export interface SubtitlesEvent extends OmakaseEvent {
+}
+export interface SubtitlesCreateEvent extends OmakaseEvent {
+    textTrack: OmakaseTextTrack<OmakaseTextTrackCue>;
+}
+export interface TimelineEvent extends OmakaseEvent {
+}
+export interface TimelineZoomEvent extends TimelineEvent {
+    zoomPercent: number;
+}
+export interface TimelineScrollEvent extends TimelineEvent {
+    scrollPercent: number;
+}
+export interface ScrollbarEvent extends OmakaseEvent {
+}
+export interface ScrollbarScrollEvent extends ScrollbarEvent {
+    scrollPercent: number;
+}
+export interface ScrollbarZoomEvent extends ScrollbarEvent {
+    zoomPercent: number;
+}
+export interface ThumbnailEvent extends OmakaseEvent {
+    thumbnail: Thumbnail;
+}
+export interface MarkerEvent extends OmakaseEvent {
+}
+export interface MarkerChangeEvent extends MarkerEvent {
+}
+export interface MarkerFocusEvent extends MarkerEvent {
+    marker: GenericMarker;
+}
+export interface MomentMarkerChangeEvent extends MarkerChangeEvent {
+    timeObservation: MomentObservation;
+}
+export interface PeriodMarkerChangeEvent extends MarkerChangeEvent {
+    timeObservation: PeriodObservation;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./common";
+export * from "./events";
+export * from "./model";
+export * from "./track";
+export * from "./vtt";

package/dist/types/model.d.ts

@@ -0,0 +1,17 @@
+export interface TimeObservation {
+}
+export interface MomentObservation extends TimeObservation {
+    time: number;
+}
+export interface PeriodObservation extends TimeObservation {
+    start: number;
+    end: number;
+}
+export interface HelpMenuGroup {
+    name: string;
+    items: HelpMenuItem[];
+}
+export interface HelpMenuItem {
+    name: string;
+    description: string;
+}