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

package/dist/react-camera.d.ts

@@ -2,7 +2,7 @@
 
 import { BehaviorSubject } from 'rxjs';
 import crossfilter from 'crossfilter2';
-import { IReactionDisposer } from 'mobx';
+import type { IReactionDisposer } from 'mobx';
 import { Observable } from 'rxjs';
 import { default as React_2 } from 'react';
 import { Subject } from 'rxjs';
@@ -78,6 +78,7 @@ declare class ArchiveChunk_2 implements Chunk_2 {
 }
 
 declare class ArchivesStore extends ApiStore {
+    private camerasStore;
     data: crossfilter.Crossfilter<ArchiveChunk_2>;
     chunksByCameraId: crossfilter.Dimension<ArchiveChunk_2, number>;
     chunksByStart: crossfilter.Dimension<ArchiveChunk_2, number>;
@@ -89,22 +90,47 @@ declare class ArchivesStore extends ApiStore {
     private pendingRequestsByCameraId;
     knownIntervals: Map<number, [Date, Date]>;
     updates: number;
-    constructor();
+    constructor(camerasStore: CamerasStore);
     /**
      * Fetches archive chunks for given camera and period
      * @param cameraId - camera id
      * @param startTime - start of the period
      * @param endTime - end of the period
      * TODO: add support for null endTime in order to remove requestedArchivesSince logic from player controller
+     * TODO: add error handling
      */
     fetch(cameraId: number, startTime: Date, endTime: Date): Observable<ArchiveChunk_2[]>;
-    extendKnownInterval(cameraId: number, chunks: ArchiveChunk_2[]): void;
+    extendKnownInterval(cameraId: number, startTime: Date, chunks: ArchiveChunk_2[]): void;
     add(chunks: ArchiveChunk_2[]): void;
     getChunks({ cameraId, from, to }: ChunksQuery): ArchiveChunk_2[];
-    findClosestChunk({ cameraId, time }: {
+    /**
+     * Returns chunk that either contain the given time or is right adjacent to it
+     * @param camera - camera id
+     * @param time - time to search for
+     * @returns ArchiveChunk or undefined if there is no such chunk in the current archive
+     */
+    getClosestChunkRight: ({ cameraId, time }: {
+        cameraId: number;
+        time: Date;
+    }) => ArchiveChunk_2;
+    /**
+     * Return chunks that either contain the given time or is left adjacent to it
+     * @param camera - camera id
+     * @param time - time to search for
+     * @returns ArchiveChunk or undefined if there is no such chunk in the current archive
+     */
+    getClosestChunkLeft: ({ cameraId, time }: {
+        cameraId: number;
+        time: Date;
+    }) => ArchiveChunk_2;
+    fetchNextChunk: ({ cameraId, time }: {
         cameraId: number;
         time: Date;
-    }): ArchiveChunk_2;
+    }) => Observable<ArchiveChunk_2 | undefined>;
+    fetchPrevChunk: ({ cameraId, time }: {
+        cameraId: number;
+        time: Date;
+    }) => Observable<ArchiveChunk_2 | undefined>;
     protected afterInit(): void;
 }
 
@@ -114,31 +140,30 @@ declare class Auth {
     storage: Storage_2;
     tokenServiceUrl: string;
     tokenStorageKey: string;
-    widgetTokenServiceUrl?: string;
     deviceInfo: string | null;
     clientId: string;
     private pendingUpdateTokenRequest;
     get isAuthenticated(): boolean;
-    constructor({ tokenServiceUrl, widgetTokenServiceUrl, storage, tokenStorageKey, deviceInfo, clientId }: AuthStoreOptions);
+    constructor({ tokenServiceUrl, storage, tokenStorageKey, deviceInfo, clientId }: AuthStoreOptions);
     signOut: () => void;
-    signIn: ({ username, password, tokenToKick, agreedWithTerms }: {
+    signIn: (options: {
         username: string;
         password: string;
-        tokenToKick?: string | undefined;
-        agreedWithTerms?: boolean | undefined;
+        replaceToken?: string;
+        agreedWithTerms?: boolean;
+        code?: string;
     }) => Promise<Token> | undefined;
     invalidateToken: () => void;
     getTokenFromStorage(): Promise<Token | null>;
     private storeToken;
     private getInitialToken;
-    private fetchTokenBy;
+    private fetchToken;
     private updateToken;
     private fetchWidgetToken;
 }
 
 declare interface AuthStoreOptions {
     tokenServiceUrl: string;
-    widgetTokenServiceUrl?: string;
     storage: Storage_2;
     tokenStorageKey: string;
     deviceInfo: any;
@@ -158,12 +183,39 @@ export declare const BoxSelector: (({ onSelect, onRequestCancel, onClose }: Prop
     displayName: string;
 };
 
-declare const Camera: ((props: Props) => JSX.Element) & {
+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: ((props: Props) => JSX.Element) & {
     displayName: string;
 };
-export default Camera;
+export default Camera_2;
 
-declare interface Camera_2 {
+declare interface Camera_3 {
     id: number;
     name: string;
     streamUrl: string;
@@ -184,6 +236,19 @@ declare interface Camera_2 {
     raw: RawCamera;
 }
 
+declare class CamerasStore extends ApiStore {
+    camerasById: Map<number, Camera>;
+    data: Camera[];
+    loading: boolean;
+    loaded: boolean;
+    constructor();
+    load: () => Observable<RawCamera[]> | undefined;
+    add: (cameras: RawCamera[]) => void;
+    sync: () => Observable<RawCamera[]>;
+    protected afterInit(): void;
+    dispose(): void;
+}
+
 declare interface CameraStatistics {
     id: number;
     month: number;
@@ -459,11 +524,12 @@ declare interface PlayerBehavior {
 
 export declare const PlayerContext: React_2.Context<PlayerController>;
 
-declare class 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;
     loading: boolean;
@@ -472,14 +538,17 @@ declare class PlayerController {
     volume: number;
     muted: boolean;
     videoResizeMode: VideoResizeMode;
-    camera: Camera_2;
+    camera: Camera_3;
     stats: any;
     mode: 'archive' | 'DVR' | 'WebRTC' | null;
     behavior: PlayerBehavior | null;
+    transform: string | null;
     width: number;
     height: number;
-    chunkRequestTime: Date | null;
-    requestedArchivesSince: Date;
+    chunkRequest: {
+        time: Date;
+        backward: boolean;
+    } | null;
     archivesRequest: Observable<ArchiveChunk[]>;
     video: HTMLVideoElement;
     clip?: Clip;
@@ -500,7 +569,7 @@ declare class PlayerController {
     };
     seekTime?: Date | null;
     constructor({ camera, startTime, endTime, clip, archivesStore, behaviors }: {
-        camera: Camera_2;
+        camera: Camera_3;
         clip?: Clip;
         startTime?: Date | null;
         endTime?: Date;
@@ -516,23 +585,40 @@ declare class PlayerController {
     seekAfterReady(): void;
     stopLoadingOnError(): void;
     replaceErrorMessageOnOffline(): void;
-    changeMedia: ({ time, chunk }: {
-        time?: Date | null | undefined;
+    changeMedia: ({ time, chunk, backward }: {
+        time: Date;
         chunk?: LiveChunk | ArchiveChunk | undefined;
+        backward?: boolean | undefined;
     }) => void;
     initCurrentTime(): void;
+    /**
+     * If the chunk after chunk request is the same as the current chunk,
+     * then we can dismiss loading indicator and seek.
+     */
+    initSameChunkRequestFix(): void;
     initLiveChunkUpdate(): void;
     initChunkRequest(): void;
-    requestArchives: (time: Date) => Observable<ArchiveChunk[]>;
     setupLiveChunk(): void;
     /**
      * Inits correct behavior for current player mode
      */
     initPlayerBehavior(): void;
+    /**
+     * 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;
     fallbackToDVR: () => void;
-    setCamera: (camera: Camera_2) => void;
-    setCameraAndStartTime: (camera: Camera_2, startTime: Date | null) => void;
+    setCamera: (camera: Camera_3) => void;
+    setCameraAndStartTime: (camera: Camera_3, startTime: Date | null) => void;
     toggleResizeMode: () => void;
     setVideoResizeMode: (mode: VideoResizeMode) => void;
     toggleMute: () => void;
@@ -541,6 +627,7 @@ declare class PlayerController {
     setPlaybackRate: (rate: number) => void;
     reactToVolumeChange(): void;
     togglePlayback: () => void;
+    setTransform(transform: string | null): void;
     play: () => void;
     pause: () => void;
     detach: () => void;
@@ -595,7 +682,13 @@ declare interface Props_7 {
     onRequestToggleFullscreen: (() => void) | null;
 }
 
-export declare const PtzControl: React_2.FC;
+declare interface Props_8 {
+    style?: React_2.CSSProperties;
+}
+
+export declare const PtzControls: (({ style }: Props_8) => JSX.Element) & {
+    displayName: string;
+};
 
 declare interface RawCamera {
     id: number;
@@ -716,29 +809,32 @@ declare interface RawSharedClip {
     validTo: string | Date;
 }
 
-declare interface RawToken {
-    access_token: string;
+declare type RawToken = {
     accessToken: string;
-    access_token_expires: string;
     accessTokenExpires: string;
-    access_token_issued: string;
     accessTokenIssued: string;
-    client_id: string;
     clientId: string;
-    expires_in: number;
     expiresIn: number;
-    refresh_token: string;
     refreshToken: string;
-    refresh_token_expires: string;
     refreshTokenExpires: string;
-    refresh_token_issued: string;
     refreshTokenIssued: string;
-    token_type: string;
     tokenType: string;
     userName: string;
+} & {
+    access_token: string;
+    access_token_expires: string;
+    access_token_issued: string;
+    client_id: string;
+    expires_in: number;
+    refresh_token: string;
+    refresh_token_expires: string;
+    refresh_token_issued: string;
+    token_type: string;
+    userName: string;
+} & {
     widgetId?: string;
     widgetToken?: string;
-}
+};
 
 declare interface RawUser {
     id: number;