@3deye-toolkit/react-camera 0.0.1-alpha.7 → 0.0.1

package/dist/react-camera.d.ts

@@ -0,0 +1,548 @@
+/// <reference types="react" />
+
+import type { IReactionDisposer } from 'mobx';
+import { Observable } from 'rxjs';
+import { default as React_2 } from 'react';
+import type { Ref } from 'react';
+import { Subscription } from 'rxjs';
+
+declare type ArchiveChunk = Chunk & {
+    isLive: false;
+};
+
+declare class ArchiveChunk_2 implements Chunk_2 {
+    json?: string;
+    startTime: Date;
+    endTime: Date;
+    streamUrl: string;
+    duration?: number;
+    isLive: false;
+    cameraId: number;
+    id: number;
+    constructor(raw: any);
+}
+
+declare interface ArchivesStore {
+    fetchPrevChunk: (params: {
+        cameraId: number;
+        time: Date;
+    }) => Observable<ArchiveChunk | undefined>;
+    fetchNextChunk: (params: {
+        cameraId: number;
+        time: Date;
+    }) => Observable<ArchiveChunk | undefined>;
+    getChunks: (query: ChunksQuery) => ArchiveChunk[];
+}
+
+declare type BehaviorFactory = (controller: PlayerController) => PlayerBehavior;
+
+declare interface Box {
+    Top: number;
+    Left: number;
+    Bottom: number;
+    Right: number;
+}
+
+export declare const BoxSelector: (({ onSelect, onRequestCancel, onClose }: Props_2) => JSX.Element) & {
+    displayName: string;
+};
+
+export declare class Camera {
+    id: number;
+    name: string;
+    imageUrl: string;
+    streamUrl: string;
+    dashStreamUrl: string;
+    address: {
+        Lat: number;
+        Lng: number;
+    } | null;
+    archiveDuration: number;
+    dvrWindowLength: number;
+    stateUpdatedAt: Date;
+    raw: RawCamera;
+    enabled: boolean;
+    isMicEnabled: boolean;
+    state: string;
+    pin: string;
+    webRtcUrl: string;
+    isPtz: boolean;
+    permissions: number;
+    get isOnline(): boolean;
+    get supportsWebRTC(): boolean;
+    constructor(raw: RawCamera);
+    update: (raw: RawCamera) => void;
+}
+
+declare const Camera_2: React_2.MemoExoticComponent<React_2.ForwardRefExoticComponent<Pick<Props & React_2.RefAttributes<HTMLDivElement>, "key" | keyof Props> & React_2.RefAttributes<HTMLDivElement>>>;
+export default Camera_2;
+
+declare interface Camera_3 {
+    id: number;
+    name: string;
+    streamUrl: string;
+    dashStreamUrl: string;
+    webRtcUrl: string;
+    pin: string;
+    dvrWindowLength: number;
+    enabled: boolean;
+    isOnline: boolean;
+    isPtz: boolean;
+    isMicEnabled: boolean;
+    address?: {
+        Lat: number;
+        Lng: number;
+    } | null;
+    archiveDuration: number;
+    permissions: number;
+    raw: RawCamera;
+}
+
+declare interface CameraStatistics {
+    id: number;
+    month: number;
+    trafficOutMBytes: number;
+    archiveStorageMBytes: number;
+    clipStorageMBytes: number;
+}
+
+declare interface Chunk {
+    startTime: Date;
+    endTime: Date;
+    streamUrl: string;
+    duration?: number;
+    cameraId: number;
+}
+
+declare interface Chunk_2 {
+    json?: string;
+    startTime: Date;
+    endTime: Date;
+    streamUrl: string;
+    duration?: number;
+}
+
+declare interface ChunksQuery {
+    cameraId: number;
+    from: Date;
+    to: Date;
+}
+
+declare interface Clip {
+    id: number;
+    cameraId: number;
+    startTime: Date;
+    endTime: Date;
+    isTimelapse: boolean;
+    duration: number;
+    clipUrl?: string;
+    name: string;
+}
+
+declare class Clip_2 {
+    id: number;
+    cameraId: number;
+    name: string;
+    startTime: Date;
+    endTime: Date;
+    type: 'Archive' | 'Timelaps' | 'Timelaps to do';
+    createdAt: Date;
+    /**
+     * clip duration in seconds
+     */
+    duration: number;
+    chunks: ArchiveChunk_2[];
+    clipUrl?: string;
+    description: string;
+    version: string;
+    raw: RawClip;
+    isDownloading: boolean;
+    archives?: ArchiveChunk_2[];
+    constructor(raw: RawClip);
+    get isTimelapse(): boolean;
+    update(raw: any): void;
+}
+
+export declare const CloseControl: {
+    ({ onClick }: Props_4): JSX.Element | null;
+    displayName: string;
+};
+
+export declare const Control: React_2.FC<Props_5>;
+
+export declare class Controls extends React_2.Component<Props_6> {
+    get player(): PlayerController;
+    static contextType: React_2.Context<PlayerController>;
+    static Spacer: React_2.FC;
+    containerRef: React_2.RefObject<HTMLDivElement>;
+    mutationObserver: MutationObserver;
+    resizeReactionDisposer: IReactionDisposer;
+    componentDidUpdate(): void;
+    componentDidMount(): void;
+    reflow: () => void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+}
+
+export declare const DefaultControls: (({ onRequestClose, fullscreenControl }: Props_8) => JSX.Element) & {
+    displayName: string;
+};
+
+export declare const FullscreenControl: {
+    ({ toggle: toggle, active }: Props_7): JSX.Element;
+    displayName: string;
+};
+
+declare class LiveChunk {
+    cameraId: number;
+    streamUrl: string;
+    dashStreamUrl: string;
+    startTime: Date;
+    endTime: Date;
+    length: number;
+    isLive: boolean;
+    isDvr: boolean;
+    hasDvr: boolean;
+    rtmpStreamUrl: string;
+    managed: boolean;
+    constructor(data: {
+        cameraId: number;
+        endTime: Date;
+        startTime: Date;
+        streamUrl: string;
+        dashStreamUrl: string;
+        length: number;
+    });
+    setBounds: (range: [Date, Date]) => void;
+}
+
+export declare const PlaybackRateControl: (() => JSX.Element | null) & {
+    displayName: string;
+};
+
+export declare const Player: React_2.MemoExoticComponent<React_2.ForwardRefExoticComponent<Pick<Props_3 & React_2.RefAttributes<HTMLDivElement>, "key" | keyof Props_3> & React_2.RefAttributes<HTMLDivElement>>>;
+
+declare interface PlayerBehavior {
+    state: PlayerState | null;
+    player: PlayerController;
+    loading: boolean;
+    error: any;
+    delay?: number;
+    live?: boolean;
+    seek?: (time: Date) => void;
+    goLive?: () => void;
+    getCurrentTime: () => Date | null;
+    getDateRange?: () => [Date, Date] | null;
+    dispose: () => Promise<void> | void;
+}
+
+export declare const PlayerContext: React_2.Context<PlayerController>;
+
+export declare class PlayerController {
+    id: number;
+    disposables: (IReactionDisposer | Subscription)[];
+    liveChunk?: LiveChunk | null;
+    currentTime: Date | null;
+    targetTime: Date | null;
+    chunk: ArchiveChunk | LiveChunk | null;
+    paused: boolean;
+    error: any;
+    get loading(): boolean;
+    playbackRate: number;
+    volume: number;
+    muted: boolean;
+    videoResizeMode: VideoResizeMode;
+    camera: Camera_3;
+    stats: any;
+    mode: 'archive' | 'DVR' | 'WebRTC' | null;
+    behavior: PlayerBehavior | null;
+    transform: string | null;
+    width: number;
+    height: number;
+    chunkRequest: {
+        time: Date;
+        backward: boolean;
+    } | null;
+    loopRange: {
+        start: Date;
+        end: Date;
+    } | null;
+    loopRangeEnabled: boolean;
+    restoreFromDvrEnabled: boolean;
+    pendingBehavior: PlayerBehavior | null;
+    video: HTMLVideoElement;
+    clip?: Clip;
+    startTime: Date | null;
+    endTime: Date | null;
+    stream: MediaStream | null;
+    canSeek: boolean;
+    canSeek$: Observable<any>;
+    progress$: Observable<any>;
+    muted$: Observable<boolean>;
+    volume$: Observable<number>;
+    ended$: Observable<any>;
+    archivesStore: ArchivesStore;
+    behaviors: {
+        archive: BehaviorFactory;
+        DVR: BehaviorFactory;
+        WebRTC: BehaviorFactory | null;
+    };
+    seekTime?: Date | null;
+    constructor({ camera, startTime, endTime, clip, archivesStore, behaviors }: {
+        camera: Camera_3;
+        clip?: Clip;
+        startTime?: Date | null;
+        endTime?: Date | null;
+        archivesStore: ArchivesStore;
+        behaviors: {
+            archive: BehaviorFactory;
+            DVR: BehaviorFactory;
+            WebRTC: BehaviorFactory | null;
+        };
+    });
+    attach(video: HTMLVideoElement, { canSeek$, progress$, muted$, volume$, ended$ }: PlayerEventStreams): void;
+    private seek;
+    private seekAfterReady;
+    private stopLoadingOnError;
+    private replaceErrorMessageOnOffline;
+    changeMedia: ({ time, chunk, backward }: {
+        time: Date;
+        chunk?: LiveChunk | ArchiveChunk | undefined;
+        backward?: boolean | undefined;
+    }) => void;
+    private initCurrentTime;
+    private initPlayableRange;
+    /**
+     * If the chunk after chunk request is the same as the current chunk,
+     * then we can dismiss loading indicator and seek.
+     */
+    private initSameChunkRequestFix;
+    private initLiveChunkUpdate;
+    private initChunkRequest;
+    private setupLiveChunk;
+    /**
+     * Inits correct behavior for current player mode
+     */
+    private initPlayerBehavior;
+    /**
+     * Rewind by given amount of milliseconds
+     * @param value milliseconds
+     * @returns
+     */
+    seekBackward: (value: number) => void;
+    /**
+     * Seek forward by given amount of milliseconds
+     * @param value
+     * @returns
+     */
+    seekForward: (value: number) => void;
+    goLive: () => void;
+    setCamera: (camera: Camera_3) => void;
+    setCameraAndStartTime: (camera: Camera_3, startTime: Date | null) => void;
+    toggleResizeMode: () => void;
+    setVideoResizeMode: (mode: VideoResizeMode) => void;
+    toggleMute: () => void;
+    setStartTime: (time: Date | null) => void;
+    setVolume: (volume: number) => void;
+    setPlaybackRate: (rate: number) => void;
+    reactToVolumeChange(): void;
+    togglePlayback: () => void;
+    setTransform(transform: string | null): void;
+    play: () => void;
+    pause: () => void;
+    detach: () => void;
+    private initUpgradeToWebRtcWhenCameraIsBackOnline;
+    private initFallbackToDVR;
+    private initUpgradeToWebRtcAfterFallbackToDvr;
+}
+
+declare interface PlayerEventStreams {
+    canSeek$: Observable<any>;
+    progress$: Observable<any>;
+    ended$: Observable<any>;
+    volume$: Observable<number>;
+    muted$: Observable<boolean>;
+}
+
+declare enum PlayerState {
+    Initial = "initial",
+    Playing = "playing",
+    Paused = "paused",
+    Reconnecting = "reconnecting",
+    Stalled = "stalled",
+    Error = "error",
+    Failed = "failed"
+}
+
+export declare const PlayPauseControl: (() => JSX.Element) & {
+    displayName: string;
+};
+
+declare interface Props extends Omit<React_2.HTMLAttributes<HTMLDivElement>, 'onMouseDown'> {
+    cameraId: number;
+    startTime?: Date | null;
+    controls?: React_2.ReactNode;
+    onMouseDown?: (e: MouseEvent) => void;
+    onRequestClose?: () => void;
+}
+
+declare interface Props_2 {
+    onSelect: (box: Box) => void;
+    onClose: () => void;
+    onRequestCancel: () => void;
+}
+
+declare interface Props_3 extends Omit<React_2.HTMLAttributes<HTMLDivElement>, 'onMouseDown'> {
+    camera: Camera;
+    startTime?: Date | null;
+    endTime?: Date | null;
+    clip?: Clip_2;
+    controls: React_2.ReactNode;
+    onMouseDown?: (e: MouseEvent) => void;
+    hideCameraTitle?: boolean;
+    webRtcOptions?: {
+        enabled: boolean;
+        allowedIceCandidateProtocols?: ('udp' | 'tcp')[];
+    };
+    controllerRef?: Ref<PlayerController>;
+    videoRef?: Ref<HTMLVideoElement>;
+    archivesStore: ArchivesStore;
+}
+
+declare interface Props_4 {
+    onClick?: () => void;
+}
+
+declare type Props_5 = Omit<React_2.HTMLAttributes<HTMLButtonElement>, 'title'> & {
+    ref?: React_2.Ref<HTMLButtonElement>;
+    title?: React_2.ReactNode;
+};
+
+declare interface Props_6 {
+    children: React_2.ReactNode;
+    style?: React_2.CSSProperties;
+}
+
+declare interface Props_7 {
+    toggle: (() => void) | null;
+    active: boolean;
+}
+
+declare interface Props_8 {
+    onRequestClose?: () => void;
+    fullscreenControl?: React_2.ReactNode;
+}
+
+export declare const PtzControls: ((props: PtzControlsProps) => JSX.Element) & {
+    displayName: string;
+};
+
+declare interface PtzControlsProps {
+    cameraId: number;
+    style?: React_2.CSSProperties;
+    initialZoomSpeed?: number;
+    initialMovementSpeed?: number;
+    disabled?: boolean;
+    disallowHomePositionUpdate?: boolean;
+    disallowGoHome?: boolean;
+}
+
+declare interface RawCamera {
+    id: number;
+    customerId: number;
+    name: string;
+    description: string;
+    cameraBrand: string;
+    cameraModel: string;
+    enabled: boolean;
+    cameraUserName: string;
+    cameraPassword: null;
+    serialNum: string;
+    isOnvif: boolean;
+    isP2P: boolean;
+    p2pRegistrationCode: null;
+    planId: null;
+    p2pState: string;
+    cameraVideoFormat: string;
+    cameraState: string;
+    cameraStateChangedTime: string;
+    cameraError: null;
+    cameraAddress: string;
+    isMicEnabled: boolean;
+    imageQuality: number;
+    cameraSourceChannel: string;
+    pin: string;
+    streamUrl: string;
+    dashStreamUrl: string;
+    rtmpUrl: string;
+    webRtcStreamHost: string;
+    webRtcUrl: string;
+    cameraHttpSourceUrl: string;
+    cameraRtspSourceUrl: string;
+    supportedResolutions: string;
+    cameraType: string;
+    isCloud: boolean;
+    generateImageUrl: null;
+    imageUrl: string;
+    qualityProfile: string;
+    encodingProfile: null;
+    width: number;
+    height: number;
+    bitRate: number;
+    frameRate: number;
+    archiveDuration: number;
+    isArchiveByMotionEvent: boolean;
+    isAnalyticsEnabled: boolean;
+    isTimelapseAvailable: boolean;
+    motionEnabled: boolean;
+    isPTZ: boolean;
+    motionDuration: number;
+    dvrWindowLength: number;
+    jsonField: string;
+    dtUpdUtc: string;
+    version: string;
+    statistics: CameraStatistics;
+}
+
+declare interface RawClip {
+    id: number;
+    recordType: string;
+    isReady: boolean;
+    name: string;
+    description: string;
+    tagName: null;
+    cameraId: number;
+    clipUrl: string;
+    thumbnailUrl: string;
+    startTime: string;
+    endTime: string;
+    duration: number;
+    validTo: string;
+    timeCreated: string;
+    timeUpdated: string;
+    version: string;
+}
+
+export declare const ResizeModeControl: (() => JSX.Element) & {
+    displayName: string;
+};
+
+export declare const SnapshotControl: React_2.FC;
+
+export declare function useFullscreen(): {
+    ref: (node: HTMLElement | null) => void;
+    toggle: () => undefined;
+    enabled: boolean;
+    active: boolean;
+};
+
+declare enum VideoResizeMode {
+    Fit = "contain",
+    Stretch = "fill"
+}
+
+export declare const VolumeControl: (() => JSX.Element) & {
+    displayName: string;
+};
+
+export { }