@openglobus/og 0.17.1 → 0.18.0

package/package.json

@@ -1,24 +1,20 @@
 {
   "name": "@openglobus/og",
-  "version": "0.17.1",
-  "description": "[OpenGlobus](https://www.openglobus.org/) is a javascript library designed to display interactive 3d maps and planets with map tiles, imagery and vector data, markers and 3d objects. It uses the WebGL technology, open source and completely free.",
+  "version": "0.18.0",
+  "description": "[openglobus](https://www.openglobus.org/) is a javascript/typescript library designed to display interactive 3d maps and planets with map tiles, imagery and vector data, markers, and 3D objects. It uses the WebGL technology, open source, and completely free.",
   "directories": {
     "example": "./sandbox"
   },
-  "main": "./src/og/index.js",
+  "main": "./src/index.ts",
   "style": "./css/og.css",
-  "types": "./types/index.d.ts",
   "scripts": {
     "docs": "jsdoc -r ./src/ -c ./jsdoc.conf.json -d ./docs",
-    "serve": "ws",
+    "serve": "ws -p 8080",
     "build": "rollup -c --bundleConfigAsCjs",
-    "webgl": "rollup -c --environment entry:webgl",
-    "core": "rollup -c --environment entry:core",
+    "dev": "rollup -c -w --bundleConfigAsCjs --environment NODE_ENV:development",
     "test": "jest --env=jsdom --runInBand --ci --coverage=false",
     "test_watch": "jest --env=jsdom --watch",
-    "lint": "eslint -c ./.eslintrc.js src/og",
-    "generate_types": "rm -rf types; tsc src/**/*.js --declaration --allowJs --emitDeclarationOnly --outDir types",
-    "compile_js_as_ts": "tsc src/og/index.js --AllowJs --checkJs --outDir dist/@openglobus/src/",
+    "lint": "eslint -c ./.eslintrc.js src/",
     "font": "node ./fonts/index.js"
   },
   "repository": {
@@ -33,21 +29,23 @@
   },
   "homepage": "https://www.openglobus.org",
   "exports": {
-    ".": "./src/og/index.js",
-    "./layer": "./src/og/layer/index.js",
-    "./bv": "./src/og/bv/index.js",
-    "./terrain": "./src/og/terrain/index.js",
-    "./entity": "./src/og/entity/index.js",
-    "./control": "./src/og/control/index.js",
-    "./webgl": "./src/og/webgl/index.js",
-    "./scene": "./src/og/scene/index.js",
+    ".": "./src/index.js",
+    "./layer": "./src/layer/index.js",
+    "./bv": "./src/index.js",
+    "./terrain": "./src/terrain/index.js",
+    "./entity": "./src/entity/index.js",
+    "./control": "./src/control/index.js",
+    "./webgl": "./src/webgl/index.js",
+    "./scene": "./src/scene/index.js",
     "./css/og.css": "./css/og.css"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.21.5",
     "@rollup/plugin-json": "^6.0.0",
     "@rollup/plugin-terser": "^0.4.1",
-    "@types/jest": "^29.5.1",
+    "@types/jest": "^29.5.3",
+    "@typescript-eslint/eslint-plugin": "^6.2.1",
+    "@typescript-eslint/parser": "^6.2.1",
     "clean-jsdoc-theme": "^4.2.7",
     "eslint": "^8.39.0",
     "jest": "^29.5.0",
@@ -59,8 +57,10 @@
     "postcss": "^8.4.23",
     "prettier": "^2.8.8",
     "rollup": "^3.21.3",
+    "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-postcss": "^4.0.2",
-    "typescript": "^5.0.4"
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.1.6"
   },
   "lint-staged": {
     "*.{js,ts}": [
@@ -70,8 +70,7 @@
   "files": [
     "src/**/*",
     "dist/**/*",
-    "css/**/*",
-    "types/**/*"
+    "css/**/*"
   ],
   "keywords": [
     "map",
@@ -79,5 +78,8 @@
     "webgl",
     "globe",
     "og"
-  ]
+  ],
+  "dependencies": {
+    "@rollup/plugin-typescript": "^11.1.2"
+  }
 }

package/src/{og/Clock.js → Clock.ts}

@@ -1,67 +1,110 @@
-"use strict";
+import * as jd from "./astro/jd";
+import {EventsHandler, createEvents} from "./Events";
+import {JulianDate} from "./astro/jd";
+import {Handler} from "./webgl/Handler";
 
-import * as jd from "./astro/jd.js";
-import { Events } from "./Events.js";
+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;
+}
 
 /**
  * Class represents application timer that stores custom current julian datetime, and time speed multiplier.
  * @class
  * @param {Object} [params] - Clock parameters:
- * @param {number} [params.startDate=0.0] - Julian start date.
- * @param {number} [params.endDate=0.0] - Julian end date.
- * @param {number} [params.currentDate] - Julian current date. Default: current date.
+ * @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 {
-    static get _staticCounter() {
-        if (!this._counter && this._counter !== 0) {
-            this._counter = 0;
-        }
-        return this._counter;
-    }
+    static __counter__: number = 0;
+    protected __id: number;
+    public __handler: Handler | null = null;
 
-    static set _staticCounter(n) {
-        this._counter = n;
-    }
+    /**
+     * Clock events.
+     * @public
+     * @type {EventsHandler<ClockEventsList>}
+     */
+    public events: EventsHandler<ClockEventsList>;
 
     /**
-     *
-     * @param {Object} [params] - Clock parameters:
+     * Clock name.
+     * @public
+     * @type {string}
      */
-    constructor(params) {
-        params = params || {};
+    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 = {}) {
+
+
+        this.__id = Clock.__counter__++;
 
-        this._id = Clock._staticCounter++;
+        this.events = createEvents<ClockEventsList>(CLOCK_EVENTS, this);
 
-        /**
-         * Clock name.
-         * @public
-         * @type {string}
-         */
         this.name = params.name || "";
 
-        /**
-         * Clock events.
-         * @public
-         * @type {Events}
-         */
-        this.events = new Events(["tick", "end", "start", "stop"], this);
-
-        /**
-         * Start julian date clock loop.
-         * @public
-         * @type {number}
-         */
         this.startDate = params.startDate || 0;
 
-        /**
-         * End julian date clock loop.
-         * @public
-         * @type {number}
-         */
         this.endDate = params.endDate || 0;
 
-        var currentDate = params.currentDate || jd.DateToUTC(new Date());
+        let currentDate = params.currentDate || jd.DateToUTC(new Date());
         if (params.startDate && currentDate < params.startDate) {
             currentDate = params.startDate;
         }
@@ -69,34 +112,13 @@ class Clock {
             currentDate = params.endDate;
         }
 
-        /**
-         * Current julian datetime.
-         * @public
-         * @type {number}
-         */
         this.currentDate = currentDate;
 
-        /**
-         * Timer speed multiplier.
-         * @public
-         * @type {number}
-         */
         this._multiplier = params.multiplier !== undefined ? params.multiplier : 1.0;
         this._running = 1;
 
-        /**
-         * Animation frame delta time.
-         * @public
-         * @readonly
-         * @type {number}
-         */
         this.deltaTicks = 0;
 
-        /**
-         * Timer activity.
-         * @public
-         * @type {boolean}
-         */
         this.active = true;
 
         this._intervalDelay = 0;
@@ -104,13 +126,13 @@ class Clock {
         this._intervalCallback = null;
     }
 
-    clearInterval() {
+    public clearInterval() {
         this._intervalDelay = 0;
         this._intervalStart = 0;
         this._intervalCallback = null;
     }
 
-    setInterval(delay, callback) {
+    public setInterval(delay: number, callback: Function) {
         this._intervalStart = this.currentDate;
         this._intervalDelay = delay * jd.ONE_BY_MILLISECONDS_PER_DAY;
         this._intervalCallback = callback;
@@ -121,8 +143,8 @@ class Clock {
      * @public
      * @param {Object} date - JavaScript Date object.
      */
-    setDate(date) {
-        var d = jd.DateToUTC(date);
+    public setDate(date: Date) {
+        let d = jd.DateToUTC(date);
         if (this.startDate && d < this.startDate) {
             d = this.startDate;
         }
@@ -137,17 +159,17 @@ class Clock {
      * @public
      * @returns {Date} - Current date.
      */
-    getDate() {
+    public getDate(): Date {
         return jd.UTCtoDate(this.currentDate);
     }
 
-    reset() {
+    public reset() {
         if (this.startDate) {
             this.currentDate = this.startDate;
         }
     }
 
-    _tick(dt) {
+    public tick(dt: number) {
         let m = this._multiplier * this._running;
         this.deltaTicks = dt * m
         if (this.active) {
@@ -184,26 +206,26 @@ class Clock {
      * @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;
+    public isEqual(clock: Clock) {
+        return this.__id === clock.__id;
     }
 
-    start() {
+    public start() {
         if (this._running === 0) {
             this._running = 1;
             this.events.dispatch(this.events.start, this);
         }
     }
 
-    get multiplier() {
+    public get multiplier(): number {
         return this._multiplier;
     }
 
-    set multiplier(value) {
+    public set multiplier(value: number) {
         this._multiplier = value;
     }
 
-    stop() {
+    public stop() {
         if (this._running === 1) {
             this._running = 0;
             this.events.dispatch(this.events.stop, this);
@@ -211,4 +233,4 @@ class Clock {
     }
 }
 
-export { Clock };
+export {Clock};

package/src/Deferred.ts

@@ -0,0 +1,17 @@
+export class Deferred<T> {
+    resolve: ((value: T | PromiseLike<T>) => void);
+    reject: ((reason?: any) => void);
+    promise: Promise<T>;
+
+    constructor() {
+        this.resolve = () => {
+        };
+        this.reject = () => {
+        };
+        this.promise = new Promise<T>((resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+        Object.freeze(this);
+    }
+}

package/src/Events.ts

@@ -0,0 +1,200 @@
+import {binaryInsert, stamp} from "./utils/shared";
+
+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 function createEvents<T extends string[]>(methodNames: T, sender?: any) {
+    return new Events(methodNames, sender) as EventsHandler<T>;
+}
+
+/**
+ * Base events class to handle custom events.
+ * @class
+ * @param {Array.<string>} [eventNames] - Event names that could be dispatched.
+ * @param {*} [sender]
+ */
+export class Events<T extends string[]> {
+
+    static __counter__: number = 0;
+
+    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) {
+
+        this.__id = Events.__counter__++;
+
+        this._eventNames = [] as any;
+
+        eventNames && this.registerNames(eventNames);
+
+        this._sender = sender || this;
+
+        this._stopPropagation = false;
+
+        this._stampCache = {};
+    }
+
+    public bindSender(sender?: any) {
+        this._sender = sender || this;
+    }
+
+    /**
+     * Function that creates event object properties that would be dispatched.
+     * @public
+     * @param {Array.<string>} eventNames - Specified event names list.
+     */
+    public registerNames(eventNames: T): this {
+        for (let i = 0; i < eventNames.length; i++) {
+            (this as any)[eventNames[i]] = {
+                active: true,
+                handlers: []
+            };
+            this._eventNames.push(eventNames[i]);
+        }
+        return this;
+    }
+
+    protected _getStamp(name: string, id: number, ogid: number) {
+        return `${name}_${id}_${ogid}`;
+    }
+
+    /**
+     * 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) {
+        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.
+     */
+    public on(name: string, callback: EventCallback, sender?: any, priority: number = 0) {
+        if (this._stamp(name, callback)) {
+            if ((this as any)[name]) {
+                let c = callback.bind(sender || this._sender) as EventCallbackStamp;
+                c._openglobus_id = (callback as EventCallbackStamp)._openglobus_id;
+                c._openglobus_priority = priority;
+                binaryInsert((this as any)[name].handlers, c, (a: EventCallbackStamp, b: EventCallbackStamp) => {
+                    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.
+     */
+    public off(name: string, callback?: EventCallback | null) {
+        if (callback) {
+            let st = this._getStamp(name, this.__id, (callback as EventCallbackStamp)._openglobus_id!);
+            if ((callback as EventCallbackStamp)._openglobus_id && this._stampCache[st]) {
+                let h = (this as any)[name].handlers;
+                let i = h.length;
+                let indexToRemove = -1;
+                while (i--) {
+                    let hi = h[i];
+                    if (hi._openglobus_id === (callback as EventCallbackStamp)._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.
+     */
+    public dispatch(event: EventCallbackHandler | undefined, ...args: any[]) {
+        let result = true;
+        if (event && event.active && !this._stopPropagation) {
+            let h = event.handlers.slice(0),
+                i = h.length;
+            while (i--) {
+                if ((h[i] as any)(...args) === false) {
+                    result = false;
+                }
+            }
+        }
+        this._stopPropagation = false;
+        return result;
+    }
+
+    /**
+     * Brakes events propagation.
+     * @public
+     */
+    public stopPropagation() {
+        this._stopPropagation = true;
+    }
+
+    /**
+     * Removes all events.
+     * @public
+     */
+    public clear() {
+        for (let i = 0; i < this._eventNames.length; i++) {
+            let e = (this as any)[this._eventNames[i]];
+            e.handlers.length = 0;
+            e.handlers = [];
+        }
+        this._eventNames.length = 0;
+        this._eventNames = [] as any;
+    }
+}