@cloud-app-dev/vidc 3.0.16 → 3.0.18

package/es/Player/live_heart.js

@@ -1,18 +1,23 @@
 import _useRafInterval from "ahooks/es/useRafInterval";
 import _useUpdateEffect from "ahooks/es/useUpdateEffect";
 import _useDocumentVisibility from "ahooks/es/useDocumentVisibility";
-import React, { useRef } from 'react';
+import { useRef } from 'react';
 import Events from './event/eventName';
 
-function LiveHeart(_ref) {
+function useLiveHeart(_ref) {
   var api = _ref.api,
-      event = _ref.event;
+      event = _ref.event,
+      isLive = _ref.isLive;
 
   var documentVisibility = _useDocumentVisibility();
 
   var cTimeRef = useRef(null);
 
   var run = function run() {
+    if (!isLive || documentVisibility !== 'visible') {
+      return;
+    }
+
     var current = api.getCurrentTime();
     var buffered = api.getSecondsLoaded();
 
@@ -38,12 +43,10 @@ function LiveHeart(_ref) {
   _useRafInterval(function () {
     var cuurentTime = api.getCurrentTime();
 
-    if (!api.video.paused && cuurentTime === cTimeRef.current) {
+    if (!!isLive && !api.video.paused && cuurentTime === cTimeRef.current) {
       event.emit(Events.ERROR);
     }
   }, 20 * 1000);
-
-  return /*#__PURE__*/React.createElement(React.Fragment, null);
 }
 
-export default LiveHeart;
+export default useLiveHeart;

package/es/Player/message.js

@@ -10,8 +10,9 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-import React, { useEffect, useState, useMemo, useRef } from 'react';
+import React, { useState, useMemo, useRef } from 'react';
 import IconFont from './iconfont';
+import { useRegisterPlayerEvent, useVideoEvent } from './event';
 import EventName from './event/eventName';
 import "./style/message.css";
 
@@ -42,99 +43,83 @@ function VideoMessage(_ref) {
 
     return '';
   }, [state.errorTimer, state.status]);
-  useEffect(function () {
-    var openLoading = function openLoading() {
-      clearTimeout(timeRef.current);
-      timeRef.current = setTimeout(function () {
-        return setState(function (old) {
-          return Object.assign(Object.assign({}, old), {
-            loading: true
-          });
-        });
-      }, 200);
-    };
 
-    var closeLoading = function closeLoading() {
-      clearTimeout(timeRef.current);
-      setState(function (old) {
+  var openLoading = function openLoading() {
+    clearTimeout(timeRef.current);
+    timeRef.current = setTimeout(function () {
+      return setState(function (old) {
         return Object.assign(Object.assign({}, old), {
-          loading: false
+          loading: true
         });
       });
-    };
-
-    var errorReload = function errorReload(timer) {
-      clearTimeout(timeRef.current);
-      setState(function () {
-        return {
-          status: 'reload',
-          errorTimer: timer,
-          loading: true
-        };
+    }, 200);
+  };
+
+  var closeLoading = function closeLoading() {
+    clearTimeout(timeRef.current);
+    setState(function (old) {
+      return Object.assign(Object.assign({}, old), {
+        loading: false
       });
-    };
-
-    var reloadFail = function reloadFail() {
-      return setState(function (old) {
-        return Object.assign(Object.assign({}, old), {
-          status: 'fail'
-        });
+    });
+  };
+
+  var errorReload = function errorReload(timer) {
+    clearTimeout(timeRef.current);
+    setState(function () {
+      return {
+        status: 'reload',
+        errorTimer: timer,
+        loading: true
+      };
+    });
+  };
+
+  var reloadFail = function reloadFail() {
+    return setState(function (old) {
+      return Object.assign(Object.assign({}, old), {
+        status: 'fail'
       });
-    };
+    });
+  };
 
-    var reloadSuccess = function reloadSuccess() {
-      return setState(function (old) {
-        return Object.assign(Object.assign({}, old), {
-          status: null
-        });
+  var reloadSuccess = function reloadSuccess() {
+    return setState(function (old) {
+      return Object.assign(Object.assign({}, old), {
+        status: null
       });
-    };
-
-    var reload = function reload() {
-      return setState(function (old) {
-        return Object.assign(Object.assign({}, old), {
-          status: 'reload',
-          loading: true
-        });
+    });
+  };
+
+  var reload = function reload() {
+    return setState(function (old) {
+      return Object.assign(Object.assign({}, old), {
+        status: 'reload',
+        loading: true
       });
-    };
-
-    var playEnd = function playEnd() {
-      clearTimeout(timeRef.current);
-      setState(function (old) {
-        return Object.assign(Object.assign({}, old), {
-          status: null,
-          loading: false
-        });
+    });
+  };
+
+  var playEnd = function playEnd() {
+    clearTimeout(timeRef.current);
+    setState(function (old) {
+      return Object.assign(Object.assign({}, old), {
+        status: null,
+        loading: false
       });
-      api.pause();
-    };
-
-    event.addEventListener('loadstart', openLoading); // event.addEventListener('waiting', openLoading);
-    // event.addEventListener('seeking', openLoading)
-
-    event.addEventListener('loadeddata', closeLoading);
-    event.addEventListener('canplay', closeLoading);
-    event.on(EventName.ERROR_RELOAD, errorReload);
-    event.on(EventName.RELOAD_FAIL, reloadFail);
-    event.on(EventName.RELOAD_SUCCESS, reloadSuccess);
-    event.on(EventName.RELOAD, reload);
-    event.on(EventName.HISTORY_PLAY_END, playEnd);
-    event.on(EventName.CLEAR_ERROR_TIMER, reloadSuccess);
-    return function () {
-      event.removeEventListener('loadstart', openLoading); // event.removeEventListener('waiting', openLoading);
-      // event.removeEventListener('seeking', openLoading)
-
-      event.removeEventListener('loadeddata', closeLoading);
-      event.removeEventListener('canplay', closeLoading);
-      event.off(EventName.ERROR_RELOAD, errorReload);
-      event.off(EventName.RELOAD_FAIL, reloadFail);
-      event.off(EventName.RELOAD_SUCCESS, reloadSuccess);
-      event.off(EventName.RELOAD, reload);
-      event.off(EventName.HISTORY_PLAY_END, playEnd);
-      event.off(EventName.CLEAR_ERROR_TIMER, reloadSuccess);
-    };
-  }, [event]);
+    });
+    api.pause();
+  };
+
+  useVideoEvent('loadstart', openLoading);
+  useVideoEvent('loadeddata', closeLoading);
+  useVideoEvent('canplay', closeLoading);
+  useRegisterPlayerEvent(EventName.ERROR_RELOAD, errorReload);
+  useRegisterPlayerEvent(EventName.RELOAD_FAIL, reloadFail);
+  useRegisterPlayerEvent(EventName.RELOAD_SUCCESS, reloadSuccess);
+  useRegisterPlayerEvent(EventName.RELOAD, reload);
+  useRegisterPlayerEvent(EventName.HISTORY_PLAY_END, playEnd);
+  useRegisterPlayerEvent(EventName.CLEAR_ERROR_TIMER, reloadSuccess);
   var loading = state.loading,
       status = state.status;
   return /*#__PURE__*/React.createElement("div", {

package/es/Player/player.d.ts

@@ -132,6 +132,16 @@ export interface ISinglePlayerProps {
    * 自定义播放器的事件
    */
   playerEvents?: CustomEvent[];
+
+  /**
+   * 开启单帧播放
+   */
+  oneFpsPlay?: boolean;
+
+  /**
+   * 获取视频针的频次 (ms)
+   */
+  fpsDelay?: number;
 }
 
 export interface IFrontendPlayerProps extends Omit<ISinglePlayerProps, 'isLive' | 'reload'> {
@@ -173,21 +183,6 @@ export const SinglePlayer: React.FunctionComponent<ISinglePlayerProps>;
 export const FrontendPlayer: React.FunctionComponent<IFrontendPlayerProps>;
 export const SegmentPlayer: React.FunctionComponent<ISegmentPlayerProps>;
 
-export interface EventName {
-  RELOAD: 'reload'; //手动视频重载
-  RELOAD_FAIL: 'reloadFail'; // 视频出错，重连失败
-  RELOAD_SUCCESS: 'reloadSuccess'; //视频出错，重连成功
-  ERROR: 'error'; //视频出错
-  ERROR_RELOAD: 'errorRload'; //视频出错，自动重连
-  HISTORY_PLAY_END: 'historyPlayEnd'; //历史视频列表播放结束
-  SEEK: 'seek'; //跳跃播放时间
-  TRANSFORM: 'transform'; //视频容器缩放
-  CHANGE_PLAY_INDEX: 'changePlayIndex'; //历史视频列表播放索引改变
-  HIDE_CONTRALLER: 'hideContraller';
-  SHOW_CONTRALLER: 'showContraller';
-  CLEAR_ERROR_TIMER: 'clearErrorTimer';
-}
-
 export type EventInfo = {
   type: string;
   listener: ((...args: any) => void)[];

package/es/Player/segment_player.js

@@ -1,14 +1,6 @@
 import _useUpdate from "ahooks/es/useUpdate";
 import _useLatest from "ahooks/es/useLatest";
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -26,13 +18,14 @@ import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import SinglePlayer from './single_player';
 import SegmentTimeLine from './segment_timeline';
 import Events from './event/eventName';
-
+import { useRegisterPlayerEvent, useVideoEvent } from './event';
 /**
  * @desc 计算第一个url
  * @param segments
  * @param defaultIndex
  * @returns
  */
+
 function getFirstUrlIndex(segments) {
   var defaultIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
 
@@ -94,24 +87,16 @@ function usePlayIndex(event, segments) {
     }
   }, [segments, state.index]); // 监听片段播放状态，自动跳转下一个片段
 
-  useEffect(function () {
-    if (!event) {
-      return undefined;
-    }
-
-    var fn = function fn() {
-      return setState(function (old) {
-        return Object.assign(Object.assign({}, old), {
-          index: old.index + 1 < segments.length ? old.index + 1 : old.index
-        });
+  var endHandle = function endHandle() {
+    return setState(function (old) {
+      return Object.assign(Object.assign({}, old), {
+        index: old.index + 1 < segments.length ? old.index + 1 : old.index
       });
-    };
+    });
+  };
 
-    event.addEventListener('ended', fn);
-    return function () {
-      return event.removeEventListener('ended', fn);
-    }; // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [event, segments].concat(_toConsumableArray(deps)));
+  useVideoEvent('ended', endHandle, event);
+  useRegisterPlayerEvent(Events.PLAY_ENDED, endHandle, event);
   return {
     index: state.index,
     setIndex: function setIndex(i) {
@@ -214,21 +199,20 @@ function SegmentPlayer(_a) {
   var hasReady = api && event;
   var timeline = customTimeLine !== null && customTimeLine !== void 0 ? customTimeLine : /*#__PURE__*/React.createElement(SegmentTimeLine, {
     begin: begin,
-    api: api,
-    event: event,
     seekTo: seekTo,
     index: index,
     segments: segments,
-    duration: duration,
-    setIndex: setIndex
+    duration: duration
   });
   var onInit = useCallback(function () {
     update();
     onCanPlayerInit === null || onCanPlayerInit === void 0 ? void 0 : onCanPlayerInit(); // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
+  console.log(playRef);
   return /*#__PURE__*/React.createElement(SinglePlayer, Object.assign({
     ref: playRef,
     url: url,
+    isLive: false,
     onCanPlayerInit: onInit,
     reload: reload,
     extActions: {

package/es/Player/segment_timeline.d.ts

@@ -1,17 +1,12 @@
 /// <reference types="react" />
-import type Api from './api';
-import type VideoEventInstance from './event';
 import type { ISegmentType } from './player';
 import './style/timeline.less';
 interface ITimeLineProps {
-    api: Api;
-    event: VideoEventInstance;
     index: number;
     segments: ISegmentType[];
     duration: number;
-    setIndex: (i: number) => void;
     begin: number;
     seekTo: (time: number) => void;
 }
-declare function SegmentTimeLine({ api, event, index, segments, duration, begin, setIndex, seekTo }: ITimeLineProps): JSX.Element;
+declare function SegmentTimeLine({ index, segments, duration, begin, seekTo }: ITimeLineProps): JSX.Element;
 export default SegmentTimeLine;

package/es/Player/segment_timeline.js

@@ -13,25 +13,29 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-import React, { useCallback, useMemo } from 'react';
+import React, { useCallback, useContext, useMemo } from 'react';
 import { useTimes } from './timeline';
 import useBarStatus from './contraller_bar/useBarStatus';
 import moment from 'moment';
 import { FMT } from './util';
+import { Context } from './context';
 import "./style/timeline.css";
 
 function SegmentTimeLine(_ref) {
-  var api = _ref.api,
-      event = _ref.event,
-      index = _ref.index,
+  var index = _ref.index,
       segments = _ref.segments,
       duration = _ref.duration,
       begin = _ref.begin,
-      setIndex = _ref.setIndex,
       seekTo = _ref.seekTo;
+
+  var _useContext = useContext(Context),
+      api = _useContext.api,
+      event = _useContext.event,
+      isFpsPlay = _useContext.isFpsPlay;
+
   var status = useBarStatus(event);
 
-  var _useTimes = useTimes(api, event),
+  var _useTimes = useTimes(api, event, isFpsPlay),
       _useTimes2 = _slicedToArray(_useTimes, 2),
       currentTime = _useTimes2[0],
       buffered = _useTimes2[1];
@@ -62,7 +66,7 @@ function SegmentTimeLine(_ref) {
     var duration = segments[i].endTime - segments[i].beginTime;
     var currentTime = current / rect.width * duration;
     seekTo(Math.round(currentTime + pTime));
-  }, [segments, api, index, setIndex]);
+  }, [segments, begin, seekTo]);
   return /*#__PURE__*/React.createElement("div", {
     className: "player-timeline-layout player-segment-timeline-layout ".concat(status === 0 ? 'hide-time-line' : '')
   }, /*#__PURE__*/React.createElement("div", {

package/es/Player/single_player.js

@@ -1,3 +1,4 @@
+import _useUpdateEffect from "ahooks/es/useUpdateEffect";
 import _useToggle3 from "ahooks/es/useToggle";
 
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
@@ -19,11 +20,13 @@ import { usePlayerEvent, useRegisterPlayerEvents, useVideoEvents } from './event
 import EventName from './event/eventName';
 import ContrallerBar from './contraller_bar';
 import ContrallerEvent from './contraller_bar/contraller_event';
-import LiveHeart from './live_heart';
+import useLiveHeart from './live_heart';
 import VideoMessage from './message';
-import ErrorEvent from './event/errorEvent';
+import useErrorEvent from './event/errorEvent';
 import { getVideoType, playReload, playUnload } from './util';
 import Timeline from './timeline';
+import FPSPlay from './fps_play';
+import { Provider } from './context';
 import "./style/index.css";
 var SinglePlayer = /*#__PURE__*/React.forwardRef(function (_a, ref) {
   var _b;
@@ -53,10 +56,13 @@ var SinglePlayer = /*#__PURE__*/React.forwardRef(function (_a, ref) {
   var flvConfig = props.flvConfig,
       hlsConfig = props.hlsConfig,
       videoEvents = props.videoEvents,
-      playerEvents = props.playerEvents;
+      playerEvents = props.playerEvents,
+      oneFpsPlay = props.oneFpsPlay,
+      fpsDelay = props.fpsDelay;
 
   var _useState = useState({
-    container: null
+    container: null,
+    isFpsPlay: false
   }),
       _useState2 = _slicedToArray(_useState, 2),
       state = _useState2[0],
@@ -85,7 +91,6 @@ var SinglePlayer = /*#__PURE__*/React.forwardRef(function (_a, ref) {
       _usePlayerApi2 = _slicedToArray(_usePlayerApi, 2),
       api = _usePlayerApi2[0],
       _usePlayerApi2$ = _slicedToArray(_usePlayerApi2[1], 3),
-      _ = _usePlayerApi2$[0],
       flv = _usePlayerApi2$[1],
       hls = _usePlayerApi2$[2]; // 判断是否有链接传入
 
@@ -112,6 +117,23 @@ var SinglePlayer = /*#__PURE__*/React.forwardRef(function (_a, ref) {
 
   var unload = function unload() {
     return playUnload(video, flv, hls);
+  };
+
+  var openFpsPlay = function openFpsPlay() {
+    setState(function (old) {
+      return Object.assign(Object.assign({}, old), {
+        isFpsPlay: true
+      });
+    });
+    api.pause();
+  };
+
+  var closeFpsPlay = function closeFpsPlay() {
+    return setState(function (old) {
+      return Object.assign(Object.assign({}, old), {
+        isFpsPlay: false
+      });
+    });
   }; // 合并api,加上代理
 
 
@@ -123,7 +145,9 @@ var SinglePlayer = /*#__PURE__*/React.forwardRef(function (_a, ref) {
     var map = Object.assign({
       reload: reload,
       unload: unload,
-      toggleFit: toggle
+      toggleFit: toggle,
+      openFpsPlay: openFpsPlay,
+      closeFpsPlay: closeFpsPlay
     }, extActions);
     return new Proxy(api, {
       get: function get(target, key) {
@@ -162,61 +186,80 @@ var SinglePlayer = /*#__PURE__*/React.forwardRef(function (_a, ref) {
       fit: fit
     };
   }, [video, state.container, playApi, playEvent, flv, hls, fit]);
-  useEffect(function () {
-    if (api && event && video) {
-      onCanPlayerInit === null || onCanPlayerInit === void 0 ? void 0 : onCanPlayerInit();
-    } // eslint-disable-next-line react-hooks/exhaustive-deps
 
-  }, [api, event, video]);
-  return /*#__PURE__*/React.createElement("div", {
-    className: "lm-player-container ".concat(className),
-    ref: domRef
-  }, /*#__PURE__*/React.createElement("div", {
-    className: "player-mask-layout"
-  }, /*#__PURE__*/React.createElement("video", {
-    style: {
-      objectFit: fit
-    },
-    autoPlay: autoPlay,
-    preload: preload,
-    muted: muted,
-    poster: poster,
-    controls: false,
-    playsInline: playsInline,
-    loop: loop
-  })), api && event && hasLink && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(VideoMessage, {
+  _useUpdateEffect(function () {
+    return api && event && video ? onCanPlayerInit === null || onCanPlayerInit === void 0 ? void 0 : onCanPlayerInit() : undefined;
+  }, [api, event, video]); // 补货视频错误，自定义处理
+
+
+  useErrorEvent({
+    unload: unload,
+    flv: flv,
+    hls: hls,
     api: playApi,
-    event: event
-  }), !hideContrallerBar && /*#__PURE__*/React.createElement(ContrallerEvent, {
     event: event,
-    container: state.container
-  }, /*#__PURE__*/React.createElement(ContrallerBar, {
+    reload: reload,
+    errorReloadTimer: errorReloadTimer
+  }); // 直播缓冲追回
+
+  useLiveHeart({
     api: playApi,
     event: event,
-    isLive: isLive,
-    container: state.container,
+    isLive: isLive
+  });
+  var videoProps = {
+    autoPlay: state.isFpsPlay ? false : autoPlay,
+    preload: preload,
+    muted: state.isFpsPlay ? false : muted,
+    poster: poster,
+    controls: false,
+    playsInline: playsInline,
+    loop: state.isFpsPlay ? false : loop
+  };
+  var contrallerProps = {
     rightExtContents: rightExtContents,
     rightMidExtContents: rightMidExtContents,
-    leftExtContents: leftExtContents,
     leftMidExtContents: leftMidExtContents,
+    leftExtContents: leftExtContents,
     reload: (_b = props.reload) !== null && _b !== void 0 ? _b : reload,
-    hideTimeProgress: !!customTimeLine
-  })), customTimeLine ? customTimeLine : !hideContrallerBar ? /*#__PURE__*/React.createElement(Timeline, {
-    api: playApi,
-    event: event
-  }) : null, /*#__PURE__*/React.createElement(ErrorEvent, {
-    unload: unload,
-    flv: flv,
-    hls: hls,
+    hideTimeProgress: !!customTimeLine,
+    oneFpsPlay: oneFpsPlay
+  };
+  return /*#__PURE__*/React.createElement(Provider, {
     api: playApi,
     event: event,
-    reload: reload,
-    errorReloadTimer: errorReloadTimer
-  }), isLive && /*#__PURE__*/React.createElement(LiveHeart, {
+    container: state.container,
+    isLive: isLive,
+    isFpsPlay: state.isFpsPlay
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "lm-player-container ".concat(className),
+    ref: domRef
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "player-mask-layout"
+  }, /*#__PURE__*/React.createElement("video", Object.assign({}, videoProps, {
+    style: {
+      objectFit: fit,
+      visibility: state.isFpsPlay ? 'hidden' : 'unset'
+    }
+  })), api && event && hasLink && state.isFpsPlay ? /*#__PURE__*/React.createElement(FPSPlay, {
+    event: event,
+    api: playApi,
+    fpsDelay: fpsDelay
+  }) : /*#__PURE__*/React.createElement(Empty, null)), api && event && hasLink ? /*#__PURE__*/React.createElement(VideoMessage, {
+    api: playApi,
+    event: event
+  }) : /*#__PURE__*/React.createElement(Empty, null), api && event && hasLink && !hideContrallerBar ? /*#__PURE__*/React.createElement(ContrallerEvent, {
+    children: /*#__PURE__*/React.createElement(ContrallerBar, Object.assign({}, contrallerProps))
+  }) : /*#__PURE__*/React.createElement(Empty, null), customTimeLine ? customTimeLine : !hideContrallerBar ? /*#__PURE__*/React.createElement(Timeline, {
     api: playApi,
-    event: playEvent
-  })), children);
+    event: event
+  }) : /*#__PURE__*/React.createElement(Empty, null), children));
 });
+
+function Empty() {
+  return /*#__PURE__*/React.createElement(React.Fragment, null);
+}
+
 SinglePlayer.defaultProps = {
   isLive: true,
   errorReloadTimer: 5,
@@ -232,6 +275,8 @@ SinglePlayer.defaultProps = {
     config: {}
   },
   hlsConfig: {},
-  extActions: {}
+  extActions: {},
+  oneFpsPlay: false,
+  fpsDelay: 100
 };
 export default SinglePlayer;

package/es/Player/style/bar.css

@@ -34,4 +34,5 @@
   line-height: 28px;
   color: #fff;
   font-size: 10px;
+  padding: 0 6px;
 }

package/es/Player/style/index.css

@@ -8,6 +8,14 @@
 .lm-player-container .lm-player-iconfont {
   color: #fff;
 }
+.lm-player-container .fps-play-canvas {
+  width: 100%;
+  height: 100%;
+  position: absolute;
+  left: 0;
+  top: 0;
+  background-color: #000;
+}
 .lm-player-container .player-mask-layout {
   width: 100%;
   height: 100%;

package/es/Player/timeline.d.ts

@@ -6,6 +6,6 @@ interface ITimeLineProps {
     api: Api;
     event: VideoEventInstance;
 }
-export declare function useTimes(api: Api, event: VideoEventInstance, isHide?: boolean): number[];
+export declare function useTimes(api: Api, event: VideoEventInstance, isFpsPlay?: boolean): number[];
 declare function TimeLine({ api, event }: ITimeLineProps): JSX.Element;
 export default TimeLine;