@openglobus/og 0.17.2 → 0.18.1

package/lib/js/Clock.d.ts

@@ -0,0 +1,106 @@
+import { EventsHandler } from "./Events";
+import { JulianDate } from "./astro/jd";
+import { Handler } from "./webgl/Handler";
+type ClockEventsList = ["tick", "end", "start", "stop"];
+export interface IClockParams {
+    name?: string;
+    startDate?: JulianDate;
+    endDate?: JulianDate;
+    currentDate?: JulianDate;
+    multiplier?: number;
+}
+/**
+ * Class represents application timer that stores custom current julian datetime, and time speed multiplier.
+ * @class
+ * @param {Object} [params] - Clock parameters:
+ * @param {JulianDate} [params.startDate=0.0] - Julian start date.
+ * @param {JulianDate} [params.endDate=0.0] - Julian end date.
+ * @param {JulianDate} [params.currentDate] - Julian current date. Default: current date.
+ * @param {number} [params.multiplier=1.0] - Time speed multiplier.
+ */
+declare class Clock {
+    static __counter__: number;
+    protected __id: number;
+    __handler: Handler | null;
+    /**
+     * Clock events.
+     * @public
+     * @type {EventsHandler<ClockEventsList>}
+     */
+    events: EventsHandler<ClockEventsList>;
+    /**
+     * Clock name.
+     * @public
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Start julian date clock loop.
+     * @public
+     * @type {JulianDate}
+     */
+    startDate: JulianDate;
+    /**
+     * End julian date clock loop.
+     * @public
+     * @type {JulianDate}
+     */
+    endDate: JulianDate;
+    /**
+     * Current julian datetime.
+     * @public
+     * @type {JulianDate}
+     */
+    currentDate: JulianDate;
+    /**
+     * Animation frame delta time.
+     * @public
+     * @readonly
+     * @type {number}
+     */
+    deltaTicks: number;
+    /**
+     * Timer activity.
+     * @public
+     * @type {boolean}
+     */
+    active: boolean;
+    /**
+     * Timer speed multiplier.
+     * @protected
+     * @type {number}
+     */
+    protected _multiplier: number;
+    protected _running: number;
+    protected _intervalDelay: number;
+    protected _intervalStart: number;
+    protected _intervalCallback: Function | null;
+    constructor(params?: IClockParams);
+    clearInterval(): void;
+    setInterval(delay: number, callback: Function): void;
+    /**
+     * Sets current clock datetime.
+     * @public
+     * @param {Object} date - JavaScript Date object.
+     */
+    setDate(date: Date): void;
+    /**
+     * Returns current application date.
+     * @public
+     * @returns {Date} - Current date.
+     */
+    getDate(): Date;
+    reset(): void;
+    tick(dt: number): void;
+    /**
+     * @public
+     * @param {Clock} clock - Clock instance to compare.
+     * @returns {boolean} - Returns true if a clock is the same instance.
+     */
+    isEqual(clock: Clock): boolean;
+    start(): void;
+    get multiplier(): number;
+    set multiplier(value: number);
+    stop(): void;
+}
+export { Clock };

package/lib/js/Clock.js

@@ -0,0 +1,141 @@
+import * as jd from "./astro/jd";
+import { createEvents } from "./Events";
+const CLOCK_EVENTS = ["tick", "end", "start", "stop"];
+/**
+ * Class represents application timer that stores custom current julian datetime, and time speed multiplier.
+ * @class
+ * @param {Object} [params] - Clock parameters:
+ * @param {JulianDate} [params.startDate=0.0] - Julian start date.
+ * @param {JulianDate} [params.endDate=0.0] - Julian end date.
+ * @param {JulianDate} [params.currentDate] - Julian current date. Default: current date.
+ * @param {number} [params.multiplier=1.0] - Time speed multiplier.
+ */
+class Clock {
+    constructor(params = {}) {
+        this.__handler = null;
+        /**
+         * Timer activity.
+         * @public
+         * @type {boolean}
+         */
+        this.active = true;
+        this.__id = Clock.__counter__++;
+        this.events = createEvents(CLOCK_EVENTS, this);
+        this.name = params.name || "";
+        this.startDate = params.startDate || 0;
+        this.endDate = params.endDate || 0;
+        let currentDate = params.currentDate || jd.DateToUTC(new Date());
+        if (params.startDate && currentDate < params.startDate) {
+            currentDate = params.startDate;
+        }
+        if (params.endDate && currentDate > params.endDate) {
+            currentDate = params.endDate;
+        }
+        this.currentDate = currentDate;
+        this._multiplier = params.multiplier !== undefined ? params.multiplier : 1.0;
+        this._running = 1;
+        this.deltaTicks = 0;
+        this.active = true;
+        this._intervalDelay = 0;
+        this._intervalStart = 0;
+        this._intervalCallback = null;
+    }
+    clearInterval() {
+        this._intervalDelay = 0;
+        this._intervalStart = 0;
+        this._intervalCallback = null;
+    }
+    setInterval(delay, callback) {
+        this._intervalStart = this.currentDate;
+        this._intervalDelay = delay * jd.ONE_BY_MILLISECONDS_PER_DAY;
+        this._intervalCallback = callback;
+    }
+    /**
+     * Sets current clock datetime.
+     * @public
+     * @param {Object} date - JavaScript Date object.
+     */
+    setDate(date) {
+        let d = jd.DateToUTC(date);
+        if (this.startDate && d < this.startDate) {
+            d = this.startDate;
+        }
+        if (this.endDate && d > this.endDate) {
+            d = this.endDate;
+        }
+        this.currentDate = d;
+    }
+    /**
+     * Returns current application date.
+     * @public
+     * @returns {Date} - Current date.
+     */
+    getDate() {
+        return jd.UTCtoDate(this.currentDate);
+    }
+    reset() {
+        if (this.startDate) {
+            this.currentDate = this.startDate;
+        }
+    }
+    tick(dt) {
+        let m = this._multiplier * this._running;
+        this.deltaTicks = dt * m;
+        if (this.active) {
+            let cd = jd.addMilliseconds(this.currentDate, this.deltaTicks);
+            if (m > 0) {
+                if (this.endDate && cd > this.endDate) {
+                    this.currentDate = this.startDate;
+                    this.events.dispatch(this.events.end, this);
+                }
+                else {
+                    this.currentDate = cd;
+                }
+            }
+            else {
+                if (this.startDate && cd < this.startDate) {
+                    this.currentDate = this.endDate;
+                    this.events.dispatch(this.events.end, this);
+                }
+                else {
+                    this.currentDate = cd;
+                }
+            }
+            if (this._intervalCallback) {
+                if (this.currentDate - this._intervalStart >= this._intervalDelay) {
+                    this._intervalStart = this.currentDate;
+                    this._intervalCallback(this);
+                }
+            }
+            this.events.dispatch(this.events.tick, this);
+        }
+    }
+    /**
+     * @public
+     * @param {Clock} clock - Clock instance to compare.
+     * @returns {boolean} - Returns true if a clock is the same instance.
+     */
+    isEqual(clock) {
+        return this.__id === clock.__id;
+    }
+    start() {
+        if (this._running === 0) {
+            this._running = 1;
+            this.events.dispatch(this.events.start, this);
+        }
+    }
+    get multiplier() {
+        return this._multiplier;
+    }
+    set multiplier(value) {
+        this._multiplier = value;
+    }
+    stop() {
+        if (this._running === 1) {
+            this._running = 0;
+            this.events.dispatch(this.events.stop, this);
+        }
+    }
+}
+Clock.__counter__ = 0;
+export { Clock };

package/lib/js/Deferred.d.ts

@@ -0,0 +1,6 @@
+export declare class Deferred<T> {
+    resolve: ((value: T | PromiseLike<T>) => void);
+    reject: ((reason?: any) => void);
+    promise: Promise<T>;
+    constructor();
+}

package/lib/js/Deferred.js

@@ -0,0 +1,13 @@
+export class Deferred {
+    constructor() {
+        this.resolve = () => {
+        };
+        this.reject = () => {
+        };
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+        Object.freeze(this);
+    }
+}

package/lib/js/Events.d.ts

@@ -0,0 +1,90 @@
+export type EventCallback = (((...args: any[]) => boolean) | ((...args: any[]) => void));
+export type EventCallbackStamp = EventCallback & {
+    _openglobus_id?: number;
+    _openglobus_priority?: number;
+};
+type EventCallbacks = Array<EventCallback>;
+type EventCallbackHandler = {
+    active: boolean;
+    handlers: EventCallbacks;
+};
+export type EventsMap<T extends string[]> = {
+    [K in T[number]]?: EventCallbackHandler;
+};
+export type EventsHandler<T extends string[]> = Events<T> & EventsMap<T>;
+export declare function createEvents<T extends string[]>(methodNames: T, sender?: any): EventsHandler<T>;
+/**
+ * Base events class to handle custom events.
+ * @class
+ * @param {Array.<string>} [eventNames] - Event names that could be dispatched.
+ * @param {*} [sender]
+ */
+export declare class Events<T extends string[]> {
+    static __counter__: number;
+    protected __id: number;
+    /**
+     * Registered event names.
+     * @protected
+     * @type {T}
+     */
+    protected _eventNames: T;
+    protected _sender: any;
+    /**
+     * Stop propagation flag
+     * @protected
+     * @type {boolean}
+     */
+    protected _stopPropagation: boolean;
+    protected _stampCache: any;
+    constructor(eventNames: T, sender?: any);
+    bindSender(sender?: any): void;
+    /**
+     * Function that creates event object properties that would be dispatched.
+     * @public
+     * @param {Array.<string>} eventNames - Specified event names list.
+     */
+    registerNames(eventNames: T): this;
+    protected _getStamp(name: string, id: number, ogid: number): string;
+    /**
+     * Returns true if event callback has stamped.
+     * @protected
+     * @param {Object} name - Event identifier.
+     * @param {Object} obj - Event callback.
+     * @return {boolean} -
+     */
+    protected _stamp(name: string, obj: any): boolean;
+    /**
+     * Attach listener.
+     * @public
+     * @param {string} name - Event name to listen.
+     * @param {EventCallback} callback - Event callback function.
+     * @param {any} [sender] - Event callback function owner.
+     * @param {number} [priority] - Priority of event callback.
+     */
+    on(name: string, callback: EventCallback, sender?: any, priority?: number): void;
+    /**
+     * Stop listening event name with specified callback function.
+     * @public
+     * @param {string} name - Event name.
+     * @param {EventCallback | null} callback - Attached  event callback.
+     */
+    off(name: string, callback?: EventCallback | null): void;
+    /**
+     * Dispatch event.
+     * @public
+     * @param {EventCallbackHandler} event - Event instance property that created by event name.
+     * @param {Object} [args] - Callback parameters.
+     */
+    dispatch(event: EventCallbackHandler | undefined, ...args: any[]): boolean;
+    /**
+     * Brakes events propagation.
+     * @public
+     */
+    stopPropagation(): void;
+    /**
+     * Removes all events.
+     * @public
+     */
+    clear(): void;
+}
+export {};

package/lib/js/Events.js

@@ -0,0 +1,145 @@
+import { binaryInsert, stamp } from "./utils/shared";
+export function createEvents(methodNames, sender) {
+    return new Events(methodNames, sender);
+}
+/**
+ * Base events class to handle custom events.
+ * @class
+ * @param {Array.<string>} [eventNames] - Event names that could be dispatched.
+ * @param {*} [sender]
+ */
+export class Events {
+    constructor(eventNames, sender) {
+        this.__id = Events.__counter__++;
+        this._eventNames = [];
+        eventNames && this.registerNames(eventNames);
+        this._sender = sender || this;
+        this._stopPropagation = false;
+        this._stampCache = {};
+    }
+    bindSender(sender) {
+        this._sender = sender || this;
+    }
+    /**
+     * Function that creates event object properties that would be dispatched.
+     * @public
+     * @param {Array.<string>} eventNames - Specified event names list.
+     */
+    registerNames(eventNames) {
+        for (let i = 0; i < eventNames.length; i++) {
+            this[eventNames[i]] = {
+                active: true,
+                handlers: []
+            };
+            this._eventNames.push(eventNames[i]);
+        }
+        return this;
+    }
+    _getStamp(name, id, ogid) {
+        return `${name}_${id}_${ogid}`;
+    }
+    /**
+     * Returns true if event callback has stamped.
+     * @protected
+     * @param {Object} name - Event identifier.
+     * @param {Object} obj - Event callback.
+     * @return {boolean} -
+     */
+    _stamp(name, obj) {
+        let ogid = stamp(obj);
+        let st = this._getStamp(name, this.__id, ogid);
+        if (!this._stampCache[st]) {
+            this._stampCache[st] = ogid;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Attach listener.
+     * @public
+     * @param {string} name - Event name to listen.
+     * @param {EventCallback} callback - Event callback function.
+     * @param {any} [sender] - Event callback function owner.
+     * @param {number} [priority] - Priority of event callback.
+     */
+    on(name, callback, sender, priority = 0) {
+        if (this._stamp(name, callback)) {
+            if (this[name]) {
+                let c = callback.bind(sender || this._sender);
+                c._openglobus_id = callback._openglobus_id;
+                c._openglobus_priority = priority;
+                binaryInsert(this[name].handlers, c, (a, b) => {
+                    return (b._openglobus_priority || 0) - (a._openglobus_priority || 0);
+                });
+            }
+        }
+    }
+    /**
+     * Stop listening event name with specified callback function.
+     * @public
+     * @param {string} name - Event name.
+     * @param {EventCallback | null} callback - Attached  event callback.
+     */
+    off(name, callback) {
+        if (callback) {
+            let st = this._getStamp(name, this.__id, callback._openglobus_id);
+            if (callback._openglobus_id && this._stampCache[st]) {
+                let h = this[name].handlers;
+                let i = h.length;
+                let indexToRemove = -1;
+                while (i--) {
+                    let hi = h[i];
+                    if (hi._openglobus_id === callback._openglobus_id) {
+                        indexToRemove = i;
+                        break;
+                    }
+                }
+                if (indexToRemove !== -1) {
+                    h.splice(indexToRemove, 1);
+                    this._stampCache[st] = undefined;
+                    delete this._stampCache[st];
+                }
+            }
+        }
+    }
+    /**
+     * Dispatch event.
+     * @public
+     * @param {EventCallbackHandler} event - Event instance property that created by event name.
+     * @param {Object} [args] - Callback parameters.
+     */
+    dispatch(event, ...args) {
+        let result = true;
+        if (event && event.active && !this._stopPropagation) {
+            let h = event.handlers.slice(0), i = h.length;
+            while (i--) {
+                if (h[i](...args) === false) {
+                    result = false;
+                }
+            }
+        }
+        this._stopPropagation = false;
+        return result;
+    }
+    /**
+     * Brakes events propagation.
+     * @public
+     */
+    stopPropagation() {
+        this._stopPropagation = true;
+    }
+    /**
+     * Removes all events.
+     * @public
+     */
+    clear() {
+        for (let i = 0; i < this._eventNames.length; i++) {
+            let e = this[this._eventNames[i]];
+            e.handlers.length = 0;
+            e.handlers = [];
+        }
+        this._eventNames.length = 0;
+        this._eventNames = [];
+    }
+}
+Events.__counter__ = 0;

package/lib/js/Extent.d.ts

@@ -0,0 +1,145 @@
+import { Ellipsoid } from "./ellipsoid/Ellipsoid";
+import { LonLat } from "./LonLat";
+/**
+ * Represents geographical coordinates extent.
+ * @class
+ * @param {LonLat} [sw] - South West extent corner coordinates.
+ * @param {LonLat} [ne] - North East extent corner coordinates.
+ */
+export declare class Extent {
+    southWest: LonLat;
+    northEast: LonLat;
+    constructor(sw?: LonLat, ne?: LonLat);
+    /**
+     * Creates extent instance from values in array.
+     * @static
+     * @param {Array.<number>} arr - South west and north-east longitude and latitudes packed in array. (exactly 4 entries)
+     * @return {Extent} Extent object.
+     */
+    static createFromArray(arr: [number, number, number, number]): Extent;
+    /**
+     * Creates bound extent instance by coordinate array.
+     * @static
+     * @param {Array.<LonLat>} arr - Coordinate array.
+     * @return {Extent} Extent object.
+     */
+    static createByCoordinates(arr: LonLat[]): Extent;
+    /**
+     * Creates bound extent instance by coordinates array.
+     * @static
+     * @param {Array.<Array<number>>} arr - Coordinate array. (exactly 2 entries)
+     * @return {Extent} Extent object.
+     */
+    static createByCoordinatesArr(arr: [number, number][]): Extent;
+    /**
+     * Creates extent by merсator grid tile coordinates.
+     * @static
+     * @param {number} x -
+     * @param {number} y -
+     * @param {number} z -
+     * @param {number} width -
+     * @param {number} height -
+     * @returns {Extent} -
+     */
+    static fromTile(x: number, y: number, z: number, width?: number, height?: number): Extent;
+    /**
+     * Sets current bounding extent object by coordinate array.
+     * @public
+     * @param {Array.<LonLat>} arr - Coordinate array.
+     * @return {Extent} Current extent.
+     */
+    setByCoordinates(arr: LonLat[]): Extent;
+    /**
+     * Determines if point inside extent.
+     * @public
+     * @param {LonLat} lonlat - Coordinate point.
+     * @return {boolean} Returns true if point inside extent.
+     */
+    isInside(lonlat: LonLat): boolean;
+    /**
+     * Returns true if two extent overlap each other.
+     * @public
+     * @param {Extent} e - Another extent.
+     * @return {boolean} -
+     */
+    overlaps(e: Extent): boolean;
+    /**
+     * Gets extent width.
+     * @public
+     * @return {number} Extent width.
+     */
+    getWidth(): number;
+    /**
+     * Gets extent height.
+     * @public
+     * @return {number} Extent height.
+     */
+    getHeight(): number;
+    /**
+     * Creates clone instance of the current extent.
+     * @public
+     * @return {Extent} Extent clone.
+     */
+    clone(): Extent;
+    /**
+     * Gets the center coordinate of the extent.
+     * @public
+     * @return {number} Center coordinate.
+     */
+    getCenter(): LonLat;
+    /**
+     * @public
+     */
+    getNorthWest(): LonLat;
+    /**
+     * @public
+     */
+    getNorthEast(): LonLat;
+    /**
+     * @public
+     */
+    getSouthWest(): LonLat;
+    /**
+     * @public
+     */
+    getSouthEast(): LonLat;
+    /**
+     * @public
+     */
+    getNorth(): number;
+    getEast(): number;
+    /**
+     * @public
+     */
+    getWest(): number;
+    /**
+     * @public
+     */
+    getSouth(): number;
+    /**
+     * Returns extents are equals.
+     * @param {Extent} extent - Extent.
+     * @returns {boolean} -
+     */
+    equals(extent: Extent): boolean;
+    /**
+     * Converts extent coordinates to mercator projection coordinates.
+     * @public
+     * @return {Extent} New instance of the current extent.
+     */
+    forwardMercator(): Extent;
+    /**
+     * Converts extent coordinates from mercator projection to degrees.
+     * @public
+     * @return {Extent} New instance of the current extent.
+     */
+    inverseMercator(): Extent;
+    /**
+     * Gets cartesian bounding bounds of the current ellipsoid.
+     * @public
+     * @param {Ellipsoid} ellipsoid - Ellipsoid.
+     * @return {Array.<number>} Cartesian 3d coordinate array. (exactly 6 entries)
+     */
+    getCartesianBounds(ellipsoid: Ellipsoid): [number, number, number, number, number, number];
+    toString(): string;
+}