@cloud-app-dev/vidc 2.1.0-alpha.8 → 2.2.0-alpha.2

package/es/Player/message.js

@@ -0,0 +1,150 @@
+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."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import React, { useEffect, useState, useMemo } from 'react';
+import IconFont from './iconfont';
+import EventName from './event/eventName';
+import "./style/message.css";
+
+function VideoMessage(_ref) {
+  var event = _ref.event,
+      api = _ref.api;
+
+  var _useState = useState({
+    status: null,
+    errorTimer: null,
+    loading: false
+  }),
+      _useState2 = _slicedToArray(_useState, 2),
+      state = _useState2[0],
+      setState = _useState2[1];
+
+  var message = useMemo(function () {
+    if (state.status === 'fail') {
+      return '视频错误';
+    }
+
+    if (state.status === 'reload') {
+      return "\u89C6\u9891\u52A0\u8F7D\u9519\u8BEF\uFF0C\u6B63\u5728\u8FDB\u884C\u91CD\u8FDE\u7B2C".concat(state.errorTimer, "\u6B21\u91CD\u8FDE");
+    }
+
+    return '';
+  }, [state.errorTimer, state.status]);
+  useEffect(function () {
+    var openLoading = function openLoading() {
+      return setState(function (old) {
+        return Object.assign(Object.assign({}, old), {
+          loading: true
+        });
+      });
+    };
+
+    var closeLoading = function closeLoading() {
+      return setState(function (old) {
+        return Object.assign(Object.assign({}, old), {
+          loading: false
+        });
+      });
+    };
+
+    var errorReload = function errorReload(timer) {
+      return 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 reload = function reload() {
+      return setState(function (old) {
+        return Object.assign(Object.assign({}, old), {
+          status: 'reload'
+        });
+      });
+    };
+
+    var playEnd = function playEnd() {
+      return 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]);
+  var loading = state.loading,
+      status = state.status;
+  return /*#__PURE__*/React.createElement("div", {
+    className: "lm-player-message-mask ".concat(loading || status === 'fail' ? 'lm-player-mask-loading-animation' : '')
+  }, /*#__PURE__*/React.createElement(IconFont, {
+    type: status === 'fail' ? 'lm-player-YesorNo_No_Dark' : 'lm-player-Loading',
+    className: "".concat(loading && status !== 'fail' ? 'lm-player-loading-animation' : status === 'fail' ? 'lm-player-loadfail' : '', " lm-player-loading-icon")
+  }), /*#__PURE__*/React.createElement("span", {
+    className: "lm-player-message"
+  }, message));
+}
+
+export var NoSource = function NoSource() {
+  return /*#__PURE__*/React.createElement("div", {
+    className: "lm-player-message-mask lm-player-mask-loading-animation"
+  }, /*#__PURE__*/React.createElement(IconFont, {
+    style: {
+      fontSize: 80
+    },
+    type: "lm-player-PlaySource",
+    title: "\u8BF7\u9009\u62E9\u89C6\u9891\u6E90"
+  }));
+};
+export default VideoMessage;

package/es/Player/player.d.ts

@@ -0,0 +1,75 @@
+import type FlvJs from 'flv.zv.js';
+import type Hls, { HlsConfig } from 'hls.js';
+import type React from 'react';
+import type Api from './api';
+import type VideoEventInstance from './event';
+
+export type FlvPlayerConfig = {
+  mediaDataSource: FlvJs.MediaDataSource;
+  config: FlvJs.Config;
+};
+
+export interface ISinglePlayerProps {
+  url?: string;
+  className?: string;
+  children?: React.ReactNode;
+  muted?: boolean;
+  scale?: boolean;
+  autoPlay?: boolean;
+  playsInline?: boolean;
+  preload?: string;
+  poster?: string;
+  loop?: boolean;
+  type?: 'flv' | 'hls' | 'native';
+  hideContrallerBar?: boolean;
+  isLive?: boolean;
+  rightExtContents?: React.ReactNode;
+  rightMidExtContents?: React.ReactNode;
+  leftExtContents?: React.ReactNode;
+  leftMidExtContents?: React.ReactNode;
+  customTimeLine?: React.ReactNode;
+  errorReloadTimer?: number;
+  flvConfig?: FlvPlayerConfig;
+  hlsConfig?: HlsConfig;
+  reload?: () => void;
+  onCanPlayerInit?: () => void;
+  videoEvents?: CustomEvent[];
+  playerEvents?: CustomEvent[];
+}
+
+export const SinglePlayer: React.FunctionComponent<ISinglePlayerProps>;
+
+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)[];
+};
+
+export type ExportPlayerType = {
+  video: HTMLVideoElement;
+  container: HTMLElement;
+  api: Api;
+  event: VideoEventInstance;
+  plugins: [FlvJs.Player, Hls];
+};
+
+export interface ISegmentType {
+  url?: string;
+  duration: number;
+}
+
+export type CustomEvent = [string, () => void];

package/es/Player/segment_player.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import type { ISegmentType, ISinglePlayerProps } from './player';
+interface ISegmentPlayerProps extends Omit<ISinglePlayerProps, 'url' | 'customTimeLine' | 'onCanPlayerInit'> {
+    segments?: ISegmentType[];
+    begin?: number;
+}
+/**
+ * @desc 主组件，负责片段整体逻辑控制
+ * @param param0
+ * @returns
+ */
+declare function SegmentPlayer({ segments, begin, ...props }: ISegmentPlayerProps): JSX.Element;
+export default SegmentPlayer;

package/es/Player/segment_player.js

@@ -0,0 +1,191 @@
+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."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import { __rest } from "tslib";
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import SinglePlayer from './single_player';
+import SegmentTimeLine from './segment_timeline';
+/**
+ * @desc 计算第一个url
+ * @param segments
+ * @param defaultIndex
+ * @returns
+ */
+
+function getFirstUrlIndex(segments) {
+  var defaultIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+  if (!(Array.isArray(segments) && segments.length > 0)) {
+    return defaultIndex;
+  }
+
+  if (segments[defaultIndex].url) {
+    return defaultIndex;
+  } else {
+    var i = defaultIndex + 1;
+
+    if (i > segments.length) {
+      return i;
+    }
+
+    return getFirstUrlIndex(segments, i);
+  }
+}
+/**
+ * @desc 片段索引控制
+ * @param event
+ * @param segments
+ * @param deps
+ * @returns
+ */
+
+
+function usePlayIndex(event, segments, deps) {
+  var _useState = useState({
+    index: getFirstUrlIndex(segments, 0)
+  }),
+      _useState2 = _slicedToArray(_useState, 2),
+      state = _useState2[0],
+      setState = _useState2[1]; // 片段发生变化重新开始计算索引
+
+
+  useEffect(function () {
+    var index = getFirstUrlIndex(segments, 0);
+    setState(function (old) {
+      return Object.assign(Object.assign({}, old), {
+        index: index
+      });
+    });
+  }, [segments]); // 索引不存在播放地址，自动跳转下一段
+
+  useEffect(function () {
+    var _a;
+
+    if (!((_a = segments[state.index]) === null || _a === void 0 ? void 0 : _a.url) && state.index < segments.length - 1) {
+      setState(function (old) {
+        return Object.assign(Object.assign({}, old), {
+          index: old.index + 1
+        });
+      });
+    }
+  }, [state.index]); // 监听片段播放状态，自动跳转下一个片段
+
+  useEffect(function () {
+    if (!event) {
+      return undefined;
+    }
+
+    var fn = function fn() {
+      return setState(function (old) {
+        return Object.assign(Object.assign({}, onload), {
+          index: old.index + 1 < segments.length ? old.index + 1 : old.index
+        });
+      });
+    };
+
+    event.addEventListener('ended', fn);
+    return function () {
+      return event.removeEventListener('ended', fn);
+    };
+  }, [event, segments].concat(_toConsumableArray(deps)));
+  return {
+    index: state.index,
+    setIndex: function setIndex(i) {
+      return setState(function (old) {
+        return Object.assign(Object.assign({}, old), {
+          index: i
+        });
+      });
+    }
+  };
+}
+/**
+ * @desc 主组件，负责片段整体逻辑控制
+ * @param param0
+ * @returns
+ */
+
+
+function SegmentPlayer(_a) {
+  var _b;
+
+  var segments = _a.segments,
+      begin = _a.begin,
+      props = __rest(_a, ["segments", "begin"]);
+
+  var _useState3 = useState({
+    forceKey: Date.now()
+  }),
+      _useState4 = _slicedToArray(_useState3, 2),
+      state = _useState4[0],
+      setState = _useState4[1];
+
+  var duration = useMemo(function () {
+    return segments === null || segments === void 0 ? void 0 : segments.map(function (v) {
+      return v.duration;
+    }).reduce(function (a, b) {
+      return a + b;
+    }, 0);
+  }, [segments]);
+  var playerRef = useRef(null);
+
+  var _usePlayIndex = usePlayIndex((_b = playerRef.current) === null || _b === void 0 ? void 0 : _b.event, segments, [state.forceKey]),
+      index = _usePlayIndex.index,
+      setIndex = _usePlayIndex.setIndex;
+
+  var url = useMemo(function () {
+    return segments && segments[index] ? segments[index].url : undefined;
+  }, [segments, index]); // 重置reload
+
+  var reload = function reload() {
+    setIndex(0);
+    playerRef.current.api.reload();
+  };
+
+  var _ref = playerRef.current || {},
+      api = _ref.api,
+      event = _ref.event; // 秒级别转换
+
+
+  var beginTemp = useMemo(function () {
+    return begin ? String(begin).length === 10 ? Math.floor(begin * 1000) : begin : begin;
+  }, []);
+  return /*#__PURE__*/React.createElement(SinglePlayer, Object.assign({
+    ref: playerRef,
+    url: url,
+    reload: reload,
+    onCanPlayerInit: function onCanPlayerInit() {
+      return setState({
+        forceKey: Date.now()
+      });
+    },
+    customTimeLine: api && event ? /*#__PURE__*/React.createElement(SegmentTimeLine, {
+      begin: beginTemp,
+      api: api,
+      event: event,
+      index: index,
+      segments: segments,
+      duration: duration,
+      setIndex: setIndex
+    }) : /*#__PURE__*/React.createElement(React.Fragment, null)
+  }, props));
+}
+
+export default SegmentPlayer;

package/es/Player/segment_timeline.d.ts

@@ -0,0 +1,16 @@
+/// <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;
+}
+declare function SegmentTimeLine({ api, event, index, segments, duration, begin, setIndex }: ITimeLineProps): JSX.Element;
+export default SegmentTimeLine;

package/es/Player/segment_timeline.js

@@ -0,0 +1,154 @@
+import "antd/lib/tooltip/style";
+import _Tooltip from "antd/lib/tooltip";
+
+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."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import React, { useCallback, useMemo } from 'react';
+import { useTimes } from './timeline';
+import useBarStatus from './contraller_bar/useBarStatus';
+import { dateFormat } from './util';
+import "./style/timeline.css";
+
+function SegmentTimeLine(_ref) {
+  var api = _ref.api,
+      event = _ref.event,
+      index = _ref.index,
+      segments = _ref.segments,
+      duration = _ref.duration,
+      begin = _ref.begin,
+      setIndex = _ref.setIndex;
+  var status = useBarStatus(event);
+
+  var _useTimes = useTimes(api, event),
+      _useTimes2 = _slicedToArray(_useTimes, 2),
+      currentTime = _useTimes2[0],
+      buffered = _useTimes2[1];
+
+  var indexDuration = useMemo(function () {
+    return segments.map(function (v) {
+      return v.duration;
+    }).reduce(function (a, b, i) {
+      return i >= index ? a : a + b;
+    }, 0);
+  }, [index]);
+  var playPercent = useMemo(function () {
+    return (currentTime + indexDuration) / duration * 100;
+  }, [currentTime, duration, indexDuration]);
+  var bufferedPercent = useMemo(function () {
+    return (buffered + indexDuration) / duration * 100;
+  }, [buffered, duration, indexDuration]);
+  var seekWithLine = useCallback(function (e, i) {
+    if (!segments[i].url) {
+      return;
+    }
+
+    var ele = e.currentTarget;
+    var rect = ele.getBoundingClientRect();
+    var current = e.pageX - rect.left;
+    var currentTime = current / rect.width * api.getDuration();
+
+    if (i !== index) {
+      setIndex(i); // 临时方案，最好方案在初始化播放器时实现，这样处理理论上也可以
+
+      setTimeout(function () {
+        return api.seekTo(currentTime);
+      }, 500);
+    } else {
+      api.seekTo(currentTime);
+    }
+  }, [api, segments, index]);
+  return /*#__PURE__*/React.createElement("div", {
+    className: "player-timeline-layout player-segment-timeline-layout ".concat(status === 0 ? 'hide-time-line' : '')
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "segment-line-box"
+  }, segments.map(function (v, i) {
+    return /*#__PURE__*/React.createElement(_Tooltip, {
+      key: "time-line-".concat(i),
+      title: /*#__PURE__*/React.createElement(TipTitle, {
+        segments: segments,
+        index: i,
+        begin: begin
+      })
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "segment-line-item ".concat(!v.url ? 'segment-line-item-none' : '', " ").concat(i === segments.length - 1 ? 'last-segment-line-item' : ''),
+      onClick: function onClick(e) {
+        return seekWithLine(e, i);
+      },
+      style: {
+        width: "".concat(v.duration / duration * 100, "%")
+      }
+    }));
+  }), /*#__PURE__*/React.createElement("div", {
+    className: "buffer-line",
+    style: {
+      width: "".concat(bufferedPercent, "%")
+    }
+  }), /*#__PURE__*/React.createElement("div", {
+    className: "current-line",
+    style: {
+      width: "".concat(playPercent, "%")
+    }
+  })));
+}
+
+function TipTitle(_ref2) {
+  var index = _ref2.index,
+      segments = _ref2.segments,
+      begin = _ref2.begin;
+
+  var _useMemo = useMemo(function () {
+    if (index === 0) {
+      var _start = begin;
+
+      var _end = begin + segments[0].duration * 1000;
+
+      return {
+        start: dateFormat(_start),
+        end: dateFormat(_end)
+      };
+    }
+
+    var indexDuration = segments.map(function (v) {
+      return v.duration;
+    }).reduce(function (a, b, i) {
+      return i >= index ? a : a + b;
+    }, 0);
+    var start = begin + indexDuration * 1000;
+    var end = start + segments[index].duration * 1000;
+    return {
+      start: dateFormat(start),
+      end: dateFormat(end)
+    };
+  }, [index, segments, begin]),
+      start = _useMemo.start,
+      end = _useMemo.end;
+
+  var hasUrl = useMemo(function () {
+    var _a;
+
+    return ((_a = segments[index]) === null || _a === void 0 ? void 0 : _a.url) ? true : false;
+  }, [index, segments]);
+  return /*#__PURE__*/React.createElement("div", {
+    className: "segment-line-tip-box"
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      fontWeight: 600
+    }
+  }, "\u5F55\u50CF\u7247\u6BB5\u4FE1\u606F"), /*#__PURE__*/React.createElement("div", null, "\u5F00\u59CB\uFF1A", start), /*#__PURE__*/React.createElement("div", null, "\u7ED3\u675F\uFF1A", end), /*#__PURE__*/React.createElement("div", null, "\u72B6\u6001\uFF1A", /*#__PURE__*/React.createElement("span", {
+    style: {
+      color: hasUrl ? 'green' : 'red'
+    }
+  }, hasUrl ? '正常' : '缺失')));
+}
+
+export default SegmentTimeLine;

package/es/Player/single_player.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { ISinglePlayerProps, ExportPlayerType } from './player';
+import './style/index.less';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<ISinglePlayerProps & React.RefAttributes<ExportPlayerType>>>;
+export default _default;