@cloud-app-dev/vidc 4.0.22 → 4.0.23

package/es/Picture/component/DrawRect/index.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { MenuRectType } from '../../interface';
+import './index.less';
+interface IDrawRectProps {
+    rect: number[];
+    canRenderMenu?: boolean;
+    containerDom: HTMLDivElement;
+    onMenuClick?: (options: MenuRectType) => void;
+    menus: MenuRectType[];
+    getRectImage: (rect: number[]) => string | null;
+}
+declare function DrawRect({ rect, canRenderMenu, containerDom, onMenuClick, menus, getRectImage }: IDrawRectProps): React.JSX.Element;
+export default DrawRect;

package/es/Picture/component/RectMenu/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { MenuRectType } from '../../../Picture/interface';
+import './index.less';
+interface IRectMenuProps {
+    x: number;
+    y: number;
+    menus: MenuRectType[];
+    containerDom: HTMLDivElement;
+    onMenuClick: (options: MenuRectType) => void;
+}
+declare function RectMenu({ x, y, menus, containerDom, onMenuClick }: IRectMenuProps): React.JSX.Element;
+export default RectMenu;

package/es/Picture/component/RectMenu/index.js

@@ -38,14 +38,20 @@ function RectMenu(_ref) {
   useEffect(function () {
     var dom = domRef.current;
     if (dom) {
+      //@ts-ignore
       dom.addEventListener('mousedown', handleCancelB, false);
+      //@ts-ignore
       dom.addEventListener('mousemove', handleCancelB, false);
+      //@ts-ignore
       dom.addEventListener('mouseup', handleCancelB, false);
     }
     return function () {
       if (dom) {
+        //@ts-ignore
         dom.removeEventListener('mousedown', handleCancelB, false);
+        //@ts-ignore
         dom.removeEventListener('mousemove', handleCancelB, false);
+        //@ts-ignore
         dom.removeEventListener('mouseup', handleCancelB, false);
       }
     };

package/es/Picture/component/RectMenu/utils.d.ts

@@ -0,0 +1,12 @@
+export declare function computedMenuPosition({ width, height, position, size }: {
+    width: number;
+    height: number;
+    position: number[];
+    size: {
+        w: number;
+        h: number;
+    };
+}): {
+    x: number;
+    y: number;
+};

package/es/Picture/component/Tools/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import './index.less';
+interface IToolsProps {
+    scale: number;
+    imgDownload?: () => void;
+    setScale: (scale: number) => void;
+    setRotate: (rotate: number) => void;
+    containerEle: HTMLDivElement;
+    resetPicture: (event: React.MouseEvent) => void;
+}
+declare function Tools({ scale, imgDownload, setScale, setRotate, containerEle, resetPicture }: IToolsProps): React.JSX.Element;
+export default Tools;

package/es/Picture/component/WheelScale/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface IWheelScaleProps {
+    dom: HTMLElement;
+    setScale: (scale: number) => void;
+}
+declare function WheelScale({ dom, setScale }: IWheelScaleProps): React.JSX.Element;
+export default WheelScale;

package/es/Picture/demo.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function App(): React.JSX.Element;

package/es/Picture/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { IPictureProps } from './interface';
+import './index.less';
+declare function Picture({ className, width, height, minHeight, disabledDrag, imagePath, rects, isOpenSelect, disabledDrawMenu, menus, hasTool, fullScreenEle, ...props }: IPictureProps): React.JSX.Element;
+export default Picture;

package/es/Picture/loadCaptureRectImage.d.ts

@@ -0,0 +1,3 @@
+import { ImageType } from './interface';
+export declare function loadCaptureRectImage(image: HTMLImageElement, rect: number[], imageType: ImageType): Promise<string>;
+export declare function getRectImagePath(image: HTMLImageElement, rect: number[]): string;

package/es/Picture/useDraw.d.ts

@@ -0,0 +1 @@
+export default function useDraw(dom: HTMLElement, open?: boolean): [number[], boolean];

package/es/Picture/utils.d.ts

@@ -0,0 +1,26 @@
+import { ImageType, RectType } from './interface';
+export declare function customContextMenu(e: any): boolean;
+export declare function cloneImageNode(image: HTMLImageElement): Promise<Node>;
+export declare function getCaptureRect(rect: number[], type: ImageType): number[];
+export declare function computedRectScale({ domImg, rects }: {
+    domImg: HTMLImageElement;
+    rects: RectType[];
+}): {
+    rect: number[];
+    type: ImageType;
+    needExpand?: boolean | undefined;
+    imgId?: string | undefined;
+    area?: number | undefined;
+    tags?: import("./interface").TagItemType[] | undefined;
+    imgUrl?: string | undefined;
+    isDefault?: boolean | undefined;
+    dupId?: string | undefined;
+    lowQuality?: boolean | undefined;
+    base64?: string | undefined;
+}[];
+export declare function getImgSize(dom: HTMLDivElement, img: HTMLImageElement): {
+    x: number;
+    y: number;
+    size: (string | number)[];
+    baseXOrY: string;
+};

package/es/Player/api/index.d.ts

@@ -0,0 +1,68 @@
+import Flvjs from '@cloud-app-dev/mpegts.js';
+import Hls, { HlsConfig } from 'hls.js';
+import type { FlvPlayerConfig } from '../player';
+declare class Api {
+    container: HTMLElement;
+    constructor(container: HTMLElement);
+    get video(): HTMLVideoElement | null;
+    play: () => void;
+    pause: () => void;
+    get paused(): boolean | undefined;
+    get muted(): boolean | undefined;
+    /**
+     * 设置currentTime实现seek
+     * @param {*} seconds
+     */
+    seekTo: (seconds: number) => void;
+    setVolume: (fraction: number) => void;
+    getVolume: () => number | undefined;
+    mute: () => void;
+    unmute: () => void;
+    /**
+     * 开启画中画功能
+     */
+    requestPictureInPicture: () => void;
+    /**
+     * 关闭画中画功能
+     */
+    exitPictureInPicture: () => void;
+    /**
+     * 设置播放速率
+     * @param {*} rate
+     */
+    setPlaybackRate: (rate: number) => void;
+    /**
+     * 获取视频总时长
+     */
+    getDuration: () => number;
+    /**
+     * 获取当前播放时间
+     */
+    getCurrentTime: () => number;
+    /**
+     * 获取缓存时间
+     */
+    getSecondsLoaded: () => number;
+    /**
+     * 获取当前视频缓存的起止时间
+     */
+    getBufferedTime: () => number[];
+    /**
+     * 视频截屏方法
+     */
+    snapshot: () => string;
+    unload: () => void;
+    reload: () => void;
+    toggleFit: () => void;
+    openFpsPlay: () => void;
+    closeFpsPlay: () => void;
+    destroy: () => void;
+}
+export type TypeAndPlay = {
+    type?: string;
+    flv?: Flvjs.Player;
+    hls?: Hls;
+};
+export declare function useTypeAndPlay(url?: string, type?: string, isLive?: boolean, container?: HTMLElement, segments?: Flvjs.MediaSegment[], flvConfig?: FlvPlayerConfig, hlsConfig?: HlsConfig): [string, Flvjs.Player, Hls];
+export declare function usePlayerApi(url?: string, type?: string, isLive?: boolean, container?: HTMLElement, segments?: Flvjs.MediaSegment[], flvConfig?: FlvPlayerConfig, hlsConfig?: HlsConfig): [Api | undefined, [string, Flvjs.Player, Hls], () => void];
+export default Api;

package/es/Player/context.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type Api from './api';
+import type VideoEventInstance from './event';
+export interface IPlayerContextProps {
+    /**
+     * @description 用于获取微应用顶层的dom节点
+     */
+    container?: HTMLElement;
+    api?: Api;
+    event?: VideoEventInstance;
+    isLive?: boolean;
+    isFpsPlay: boolean;
+    children: React.ReactNode;
+    getContainer?: () => HTMLElement;
+}
+export declare const Context: React.Context<Omit<IPlayerContextProps, "children">>;
+export declare function Provider({ children, getContainer, ...props }: IPlayerContextProps): React.JSX.Element;

package/es/Player/contraller_bar/bar.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface IBarProps extends React.HTMLAttributes<HTMLSpanElement> {
+    visibel?: boolean;
+    className?: string;
+    children?: React.ReactNode;
+}
+declare function Bar({ visibel, className, children, ...props }: IBarProps): React.JSX.Element | null;
+export default Bar;

package/es/Player/contraller_bar/contraller_event.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface IContrallerEventProps {
+    children?: React.ReactNode;
+}
+declare function ContrallerEvent({ children }: IContrallerEventProps): React.JSX.Element;
+export default ContrallerEvent;

package/es/Player/contraller_bar/contraller_event.js

@@ -19,11 +19,13 @@ function ContrallerEvent(_ref) {
     visibel = _useState2[0],
     setVisibel = _useState2[1];
   var showContraller = function showContraller() {
+    //@ts-ignore
     clearTimeout(timer.current);
     setVisibel(true);
     event === null || event === void 0 || event.emit(EventName.SHOW_CONTRALLER);
   };
   var hideContraller = function hideContraller() {
+    //@ts-ignore
     clearTimeout(timer.current);
     timer.current = setTimeout(function () {
       setVisibel(false);

package/es/Player/contraller_bar/index.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import '../style/bar.less';
+interface IContrallerBarProps {
+    rightExtContents: React.ReactNode;
+    rightMidExtContents: React.ReactNode;
+    visibel?: boolean;
+    leftExtContents: React.ReactNode;
+    leftMidExtContents: React.ReactNode;
+    reload: () => void;
+    hideTimeProgress?: boolean;
+    oneFpsPlay?: boolean;
+}
+declare function ContrallerBar({ rightExtContents, rightMidExtContents, visibel, leftExtContents, leftMidExtContents, reload, hideTimeProgress, oneFpsPlay }: IContrallerBarProps): React.JSX.Element;
+export default ContrallerBar;

package/es/Player/contraller_bar/left_bar.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface ILeftBarProps {
+    leftExtContents?: React.ReactNode;
+    leftMidExtContents?: React.ReactNode;
+    reload: () => void;
+    hideTimeProgress?: boolean;
+    oneFpsPlay?: boolean;
+}
+declare function LeftBar({ reload, leftExtContents, leftMidExtContents, hideTimeProgress, oneFpsPlay }: ILeftBarProps): React.JSX.Element;
+export default LeftBar;

package/es/Player/contraller_bar/right_bar.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface IRightBarProps {
+    visibel?: boolean;
+    rightExtContents: React.ReactNode;
+    rightMidExtContents: React.ReactNode;
+}
+declare function RightBar({ rightExtContents, rightMidExtContents }: IRightBarProps): React.JSX.Element;
+export default RightBar;

package/es/Player/contraller_bar/time.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare function Time(): React.JSX.Element;
+export default Time;

package/es/Player/contraller_bar/useBarStatus.d.ts

@@ -0,0 +1,2 @@
+declare function useBarStatus(): number;
+export default useBarStatus;

package/es/Player/contraller_bar/volume.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type Api from '../api';
+import '../style/volume.less';
+declare function Volume({ api, style }: {
+    api?: Api;
+    style?: React.CSSProperties;
+}): React.JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof Volume>;
+export default _default;

package/es/Player/contraller_bar/volume.js

@@ -21,7 +21,7 @@ function Volume(_ref) {
   // eslint-disable-next-line react-hooks/exhaustive-deps
   var volume = useMemo(function () {
     return api !== null && api !== void 0 && api.muted ? 0 : val;
-  }, undefined);
+  }, []);
   var onChange = function onChange(num) {
     if (api !== null && api !== void 0 && api.muted) {
       api === null || api === void 0 || api.unmute();

package/es/Player/demo.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const App: () => React.JSX.Element;
+export default App;

package/es/Player/empty.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function Empty(): React.JSX.Element;

package/es/Player/event/errorEvent.d.ts

@@ -0,0 +1,14 @@
+import Flvjs from '@cloud-app-dev/mpegts.js';
+import Hls from 'hls.js';
+import type VideoEventInstance from '.';
+interface IErrorEventProps {
+    event?: VideoEventInstance;
+    errorReloadTimer: number;
+    flv: Flvjs.Player;
+    hls: Hls;
+    reload: () => void;
+    unload: () => void;
+    errorHandleAdapter?: (errorInfo: any) => boolean;
+}
+declare function useErrorEvent({ event, reload, unload, errorReloadTimer, flv, hls, errorHandleAdapter }: IErrorEventProps): void;
+export default useErrorEvent;

package/es/Player/event/eventName.d.ts

@@ -0,0 +1,18 @@
+declare const Events: {
+    RELOAD: string;
+    RELOAD_FAIL: string;
+    RELOAD_SUCCESS: string;
+    ERROR: string;
+    ERROR_RELOAD: string;
+    HISTORY_PLAY_END: string;
+    PLAY_ENDED: string;
+    SEEK: string;
+    TRANSFORM: string;
+    CHANGE_PLAY_INDEX: string;
+    HIDE_CONTRALLER: string;
+    SHOW_CONTRALLER: string;
+    CLEAR_ERROR_TIMER: string;
+    CANVAS_PAUSE: string;
+    CANVAS_PLAY: string;
+};
+export default Events;

package/es/Player/event/index.d.ts

@@ -0,0 +1,24 @@
+import type { CustomEvent, EventInfo } from '../player';
+declare class VideoEventInstance {
+    video: HTMLVideoElement;
+    events: {
+        [key: string]: EventInfo;
+    };
+    playerEvents: {
+        [key: string]: (() => void)[];
+    };
+    constructor(video: HTMLVideoElement);
+    on(eventName: string, handle: () => void): void;
+    addEventListener(eventName: string, handle: () => void): void;
+    removeEventListener(eventName: string, handle: () => void): void;
+    emit(eventName: string, ...data: any): void;
+    off(eventName: string, handle: () => void): void;
+    destroy(): void;
+}
+type PlayEvent = VideoEventInstance;
+export declare function usePlayerEvent(video?: HTMLVideoElement): PlayEvent | undefined;
+export declare function useVideoEvent(eventName: string, handle: (event: any) => void, context?: VideoEventInstance): void;
+export declare function useRegisterPlayerEvent(eventName: string, handle: (event: any) => void, context?: VideoEventInstance): void;
+export declare function useVideoEvents(event?: VideoEventInstance, events?: CustomEvent[]): void;
+export declare function useRegisterPlayerEvents(event?: VideoEventInstance, events?: CustomEvent[]): void;
+export default VideoEventInstance;

package/es/Player/fps_play.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type Api from './api';
+import type VideoEventInstance from './event';
+interface IFPSPlay {
+    api?: Api;
+    event?: VideoEventInstance;
+    fpsDelay?: number;
+    fps?: number;
+}
+declare function FPSPlay({ api, event, fpsDelay, fps }: IFPSPlay): React.JSX.Element;
+export default FPSPlay;

package/es/Player/frontend_player.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { IFrontendPlayerProps } from './player';
+/**
+ * @desc 主组件，负责片段整体逻辑控制
+ * @return JSX.Element
+ */
+declare function FrontendPlayer({ url, begin, end, onSeek, forwordRef, customTimeLine, onCanPlayerInit, ...props }: IFrontendPlayerProps): React.JSX.Element;
+export default FrontendPlayer;

package/es/Player/frontend_timeline.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import './style/timeline.less';
+interface ITimeLineProps {
+    duration: number;
+    begin: number;
+    end: number;
+    onSeek?: (time: number) => void;
+}
+declare function FrontendTimeLine({ duration, begin, end, onSeek }: ITimeLineProps): React.JSX.Element;
+export default FrontendTimeLine;

package/es/Player/iconfont.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { IIconFontProps } from '../IconFont';
+import './style/iconfont.js';
+declare function IconFont({ className, ...props }: IIconFontProps): React.JSX.Element;
+export default IconFont;

package/es/Player/index.d.ts

@@ -0,0 +1,2 @@
+import SinglePlayer from './single_player';
+export default SinglePlayer;

package/es/Player/live_heart.d.ts

@@ -0,0 +1,8 @@
+import type Api from './api';
+import type VideoEventInstance from './event';
+declare function useLiveHeart({ api, event, isLive }: {
+    api?: Api;
+    event?: VideoEventInstance;
+    isLive?: boolean;
+}): void;
+export default useLiveHeart;

package/es/Player/message.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import './style/message.less';
+declare function VideoMessage(): React.JSX.Element;
+export declare const NoSource: () => React.JSX.Element;
+export default VideoMessage;

package/es/Player/message.js

@@ -40,6 +40,7 @@ function VideoMessage() {
     return '';
   }, [state.errorTimer, state.status]);
   var openLoading = function openLoading() {
+    //@ts-ignore
     clearTimeout(timeRef.current);
     timeRef.current = setTimeout(function () {
       return setState(function (old) {
@@ -50,6 +51,7 @@ function VideoMessage() {
     }, 200);
   };
   var closeLoading = function closeLoading() {
+    //@ts-ignore
     clearTimeout(timeRef.current);
     setState(function (old) {
       return _objectSpread(_objectSpread({}, old), {}, {
@@ -58,6 +60,7 @@ function VideoMessage() {
     });
   };
   var errorReload = function errorReload(timer) {
+    //@ts-ignore
     clearTimeout(timeRef.current);
     setState(function () {
       return {
@@ -90,6 +93,7 @@ function VideoMessage() {
     });
   };
   var playEnd = function playEnd() {
+    //@ts-ignore
     clearTimeout(timeRef.current);
     setState(function (old) {
       return _objectSpread(_objectSpread({}, old), {}, {

package/es/Player/segment_player.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { ISegmentPlayerProps } from './player';
+/**
+ * @desc 主组件，负责片段整体逻辑控制
+ * @param param0
+ * @returns
+ */
+declare function SegmentPlayer({ segments, begin, forwordRef, defaultIndex, onCanPlayerInit, customTimeLine, ...props }: ISegmentPlayerProps): React.JSX.Element;
+export default SegmentPlayer;

package/es/Player/segment_timeline.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { ISegmentType } from './player';
+import './style/timeline.less';
+interface ITimeLineProps {
+    index: number;
+    segments: ISegmentType[];
+    duration: number;
+    begin: number;
+    seekTo: (time: number) => void;
+}
+declare function SegmentTimeLine({ index, segments, duration, begin, seekTo }: ITimeLineProps): React.JSX.Element;
+export default SegmentTimeLine;

package/es/Player/single_player.d.ts

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

package/es/Player/timeline.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import './style/timeline.less';
+export declare function useTimes(): number[];
+declare function TimeLine(): React.JSX.Element;
+export default TimeLine;

package/es/Player/util.d.ts

@@ -0,0 +1,43 @@
+import Flvjs from '@cloud-app-dev/mpegts.js';
+import Hls, { HlsConfig } from 'hls.js';
+import type VideoEventInstance from './event';
+import type { FlvPlayerConfig } from './player';
+/**
+ * 创建HLS对象
+ * @param {HTMLVideoElement} video
+ * @param {string} url
+ */
+export declare function createHlsPlayer(video: HTMLVideoElement, url?: string, isLive?: boolean, hlsConfig?: HlsConfig): Hls | undefined;
+/**
+ * 创建FLV对象
+ * @param {*} video
+ * @param {*} options
+ */
+export declare function createFlvPlayer(video: HTMLVideoElement, url?: string, isLive?: boolean, flvConfig?: FlvPlayerConfig): Flvjs.Player | undefined;
+/**
+ * video unload
+ * @param video
+ * @param flv
+ * @param hls
+ * @returns
+ */
+export declare const playUnload: (video?: HTMLVideoElement, flv?: Flvjs.Player, hls?: Hls) => void;
+/**
+ * reload
+ * @param video
+ * @param event
+ * @param flv
+ * @param hls
+ * @param url
+ */
+export declare const playReload: (video?: HTMLVideoElement, event?: VideoEventInstance, flv?: Flvjs.Player, hls?: Hls, url?: string) => undefined;
+/**
+ * 获取播放文件类型
+ * @param {*} url
+ */
+export declare function getVideoType(url?: string): "flv" | "hls" | "native";
+export declare function timeStamp(second: number): string;
+export declare function getRandom(): string;
+export declare const FMT = "YYYY-MM-DD HH:mm:ss";
+export declare function getDomStyleValue(dom: HTMLElement, styleKey: string): string;
+export declare function createProxy<T>(obj: T, getObj?: any): T;

package/es/PlayerExt/demo.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const App: () => React.JSX.Element;
+export default App;

package/es/PlayerExt/index.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="react" />
+import { ISegmentType } from 'src/Player/player';
+import './index.less';
+export type PlayModeType = 1 | 2;
+export interface IPluginProps {
+    url?: string;
+    children: JSX.Element;
+    /**
+     * @description 模式1浏览器模式，2插件模式
+     * @default 1
+     */
+    mode?: PlayModeType;
+    /**
+     * @description 插件下载地址
+     */
+    pluginDownloadUrl?: string;
+    /**
+     * @description 插件模式下传递的参数 ’&’开头
+     * @default ''
+     */
+    pluginParams?: string;
+    segments?: ISegmentType[];
+    /**
+     * 正在获取视频数据
+     */
+    loading?: boolean;
+}
+/**
+ * 客户端插件模式，随机端口
+ */
+export declare const LOCAL_PORT: string[];
+/**
+ * 随机获取端口号
+ * @returns
+ */
+export declare function getLocalPort(): string;
+/**
+ * @desc 转码插件模式下的url
+ * @param url
+ * @param params
+ * @returns
+ */
+export declare function getLocalPlayPath(url: string, params?: string): string;
+export declare function usePlugin(mode?: PlayModeType, key?: any): {
+    needInstall: boolean;
+};
+export declare function ExtModel({ url, children, mode, pluginDownloadUrl, pluginParams, loading, segments }: IPluginProps): JSX.Element;
+export { ExtModel as default };

package/es/Progress/index.d.ts

@@ -1,9 +1,7 @@
-import * as React from 'react';
-
-export interface ProgressInterface {
-  status: 'over' | 'error' | 'loading';
-}
-
-declare const Progress: React.FunctionComponent<ProgressInterface>;
-
-export default Progress;
+import React from 'react';
+import './index.less';
+interface IProgressComponentProps {
+    status: 'over' | 'error' | 'loading';
+}
+declare function ProgressComponent({ status }: IProgressComponentProps): React.JSX.Element;
+export default ProgressComponent;

package/es/ROI/demo.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const App: () => React.JSX.Element;
+export default App;