@openglobus/og 0.14.4 → 0.15.0

package/src/og/ui/View.js

@@ -0,0 +1,190 @@
+'use strict';
+
+
+import { stringTemplate } from '../utils/shared.js';
+import { parseHTML } from "../utils/shared.js";
+import { Events } from '../Events.js';
+
+class View {
+    constructor(options = {}) {
+        this.__id = View.__staticCounter++;
+        this._events = new Events(options.eventList || []);
+        this.model = options.model || null;
+        this.template = options.template || "";
+        this.parent = options.parent || null;
+        this._classList = options.classList || [];
+        if (options.appendTo) {
+            this.appendTo(options.appendTo);
+        }
+    }
+
+    static set __staticCounter(n) {
+        this.__counter__ = n;
+    }
+
+    static get __staticCounter() {
+        if (!this.__counter__ && this.__counter__ !== 0) {
+            this.__counter__ = 0;
+        }
+        return this.__counter__;
+    }
+
+    static getHTML(template, params) {
+        return stringTemplate(template, params);
+    }
+
+    static parseHTML(htmlStr) {
+        return parseHTML(htmlStr);
+    }
+
+    static insertAfter(newNodes, referenceNode) {
+        if (!Array.isArray(newNodes)) {
+            newNodes = [newNodes];
+        }
+        for (let i = 0; i < newNodes.length; i++) {
+            if (referenceNode.parentNode) {
+                referenceNode.parentNode.insertBefore(newNodes[i], referenceNode.nextSibling);
+            }
+        }
+        return newNodes;
+    }
+
+    static insertBefore(newNodes, referenceNode) {
+        if (!Array.isArray(newNodes)) {
+            newNodes = [newNodes];
+        }
+        for (let i = 0; i < newNodes.length; i++) {
+            if (referenceNode.parentNode) {
+                referenceNode.parentNode.insertBefore(newNodes[i], referenceNode);
+            }
+        }
+    }
+
+    on(eventName, callback, sender) {
+        return this._events.on(eventName, callback, sender);
+    }
+
+    off(eventName, callback) {
+        return this._events.off(eventName, callback);
+    }
+
+    insertBefore(view) {
+        if (!this.el) {
+            this.render();
+        }
+        if (this.el) {
+            if (view instanceof HTMLElement && view.parentNode) {
+                View.insertBefore(this.el, view);
+            }
+            if (view instanceof View && view.el.parentNode) {
+                View.insertBefore(this.el, view.el);
+            }
+        }
+    }
+
+    insertAfter(view) {
+        if (!this.el) {
+            this.render();
+        }
+        if (this.el) {
+            if (view instanceof HTMLElement && view.parentNode) {
+                View.insertAfter(this.el, view);
+            }
+            if (view instanceof View && view.el.parentNode) {
+                View.insertAfter(this.el, view.el);
+            }
+        }
+    }
+
+    isEqual(view) {
+        return view.__id === this.__id;
+    }
+
+    appendTo(node, clean, firstPosition) {
+        if (node) {
+            if (!this.el) {
+                this.beforeRender(node);
+                this.render();
+            }
+
+            if (this.el && this.el.parentNode) {
+                this.el.parentNode.removeChild(this.el);
+            }
+
+            if (clean) {
+                node.innerHTML = "";
+            }
+
+            if (firstPosition) {
+                if (node.childNodes[0]) {
+                    View.insertBefore(this.el, node.childNodes[0]);
+                } else {
+                    node.appendChild(this.el);
+                }
+            } else {
+                node.appendChild(this.el);
+            }
+            this.afterRender(node);
+        }
+
+        return this;
+    }
+
+    afterRender(parentNode) {
+        //virtual
+    }
+
+    beforeRender(parentNode) {
+        //virtual
+    }
+
+    stopPropagation() {
+        this._events.stopPropagation();
+    }
+
+    renderTemplate(params) {
+        return View.parseHTML(View.getHTML(this.template, params || {}))[0];
+    }
+
+    render(params) {
+        this.el = this.renderTemplate(params);
+        for (let i = 0, len = this._classList.length; i < len; i++) {
+            this.el.classList.add(this._classList[i]);
+        }
+        return this;
+    }
+
+    select(queryStr) {
+        return this.el.querySelector(queryStr);
+    }
+
+    selectRemove(queryStr) {
+        if (this.el) {
+            let r = this.select(queryStr);
+            if (r && r.parentNode) {
+                r.parentNode.removeChild(r);
+                return r;
+            }
+        }
+    }
+
+    selectAll(queryStr, callback) {
+        if (this.el) {
+            const res = this.el.querySelectorAll(queryStr);
+            if (callback) {
+                for (let i = 0, len = res.length; i < len; i++) {
+                    callback(res[i], i);
+                }
+            }
+            return res;
+        }
+    }
+
+    remove() {
+        if (this.el && this.el.parentNode) {
+            this.el.parentNode.removeChild(this.el);
+        }
+    }
+}
+
+export { View };

package/src/og/utils/shared.js

@@ -4,7 +4,6 @@
 
 "use strict";
 
-import { ajax } from "../ajax.js";
 import { colorTable } from "./colorTable.js";
 import { Extent } from "../Extent.js";
 import { LonLat } from "../LonLat.js";
@@ -20,6 +19,20 @@ export function isEmpty(v) {
     return v == null;
 }
 
+/**
+ * Returns true if the object pointer is undefined.
+ * @function
+ * @param {Object} obj - Object pointer.
+ * @returns {boolean} Returns true if object is undefined.
+ */
+export function isUndef(obj) {
+    return obj === void 0;
+}
+
+export function isUndefExt(obj, defVal) {
+    return isUndef(obj) ? defVal : obj;
+}
+
 let _stampCounter = 0;
 
 export function stamp(obj) {
@@ -34,24 +47,6 @@ export function isString(s) {
     return typeof s === "string" || s instanceof String;
 }
 
-/**
- * Synchronous text file loading. Returns file text.
- * @param {string} fileUrl - File name path.
- * @returns {string} -
- */
-export function readTextFile(fileUrl) {
-    var res = "";
-
-    ajax.request(fileUrl, {
-        async: false,
-        success: function (data) {
-            res = data;
-        }
-    });
-
-    return res;
-}
-
 /**
  * Convert html color string to the RGBA number vector.
  * @param {string} htmlColor - HTML string("#C6C6C6" or "#EF5" or "rgb(8,8,8)" or "rgba(8,8,8)") color.
@@ -797,34 +792,50 @@ export function makeArray(arr) {
  * @param {TypedArray | Array} arr
  * @param {Number} starting
  * @param {Number} deleteCount
- * @param {Array} elements
+ * @param {Object} outArr
  */
 
-export function spliceArray(arr, starting, deleteCount, elements) {
+export function spliceArray(arr, starting, deleteCount, out) {
     if (ArrayBuffer.isView(arr)) {
-        return spliceTypedArray(arr, starting, deleteCount, elements);
+        if (starting < 0) {
+            deleteCount = Math.abs(starting);
+            starting += arr.length;
+        }
+        return spliceTypedArray(arr, starting, deleteCount, out);
     } else {
-        arr.splice(starting, deleteCount);
+        let res;
+        if (starting < 0) {
+            res = arr.splice(starting);
+        } else {
+            res = arr.splice(starting, deleteCount);
+        }
+        if (out) {
+            out.result = res;
+        }
         return arr;
     }
 }
 
+window.spliceArray = spliceArray;
+
 /**
  *
  * @param {TypedArray} arr
  * @param {Number} starting
  * @param {Number} deleteCount
- * @param {Array} elements
+ * @param {Array} outArr
  */
-export function spliceTypedArray(arr, starting, deleteCount, elements = []) {
+export function spliceTypedArray(arr, starting, deleteCount, out) {
     if (arr.length === 0) {
         return arr;
     }
-    const newSize = arr.length - deleteCount + elements.length;
+    const newSize = arr.length - deleteCount;
     const splicedArray = new arr.constructor(newSize);
     splicedArray.set(arr.subarray(0, starting));
-    splicedArray.set(elements, starting);
-    splicedArray.set(arr.subarray(starting + deleteCount), starting + elements.length);
+    splicedArray.set(arr.subarray(starting + deleteCount), starting);
+    if (out) {
+        out.result = arr.subarray(starting, starting + deleteCount);
+    }
     return splicedArray;
 }
 
@@ -933,11 +944,18 @@ export function cloneArray(items) {
 }
 
 /**
- * Returns true if the object pointer is undefined.
+ * Promise for load images
  * @function
- * @param {Object} obj - Object pointer.
- * @returns {boolean} Returns true if object is undefined.
+ * @param {string} url - link to image.
+ * @returns {Promise<Image>} Returns promise.
  */
-export function isUndef(obj) {
-    return obj === void 0;
+export async function loadImage(url) {
+    return new Promise(resolve => {
+        const image = new Image();
+        image.addEventListener('load', () => {
+            resolve(image);
+        });
+        image.src = url;
+        return image;
+    });
 }