@videojs/core/dist/store.d.ts

Core components and utilities for Video.js

//#region src/store/definitions/current-time-display.d.ts
interface CurrentTimeDisplayState {
  /** The current time value in seconds */
  currentTime: number | undefined;
  /** The total duration in seconds (for future functionality) */
  duration: number | undefined;
}
declare const currentTimeDisplayStateDefinition: {
  keys: readonly ["currentTime", "duration"];
  stateTransform: (rawState: Record<string, any>) => CurrentTimeDisplayState;
  createRequestMethods: (_dispatch: (action: {
    type: string;
    detail?: any;
  }) => void) => {};
};
type CurrentTimeDisplayStateDefinition = typeof currentTimeDisplayStateDefinition;
type CurrentTimeDisplayComponentState = ReturnType<typeof currentTimeDisplayStateDefinition.stateTransform>;
type CurrentTimeDisplayRequestMethods = ReturnType<typeof currentTimeDisplayStateDefinition.createRequestMethods>;
//#endregion
//#region src/store/definitions/duration-display.d.ts
interface DurationDisplayState {
  /** The raw duration value in seconds */
  duration: number | undefined;
}
declare const durationDisplayStateDefinition: {
  keys: readonly ["duration"];
  stateTransform: (rawState: Record<string, any>) => DurationDisplayState;
  createRequestMethods: (_dispatch: (action: {
    type: string;
    detail?: any;
  }) => void) => {};
};
type DurationDisplayStateDefinition = typeof durationDisplayStateDefinition;
type DurationDisplayComponentState = ReturnType<typeof durationDisplayStateDefinition.stateTransform>;
type DurationDisplayRequestMethods = ReturnType<typeof durationDisplayStateDefinition.createRequestMethods>;
//#endregion
//#region src/store/definitions/fullscreen-button.d.ts
interface FullscreenButtonState {
  fullscreen: boolean;
}
interface FullscreenButtonMethods {
  requestEnterFullscreen: () => void;
  requestExitFullscreen: () => void;
}
interface FullscreenButtonStateDefinition {
  keys: string[];
  stateTransform: (rawState: any) => FullscreenButtonState;
  createRequestMethods: (dispatch: (action: {
    type: string;
    detail?: any;
  }) => void) => FullscreenButtonMethods;
}
declare const fullscreenButtonStateDefinition: FullscreenButtonStateDefinition;
//#endregion
//#region src/store/definitions/mute-button.d.ts
interface MuteButtonState {
  muted: boolean;
  volumeLevel: string;
}
interface MuteButtonMethods {
  requestMute: () => void;
  requestUnmute: () => void;
}
interface MuteButtonStateDefinition {
  keys: string[];
  stateTransform: (rawState: any) => MuteButtonState;
  createRequestMethods: (dispatch: (action: {
    type: string;
  }) => void) => MuteButtonMethods;
}
declare const muteButtonStateDefinition: MuteButtonStateDefinition;
//#endregion
//#region src/store/definitions/play-button.d.ts
interface PlayButtonState {
  paused: boolean;
}
interface PlayButtonMethods {
  requestPlay: () => void;
  requestPause: () => void;
}
interface PlayButtonStateDefinition {
  keys: string[];
  stateTransform: (rawState: any) => PlayButtonState;
  createRequestMethods: (dispatch: (action: {
    type: string;
    detail?: unknown;
  }) => void) => PlayButtonMethods;
}
declare const playButtonStateDefinition: PlayButtonStateDefinition;
//#endregion
//#region src/store/definitions/preview-time-display.d.ts
interface PreviewTimeDisplayState {
  /** The preview time value in seconds */
  previewTime: number | undefined;
}
interface PreviewTimeDisplayStateDefinition {
  keys: (keyof PreviewTimeDisplayState)[];
  stateTransform: (rawState: any) => PreviewTimeDisplayState;
}
declare const previewTimeDisplayStateDefinition: PreviewTimeDisplayStateDefinition;
//#endregion
//#region src/store/definitions/time-slider.d.ts
interface TimeSliderState {
  currentTime: number;
  duration: number;
  previewTime: number;
}
interface TimeSliderMethods {
  requestSeek: (time: number) => void;
  requestPreview: (time: number) => void;
}
interface TimeSliderStateDefinition {
  keys: string[];
  stateTransform: (rawState: any) => TimeSliderState;
  createRequestMethods: (dispatch: (action: {
    type: string;
    detail?: any;
  }) => void) => TimeSliderMethods;
}
declare const timeSliderStateDefinition: TimeSliderStateDefinition;
//#endregion
//#region src/store/definitions/volume-slider.d.ts
interface VolumeSliderState {
  volume: number;
  muted: boolean;
  volumeLevel: "high" | "medium" | "low" | "off";
}
interface VolumeSliderMethods {
  requestVolumeChange: (volume: number) => void;
}
interface VolumeSliderStateDefinition {
  keys: string[];
  stateTransform: (rawState: any) => VolumeSliderState;
  createRequestMethods: (dispatch: (action: {
    type: string;
    detail?: any;
  }) => void) => VolumeSliderMethods;
}
declare const volumeSliderStateDefinition: VolumeSliderStateDefinition;
//#endregion
//#region src/store/types.d.ts
interface StateOwners {
  media?: HTMLMediaElement;
  container?: HTMLElement;
}
//#endregion
//#region src/store/factory.d.ts
interface EventOrAction<D = undefined> {
  type: string;
  detail?: D;
  target?: EventTarget;
}
type FacadeGetter<T, D = T> = (stateOwners: StateOwners, event?: EventOrAction<D>) => T;
type FacadeSetter<T> = (value: T, stateOwners: StateOwners) => void;
type StateOwnerUpdateHandler<T> = (handler: (value?: T) => void, stateOwners: StateOwners) => (() => void) | void;
interface ReadonlyFacadeProp<T, D = T> {
  get: FacadeGetter<T, D>;
  stateOwnersUpdateHandlers?: StateOwnerUpdateHandler<T>[];
}
type FacadeProp<T, S = T, D = T> = ReadonlyFacadeProp<T, D> & {
  set: FacadeSetter<S>;
  /** @TODO We probably need to refactor this for more complex cases where we can't simply translate to a setter */
  actions: {
    [k: string]: (val: {
      type: string;
      detail?: unknown;
    }) => ReturnType<FacadeGetter<T, D>>;
  };
};
interface StateMediator {
  paused: FacadeProp<HTMLMediaElement["paused"]>;
  muted: FacadeProp<HTMLMediaElement["muted"]>;
  volume: FacadeProp<HTMLMediaElement["volume"]>;
  volumeLevel: ReadonlyFacadeProp<"high" | "medium" | "low" | "off">;
  currentTime: FacadeProp<HTMLMediaElement["currentTime"]>;
  duration: ReadonlyFacadeProp<HTMLMediaElement["duration"]>;
  seekable: ReadonlyFacadeProp<[number, number] | undefined>;
  previewTime: FacadeProp<number>;
  fullscreen: FacadeProp<boolean>;
}
interface MediaStore {
  dispatch: (action: {
    type: string;
    detail?: unknown;
  }) => void;
  getState: () => any;
  getKeys: (keys: string[]) => Record<string, any>;
  subscribeKeys: (keys: string[], callback: (state: any) => void) => void;
  subscribe: (callback: (state: any) => void) => void;
}
declare function createMediaStore$1({
  stateMediator
}: {
  media?: any;
  container?: any;
  stateMediator: Partial<StateMediator>;
}): MediaStore;
//#endregion
//#region src/store/media-store.d.ts
type Params = Partial<Parameters<typeof createMediaStore$1>[0]>;
declare function createMediaStore(params?: Params): MediaStore;
//#endregion
//#region src/store/mediators/audible.d.ts
declare const audible: {
  muted: {
    get(stateOwners: StateOwners): boolean;
    set(value: boolean, stateOwners: StateOwners): void;
    stateOwnersUpdateHandlers: readonly [(handler: (value?: boolean) => void, stateOwners: StateOwners) => (() => void) | void];
    actions: {
      /** @TODO Refactor me to play more nicely with side effects that don't/can't correlate with set() API or aren't simple 1:1 with getter vs. setter (CJP) */
      muterequest: () => boolean;
      unmuterequest: () => boolean;
    };
  };
  volume: {
    get(stateOwners: StateOwners): number;
    set(value: number, stateOwners: StateOwners): void;
    stateOwnersUpdateHandlers: readonly [(handler: (value?: number) => void, stateOwners: StateOwners) => (() => void) | void];
    actions: {
      /** @TODO Refactor me to play more nicely with side effects that don't/can't correlate with set() API (CJP) */
      volumerequest: ({
        detail
      }?: Pick<CustomEvent<any>, "detail">) => number;
    };
  };
  volumeLevel: {
    get(stateOwners: StateOwners): "high" | "medium" | "low" | "off";
    stateOwnersUpdateHandlers: readonly [(handler: (value?: "high" | "medium" | "low" | "off") => void, stateOwners: any) => void | (() => void)];
  };
};
//#endregion
//#region src/store/mediators/playable.d.ts
declare const playable: {
  paused: {
    get(stateOwners: any): boolean;
    set(value: boolean, stateOwners: any): void;
    stateOwnersUpdateHandlers: readonly [(handler: (value?: boolean) => void, stateOwners: any) => void | (() => void)];
    actions: {
      /** @TODO Refactor me to play more nicely with side effects that don't/can't correlate with set() API (CJP) */
      playrequest: () => boolean;
      pauserequest: () => boolean;
    };
  };
};
//#endregion
//#region src/store/mediators/temporal.d.ts
declare const temporal: {
  currentTime: {
    get(stateOwners: any): number;
    set(value: number, stateOwners: any): void;
    stateOwnersUpdateHandlers: readonly [(handler: (value?: number) => void, stateOwners: any) => void | (() => void)];
    actions: {
      /** @TODO Support more sophisticated seeking patterns like seek-to-live, relative seeking, etc. (CJP) */
      seekrequest: ({
        detail
      }?: Pick<CustomEvent<any>, "detail">) => number;
    };
  };
  duration: {
    get(stateOwners: any): number;
    stateOwnersUpdateHandlers: readonly [(handler: (value?: number) => void, stateOwners: any) => void | (() => void)];
  };
  seekable: {
    get(stateOwners: any): [number, number] | undefined;
    stateOwnersUpdateHandlers: readonly [(handler: (value?: [number, number] | undefined) => void, stateOwners: any) => void | (() => void)];
  };
};
//#endregion
export { CurrentTimeDisplayComponentState, CurrentTimeDisplayRequestMethods, CurrentTimeDisplayState, CurrentTimeDisplayStateDefinition, DurationDisplayComponentState, DurationDisplayRequestMethods, DurationDisplayState, DurationDisplayStateDefinition, EventOrAction, FacadeGetter, FacadeProp, FacadeSetter, FullscreenButtonMethods, FullscreenButtonState, FullscreenButtonStateDefinition, MediaStore, MuteButtonMethods, MuteButtonState, MuteButtonStateDefinition, PlayButtonMethods, PlayButtonState, PlayButtonStateDefinition, PreviewTimeDisplayState, PreviewTimeDisplayStateDefinition, ReadonlyFacadeProp, StateMediator, StateOwnerUpdateHandler, TimeSliderMethods, TimeSliderState, TimeSliderStateDefinition, VolumeSliderMethods, VolumeSliderState, VolumeSliderStateDefinition, audible, createMediaStore, currentTimeDisplayStateDefinition, durationDisplayStateDefinition, fullscreenButtonStateDefinition, muteButtonStateDefinition, playButtonStateDefinition, playable, previewTimeDisplayStateDefinition, temporal, timeSliderStateDefinition, volumeSliderStateDefinition };
//# sourceMappingURL=store.d.ts.map