@openglobus/og 0.18.0 → 0.18.1

package/{src/Events.ts → lib/js/Events.js}

@@ -1,78 +1,33 @@
-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
+import { binaryInsert, stamp } from "./utils/shared";
+export function createEvents(methodNames, sender) {
+    return new Events(methodNames, sender);
 }
-
-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) {
-
+export class Events {
+    constructor(eventNames, sender) {
         this.__id = Events.__counter__++;
-
-        this._eventNames = [] as any;
-
+        this._eventNames = [];
         eventNames && this.registerNames(eventNames);
-
         this._sender = sender || this;
-
         this._stopPropagation = false;
-
         this._stampCache = {};
     }
-
-    public bindSender(sender?: any) {
+    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.
      */
-    public registerNames(eventNames: T): this {
+    registerNames(eventNames) {
         for (let i = 0; i < eventNames.length; i++) {
-            (this as any)[eventNames[i]] = {
+            this[eventNames[i]] = {
                 active: true,
                 handlers: []
             };
@@ -80,11 +35,9 @@ export class Events<T extends string[]> {
         }
         return this;
     }
-
-    protected _getStamp(name: string, id: number, ogid: number) {
+    _getStamp(name, id, ogid) {
         return `${name}_${id}_${ogid}`;
     }
-
     /**
      * Returns true if event callback has stamped.
      * @protected
@@ -92,18 +45,15 @@ export class Events<T extends string[]> {
      * @param {Object} obj - Event callback.
      * @return {boolean} -
      */
-    protected _stamp(name: string, obj: any) {
+    _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
@@ -112,40 +62,38 @@ export class Events<T extends string[]> {
      * @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) {
+    on(name, callback, sender, priority = 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;
+            if (this[name]) {
+                let c = callback.bind(sender || this._sender);
+                c._openglobus_id = callback._openglobus_id;
                 c._openglobus_priority = priority;
-                binaryInsert((this as any)[name].handlers, c, (a: EventCallbackStamp, b: EventCallbackStamp) => {
+                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.
      */
-    public off(name: string, callback?: EventCallback | null) {
+    off(name, callback) {
         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 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 as EventCallbackStamp)._openglobus_id) {
+                    if (hi._openglobus_id === callback._openglobus_id) {
                         indexToRemove = i;
                         break;
                     }
                 }
-
                 if (indexToRemove !== -1) {
                     h.splice(indexToRemove, 1);
                     this._stampCache[st] = undefined;
@@ -154,20 +102,18 @@ export class Events<T extends string[]> {
             }
         }
     }
-
     /**
      * 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[]) {
+    dispatch(event, ...args) {
         let result = true;
         if (event && event.active && !this._stopPropagation) {
-            let h = event.handlers.slice(0),
-                i = h.length;
+            let h = event.handlers.slice(0), i = h.length;
             while (i--) {
-                if ((h[i] as any)(...args) === false) {
+                if (h[i](...args) === false) {
                     result = false;
                 }
             }
@@ -175,26 +121,25 @@ export class Events<T extends string[]> {
         this._stopPropagation = false;
         return result;
     }
-
     /**
      * Brakes events propagation.
      * @public
      */
-    public stopPropagation() {
+    stopPropagation() {
         this._stopPropagation = true;
     }
-
     /**
      * Removes all events.
      * @public
      */
-    public clear() {
+    clear() {
         for (let i = 0; i < this._eventNames.length; i++) {
-            let e = (this as any)[this._eventNames[i]];
+            let e = this[this._eventNames[i]];
             e.handlers.length = 0;
             e.handlers = [];
         }
         this._eventNames.length = 0;
-        this._eventNames = [] as any;
+        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;
+}