@openglobus/og 0.19.4 → 0.20.0

package/lib/@openglobus/js/control/elevationProfile/ElevationProfileControl.d.ts

@@ -0,0 +1,33 @@
+import { Control, IControlParams } from "../Control";
+import { Dialog } from "../../ui/Dialog";
+import { View } from "../../ui/View";
+import { ToggleButton } from "../../ui/ToggleButton";
+import { ElevationProfileView } from "./ElevationProfileView";
+import { ElevationProfileScene } from "./ElevationProfileScene";
+import { ElevationProfileButtonsView } from "./ElevationProfileButtonsView";
+import { PointListDialog } from "./PointListDialog";
+import { GroundItem, TrackItem } from "./ElevationProfile";
+import { ElevationProfileLegend } from "./ElevationProfileLegend";
+interface IElevationProfileGraphParams extends IControlParams {
+}
+export declare class ElevationProfileControl extends Control {
+    protected _toggleBtn: ToggleButton;
+    protected _dialog: Dialog<null>;
+    protected _graphView: View<null>;
+    protected _poiListDialog: PointListDialog;
+    protected _elevationProfileView: ElevationProfileView;
+    protected _elevationProfileScene: ElevationProfileScene;
+    protected _elevationProfileButtonsView: ElevationProfileButtonsView;
+    protected _elevationProfileLegend: ElevationProfileLegend;
+    protected _collectProfileThrottled: () => void;
+    constructor(options?: IElevationProfileGraphParams);
+    oninit(): void;
+    protected _onSceneChange: () => void;
+    onactivate(): void;
+    ondeactivate(): void;
+    protected _onElevationProfilePointer: (pointerDistance: number, tp0: TrackItem, tp1: TrackItem, gp0: GroundItem, gp1: GroundItem, trackPoiIndex: number, groundPoiIndex: number, elevation: number) => void;
+    protected _onElevationProfileDblClick: (pointerDistance: number, tp0: TrackItem, tp1: TrackItem, gp0: GroundItem, gp1: GroundItem, trackPoiIndex: number, groundPoiIndex: number, elevation: number) => void;
+    protected _onElevationProfileMouseEnter: () => void;
+    protected _onElevationProfileMouseLeave: () => void;
+}
+export {};

package/lib/@openglobus/js/control/elevationProfile/ElevationProfileLegend.d.ts

@@ -0,0 +1,20 @@
+import { IViewParams, View } from '../../ui/View';
+export interface IElevationProfileLegendParams extends IViewParams {
+}
+export declare class ElevationProfileLegend extends View<null> {
+    $groundValue: HTMLElement | null;
+    $trackValue: HTMLElement | null;
+    $warningValue: HTMLElement | null;
+    $collisionValue: HTMLElement | null;
+    $trackUnits: HTMLElement | null;
+    $groundUnits: HTMLElement | null;
+    $warningUnits: HTMLElement | null;
+    $collisionUnits: HTMLElement | null;
+    constructor(params?: IElevationProfileLegendParams);
+    render(params: any): this;
+    clear(): void;
+    setTrackLength(trackLength: number): void;
+    setGroundLength(groundLength: number): void;
+    setWarningLength(warningLength: number): void;
+    setCollisionLength(collisionLength: number): void;
+}

package/lib/@openglobus/js/control/elevationProfile/ElevationProfileScene.d.ts

@@ -0,0 +1,80 @@
+import { Entity } from '../../entity/Entity';
+import { EventsHandler } from '../../Events';
+import { LonLat } from "../../LonLat";
+import { Planet } from "../../scene/Planet";
+import { RenderNode } from '../../scene/RenderNode';
+import { Vector } from '../../layer/Vector';
+import { Vec2 } from '../../math/Vec2';
+import { Vec3 } from '../../math/Vec3';
+import { IMouseState } from "../../renderer/RendererEvents";
+import { Ellipsoid } from "../../ellipsoid/Ellipsoid";
+export interface IElevationProfileSceneParams {
+    name?: string;
+    planet?: Planet;
+}
+declare class ElevationProfileScene extends RenderNode {
+    events: EventsHandler<ElevationProfileSceneEventsList>;
+    protected _planet: Planet | null;
+    protected _trackLayer: Vector;
+    protected _groundPointersLayer: Vector;
+    protected _columnPointersLayer: Vector;
+    protected _headPointersLayer: Vector;
+    protected _heightsLayer: Vector;
+    protected _trackEntity: Entity;
+    protected _pickedGroundEntity: Entity | null;
+    protected _pickedHeadEntity: Entity | null;
+    protected _pointerLayer: Vector;
+    protected _pointerHeadEntity: Entity;
+    protected _pointerLabelEntity: Entity;
+    protected _pointerRayEntity: Entity;
+    protected _startClickPos: Vec2;
+    protected _startEntityPos: Vec2;
+    protected _clampToGround: boolean;
+    constructor(options?: IElevationProfileSceneParams);
+    flyExtent(): void;
+    get planet(): Planet | null;
+    protected _createGroundPointer(groundCart: Vec3, altitude?: number): {
+        headEntity: Entity;
+        groundEntity: Entity;
+        columnEntity: Entity;
+        heightLabelEntity: Entity;
+    };
+    setPointerCartesian3v(p: Vec3, height: number): void;
+    bindPlanet(planet: Planet): void;
+    init(): void;
+    onremove(): void;
+    _activate(): void;
+    getPointLonLat(index: number): LonLat | undefined;
+    getPointsLonLat(): LonLat[];
+    getHeightMSL(lonLat: LonLat): number;
+    getHeightELLAsync(lonLat: LonLat): Promise<number>;
+    addPointLonLatArrayAsync(lonLatArr: LonLat[], stopPropagation?: boolean): Promise<Entity>[];
+    addPointLonLatAsync(lonLat: LonLat, stopPropagation?: boolean): Promise<Entity>;
+    addGroundPointLonLatAsync(lonLat: LonLat, altitude?: number, stopPropagation?: boolean): Promise<Entity>;
+    addGroundPoint3vAsync(groundPos: Vec3, altitude?: number, stopPropagation?: boolean): Promise<Entity>;
+    protected _addPoint(groundPos: Vec3, lonLat: LonLat, altitude: number, stopPropagation?: boolean): Promise<Entity>;
+    protected _onLClick: (e: IMouseState) => void;
+    protected _onMouseMove: (e: IMouseState) => void;
+    setHeadPointCartesian3v(entityIndex: number, headPos: Vec3): void;
+    setGroundPointCartesian3v(entityIndex: number, groundPos: Vec3): void;
+    protected _onLUp: (e: IMouseState) => void;
+    protected _onGroundPointerEnter: (e: IMouseState) => void;
+    protected _onGroundPointerLeave: (e: IMouseState) => void;
+    protected _onGroundPointerLDown: (e: IMouseState) => void;
+    protected _onGroundPointerLUp: (e: IMouseState) => void;
+    protected _onHeadPointerEnter: (e: IMouseState) => void;
+    protected _onHeadPointerLeave: (e: IMouseState) => void;
+    protected _onHeadPointerLDown: (e: IMouseState) => void;
+    protected _onHeadPointerLUp: (e: IMouseState) => void;
+    protected _deactivate(): void;
+    setPointerVisibility(visibility: boolean): void;
+    setVisibility(visibility: boolean): void;
+    clear(): void;
+    frame(): void;
+    get ellipsoid(): Ellipsoid | null;
+}
+type ElevationProfileSceneEventsList = [
+    "change",
+    "addpoint"
+];
+export { ElevationProfileScene };

package/lib/@openglobus/js/control/elevationProfile/ElevationProfileView.d.ts

@@ -0,0 +1,63 @@
+import { EventsHandler } from "../../Events";
+import { IViewParams, View, ViewEventsList } from '../../ui/View';
+import { ElevationProfile, GroundItem, TrackItem } from './ElevationProfile';
+import { MouseEventExt } from "../../input/MouseHandler";
+interface IElevationProfileViewParams extends IViewParams {
+    fillStyle?: string;
+}
+type ElevationProfileViewEventsList = ["startdrag", "stopdrag", "pointer", "mouseenter", "mouseleave", "dblclick", "tracklength", "groundlength", "warninglength", "collisionlength"];
+declare class ElevationProfileView extends View<ElevationProfile> {
+    events: EventsHandler<ElevationProfileViewEventsList> & EventsHandler<ViewEventsList>;
+    fillStyle: string;
+    protected _pixelsInMeter_x: number;
+    protected _pixelsInMeter_y: number;
+    protected _canvasScale: number;
+    $canvas: HTMLCanvasElement;
+    $pointerCanvas: HTMLCanvasElement;
+    protected _ctx: CanvasRenderingContext2D;
+    protected _pointerCtx: CanvasRenderingContext2D;
+    protected _onResizeObserver_: () => void;
+    protected _resizeObserver: ResizeObserver;
+    $loading: HTMLElement | null;
+    protected _isMouseOver: boolean;
+    protected _isDragging: boolean;
+    protected _clickPosX: number;
+    protected _clickLeftDistance: number;
+    protected _clickRightDistance: number;
+    protected _leftDistance: number;
+    protected _rightDistance: number;
+    protected _customFrame: boolean;
+    protected _timeStartHandler: number;
+    constructor(options?: IElevationProfileViewParams);
+    protected _onResizeObserver(): void;
+    get canvasScale(): number;
+    set canvasScale(scale: number);
+    resize(): void;
+    render(): this;
+    protected _hideLoading(): void;
+    protected _showLoading(): void;
+    protected _onMouseDblClick: (e: MouseEvent) => void;
+    protected _onMouseEnter: (e: MouseEvent) => void;
+    protected _onMouseOut: (e: MouseEvent) => void;
+    protected _onMouseDown: (e: MouseEvent) => void;
+    protected _onMouseUp: (e: MouseEvent) => void;
+    protected _onCanvasMouseMove: (e: MouseEvent) => void;
+    redrawPointerCanvas(x: number): void;
+    protected _onMouseMove: (e: MouseEvent) => void;
+    protected _onMouseWheelFF: (e: MouseEventExt) => void;
+    protected _onMouseWheel: (e: MouseEventExt) => void;
+    get clientWidth(): number;
+    get clientHeight(): number;
+    protected _resize(): void;
+    clearPointerCanvas(): void;
+    clearCanvas(): void;
+    setFrame(leftDistance: number, rightDistance: number): void;
+    _updateUnits(): void;
+    clear(): void;
+    draw(): void;
+    protected _drawLabels(coords: TrackItem[], groundCoords: GroundItem[]): void;
+    protected _drawTrack(coords: TrackItem[], groundCoords: GroundItem[]): void;
+    protected _drawTerrain(coords: number[][]): void;
+    protected _drawWarningAndCollision(coords: number[][]): void;
+}
+export { ElevationProfileView };

package/lib/@openglobus/js/control/elevationProfile/PointListDialog.d.ts

@@ -0,0 +1,12 @@
+import { IDialogParams, Dialog } from "../../ui/Dialog";
+import { ElevationProfileScene } from "./ElevationProfileScene";
+interface IPointListDialog extends IDialogParams {
+    model: ElevationProfileScene;
+}
+declare class PointListDialog extends Dialog<ElevationProfileScene> {
+    $textarea: HTMLTextAreaElement | null;
+    constructor(params: IPointListDialog);
+    render(params?: any): this;
+    protected _onApplyClick: () => void;
+}
+export { PointListDialog };

package/lib/@openglobus/js/control/heightRuler/HeightRuler.d.ts

@@ -0,0 +1,7 @@
+import { Ruler, IRulerParams } from "../ruler/Ruler";
+interface IHeightRulerParams extends IRulerParams {
+}
+export declare class HeightRuler extends Ruler {
+    constructor(options?: IHeightRulerParams);
+}
+export {};

package/lib/@openglobus/js/control/heightRuler/HeightRulerScene.d.ts

@@ -0,0 +1,35 @@
+import { Entity } from '../../entity/Entity';
+import { LonLat } from "../../LonLat";
+import { RulerScene, IRulerSceneParams } from "../ruler/RulerScene";
+import { Vector } from "../../layer/Vector";
+import { Vec3 } from "../../math/Vec3";
+interface IHeightRulerSceneParams extends IRulerSceneParams {
+}
+declare class HeightRulerScene extends RulerScene {
+    protected _geoRulerLayer: Vector;
+    protected _heightLabels: Entity[];
+    protected _rayH: Entity;
+    protected _rayV: Entity;
+    constructor(options?: IHeightRulerSceneParams);
+    setVisibility(visibility: boolean): void;
+    get deltaLabel(): Entity;
+    get startLabel(): Entity;
+    get endLabel(): Entity;
+    get corners(): Entity[];
+    get startCorner(): Entity;
+    get endCorner(): Entity;
+    get startCornerLonLat(): LonLat;
+    get startCornerHeight(): number;
+    get endCornerLonLat(): LonLat;
+    get endCornerHeight(): number;
+    get maxHeightCornerLonLat(): LonLat;
+    get minHeightCornerLonLat(): LonLat;
+    get deltaHeight(): number;
+    _drawLine(startLonLat: LonLat, endLonLat: LonLat, startPos?: Vec3): void;
+    protected _updateHeightRaysAndLabels(): Promise<void>;
+    clear(): void;
+    _createCorners(): void;
+    init(): void;
+    frame(): void;
+}
+export { HeightRulerScene };

package/lib/@openglobus/js/control/heightRuler/HeightRulerSwitcher.d.ts

@@ -0,0 +1,6 @@
+import { RulerSwitcher } from "../RulerSwitcher";
+export declare class HeightRulerSwitcher extends RulerSwitcher {
+    constructor(options?: {
+        ignoreTerrain?: boolean;
+    });
+}

package/lib/@openglobus/js/control/index.d.ts

@@ -0,0 +1,29 @@
+import { CompassButton } from "./CompassButton";
+import { Control } from "./Control";
+import { DebugInfo } from "./DebugInfo";
+import { DrawingSwitcher } from "./DrawingSwitcher";
+import { EarthCoordinates } from "./EarthCoordinates";
+import { EarthNavigation } from "./EarthNavigation";
+import { GeoImageDragControl } from "./GeoImageDragControl";
+import { KeyboardNavigation } from "./KeyboardNavigation";
+import { LayerAnimation } from "./LayerAnimation";
+import { LayerSwitcher } from "./LayerSwitcher";
+import { Lighting } from "./Lighting";
+import { MouseNavigation } from "./MouseNavigation";
+import { MouseWheelZoomControl } from "./MouseWheelZoomControl";
+import { RulerSwitcher } from "./RulerSwitcher";
+import { ScaleControl } from "./ScaleControl";
+import { ShowFps } from "./ShowFps";
+import { SimpleNavigation } from "./SimpleNavigation";
+import { SimpleSkyBackground } from "./SimpleSkyBackground";
+import { Sun } from "./Sun";
+import { ToggleWireframe } from "./ToggleWireframe";
+import { TouchNavigation } from "./TouchNavigation";
+import { ZoomControl } from "./ZoomControl";
+import { DrawingControl } from "./drawing/DrawingControl";
+import { HeightRuler } from "./heightRuler/HeightRuler";
+import { Ruler } from "./ruler/Ruler";
+import { Selection } from "./selection/Selection";
+import { TimelineControl } from "./timeline/TimelineControl";
+import { ElevationProfileControl } from "./elevationProfile/ElevationProfileControl";
+export { CompassButton, Control, DebugInfo, DrawingControl, DrawingSwitcher, EarthCoordinates, EarthNavigation, GeoImageDragControl, HeightRuler, KeyboardNavigation, LayerAnimation, LayerSwitcher, Lighting, MouseNavigation, MouseWheelZoomControl, Ruler, RulerSwitcher, ScaleControl, Selection, ShowFps, SimpleNavigation, SimpleSkyBackground, Sun, TimelineControl, ToggleWireframe, TouchNavigation, ZoomControl, ElevationProfileControl };

package/lib/@openglobus/js/control/ruler/Ruler.d.ts

@@ -0,0 +1,13 @@
+import { Control, IControlParams } from "../Control";
+import { RulerScene } from "./RulerScene";
+export interface IRulerParams extends IControlParams {
+    ignoreTerrain?: boolean;
+}
+export declare class Ruler extends Control {
+    protected _rulerScene: RulerScene;
+    constructor(options?: IRulerParams);
+    set ignoreTerrain(v: boolean);
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+}

package/lib/@openglobus/js/control/ruler/RulerScene.d.ts

@@ -0,0 +1,88 @@
+import { Entity } from '../../entity/Entity';
+import { EventsHandler } from '../../Events';
+import { LonLat } from "../../LonLat";
+import { Planet } from "../../scene/Planet";
+import { RenderNode } from '../../scene/RenderNode';
+import { Vector } from '../../layer/Vector';
+import { Vec2 } from '../../math/Vec2';
+import { Vec3 } from '../../math/Vec3';
+import { IMouseState } from "../../renderer/RendererEvents";
+import { Ellipsoid } from "../../ellipsoid/Ellipsoid";
+export interface IRulerSceneParams {
+    name?: string;
+    ignoreTerrain?: boolean;
+    planet?: Planet;
+}
+export declare const distanceFormat: (v: number) => string;
+type RulerSceneEventsList = [
+    "add",
+    "remove",
+    "mousemove",
+    "mouseenter",
+    "mouseleave",
+    "lclick",
+    "rclick",
+    "mclick",
+    "ldblclick",
+    "rdblclick",
+    "mdblclick",
+    "lup",
+    "rup",
+    "mup",
+    "ldown",
+    "rdown",
+    "mdown",
+    "lhold",
+    "rhold",
+    "mhold",
+    "mousewheel",
+    "touchmove",
+    "touchstart",
+    "touchend",
+    "doubletouch",
+    "touchleave",
+    "touchenter"
+];
+declare class RulerScene extends RenderNode {
+    events: EventsHandler<RulerSceneEventsList>;
+    protected _ignoreTerrain: boolean;
+    protected _planet: Planet | null;
+    protected _startLonLat: LonLat | null;
+    protected _preventClick: boolean;
+    protected _stopDrawing: boolean;
+    protected _pickedCorner: Entity | null;
+    protected _startPos: Vec2 | null;
+    protected _startClick: Vec2;
+    protected _heading: number;
+    protected _trackLayer: Vector;
+    protected _labelLayer: Vector;
+    protected _cornersLayer: Vector;
+    protected _cornerEntity: Entity[];
+    protected _propsLabel: Entity;
+    protected _trackEntity: Entity;
+    protected _anchorLonLat: LonLat | null;
+    protected _timeout: any;
+    constructor(options?: IRulerSceneParams);
+    set ignoreTerrain(v: boolean);
+    bindPlanet(planet: Planet): void;
+    protected _createCorners(): void;
+    init(): void;
+    onremove(): void;
+    _activate(): void;
+    protected _deactivate(): void;
+    protected _onCornerLdown: (e: IMouseState) => void;
+    protected _onLUp: () => void;
+    protected _onCornerLup: () => void;
+    protected _onCornerEnter: (e: IMouseState) => void;
+    protected _onCornerLeave: (e: IMouseState) => void;
+    protected _onLdblclick: () => void;
+    setVisibility(visibility: boolean): void;
+    protected _onLclick: (e: IMouseState) => void;
+    protected _drawLine(startLonLat: LonLat, endLonLat: LonLat, startPos?: Vec3): void;
+    protected _onMouseMove: (e: IMouseState) => void;
+    clear(): void;
+    isCornersPositionChanged(): boolean;
+    frame(): void;
+    get ellipsoid(): Ellipsoid | null;
+}
+export { RulerScene };

package/lib/@openglobus/js/control/selection/Selection.d.ts

@@ -0,0 +1,55 @@
+import { Control, IControlParams } from "../Control";
+import { SelectionScene } from "./SelectionScene";
+import { ToggleButton } from "../../ui/ToggleButton";
+interface ISelectionParams extends IControlParams {
+    ignoreTerrain?: boolean;
+    onSelect?: boolean;
+    autoSelectionHide?: boolean;
+}
+/**
+ * Activate Selection
+ * @param {boolean} [options.ignoreTerrain=false].
+ * @param {function} options.onSelect - callback (extent) => {} where extent is selected extent array [minLon,minLat,maxLon,maxLat]
+ * @param {boolean} [options.autoSelectionHide=false] - clear selection rectangle  after passing extent to callback
+ * @example:
+ * to use bootstrap icons, include
+ *  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.10.2/font/bootstrap-icons.css">
+ *
+ * new Selection({
+ *       ignoreTerrain: false,
+ *       autoSelectionHide:true,
+ *       onSelect: (extent) => {
+ *
+ *           var vectorSource = new ol.source.Vector({
+ *               format: new GeoJSON(),
+ *               url: function (extent) {
+ *                   return 'https://snap.ogs.trieste.it/geoserver/snap/ows?service=WFS&' +
+ *                           'version=1.1.0&request=GetFeature&typename=snap:all_dataset_segy_view&' +
+ *                           'outputFormat=application/json&srsname=EPSG:4326&' +
+ *                           'bbox=' + extent.join(',') + ',EPSG:4326';
+ *               },
+ *               strategy: function (extent, resolution) {
+ *                   if (this.resolution && this.resolution != resolution) {
+ *                       this.loadedExtentsRtree_.clear();
+ *                   }
+ *                   return [extent];
+ *               }
+ *           });
+ *
+ *           vectorSource.loadFeatures(extent);
+ *
+ *           console.log(extent);
+ *
+ *       }
+ *   });
+ */
+export declare class Selection extends Control {
+    protected _selectorScene: SelectionScene;
+    protected _toggleBtn: ToggleButton;
+    constructor(options?: ISelectionParams);
+    set ignoreTerrain(v: boolean);
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+}
+export {};

package/lib/@openglobus/js/control/selection/SelectionScene.d.ts

@@ -0,0 +1,44 @@
+import { Entity } from '../../entity/Entity';
+import { Events } from '../../Events';
+import { Vector } from '../../layer/Vector';
+import { RenderNode } from '../../scene/RenderNode';
+declare class SelectionScene extends RenderNode {
+    events: Events<string[]>;
+    _ignoreTerrain: boolean;
+    _onSelect: any;
+    _autoSelectionHide: any;
+    _planet: any;
+    _startLonLat: any;
+    _heading: number;
+    _propsLabel: Entity;
+    _trackEntity: Entity;
+    _cornerEntity: Entity[];
+    _trackLayer: Vector;
+    _cornersLayer: Vector;
+    _onMouseMove_: any;
+    _onMouseLdown_: any;
+    _onMouseLup_: any;
+    _pickedCorner: any;
+    _anchorLonLat: any;
+    constructor(options?: {
+        name?: string;
+        ignoreTerrain?: boolean;
+        onSelect?: any;
+        autoSelectionHide?: boolean;
+        planet?: any;
+    });
+    set ignoreTerrain(v: boolean);
+    bindPlanet(planet: any): void;
+    init(): void;
+    onremove(): void;
+    _activate(): void;
+    _deactivate(): void;
+    _onMouseLdown(e: any): void;
+    _onMouseLup(e: any): void;
+    _drawLine(startLonLat: any, endLonLat: any, startPos?: any): void;
+    _onMouseMove(e: any): void;
+    clear(): void;
+    frame(): void;
+    get ellipsoid(): any;
+}
+export { SelectionScene };

package/lib/@openglobus/js/control/timeline/TimelineControl.d.ts

@@ -0,0 +1,18 @@
+import { Dialog } from "../../ui/Dialog";
+import { ToggleButton } from "../../ui/ToggleButton";
+import { Control, IControlParams } from '../Control';
+import { TimelineView } from './TimelineView';
+interface ITimelineControlParams extends IControlParams {
+    name?: string;
+    current?: Date;
+    rangeStart?: Date;
+    rangeEnd?: Date;
+}
+declare class TimelineControl extends Control {
+    protected _timelineView: TimelineView;
+    protected _toggleBtn: ToggleButton;
+    protected _dialog: Dialog<null>;
+    constructor(options?: ITimelineControlParams);
+    oninit(): void;
+}
+export { TimelineControl };

package/lib/@openglobus/js/control/timeline/TimelineModel.d.ts

@@ -0,0 +1,41 @@
+import { EventsHandler } from '../../Events';
+type TimelineEventsList = ["change", "current"];
+interface ITimelineParams {
+    current?: Date;
+    rangeStart?: Date;
+    rangeEnd?: Date;
+    minDate?: Date | null;
+    maxDate?: Date | null;
+    multiplier?: number;
+}
+declare class TimelineModel {
+    events: EventsHandler<TimelineEventsList>;
+    protected _current: Date;
+    protected _rangeStart: Date;
+    protected _rangeEnd: Date;
+    protected _range: number;
+    protected _minDate: Date | null;
+    protected _maxDate: Date | null;
+    protected _requestAnimationFrameId: number;
+    protected _prevNow: number;
+    multiplier: number;
+    dt: number;
+    constructor(options?: ITimelineParams);
+    play(): void;
+    stop(): void;
+    stopped(): boolean;
+    protected _animationFrameCallback(): void;
+    protected _frame(): void;
+    get range(): number;
+    set(rangeStart: Date, rangeEnd: Date): void;
+    get current(): Date;
+    get rangeStart(): Date;
+    get rangeEnd(): Date;
+    get rangeStartTime(): number;
+    get rangeEndTime(): number;
+    get currentTime(): number;
+    set current(current: Date);
+    set rangeStart(date: Date);
+    set rangeEnd(date: Date);
+}
+export { TimelineModel };

package/lib/@openglobus/js/control/timeline/TimelineView.d.ts

@@ -0,0 +1,85 @@
+import { EventsHandler } from "../../Events";
+import { ButtonGroup } from "../../ui/ButtonGroup";
+import { IViewParams, View, ViewEventsList } from '../../ui/View';
+import { ToggleButton } from "../../ui/ToggleButton";
+import { TimelineModel } from './TimelineModel';
+import { MouseEventExt } from "../../input/MouseHandler";
+interface ITimelineViewParams extends IViewParams {
+    currentDate?: Date;
+    rangeStart?: Date;
+    rangeEnd?: Date;
+    minDate?: Date;
+    maxDate?: Date;
+    fillStyle?: string;
+}
+type TimelineViewEventsList = [
+    'startdrag',
+    'stopdrag',
+    'startdragcurrent',
+    'stopdragcurrent',
+    'setcurrent',
+    'reset',
+    'play',
+    'playback',
+    'pause',
+    'visibility'
+];
+declare class TimelineView extends View<TimelineModel> {
+    events: EventsHandler<TimelineViewEventsList> & EventsHandler<ViewEventsList>;
+    fillStyle: string;
+    $controls: HTMLElement | null;
+    protected _frameEl: HTMLElement | null;
+    protected _currentEl: HTMLElement | null;
+    protected _canvasEl: HTMLCanvasElement;
+    protected _ctx: CanvasRenderingContext2D;
+    protected _isMouseOver: boolean;
+    protected _isDragging: boolean;
+    protected _isCurrentDragging: boolean;
+    protected _isCurrentMouseOver: boolean;
+    protected _minWidth: number;
+    protected _canvasScale: number;
+    protected _millisecondsInPixel: number;
+    protected _clickPosX: number;
+    protected _clickRangeStart: Date;
+    protected _clickRangeEnd: Date;
+    protected _clickCurrentDate: Date;
+    protected _clickTime: number;
+    protected _clickDelay: number;
+    protected _onResizeObserver_: () => void;
+    protected _resizeObserver: ResizeObserver;
+    protected _pauseBtn: ToggleButton;
+    protected _playBtn: ToggleButton;
+    protected _buttons: ButtonGroup;
+    protected _visibility: boolean;
+    constructor(options?: ITimelineViewParams);
+    protected _onResizeObserver(): void;
+    get canvasScale(): number;
+    set canvasScale(scale: number);
+    resize(): void;
+    afterRender(parentNode: HTMLElement): void;
+    render(): this;
+    setVisibility(visibility: boolean): void;
+    reset(): void;
+    play(): void;
+    pause(): void;
+    playBack(): void;
+    protected _onMouseWheel: (e: MouseEventExt) => void;
+    protected _onMouseWheelFF: (e: MouseEventExt) => void;
+    protected _zoom(pointerTime: number, pointerCenterOffsetX: number, dir: number): void;
+    protected _onMouseDown: (e: MouseEvent) => void;
+    protected _onMouseUp: (e: MouseEvent) => void;
+    protected _onMouseEnter: () => void;
+    protected _onMouseOut: () => void;
+    protected _onCurrentMouseEnter: () => void;
+    protected _onCurrentMouseOut: () => void;
+    protected _onMouseMove: (e: MouseEvent) => void;
+    get clientWidth(): number;
+    get clientHeight(): number;
+    protected _resize(): void;
+    getOffsetByTime(milliseconds: number): number;
+    remove(): void;
+    protected _clearCanvas(): void;
+    protected _drawCurrent(): void;
+    draw(): void;
+}
+export { TimelineView };

package/lib/@openglobus/js/control/timeline/timelineUtils.d.ts

@@ -0,0 +1,12 @@
+type BaselineType = "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top";
+type AlignType = "center" | "end" | "left" | "right" | "start";
+export declare function addSeconds(date: Date, seconds: number): Date;
+export declare function dateToStr(date: Date, showTime?: boolean, showMilliseconds?: boolean): string;
+export declare function createCanvasHTML(): HTMLCanvasElement;
+export declare function getNearestTimeLeft(t: number, div: number): number;
+export declare function drawNotch(ctx: CanvasRenderingContext2D, xOffset?: number, size?: number, thickness?: number, color?: string): void;
+export declare function drawText(ctx: CanvasRenderingContext2D, text: string, x: number, y: number, font?: string, fillStyle?: string, align?: AlignType, baseLine?: BaselineType, rotDeg?: number): void;
+export declare const SCALES: [number, number][];
+export declare function getScale(seconds: number): [number, number] | undefined;
+export declare const MONTHS: string[];
+export {};

package/lib/@openglobus/js/control/visibleExtent/drawnode.d.ts

@@ -0,0 +1,7 @@
+import { Program } from "../../webgl/Program";
+export declare function drawnode_screen_nl(): Program;
+export declare function drawnode_screen_wl(): Program;
+export declare function drawnode_screen_wl_webgl2(): Program;
+export declare function drawnode_colorPicking(): Program;
+export declare function drawnode_heightPicking(): Program;
+export declare function drawnode_depth(): Program;