@evercam/ui 0.0.55-beta.21 → 0.0.55-beta.22

package/dist/src/components/ETimeline.vue.d.ts

@@ -1,7 +1,7 @@
 import * as d3 from "d3";
 import { D3ZoomEvent } from "d3";
 import Vue from "vue";
-import { TimelineAxesConfig, TimelineAxis, TimelineCountEvent, TimelineEvent, TimelineEventsByType, TimelineEventsGroup, TimelineInterval, TimelineIntervalChangeTrigger, TimelineMarker, TimelinePrecision, TimelineTicksConfig, Timestamp } from '../types';
+import { TimelineAxesConfig, TimelineAxis, TimelineCountEvent, TimelineEvent, TimelineEventsByType, TimelineEventsGroup, TimelineIntervalChangeTrigger, TimelineMarker, TimelinePrecision, TimelineTicksConfig, Timestamp } from '../types';
 declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => Vue<Record<string, any>, Record<string, any>, never, never, any>>, {
     tooltip: HTMLElement;
     cursor: HTMLElement;
@@ -61,8 +61,6 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
     selectedMilestoneId: any;
     isInitialized: boolean;
     lastValidTransform: d3.ZoomTransform;
-    lastPanTransform: d3.ZoomTransform;
-    isZoomingInterval: boolean;
 }, {
     updateTimeline(): void;
     initTimeline(startDate?: string, endDate?: string): void;
@@ -77,8 +75,7 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
     updateYScaleDomain(): void;
     initZoomBehavior(): void;
     zoomToFitMarkers(): void;
-    zoomToTargetInterval(start?: string | number, end?: string | number): void;
-    translateIntervalIntoView(minTimestamp: number, maxTimestamp: number, scaleFactor: number): void;
+    translateMarkersIntoView(minTimestamp: number, maxTimestamp: number, scaleFactor: number): void;
     initSelectedTimestampCursor(): void;
     updateMarkers(): void;
     updateAndRedrawTimeline(): void;
@@ -141,7 +138,8 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
     initCurtains(): void;
     createCurtains(): void;
     updateCurtains(): void;
-    updateForbiddenIntervals(reset?: boolean): void;
+    initForbiddenIntervals(): void;
+    updateForbiddenIntervals(): void;
     drawEventsGroups(): void;
     drawLineGraphEventsGroups(): void;
     drawLineGraph({ events, gElement, color, type, }: {
@@ -156,13 +154,14 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
         color: string;
         type: string;
     }): void;
-    drawSingleBarEventsGroup({ type, eventsGroup, milestone, dots, dotsSize, bottom, }: {
+    drawSingleBarEventsGroup({ type, eventsGroup, index, milestone, height, dots, dotsSize, }: {
         type: string;
         eventsGroup: TimelineEventsGroup;
+        index?: number | undefined;
         milestone?: boolean | undefined;
+        height?: number | undefined;
         dots?: boolean | undefined;
         dotsSize?: number | undefined;
-        bottom?: boolean | undefined;
     }): void;
     drawBarEventsGroups(): void;
     drawMilestonesPlaceholder(): void;
@@ -172,8 +171,6 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
         border: string;
     };
     getMilestoneGroupYPosition(groupName: string): number;
-    getBarGroupYPosition(groupName: string, bottom?: boolean): number;
-    getBarGroupHeight(eventsGroup: TimelineEventsGroup): number;
     updateMilestonesPositions(): void;
     drawBarChartEventsGroups(): void;
     drawProgressIndicator({ yPosition, type, isLoading, }: {
@@ -188,7 +185,7 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
         color: string;
         height?: number | undefined;
     }): void;
-    drawBars({ events, gElement, yPosition, color, type, dots, dotsSize, height, barBorderRadius, }: {
+    drawBars({ events, gElement, yPosition, color, type, dots, dotsSize, }: {
         events: TimelineEvent[];
         gElement: d3.Selection<SVGGElement, any, any, any>;
         yPosition: number;
@@ -196,8 +193,6 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
         type: string;
         dots?: boolean | undefined;
         dotsSize?: number | undefined;
-        height?: number | undefined;
-        barBorderRadius?: number | undefined;
     }): void;
     drawBarsChart({ events, gElement, color, yOffset, type, index, }: {
         events: TimelineEvent[];
@@ -251,7 +246,6 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
     getSortedEvents(events: TimelineEvent[]): TimelineEvent[];
 }, {
     combinedBarsHeight: number;
-    combinedBottomBarsHeight: number;
     combinedMilestonesHeight: number;
     milestonesYOffset: number;
     chartsYOffset: number;
@@ -298,11 +292,12 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
     barYPadding: number;
     barXPadding: number;
     chartMinHeight: number;
-    chartMinLabelHeight: number;
     minZoom: number;
     maxZoom: number;
     minDate: string;
     maxDate: string;
+    minVisibleDate: string;
+    maxVisibleDate: string;
     cursorTimestamp: string | undefined;
     selectedClass: string | undefined;
     panOnDateClick: boolean;
@@ -312,13 +307,9 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
     markers: TimelineMarker[];
     stickyMarkers: boolean;
     fitMarkersOnChange: boolean;
-    zoomToIntervalTransitionDuration: number;
+    fitMarkersTransitionDuration: number;
     zoomToBoundariesTransitionDuration: number;
     milestoneBulletSize: number;
     milestonesFirst: boolean;
-    forbiddenIntervals: TimelineInterval[];
-    forbiddenIntervalColor: string;
-    focusedInterval: TimelineInterval | undefined;
-    locked: boolean;
 }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
 export default _default;

package/dist/src/components/EToggleSwitch.vue.d.ts

@@ -0,0 +1,34 @@
+import Vue from "vue";
+import { Size } from '../types';
+export interface EToggleSwitchOption {
+    title: string;
+    value: any;
+}
+export type CssClassMap = Record<string, boolean>;
+type SizeClasses = {
+    container: CssClassMap;
+    button: CssClassMap;
+    text: CssClassMap;
+};
+declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => Vue<Record<string, any>, Record<string, any>, never, never, any>>, {
+    value: any;
+}, {
+    getButtonClasses(optionValue: any): {
+        "e-bg-inherit": boolean;
+        "e-bg-brand-600": boolean;
+        "e-bg-gray-600": boolean;
+        "e-bg-[#629efc] e-text-gray-900 e-font-normal": boolean;
+    };
+    handleClick(value: any): void;
+}, {
+    sizeClasses: SizeClasses;
+    containerClasses: CssClassMap;
+    textClasses: CssClassMap;
+    buttonBaseClasses: CssClassMap;
+}, {
+    options: EToggleSwitchOption[];
+    color: string;
+    size: Size;
+    defaultValue: string | number | boolean;
+}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+export default _default;

package/dist/src/components/EVideoPlayer.vue.d.ts

@@ -1,11 +1,83 @@
-import Hls from "hls.js";
-import Vue from "vue";
+import Hls, { ErrorData, Events } from "hls.js";
+import { PropType } from "vue";
 export type VideoSource = {
     type: string;
     src: string;
 };
 export declare const VIDEO_PLAYER_EVENTS: string[];
-declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => Vue<Record<string, any>, Record<string, any>, never, never, any>>, {
+export declare enum EdgeVideoResolution {
+    _240 = 240,
+    _480 = 480,
+    _640 = 640,
+    _720 = 720,
+    _1080 = 1080
+}
+declare const _default: import("vue").DefineComponent<{
+    targetTimestamp: {
+        type: (StringConstructor | DateConstructor)[];
+        default: undefined;
+    };
+    sources: {
+        type: PropType<string | VideoSource[]>;
+        required: true;
+    };
+    videoListeners: {
+        type: PropType<Partial<HTMLVideoElement>>;
+        default: () => {};
+    };
+    videoOptions: {
+        type: PropType<Partial<HTMLVideoElement>>;
+        default: () => {};
+    };
+    isHls: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    streamingToken: {
+        type: StringConstructor;
+        default: string;
+    };
+    pauseOnClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isHlsLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isPlaying: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectedResolution: {
+        type: PropType<EdgeVideoResolution | undefined>;
+        default: undefined;
+    };
+    isZoomable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    zoomableIgnorePointerEvents: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    timezone: {
+        type: StringConstructor;
+        default: string;
+    };
+    playPauseAnimation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disablePlayPauseAnimation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isWebRtc: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {}, {
     playing: boolean;
     percentagePlayed: number;
     videoLength: string;
@@ -20,10 +92,23 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
     isLoading: boolean;
     isError: boolean;
     player: Hls;
+    playbackRetries: number;
+    preloadedSeconds: number;
+    preloadedInterval: {
+        start: string;
+        end: string;
+    };
+}, {
+    sourceItems(): VideoSource[];
+    hasStartedOrFinished(): boolean;
+    withControls(): "" | "hide";
 }, {
     initHls(): void;
+    onContainerClick(): void;
     handle404Error(): void;
+    handleHlsError(_: Events.ERROR, data: ErrorData): void;
     bindEvents(): void;
+    onProgress(): void;
     unbindEvents(): void;
     bindVideoEvent(which: string): void;
     initializePlayer(): void;
@@ -35,9 +120,9 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
     handleScrubbingOnMouseEnd(e: MouseEvent): void;
     handleEnded(): void;
     handleLoading(): void;
-    play(): void;
+    play(): Promise<void>;
     pause(): void;
-    togglePlay(): void;
+    togglePlay(): Promise<void>;
     setPlaying(state: boolean): void;
     seekToPercentage(percentage: number): void;
     convertTimeToDuration(seconds: number): string;
@@ -50,16 +135,86 @@ declare const _default: import("vue/types/vue").ExtendedVue<Vue<Record<string, a
     skip(duration?: number): void;
     toggleScrubbing(e: MouseEvent): Promise<void>;
     handleKeyDown(e: KeyboardEvent): void;
-}, {
-    sourceItems: VideoSource[];
-    hasStartedOrFinished: boolean;
-    withControls: "" | "hide";
-}, {
-    sources: string | VideoSource[];
-    videoListeners: {};
-    videoOptions: {};
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+    targetTimestamp: {
+        type: (StringConstructor | DateConstructor)[];
+        default: undefined;
+    };
+    sources: {
+        type: PropType<string | VideoSource[]>;
+        required: true;
+    };
+    videoListeners: {
+        type: PropType<Partial<HTMLVideoElement>>;
+        default: () => {};
+    };
+    videoOptions: {
+        type: PropType<Partial<HTMLVideoElement>>;
+        default: () => {};
+    };
+    isHls: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    streamingToken: {
+        type: StringConstructor;
+        default: string;
+    };
+    pauseOnClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isHlsLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isPlaying: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectedResolution: {
+        type: PropType<EdgeVideoResolution | undefined>;
+        default: undefined;
+    };
+    isZoomable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    zoomableIgnorePointerEvents: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    timezone: {
+        type: StringConstructor;
+        default: string;
+    };
+    playPauseAnimation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disablePlayPauseAnimation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isWebRtc: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    timezone: string;
+    isPlaying: boolean;
+    targetTimestamp: string | Date;
+    videoListeners: Partial<HTMLVideoElement>;
+    videoOptions: Partial<HTMLVideoElement>;
     isHls: boolean;
     streamingToken: string;
-    isLiveView: boolean;
-}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    pauseOnClick: boolean;
+    isHlsLoading: boolean;
+    selectedResolution: EdgeVideoResolution | undefined;
+    isZoomable: boolean;
+    zoomableIgnorePointerEvents: boolean;
+    playPauseAnimation: boolean;
+    disablePlayPauseAnimation: boolean;
+    isWebRtc: boolean;
+}>;
 export default _default;

package/dist/src/components/EZoomable.vue.d.ts

@@ -0,0 +1,64 @@
+declare const _default: import("vue").DefineComponent<{
+    ignorePointerEvents: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withOverlay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {}, {
+    scale: number;
+    minScale: number;
+    maxScale: number;
+    top: number;
+    left: number;
+    isPanning: boolean;
+    panStart: {
+        x: number;
+        y: number;
+    };
+    isPinching: boolean;
+    previousPinchDistance: number;
+    pinchDistance: number;
+    pointers: {};
+    transform: string;
+}, {
+    contentStyle(): {
+        transform: string;
+    };
+    isZoomed(): boolean;
+}, {
+    updateZoomScale(): void;
+    handleZoom(e: any): void;
+    handleMouseDown(e: any): void;
+    handleMouseUp(): void;
+    handleMouseLeave(): void;
+    handleMouseMove(e: any): void;
+    applyBoundsCorrection(): void;
+    updateTransform(): void;
+    getPointersDistance(a: any, b: any): number;
+    getPointersMidPoint(a: any, b: any): {
+        x: any;
+        y: any;
+    };
+    updatePointerEvent(e: any): void;
+    clearPointerEvent(e: any): void;
+    updatePinchDistance(): void;
+    handlePointerDown(e: any): void;
+    handlePointerMove(e: any): void;
+    handlePointerUp(e: any): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+    ignorePointerEvents: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withOverlay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    ignorePointerEvents: boolean;
+    withOverlay: boolean;
+}>;
+export default _default;

package/dist/src/constants.d.ts

@@ -5,6 +5,7 @@ export declare const Colors: any;
 export declare const BadgeSizes: readonly [Size.dot, Size.xs, Size.sm, Size.md, Size.lg, Size.xl];
 export declare const AvatarSizes: readonly [Size.xs, Size.sm, Size.md, Size.lg, Size.xl, (typeof Size)["2xl"]];
 export declare const IconSizes: readonly [Size.xs, Size.sm, Size.md, Size.md, Size.lg, Size.xl, (typeof Size)["2xl"], (typeof Size)["3xl"], (typeof Size)["4xl"], (typeof Size)["5xl"], (typeof Size)["6xl"], (typeof Size)["7xl"], (typeof Size)["8xl"], (typeof Size)["9xl"]];
+export declare const ToggleSwitchSizes: readonly [Size.sm, Size.md, Size.md, Size.lg];
 export declare const BadgeColors: readonly [BaseColor.warning, BaseColor.error, BaseColor.info, BaseColor.success, BaseColor.primary, BaseColor.default];
 export declare const EVENTS: string[];
 declare const _default: {};