@openglobus/og 0.15.1 → 0.15.3

package/src/og/shaders/polyline.js

@@ -6,6 +6,188 @@
 
 import { Program } from '../webgl/Program.js';
 
+export function polyline_screen() {
+    return new Program("polyline_screen", {
+        uniforms: {
+            viewport: "vec2",
+            proj: "mat4",
+            view: "mat4",
+            eyePositionHigh: "vec3",
+            eyePositionLow: "vec3",
+            uFloatParams: "vec2",
+            thickness: "float",
+            opacity: "float",
+            depthOffset: "float"
+        },
+        attributes: {
+            prevHigh: "vec3",
+            currentHigh: "vec3",
+            nextHigh: "vec3",
+
+            prevLow: "vec3",
+            currentLow: "vec3",
+            nextLow: "vec3",
+
+            order: "float",
+
+            color: "vec4"
+        },
+
+        vertexShader:
+            `precision highp float;
+
+                attribute vec3 prevHigh;
+                attribute vec3 currentHigh;
+                attribute vec3 nextHigh;
+
+                attribute vec3 prevLow;
+                attribute vec3 currentLow;
+                attribute vec3 nextLow;
+
+                attribute float order;
+
+                attribute vec4 color;
+
+                uniform float thickness;
+                uniform mat4 proj;
+                uniform mat4 view;
+                uniform vec2 viewport;
+                uniform vec3 eyePositionHigh;
+                uniform vec3 eyePositionLow;
+                uniform float opacity;
+                uniform float depthOffset;
+
+                varying vec4 vColor;
+                varying vec3 vPos;
+                varying vec3 uCamPos;
+
+                const float NEAR = -1.0;
+
+                vec2 getIntersection(vec2 start1, vec2 end1, vec2 start2, vec2 end2){
+                    vec2 dir = end2 - start2;
+                    vec2 perp = vec2(-dir.y, dir.x);
+                    float d2 = dot(perp, start2);
+                    float seg = dot(perp, start1) - d2;
+                    float prl = seg - dot(perp, end1) + d2;
+                    if(prl > -1.0 && prl < 1.0){
+                        return start1;
+                    }
+                    float u = seg / prl;
+                    return start1 + u * (end1 - start1);
+                }
+
+                vec2 project(vec4 p){
+                    return (0.5 * p.xyz / p.w + 0.5).xy * viewport;
+                }
+
+                void main(){
+
+                    uCamPos = eyePositionHigh + eyePositionLow;
+
+                    vColor = vec4(color.rgb, color.a * opacity);
+
+                    vec3 current = currentHigh + currentLow;
+
+                    vPos = current;
+
+                    mat4 viewMatrixRTE = view;
+                    viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+                    vec3 highDiff, lowDiff;
+
+                    highDiff = currentHigh - eyePositionHigh;
+                    lowDiff = currentLow - eyePositionLow;
+                    vec4 vCurrent = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+
+                    highDiff = prevHigh - eyePositionHigh;
+                    lowDiff = prevLow - eyePositionLow;
+                    vec4 vPrev = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+
+                    highDiff = nextHigh - eyePositionHigh;
+                    lowDiff = nextLow - eyePositionLow;
+                    vec4 vNext = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+
+                    /*Clip near plane, the point behind view plane*/
+                    if(vCurrent.z > NEAR) {
+                        if(vPrev.z < NEAR && abs(order) == 1.0){
+                            vCurrent = vPrev + (vCurrent - vPrev) * (NEAR - vPrev.z) / (vCurrent.z - vPrev.z);
+                        } else if(vNext.z < NEAR && abs(order) == 2.0){
+                            vCurrent = vNext + (vCurrent - vNext) * (NEAR - vNext.z) / (vCurrent.z - vNext.z);
+                        }
+                    }
+
+                    vec4 dCurrent = proj * vCurrent;
+                    vec2 _next = project(proj * vNext);
+                    vec2 _prev = project(proj * vPrev);
+                    vec2 _current = project(dCurrent);
+
+                    if(_prev == _current){
+                        if(_next == _current){
+                            _next = _current + vec2(1.0, 0.0);
+                            _prev = _current - _next;
+                        }else{
+                            _prev = _current + normalize(_current - _next);
+                        }
+                    }
+
+                    if(_next == _current){
+                        _next = _current + normalize(_current - _prev);
+                    }
+
+                    vec2 sNext = _next,
+                         sCurrent = _current,
+                         sPrev = _prev;
+
+                    vec2 dirNext = normalize(sNext - sCurrent);
+                    vec2 dirPrev = normalize(sPrev - sCurrent);
+                    float dotNP = dot(dirNext, dirPrev);
+
+                    vec2 normalNext = normalize(vec2(-dirNext.y, dirNext.x));
+                    vec2 normalPrev = normalize(vec2(dirPrev.y, -dirPrev.x));
+
+                    float d = thickness * sign(order);
+
+                    vec2 m;
+                    if(dotNP >= 0.99991){
+                        m = sCurrent - normalPrev * d;
+                    }else{
+                        m = getIntersection( sCurrent + normalPrev * d, sPrev + normalPrev * d,
+                                sCurrent + normalNext * d, sNext + normalNext * d );
+
+                        if( dotNP > 0.5 && dot(dirNext + dirPrev, m - sCurrent) < 0.0 ){
+                            float occw = order * sign(dirNext.x * dirPrev.y - dirNext.y * dirPrev.x);
+                            if(occw == -1.0){
+                                m = sCurrent + normalPrev * d;
+                            }else if(occw == 1.0){
+                                m = sCurrent + normalNext * d;
+                            }else if(occw == -2.0){
+                                m = sCurrent + normalNext * d;
+                            }else if(occw == 2.0){
+                                m = sCurrent + normalPrev * d;
+                            }
+                        }else if(distance(sCurrent, m) > min(distance(sCurrent, sNext), distance(sCurrent, sPrev))){
+                            m = sCurrent + normalNext * d;
+                        }
+                    }
+
+                    gl_Position = vec4((2.0 * m / viewport - 1.0) * dCurrent.w, dCurrent.z + depthOffset, dCurrent.w);
+                }`,
+
+        fragmentShader:
+            `precision highp float;
+                uniform vec2 uFloatParams;
+                varying vec3 uCamPos;
+                varying vec4 vColor;
+                varying vec3 vPos;
+                void main() {
+                    vec3 look = vPos - uCamPos;
+                    float lookLength = length(look);
+                    float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));
+                    gl_FragColor = vec4(vColor.rgb, a);
+                }`
+    });
+}
+
 // export function polyline_screen() {
 //     return new Program("polyline_screen", {
 //         uniforms: {
@@ -34,19 +216,21 @@ import { Program } from '../webgl/Program.js';
 //         },
 //
 //         vertexShader:
-//             `precision highp float;
+//             `#version 300 es
 //
-//                 attribute vec3 prevHigh;
-//                 attribute vec3 currentHigh;
-//                 attribute vec3 nextHigh;
+//                 precision highp float;
 //
-//                 attribute vec3 prevLow;
-//                 attribute vec3 currentLow;
-//                 attribute vec3 nextLow;
+//                 in vec3 prevHigh;
+//                 in vec3 currentHigh;
+//                 in vec3 nextHigh;
 //
-//                 attribute float order;
+//                 in vec3 prevLow;
+//                 in vec3 currentLow;
+//                 in vec3 nextLow;
 //
-//                 attribute vec4 color;
+//                 in float order;
+//
+//                 in vec4 color;
 //
 //                 uniform float thickness;
 //                 uniform mat4 proj;
@@ -57,9 +241,9 @@ import { Program } from '../webgl/Program.js';
 //                 uniform float opacity;
 //                 uniform float depthOffset;
 //
-//                 varying vec4 vColor;
-//                 varying vec3 vPos;
-//                 varying vec3 uCamPos;
+//                 out vec4 vColor;
+//                 out vec3 vPos;
+//                 out vec3 uCamPos;
 //
 //                 const float NEAR = -1.0;
 //
@@ -174,215 +358,31 @@ import { Program } from '../webgl/Program.js';
 //                 }`,
 //
 //         fragmentShader:
-//             `precision highp float;
+//             `#version 300 es
+//
+//                 precision highp float;
+//
 //                 uniform vec2 uFloatParams;
-//                 varying vec3 uCamPos;
-//                 varying vec4 vColor;
-//                 varying vec3 vPos;
+//
+//                 layout(location = 0) out vec4 diffuseColor;
+//                 layout(location = 1) out vec4 normalColor;
+//                 layout(location = 2) out vec4 distanceColor;
+//
+//                 in vec3 uCamPos;
+//                 in vec4 vColor;
+//                 in vec3 vPos;
+//
 //                 void main() {
 //                     vec3 look = vPos - uCamPos;
 //                     float lookLength = length(look);
 //                     float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));
-//                     gl_FragColor = vec4(vColor.rgb, a);
+//                     diffuseColor = vec4(vColor.rgb, a);
+//                     normalColor = vec4(1.0);
+//                     distanceColor = vec4(1.0);
 //                 }`
 //     });
 // }
 
-export function polyline_screen() {
-    return new Program("polyline_screen", {
-        uniforms: {
-            viewport: "vec2",
-            proj: "mat4",
-            view: "mat4",
-            eyePositionHigh: "vec3",
-            eyePositionLow: "vec3",
-            uFloatParams: "vec2",
-            thickness: "float",
-            opacity: "float",
-            depthOffset: "float"
-        },
-        attributes: {
-            prevHigh: "vec3",
-            currentHigh: "vec3",
-            nextHigh: "vec3",
-
-            prevLow: "vec3",
-            currentLow: "vec3",
-            nextLow: "vec3",
-
-            order: "float",
-
-            color: "vec4"
-        },
-
-        vertexShader:
-            `#version 300 es
-                
-                precision highp float;
-                
-                in vec3 prevHigh;
-                in vec3 currentHigh;
-                in vec3 nextHigh;
-                
-                in vec3 prevLow;
-                in vec3 currentLow;
-                in vec3 nextLow;
-
-                in float order;
-
-                in vec4 color;
-
-                uniform float thickness;
-                uniform mat4 proj;
-                uniform mat4 view;
-                uniform vec2 viewport;
-                uniform vec3 eyePositionHigh;
-                uniform vec3 eyePositionLow;
-                uniform float opacity;
-                uniform float depthOffset;
-
-                out vec4 vColor;
-                out vec3 vPos;
-                out vec3 uCamPos;
-                
-                const float NEAR = -1.0;
-                
-                vec2 getIntersection(vec2 start1, vec2 end1, vec2 start2, vec2 end2){
-                    vec2 dir = end2 - start2;
-                    vec2 perp = vec2(-dir.y, dir.x);
-                    float d2 = dot(perp, start2);
-                    float seg = dot(perp, start1) - d2;
-                    float prl = seg - dot(perp, end1) + d2;
-                    if(prl > -1.0 && prl < 1.0){
-                        return start1;
-                    }
-                    float u = seg / prl;
-                    return start1 + u * (end1 - start1);
-                }
-                
-                vec2 project(vec4 p){
-                    return (0.5 * p.xyz / p.w + 0.5).xy * viewport;
-                }
-                
-                void main(){
-
-                    uCamPos = eyePositionHigh + eyePositionLow;
-
-                    vColor = vec4(color.rgb, color.a * opacity);
-
-                    vec3 current = currentHigh + currentLow;
-
-                    vPos = current;                    
-
-                    mat4 viewMatrixRTE = view;
-                    viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
-
-                    vec3 highDiff, lowDiff;
-
-                    highDiff = currentHigh - eyePositionHigh;
-                    lowDiff = currentLow - eyePositionLow;
-                    vec4 vCurrent = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
-
-                    highDiff = prevHigh - eyePositionHigh;
-                    lowDiff = prevLow - eyePositionLow;    
-                    vec4 vPrev = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
-
-                    highDiff = nextHigh - eyePositionHigh;
-                    lowDiff = nextLow - eyePositionLow;    
-                    vec4 vNext = viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
-
-                    /*Clip near plane, the point behind view plane*/
-                    if(vCurrent.z > NEAR) {
-                        if(vPrev.z < NEAR && abs(order) == 1.0){
-                            vCurrent = vPrev + (vCurrent - vPrev) * (NEAR - vPrev.z) / (vCurrent.z - vPrev.z);
-                        } else if(vNext.z < NEAR && abs(order) == 2.0){
-                            vCurrent = vNext + (vCurrent - vNext) * (NEAR - vNext.z) / (vCurrent.z - vNext.z);
-                        }
-                    }
-                    
-                    vec4 dCurrent = proj * vCurrent;
-                    vec2 _next = project(proj * vNext);
-                    vec2 _prev = project(proj * vPrev);
-                    vec2 _current = project(dCurrent);
-
-                    if(_prev == _current){
-                        if(_next == _current){
-                            _next = _current + vec2(1.0, 0.0);
-                            _prev = _current - _next;
-                        }else{
-                            _prev = _current + normalize(_current - _next);
-                        }
-                    }
-
-                    if(_next == _current){
-                        _next = _current + normalize(_current - _prev);
-                    }
-                    
-                    vec2 sNext = _next,
-                         sCurrent = _current,
-                         sPrev = _prev;
-
-                    vec2 dirNext = normalize(sNext - sCurrent);
-                    vec2 dirPrev = normalize(sPrev - sCurrent);
-                    float dotNP = dot(dirNext, dirPrev);
-                    
-                    vec2 normalNext = normalize(vec2(-dirNext.y, dirNext.x));
-                    vec2 normalPrev = normalize(vec2(dirPrev.y, -dirPrev.x));
-                    
-                    float d = thickness * sign(order);
-                    
-                    vec2 m;
-                    if(dotNP >= 0.99991){
-                        m = sCurrent - normalPrev * d;
-                    }else{
-                        m = getIntersection( sCurrent + normalPrev * d, sPrev + normalPrev * d,
-                                sCurrent + normalNext * d, sNext + normalNext * d );
-                        
-                        if( dotNP > 0.5 && dot(dirNext + dirPrev, m - sCurrent) < 0.0 ){
-                            float occw = order * sign(dirNext.x * dirPrev.y - dirNext.y * dirPrev.x);
-                            if(occw == -1.0){
-                                m = sCurrent + normalPrev * d;
-                            }else if(occw == 1.0){
-                                m = sCurrent + normalNext * d;
-                            }else if(occw == -2.0){
-                                m = sCurrent + normalNext * d;
-                            }else if(occw == 2.0){
-                                m = sCurrent + normalPrev * d;
-                            }
-                        }else if(distance(sCurrent, m) > min(distance(sCurrent, sNext), distance(sCurrent, sPrev))){
-                            m = sCurrent + normalNext * d;
-                        }
-                    }
-                                            
-                    gl_Position = vec4((2.0 * m / viewport - 1.0) * dCurrent.w, dCurrent.z + depthOffset, dCurrent.w);
-                }`,
-
-        fragmentShader:
-            `#version 300 es
-                
-                precision highp float;
-                
-                uniform vec2 uFloatParams;
-                
-                layout(location = 0) out vec4 diffuseColor;
-                layout(location = 1) out vec4 normalColor;
-                layout(location = 2) out vec4 distanceColor;
-                
-                in vec3 uCamPos;
-                in vec4 vColor;
-                in vec3 vPos;
-                
-                void main() {
-                    vec3 look = vPos - uCamPos;
-                    float lookLength = length(look);
-                    float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));                    
-                    diffuseColor = vec4(vColor.rgb, a);
-                    normalColor = vec4(1.0);
-                    distanceColor = vec4(1.0);                    
-                }`
-    });
-}
-
 export function polyline_picking() {
     return new Program("polyline_picking", {
         uniforms: {

package/src/og/terrain/BilTerrain.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import { GlobusTerrain } from "./GlobusTerrain.js";
+import { Layer } from "../layer/Layer.js";
 import { WMS } from "../layer/WMS.js";
 import { isPowerOfTwo, nextHighestPowerOfTwo } from "../math.js";
 import { getTileExtent } from "../mercator.js";
-import { Layer } from "../layer/Layer.js";
+import { GlobusTerrain } from "./GlobusTerrain.js";
 
 class BilTerrain extends GlobusTerrain {
     constructor(options) {
@@ -34,8 +34,8 @@ class BilTerrain extends GlobusTerrain {
             options.plainGridSize != undefined
                 ? options.plainGridSize
                 : isPowerOfTwo(this._imageSize)
-                ? this._imageSize / 2
-                : nextHighestPowerOfTwo(this._imageSize) / 2;
+                    ? this._imageSize / 2
+                    : nextHighestPowerOfTwo(this._imageSize) / 2;
 
         this._dataType = "arrayBuffer";
     }

package/src/og/terrain/GlobusTerrain.js

@@ -3,19 +3,19 @@
  */
 "use strict";
 
+import { Events } from "../Events.js";
 import * as mercator from "../mercator.js";
-import { EmptyTerrain } from "./EmptyTerrain.js";
 import { EPSG3857 } from "../proj/EPSG3857.js";
-import { Events } from "../Events.js";
-import { Loader } from "../utils/Loader.js";
 import { NOTRENDERING } from "../quadTree/quadTree.js";
+import { Loader } from "../utils/Loader.js";
+import { EmptyTerrain } from "./EmptyTerrain.js";
 // import { QueueArray } from '../QueueArray.js';
-import { createExtent, stringTemplate } from "../utils/shared.js";
-import { Layer } from "../layer/Layer.js";
-import { Vec3 } from "../math/Vec3.js";
-import { Ray } from "../math/Ray.js";
 import { Extent } from "../Extent.js";
+import { Layer } from "../layer/Layer.js";
 import { LonLat } from "../LonLat.js";
+import { Ray } from "../math/Ray.js";
+import { Vec3 } from "../math/Vec3.js";
+import { createExtent, stringTemplate } from "../utils/shared.js";
 
 const EVENT_NAMES = [
     /**

package/src/og/terrain/MapboxTerrain.js

@@ -1,8 +1,8 @@
-import { getTileExtent } from "../mercator.js";
 import { Layer } from "../layer/Layer.js";
-import { GlobusTerrain } from "./GlobusTerrain.js";
 import { isPowerOfTwo } from "../math.js";
 import * as mercator from "../mercator.js";
+import { getTileExtent } from "../mercator.js";
+import { GlobusTerrain } from "./GlobusTerrain.js";
 
 const KEY =
     "pk.eyJ1IjoiZm94bXVsZGVyODMiLCJhIjoiY2pqYmR3dG5oM2Z1bzNrczJqYm5pODhuNSJ9.Y4DRmEPhb-XSlCR9CAXACQ";

package/src/og/terrain/index.js

@@ -1,6 +1,6 @@
+import { BilTerrain } from './BilTerrain';
 import { EmptyTerrain } from './EmptyTerrain';
 import { GlobusTerrain } from './GlobusTerrain';
 import { MapboxTerrain } from './MapboxTerrain';
-import { BilTerrain } from './BilTerrain';
 
-export { EmptyTerrain, GlobusTerrain, MapboxTerrain, BilTerrain };
+export { EmptyTerrain, GlobusTerrain, MapboxTerrain, BilTerrain };

package/src/og/ui/Button.js

@@ -1,10 +1,10 @@
 'use strict'
 
-import { View } from './View.js';
 import { stringTemplate } from '../utils/shared.js';
+import { View } from './View.js';
 
 const TEMPLATE =
-    `<div class="og-button">
+    `<div class="og-button" title="{title}">
        <div class="og-button-icon">{icon}</div>
        <div class="og-button-text">{text}</div>
     </div>`;
@@ -14,7 +14,8 @@ class Button extends View {
         super({
             template: stringTemplate(TEMPLATE, {
                 icon: options.icon || "",
-                text: options.text || ""
+                text: options.text || "",
+                title: options.title || ""
             }),
             ...options,
             eventList: ["click", "mousedown", "mouseup", "touchstart", "touchend", "touchcancel", ...(options.eventList || [])]
@@ -103,4 +104,4 @@ class Button extends View {
     }
 }
 
-export { Button }
+export { Button };

package/src/og/ui/Dialog.js

@@ -1,8 +1,9 @@
 'use strict'
 
-import { View } from './View.js';
 import { getDefault, stringTemplate } from '../utils/shared.js';
 import { Button } from './Button.js';
+import { CLOSE_ICON } from './icons.js';
+import { View } from './View.js';
 
 const TEMPLATE = `<div class="og-ddialog" 
         style="display:{display}; resize:{resize}; width: {width}px; {height}; top: {top}px; left: {left}px; min-height: {minHeight}; max-height: {maxHeight}; min-width: {minWidth}; max-width: {maxWidth};">
@@ -13,10 +14,6 @@ const TEMPLATE = `<div class="og-ddialog"
        <div class="og-ddialog-container"></div>
     </div>>`;
 
-const CLOSE_ICON = `<svg className="svg-icon" style="width: 1em; height: 1em;vertical-align: middle;fill: currentColor; overflow: hidden;" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg">
-    <path d="M777.856 280.192l-33.92-33.952-231.872 231.872-231.84-231.872-33.984 33.888 231.872 231.904-231.84 231.84 33.888 33.984 231.904-231.904 231.84 231.872 33.952-33.888-231.872-231.904z"/>
-</svg>`
-
 class Dialog extends View {
     constructor(options = {}) {
         super({
@@ -239,4 +236,4 @@ class Dialog extends View {
     }
 }
 
-export { Dialog }
+export { Dialog };

package/src/og/ui/Slider.js

@@ -1,8 +1,8 @@
 'use strict';
 
-import { View } from './View.js';
-import { stringTemplate } from '../utils/shared.js';
 import { clamp } from '../math.js';
+import { stringTemplate } from '../utils/shared.js';
+import { View } from './View.js';
 
 const TEMPLATE = `<div class="og-slider">
       <div class="og-slider-label">{label}</div>
@@ -81,6 +81,23 @@ class Slider extends View {
 
         this._onMouseWheel_ = this._onMouseWheel.bind(this);
         this.$panel.addEventListener("mousewheel", this._onMouseWheel_);
+
+        this._onMouseWheelFF_ = this._onMouseWheelFF.bind(this);
+        this.$panel.addEventListener("wheel", this._onMouseWheelFF_);
+    }
+
+    _clearEvents() {
+        this.$panel.removeEventListener("mousedown", this._onMouseDown_);
+        this._onMouseDown_ = undefined;
+
+        this.$input.removeEventListener("input", this._onInput_);
+        this._onInput_ = undefined;
+
+        this.$panel.removeEventListener("mousewheel", this._onMouseWheel_);
+        this._onMouseWheel_ = undefined;
+
+        this.$panel.removeEventListener("wheel", this._onMouseWheelFF_);
+        this._onMouseWheelFF_ = undefined;
     }
 
     _onMouseWheel(e) {
@@ -90,6 +107,10 @@ class Slider extends View {
         this.value = this._value + Math.sign(e.wheelDelta) * (this._max - this._min) / 100.0;
     }
 
+    _onMouseWheelFF(e) {
+        this._onMouseWheel(e);
+    }
+
     _onInput(e) {
         e = e || window.event;
         e.preventDefault();
@@ -137,8 +158,13 @@ class Slider extends View {
         document.removeEventListener("mousemove", this._onMouseMove_);
         this._onMouseMove_ = undefined;
     }
+
+    remove() {
+        this._clearEvents();
+        super.remove();
+    }
 }
 
 export {
     Slider
-}
+};

package/src/og/ui/View.js

@@ -1,9 +1,8 @@
 'use strict';
 
 
-import { stringTemplate } from '../utils/shared.js';
-import { parseHTML } from "../utils/shared.js";
 import { Events } from '../Events.js';
+import { parseHTML, stringTemplate } from '../utils/shared.js';
 
 class View {
     constructor(options = {}) {
@@ -13,9 +12,6 @@ class View {
         this.template = options.template || "";
         this.parent = options.parent || null;
         this._classList = options.classList || [];
-        if (options.appendTo) {
-            this.appendTo(options.appendTo);
-        }
     }
 
     static set __staticCounter(n) {
@@ -60,6 +56,10 @@ class View {
         }
     }
 
+    get events() {
+        return this._events;
+    }
+
     on(eventName, callback, sender) {
         return this._events.on(eventName, callback, sender);
     }