@openglobus/og 0.18.0 → 0.18.2

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/{src/Clock.ts → lib/js/Clock.js}

@@ -1,20 +1,6 @@
 import * as jd from "./astro/jd";
-import {EventsHandler, createEvents} from "./Events";
-import {JulianDate} from "./astro/jd";
-import {Handler} from "./webgl/Handler";
-
-type ClockEventsList = ["tick", "end", "start", "stop"];
-
-const CLOCK_EVENTS: ClockEventsList = ["tick", "end", "start", "stop"];
-
-export interface IClockParams {
-    name?: string;
-    startDate?: JulianDate;
-    endDate?: JulianDate;
-    currentDate?: JulianDate;
-    multiplier?: number;
-}
-
+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
@@ -25,85 +11,19 @@ export interface IClockParams {
  * @param {number} [params.multiplier=1.0] - Time speed multiplier.
  */
 class Clock {
-    static __counter__: number = 0;
-    protected __id: number;
-    public __handler: Handler | null = null;
-
-    /**
-     * Clock events.
-     * @public
-     * @type {EventsHandler<ClockEventsList>}
-     */
-    public events: EventsHandler<ClockEventsList>;
-
-    /**
-     * Clock name.
-     * @public
-     * @type {string}
-     */
-    public name: string;
-
-    /**
-     * Start julian date clock loop.
-     * @public
-     * @type {JulianDate}
-     */
-    public startDate: JulianDate;
-
-    /**
-     * End julian date clock loop.
-     * @public
-     * @type {JulianDate}
-     */
-    public endDate: JulianDate;
-
-    /**
-     * Current julian datetime.
-     * @public
-     * @type {JulianDate}
-     */
-    public currentDate: JulianDate;
-
-    /**
-     * Animation frame delta time.
-     * @public
-     * @readonly
-     * @type {number}
-     */
-    public deltaTicks: number;
-
-    /**
-     * Timer activity.
-     * @public
-     * @type {boolean}
-     */
-    public active: boolean = true;
-
-    /**
-     * 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 = {}) {
-
-
+    constructor(params = {}) {
+        this.__handler = null;
+        /**
+         * Timer activity.
+         * @public
+         * @type {boolean}
+         */
+        this.active = true;
         this.__id = Clock.__counter__++;
-
-        this.events = createEvents<ClockEventsList>(CLOCK_EVENTS, this);
-
+        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;
@@ -111,39 +31,31 @@ class Clock {
         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;
     }
-
-    public clearInterval() {
+    clearInterval() {
         this._intervalDelay = 0;
         this._intervalStart = 0;
         this._intervalCallback = null;
     }
-
-    public setInterval(delay: number, callback: Function) {
+    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.
      */
-    public setDate(date: Date) {
+    setDate(date) {
         let d = jd.DateToUTC(date);
         if (this.startDate && d < this.startDate) {
             d = this.startDate;
@@ -153,84 +65,77 @@ class Clock {
         }
         this.currentDate = d;
     }
-
     /**
      * Returns current application date.
      * @public
      * @returns {Date} - Current date.
      */
-    public getDate(): Date {
+    getDate() {
         return jd.UTCtoDate(this.currentDate);
     }
-
-    public reset() {
+    reset() {
         if (this.startDate) {
             this.currentDate = this.startDate;
         }
     }
-
-    public tick(dt: number) {
+    tick(dt) {
         let m = this._multiplier * this._running;
-        this.deltaTicks = dt * m
+        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 {
+                }
+                else {
                     this.currentDate = cd;
                 }
-            } else {
+            }
+            else {
                 if (this.startDate && cd < this.startDate) {
                     this.currentDate = this.endDate;
                     this.events.dispatch(this.events.end, this);
-                } else {
+                }
+                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.
      */
-    public isEqual(clock: Clock) {
+    isEqual(clock) {
         return this.__id === clock.__id;
     }
-
-    public start() {
+    start() {
         if (this._running === 0) {
             this._running = 1;
             this.events.dispatch(this.events.start, this);
         }
     }
-
-    public get multiplier(): number {
+    get multiplier() {
         return this._multiplier;
     }
-
-    public set multiplier(value: number) {
+    set multiplier(value) {
         this._multiplier = value;
     }
-
-    public stop() {
+    stop() {
         if (this._running === 1) {
             this._running = 0;
             this.events.dispatch(this.events.stop, this);
         }
     }
 }
-
-export {Clock};
+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 {};